ModalitiesVerifyMatcher.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Applicant.h"
#include "enrollment/Export.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/ModalitiesICSTemplateDefaultFactory.h"
#include "enrollment/ModalitiesMatcher.h"
#include "enrollment/MultiModality/MultiModalityExecutor.h"
#include <array>
#include <vector>
 
namespace inno
{
     */
    class ModalitiesVerifyMatcher : public ModalitiesMatcher
    {
    public:
         */
        class Config : public Serializable
        {
        public:
             */
            void SetMaxRotation(unsigned int value)
            {
                static constexpr unsigned int MaxRotation = 180;
                if (value > MaxRotation)
                {
                    throw EnrollmentInvalidArgumentException("Max rotation MUST be in range <0,180>");
                }
                maxRotation = value;
            }
             */
            [[nodiscard]] unsigned int GetMaxRotation() const
            {
                return maxRotation;
            }
             */
            void WriteTo(Writer& writer) const final
            {
                writer.Write("r", maxRotation);
            }

             */
            static Config Default()
            {
                static const Config Cfg;
                return Cfg;
            }

            Config() = default;
            Config(const Config&) = default;
            Config(Config&&) = default;
            Config& operator=(const Config&) = default;
            Config& operator=(Config&&) = default;
            virtual ~Config() = default;
 
        private:
            static constexpr unsigned int DefaultMaxRotation = 180;
            unsigned int maxRotation = DefaultMaxRotation;
        };

         */
        [[nodiscard]] ModalityScore Match(const Applicant& probe, const Applicant& gallery) const final
        {
            log.LogInfo("Matching applicant probe %v and gallery %v with config %v", probe, gallery, cfg);
            auto probeTemplate = probe.ToTemplate();
            auto galleryTemplate = gallery.ToTemplate();
            auto score = Match(*probeTemplate, *galleryTemplate);
            log.LogInfo("Matching applicant probe %v and gallery %v with score %v", probe, gallery, score);
            return score;
        }

         */
        [[nodiscard]] ModalityScore Match(const ModalitiesTemplate& probe,
                                          const ModalitiesTemplate& gallery) const final
        {
            log.LogInfo("Matching applicant template probe %v and gallery %v with config %v", probe, gallery, cfg);
            auto score = ModalityScore{ MatchFaces(probe.GetFaceTemplates(), gallery.GetFaceTemplates()),
                                        MatchIrises(probe.GetIrisTemplates(), gallery.GetIrisTemplates()),
                                        MatchPrints(probe.GetPrintTemplates(), gallery.GetPrintTemplates()) };
            log.LogInfo("Matching applicant template probe %v and gallery %v with score %v", probe, gallery, score);
            return score;
        }

         */
        [[nodiscard]] virtual PrintSimilarityScore MatchPrints(
          const std::vector<std::shared_ptr<PrintTemplate>>& probe,
          const std::vector<std::shared_ptr<PrintTemplate>>& gallery) const
        {
            int printScore = 0;
            int dummyScore = 0;
 
            const auto factory = ModalitiesICSTemplateDefaultFactory(exec);
            const auto icsProbe = factory.CreateModalitiesICSTemplate(PrintTemplate::ToICSTemplates(probe), {}, {})
                                    ->GetModalitiesICSTemplateData();
            const auto icsGallery = factory.CreateModalitiesICSTemplate(PrintTemplate::ToICSTemplates(gallery), {}, {})
                                      ->GetModalitiesICSTemplateData();
 
            exec->Verify(log.GetLogger(),
                         icsProbe.data(),
                         icsProbe.size(),
                         icsGallery.data(),
                         icsGallery.size(),
                         cfg.GetMaxRotation(),
                         &printScore,
                         &dummyScore,
                         &dummyScore,
                         ThrowOnError{});
 
            return static_cast<PrintSimilarityScore>(printScore);
        }

         */
        [[nodiscard]] static FaceSimilarityScore MatchFaces(const std::vector<std::shared_ptr<FaceTemplate>>& probe,
                                                            const std::vector<std::shared_ptr<FaceTemplate>>& gallery)
        {
            FaceSimilarityScore faceScore = 0;
            for (const auto& probeFace : probe)
            {
                for (const auto& galleryFace : gallery)
                {
                    auto score = probeFace->SimilarWith(*galleryFace);
                    faceScore = std::max(faceScore, score);
                }
            }
            return faceScore;
        }

