ModalitiesEmbeddingVerifyMatcher.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/ModalitiesTemplate.h"
#include "enrollment/ModalitiesVerifyMatcher.h"
#include "enrollment/Print/EmbeddingVerifyMatcher.h"
#include "enrollment/Print/PrintExecutor.h"
#include "enrollment/Serialization/Writer.h"
#include "enrollment/SimilarityScore.h"
#include <array>
#include <memory>
#include <mutex>
#include <unordered_map>
#include <vector>
 
namespace inno
{
    class Logger;
     */
    class ModalitiesEmbeddingVerifyMatcher : public ModalitiesVerifyMatcher
    {
    public:
         */
        [[nodiscard]] PrintSimilarityScore MatchPrints(
          const std::vector<std::shared_ptr<PrintTemplate>>& probe,
          const std::vector<std::shared_ptr<PrintTemplate>>& gallery) const final
        {
            log.LogInfo("Matching embedding probe %v and gallery %v", probe, gallery);
 
            auto probeEmbeddings = PrintTemplate::ToEmbeddingTemplates(probe);
            auto galleryEmbeddings = PrintTemplate::ToEmbeddingTemplates(gallery);
 
            using Position = int;
            constexpr Position Unknown = -1;
 
            std::unordered_map<Position, PrintSimilarityScore> scoreOnPosition;
 
            for (const auto& pe : probeEmbeddings)
            {
                if (pe == nullptr)
                {
                    continue;
                }
                std::optional<Position> probePos;
                if (pe->IsEmbeddingTemplateBiometricPositionKnown())
                {
                    probePos = static_cast<Position>(pe->GetEmbeddingTemplateBiometricPosition());
                }
                for (const auto& ge : galleryEmbeddings)
                {
                    if (ge == nullptr)
                    {
                        continue;
                    }
                    std::optional<Position> galleryPos;
                    if (ge->IsEmbeddingTemplateBiometricPositionKnown())
                    {
                        galleryPos = static_cast<Position>(ge->GetEmbeddingTemplateBiometricPosition());
                    }
                    const bool probeIsUnknown = !probePos.has_value();
                    const bool galleryIsUnknown = !galleryPos.has_value();
                    if (probeIsUnknown || galleryIsUnknown || probePos == galleryPos)
                    {
                        const PrintSimilarityScore s = pe->SimilarWith(*ge, matcher);
                        const auto p = probePos.value_or(Unknown);
                        scoreOnPosition[p] = std::max(scoreOnPosition[p], s);
                    }
                }
            }
            double scoreSum = 0;
            for (const auto& [_, score] : scoreOnPosition)
            {
                scoreSum += score;
            }
            PrintSimilarityScore averageScore = 0;
            if (!scoreOnPosition.empty())
            {
                averageScore =
                  static_cast<PrintSimilarityScore>(scoreSum / static_cast<double>(scoreOnPosition.size()));
            }
 
            log.LogInfo("Matching embedding probe %v and gallery %v with score %d", probe, gallery, averageScore);
 
            return averageScore;
        }

         */
        ModalitiesEmbeddingVerifyMatcher()
          : log(GlobalLogger::Get())
          , exec(GlobalMultiModalityExecutor::Get())
        {
        }

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