Applicant.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/ApplicantMatcher.h"
#include "enrollment/Face/Face.h"
#include "enrollment/Iris/Iris.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/ModalitiesICSTemplateDefaultFactory.h"
#include "enrollment/ModalitiesTemplate.h"
#include "enrollment/Print/ExtractedPrint.h"
#include "enrollment/Print/ICSVerifyMatcher.h"
#include "enrollment/Print/Print.h"
#include "enrollment/Print/PrintCapture.h"
#include "enrollment/Serialization/Writer.h"
#include "enrollment/SimilarityThreshold.h"
#include <algorithm>
#include <atomic>
#include <memory>
#include <mutex>
#include <vector>
 
namespace inno
{
    class Logger;
    class Print;

     */
    class ApplicantPrintValidation
    {
    public:
        virtual bool Validate(const std::shared_ptr<ExtractedPrint>& probe,
                              const std::vector<std::shared_ptr<ExtractedPrint>>& gallery) = 0;
 
        ApplicantPrintValidation() = default;
        ApplicantPrintValidation(ApplicantPrintValidation&&) = delete;
        ApplicantPrintValidation(const ApplicantPrintValidation&) = delete;
        ApplicantPrintValidation& operator=(ApplicantPrintValidation&&) = delete;
        ApplicantPrintValidation& operator=(const ApplicantPrintValidation&) = delete;
        virtual ~ApplicantPrintValidation() = default;
    };

     */
    class FlatteningValidation : public ApplicantPrintValidation
    {
    public:
         */
        std::shared_ptr<ExtractedPrint> GetInvalidatingPrint() const
        {
            const std::scoped_lock lock(invalidatingPrintMux);
            return invalidatingPrint;
        }

         */
        bool Validate(const std::shared_ptr<ExtractedPrint>& probe,
                      const std::vector<std::shared_ptr<ExtractedPrint>>& gallery) final
        {
            if (probe == nullptr)
            {
                throw NullArgumentException("Probe cannot be null");
            }
 
            if (probe->print == nullptr)
            {
                throw NullArgumentException("Probe print cannot be null");
            }
 
            return std::all_of(gallery.cbegin(),
                               gallery.cend(),
                               [this, probe](auto& g)
                               {
                                   if (probe->print->position == g->print->position)
                                   {
                                       if (probe->SimilarWith(*g, matcher) < samePositionTh)
                                       {
                                           const std::scoped_lock lock(invalidatingPrintMux);
                                           invalidatingPrint = g;
                                           return false;
                                       }
                                   }
                                   else
                                   {
                                       if (probe->SimilarWith(*g, matcher) > differentPositionTh)
                                       {
                                           const std::scoped_lock lock(invalidatingPrintMux);
                                           invalidatingPrint = g;
                                           return false;
                                       }
                                   }
                                   return true;
                               });
        }

         */
        FlatteningValidation(SimilarityThreshold samePositionThreshold,
                             SimilarityThreshold differentPositionThreshold,
                             ICSMatcher& printMatcher)
          : samePositionTh(samePositionThreshold)
          , differentPositionTh(differentPositionThreshold)
          , matcher(printMatcher)
        {
        }

        FlatteningValidation() = default;
        FlatteningValidation(FlatteningValidation&&) = delete;
        FlatteningValidation(const FlatteningValidation&) = delete;
        FlatteningValidation& operator=(FlatteningValidation&&) = delete;
        FlatteningValidation& operator=(const FlatteningValidation&) = delete;
        virtual ~FlatteningValidation() = default;
 
    private:
        static constexpr SimilarityThreshold DefaultSamePositionThreshold = 40;
        SimilarityThreshold samePositionTh = DefaultSamePositionThreshold;
        static constexpr SimilarityThreshold DefaultDifferentPositionThreshold = 15;
        SimilarityThreshold differentPositionTh = DefaultDifferentPositionThreshold;
        ICSVerifyMatcher::Config defaultMatcherConfig;
        ICSVerifyMatcher defaultMatcher;
        // We do not create ICSMatcher as smart pointer in API, up to now we do not change the API due to this
        // observation.
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
        ICSMatcher& matcher = defaultMatcher;
        mutable std::mutex invalidatingPrintMux;
        std::shared_ptr<ExtractedPrint> invalidatingPrint;
    };

     */
    class ApplicantFaceValidation
    {
    public:
        virtual bool Validate(const std::shared_ptr<ExtractedFace>& probe,
                              const std::vector<std::shared_ptr<ExtractedFace>>& gallery) = 0;
 
        ApplicantFaceValidation() = default;
        ApplicantFaceValidation(ApplicantFaceValidation&&) = delete;
        ApplicantFaceValidation(const ApplicantFaceValidation&) = delete;
        ApplicantFaceValidation& operator=(ApplicantFaceValidation&&) = delete;
        ApplicantFaceValidation& operator=(const ApplicantFaceValidation&) = delete;
        virtual ~ApplicantFaceValidation() = default;
    };

     */
    class Applicant final : public Serializable
    {
    public:
         */
        std::vector<std::shared_ptr<ExtractedPrint>> GetEnrolledPrints() const
        {
            const std::scoped_lock lock(printMutex);
            return ps;
        }

         */
        std::vector<std::shared_ptr<ExtractedFace>> GetEnrolledFaces() const
        {
            const std::scoped_lock lock(faceMutex);
            return fs;
        }
         */
        std::vector<std::shared_ptr<ExtractedIris>> GetEnrolledIrises() const
        {
            const std::scoped_lock lock(irisMutex);
            return ir;
        }