         */
        [[nodiscard]] static IrisSimilarityScore MatchIrises(const std::vector<std::shared_ptr<IrisTemplate>>& probe,
                                                             const std::vector<std::shared_ptr<IrisTemplate>>& gallery)
        {
            IrisSimilarityScore irisScore = 0;
            IrisSimilarityScore irisLeftScore = 0;
            IrisSimilarityScore irisRightScore = 0;
            IrisSimilarityScore irisUnknownScore = 0;
            unsigned int irisUnknownScoreCount = 0;
            unsigned int irisLeftScoresCount = 0;
            unsigned int irisRightScoresCount = 0;
            for (const auto& probeIris : probe)
            {
                for (const auto& galleryIris : gallery)
                {
                    if (probeIris->IsIrisTemplateBiometricPositionKnown() &&
                        galleryIris->IsIrisTemplateBiometricPositionKnown())
                    {
                        if (probeIris->GetIrisTemplateBiometricPosition() == IrisPosition::LEFT_EYE &&
                            galleryIris->GetIrisTemplateBiometricPosition() == IrisPosition::LEFT_EYE)
                        {
                            auto score = probeIris->SimilarWith(*galleryIris);
                            irisLeftScore = std::max(irisLeftScore, score);
                            irisLeftScoresCount = 1;
                        }
                        if (probeIris->GetIrisTemplateBiometricPosition() == IrisPosition::RIGHT_EYE &&
                            galleryIris->GetIrisTemplateBiometricPosition() == IrisPosition::RIGHT_EYE)
                        {
                            auto score = probeIris->SimilarWith(*galleryIris);
                            irisRightScore = std::max(irisRightScore, score);
                            irisRightScoresCount = 1;
                        }
                    }
                    else
                    {
                        auto score = probeIris->SimilarWith(*galleryIris);
                        irisUnknownScore += score;
                        irisUnknownScoreCount++;
                    }
                }
            }
 
            if (auto scoresCount = irisUnknownScoreCount + irisLeftScoresCount + irisRightScoresCount; scoresCount != 0)
            {
                irisScore = (irisLeftScore + irisRightScore + irisUnknownScore) / scoresCount;
            }
 
            return irisScore;
        }

         */
        ModalitiesVerifyMatcher()
          : cfg(Config::Default())
          , log(GlobalLogger::Get())
          , exec(GlobalMultiModalityExecutor::Get())
        {
        }

         */
        explicit ModalitiesVerifyMatcher(Config config)
          : cfg(std::move(config))
          , log(GlobalLogger::Get())
          , exec(GlobalMultiModalityExecutor::Get())
        {
        }

         */
        ModalitiesVerifyMatcher(Config config, std::shared_ptr<MultiModalityExecutor> executor)
          : cfg(std::move(config))
          , log(GlobalLogger::Get())
          , exec(std::move(executor))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
        }

         */
        ModalitiesVerifyMatcher(Config config,
                                std::shared_ptr<MultiModalityExecutor> executor,
                                std::shared_ptr<Logger> logger)
          : cfg(std::move(config))
          , log(std::move(logger))
          , exec(std::move(executor))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
        }

         */
        explicit ModalitiesVerifyMatcher(std::shared_ptr<MultiModalityExecutor> executor)
          : cfg(Config::Default())
          , log(GlobalLogger::Get())
          , exec(std::move(executor))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
        }
 
        ModalitiesVerifyMatcher(const ModalitiesVerifyMatcher&) = delete;
        ModalitiesVerifyMatcher(ModalitiesVerifyMatcher&&) = delete;
        ModalitiesVerifyMatcher& operator=(const ModalitiesVerifyMatcher&) = delete;
        ModalitiesVerifyMatcher& operator=(ModalitiesVerifyMatcher&&) = delete;
        virtual ~ModalitiesVerifyMatcher() = default;
 
    private:
        Config cfg;
        FormattingLogger log;
        std::shared_ptr<MultiModalityExecutor> exec;
    };
} // namespace inno