EmbeddingVerifyMatcher.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/Print/EmbeddingMatcher.h"
#include "enrollment/Print/EmbeddingTemplate.h"
#include "enrollment/Print/PrintExecutor.h"
#include "enrollment/Serialization/Writer.h"
#include "enrollment/SimilarityScore.h"
#include <array>
#include <memory>
#include <mutex>
#include <vector>
 
namespace inno
{
    class Logger;
     */
    class EmbeddingVerifyMatcher : public EmbeddingMatcher
    {
    public:
         */
        [[nodiscard]] PrintSimilarityScore Match(const EmbeddingTemplate& probe,
                                                 const EmbeddingTemplate& gallery) const final
        {
            log.LogInfo("Matching embeddings probe %v and gallery %v", probe, gallery);
            const CallbackLogger slog(log.GetLogger());
 
            const float score = exec->MatchEmbedding(module.get(),
                                                     probe.embeddingTemplateData.data(),
                                                     static_cast<unsigned int>(probe.embeddingTemplateData.size()),
                                                     gallery.embeddingTemplateData.data(),
                                                     static_cast<unsigned int>(gallery.embeddingTemplateData.size()),
                                                     slog.GetCallbacks(),
                                                     ThrowOnError{});
 
            log.LogInfo("Matching embeddings probe %v and gallery %v with score %f", probe, gallery, score);
            return static_cast<PrintSimilarityScore>(score);
        }

         */
        EmbeddingVerifyMatcher()
          : log(GlobalLogger::Get())
          , exec(GlobalPrintExecutor::Get())
          , module(Initialize())
        {
        }

         */
        explicit EmbeddingVerifyMatcher(std::shared_ptr<PrintExecutor> executor)
          : log(GlobalLogger::Get())
          , exec(std::move(executor))
          , module(Initialize())
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
        }
 
        EmbeddingVerifyMatcher(const EmbeddingVerifyMatcher&) = delete;
        EmbeddingVerifyMatcher(EmbeddingVerifyMatcher&&) = delete;
        EmbeddingVerifyMatcher& operator=(const EmbeddingVerifyMatcher&) = delete;
        EmbeddingVerifyMatcher& operator=(EmbeddingVerifyMatcher&&) = delete;
        virtual ~EmbeddingVerifyMatcher() = default;
 
    private:
        std::unique_ptr<void, inno_Deleter> Initialize()
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
 
            inno_Deleter moduleDeleter = nullptr;
            auto* mod = exec->IFingerCreateMatchingModule(&moduleDeleter, ThrowOnError{});
            std::unique_ptr<void, inno_Deleter> matcherModule(mod, moduleDeleter);
 
            return matcherModule;
        }
 
        FormattingLogger log;
        std::shared_ptr<PrintExecutor> exec;
        std::unique_ptr<void, inno_Deleter> module;
    };
} // namespace inno