         */
        std::shared_ptr<ModalitiesTemplate> ToTemplate() const
        {
            const std::scoped_lock lock(printMutex, faceMutex, irisMutex);
            auto prints = ExtractedPrint::ToTemplates(ps);
            auto faces = ExtractedFace::ToTemplates(fs);
            auto irises = ExtractedIris::ToTemplates(ir);
            return ModalitiesTemplate::Create(prints, faces, irises);
        }

         */
        std::shared_ptr<ModalitiesICSTemplate> ToICSTemplate() const
        {
            ModalitiesICSTemplateDefaultFactory factory;
            return ToICSTemplate(factory);
        }

         */
        std::shared_ptr<ModalitiesICSTemplate> ToICSTemplate(ModalitiesICSTemplateFactory& factory) const
        {
            const std::scoped_lock lock(printMutex, faceMutex, irisMutex);
            auto prints = ExtractedPrint::ToICSTemplates(ps);
            auto faces = ExtractedFace::ToTemplates(fs);
            auto irises = ExtractedIris::ToTemplates(ir);
            return factory.CreateModalitiesICSTemplate(prints, faces, irises);
        }

         */
        [[nodiscard]] ModalityScore SimilarWith(const Applicant& gallery, ApplicantMatcher& matcher) const
        {
            return matcher.Match(*this, gallery);
        }

         */
        std::shared_ptr<ExtractedPrint> AddUniquePrint(std::shared_ptr<ExtractedPrint> print)
        {
            FlatteningValidation defaultFlatteningValidation;
            auto isValid = AddValidPrint(std::move(print), defaultFlatteningValidation);
 
            if (isValid)
            {
                return nullptr;
            }
            return defaultFlatteningValidation.GetInvalidatingPrint();
        }

         */
        bool AddValidPrint(std::shared_ptr<ExtractedPrint> print, ApplicantPrintValidation& validation)
        {
            if (print == nullptr)
            {
                throw NullArgumentException("ExtractedPrint cannot be null");
            }
 
            const std::scoped_lock lock(printMutex);
            auto isValid = validation.Validate(print, ps);
 
            if (isValid)
            {
                DoAddPrint(std::move(print));
            }
 
            return isValid;
        }

         */
        void AddPrint(std::shared_ptr<ExtractedPrint> print)
        {
            if (print == nullptr)
            {
                throw NullArgumentException("Print cannot be null");
            }
 
            DoAddPrint(std::move(print));
        }

         */
        void AddSlap(std::shared_ptr<SlapCapture> slap)
        {
            if (slap == nullptr)
            {
                throw NullArgumentException("SlapCapture cannot be null");
            }
            log.LogInfo("Adding %v", slap);
            const std::scoped_lock lock(slapMutex);
            ss.emplace_back(std::move(slap));
        }

         */
        void AddThumbs(std::shared_ptr<ThumbsCapture> thumbs)
        {
            if (thumbs == nullptr)
            {
                throw NullArgumentException("ThumbsCapture cannot be null");
            }
            log.LogInfo("Adding %v", thumbs);
            const std::scoped_lock lock(thumbsMutex);
            ts.emplace_back(std::move(thumbs));
        }

         */
        bool AddValidFace(std::shared_ptr<ExtractedFace> face, ApplicantFaceValidation& validation)
        {
            if (face == nullptr)
            {
                throw NullArgumentException("ExtractedFace cannot be null");
            }
 
            const std::scoped_lock lock(faceMutex);
 
            auto isValid = validation.Validate(face, fs);
 
            if (isValid)
            {
                DoAddFace(std::move(face));
            }
 
            return isValid;
        }

         */
        void AddFace(std::shared_ptr<ExtractedFace> face)
        {
            if (face == nullptr)
            {
                throw NullArgumentException("Face cannot be null");
            }
 
            const std::scoped_lock lock(faceMutex);
            DoAddFace(std::move(face));
        }

         */
        void AddIris(std::shared_ptr<ExtractedIris> iris)
        {
            if (iris == nullptr)
            {
                throw NullArgumentException("Iris cannot be null");
            }
 
            log.LogInfo("Adding %v", iris);
 
            const std::scoped_lock lock(irisMutex);
            ir.emplace_back(std::move(iris));
        }

         */
        void WriteTo(Writer& writer) const final
        {
            const std::scoped_lock lock(printMutex, faceMutex, irisMutex, slapMutex, thumbsMutex);
 
            writer.WriteArray("ps", ps);
            writer.WriteArray("fs", fs);
            writer.WriteArray("ir", ir);
            writer.WriteArray("ss", ss);
            writer.WriteArray("ts", ts);
        }

         */
        Applicant()
          : log(GlobalLogger::Get())
        {
        }
 
        Applicant(const Applicant&) = delete;
        Applicant(Applicant&&) = delete;
        Applicant& operator=(const Applicant&) = delete;
        Applicant& operator=(Applicant&&) = delete;
        ~Applicant() = default;
 
    private:
        FormattingLogger log;
        mutable std::mutex printMutex;
        mutable std::mutex faceMutex;
        mutable std::mutex irisMutex;
        mutable std::mutex slapMutex;
        mutable std::mutex thumbsMutex;
        std::vector<std::shared_ptr<ExtractedPrint>> ps;
        std::vector<std::shared_ptr<ExtractedFace>> fs;
        std::vector<std::shared_ptr<ExtractedIris>> ir;
        std::vector<std::shared_ptr<SlapCapture>> ss;
        std::vector<std::shared_ptr<ThumbsCapture>> ts;
 
        void DoAddPrint(std::shared_ptr<ExtractedPrint> tmpl)
        {
            log.LogInfo("Adding %v", tmpl->print);
            ps.emplace_back(std::move(tmpl));
        }
 
        void DoAddFace(std::shared_ptr<ExtractedFace> tmpl)
        {
            log.LogInfo("Adding %v", tmpl->face);
            fs.emplace_back(std::move(tmpl));
        }
    };
} // namespace inno