ICSVerifyMatcher.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/Print/ICSMatcher.h"
#include "enrollment/Print/ICSTemplate.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 ICSVerifyMatcher : public ICSMatcher
    {
    public:
         */
        class Artifact
        {
        private:
            virtual void ConfigureMatchingParameters(const ICSTemplate& probe,
                                                     const ICSTemplate& gallery,
                                                     inno_ICSVerifyMatcher_params& params) = 0;
            virtual void OnCreated() = 0;
            virtual void CheckCompatibility(inno_ICSVerifyMatcher_params& params) = 0;
 
        public:
            Artifact() = default;
            Artifact(const Artifact&) = delete;
            Artifact(Artifact&&) = delete;
            Artifact& operator=(const Artifact&) = delete;
            Artifact& operator=(Artifact&& c) = delete;
            virtual ~Artifact() = default;
 
            friend class ICSVerifyMatcher;
        };

         */
        class Artifacts : public Artifact
        {
        public:
             */
            void Add(Artifact& artifact)
            {
                const std::lock_guard lock(artifactsMux);
 
                if (isMatchingInProgress)
                {
                    throw EnrollmentRuntimeException("cannot add artifact during matching");
                }
 
                inno_ICSVerifyMatcher_params param = {};
 
                for (auto* a : artifacts)
                {
                    a->CheckCompatibility(param);
                }
 
                // when not compatible then it will throw
                artifact.CheckCompatibility(param);
 
                artifacts.emplace_back(&artifact);
            }
 
        private:
            void ConfigureMatchingParameters(const ICSTemplate& probe,
                                             const ICSTemplate& gallery,
                                             inno_ICSVerifyMatcher_params& params) final
            {
                const std::lock_guard lock(artifactsMux);
 
                for (auto* a : artifacts)
                {
                    a->ConfigureMatchingParameters(probe, gallery, params);
                }
 
                isMatchingInProgress = true;
            }
 
            void OnCreated() final
            {
                const std::lock_guard lock(artifactsMux);
 
                for (auto* a : artifacts)
                {
                    a->OnCreated();
                }
 
                isMatchingInProgress = false;
            }
 
            void CheckCompatibility(inno_ICSVerifyMatcher_params& params) final
            {
                const std::lock_guard lock(artifactsMux);
 
                for (auto* a : artifacts)
                {
                    a->CheckCompatibility(params);
                }
            }
 
            std::vector<Artifact*> artifacts;
            std::mutex artifactsMux;
            bool isMatchingInProgress = false;
 
        public:
            Artifacts() = default;
            Artifacts(const Artifacts&) = delete;
            Artifacts(Artifacts&&) = delete;
            Artifacts& operator=(const Artifacts&) = delete;
            Artifacts& operator=(Artifacts&& c) = delete;
            virtual ~Artifacts() = default;
        };

         */
        class MatchingMinutiae : public Artifact
        {
        public:
             */
            std::vector<std::shared_ptr<Minutia>> GetProbeMinutiae() const
            {
                const std::scoped_lock lock(dataMux);
 
                if (isMatchingInProgress)
                {
                    throw EnrollmentRuntimeException("matching in progress, cannot get probe minutiae");
                }
 
                return probe;
            }
             */
            std::vector<std::shared_ptr<Minutia>> GetGalleryMinutiae() const
            {
                const std::scoped_lock lock(dataMux);
 
                if (isMatchingInProgress)
                {
                    throw EnrollmentRuntimeException("matching in progress, cannot get gallery minutiae");
                }
 
                return gallery;
            }
 
            MatchingMinutiae() = default;
            MatchingMinutiae(const MatchingMinutiae&) = delete;
            MatchingMinutiae(MatchingMinutiae&&) = delete;
            MatchingMinutiae& operator=(const MatchingMinutiae&) = delete;
            MatchingMinutiae& operator=(MatchingMinutiae&& c) = delete;
            virtual ~MatchingMinutiae() = default;
 
        private:
            std::vector<std::shared_ptr<Minutia>> probe;
            std::vector<uint16_t> matchingProbeIndices;
            std::vector<std::shared_ptr<Minutia>> gallery;
            std::vector<uint16_t> matchingGalleryIndices;
            int maxMatchingMinutiae = 0;
            mutable std::mutex dataMux;
            bool isMatchingInProgress = false;
 
            void ConfigureMatchingParameters(const ICSTemplate& probeTemplate,
                                             const ICSTemplate& galleryTemplate,
                                             inno_ICSVerifyMatcher_params& params) final
            {
                const std::scoped_lock lock(dataMux);
 
                if (isMatchingInProgress)
                {
                    throw EnrollmentRuntimeException("matching minutiae already used in matching");
                }
 
                isMatchingInProgress = true;
 
                probe = probeTemplate.GetMinutiae();
                gallery = galleryTemplate.GetMinutiae();
                // It is not possible to have more matching minutiae than number of minutiae in probe or gallery
                maxMatchingMinutiae = static_cast<int>(std::min(probe.size(), gallery.size()));
                matchingProbeIndices.resize(maxMatchingMinutiae);
                matchingGalleryIndices.resize(maxMatchingMinutiae);
 
                params.assocGalleryMinutiae = matchingGalleryIndices.data();
                params.assocProbeMinutiae = matchingProbeIndices.data();
                params.associationCount = &maxMatchingMinutiae;
            }
 
            void OnCreated() final
            {
                const std::scoped_lock lock(dataMux);
 
                // reorder according to matching indices
                std::vector<std::shared_ptr<Minutia>> reorderedMinutiae;
                // maxMatchingMinutiae is modified by IEngine during matching and contains actual (not max) number of
                // matching minutiae
                reorderedMinutiae.reserve(maxMatchingMinutiae);
                for (int i = 0; i < maxMatchingMinutiae; ++i)
                {
                    reorderedMinutiae.emplace_back(probe[matchingProbeIndices[i]]);
                }
                std::swap(probe, reorderedMinutiae);
 
                reorderedMinutiae.clear();
                reorderedMinutiae.reserve(maxMatchingMinutiae);
                for (int i = 0; i < maxMatchingMinutiae; ++i)
                {
                    reorderedMinutiae.emplace_back(gallery[matchingGalleryIndices[i]]);
                }
                std::swap(gallery, reorderedMinutiae);
 
                isMatchingInProgress = false;
            }
 
            void CheckCompatibility(inno_ICSVerifyMatcher_params& params) final
            {
                if (params.assocGalleryMinutiae != nullptr || params.associationCount != nullptr ||
                    params.assocProbeMinutiae != nullptr)
                {
                    throw EnrollmentRuntimeException("matching minutiae artifact is already enabled");
                }
 
                static uint16_t c = 0;
                static int d = 0;
 
                params.assocGalleryMinutiae = &c;
                params.assocProbeMinutiae = &c;
                params.associationCount = &d;
            }
        };

         */
        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]] PrintSimilarityScore Match(const ICSTemplate& probe, const ICSTemplate& gallery) const final
        {
            auto nullArtifact = NullArtifact();
            return Match(probe, gallery, nullArtifact);
        }

         */
        [[nodiscard]] PrintSimilarityScore Match(const ICSTemplate& probe,
                                                 const ICSTemplate& gallery,
                                                 Artifact& artifact) const
        {
            log.LogInfo("Matching prints probe %v and gallery %v with config %v", probe, gallery, cfg);
            const CallbackLogger slog(log.GetLogger());
            inno_ICSVerifyMatcher_params params = {};
            params.galleryData = gallery.icsTemplateData.data();
            params.gallerySize = gallery.icsTemplateData.size();
            params.probeData = probe.icsTemplateData.data();
            params.probeSize = probe.icsTemplateData.size();
            params.speed = 0;
            params.maxRotation = static_cast<int>(cfg.GetMaxRotation());
 
            artifact.ConfigureMatchingParameters(probe, gallery, params);
 
            exec->MatchICS(&params, slog.GetCallbacks(), ThrowOnError{});
 
            artifact.OnCreated();
 
            log.LogInfo("Matching prints probe %v and gallery %v with score %d", probe, gallery, params.score);
            return params.score;
        }

         */
        ICSVerifyMatcher()
          : cfg(Config::Default())
          , log(GlobalLogger::Get())
          , exec(GlobalPrintExecutor::Get())
        {
        }

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

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

         */
        explicit ICSVerifyMatcher(std::shared_ptr<PrintExecutor> executor)
          : cfg(Config::Default())
          , log(GlobalLogger::Get())
          , exec(std::move(executor))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
        }
 
        ICSVerifyMatcher(const ICSVerifyMatcher&) = delete;
        ICSVerifyMatcher(ICSVerifyMatcher&&) = delete;
        ICSVerifyMatcher& operator=(const ICSVerifyMatcher&) = delete;
        ICSVerifyMatcher& operator=(ICSVerifyMatcher&&) = delete;
        virtual ~ICSVerifyMatcher() = default;
 
    private:
        Config cfg;
        FormattingLogger log;
        std::shared_ptr<PrintExecutor> exec;
 
        class NullArtifact final : public Artifact
        {
        private:
            void ConfigureMatchingParameters(const ICSTemplate& /* probe */,
                                             const ICSTemplate& /* gallery */,
                                             inno_ICSVerifyMatcher_params& /* params */) final
            {
            }
            void OnCreated() final
            {
            }
            void CheckCompatibility(inno_ICSVerifyMatcher_params& /*params*/) final
            {
            }
 
        public:
            NullArtifact() = default;
            NullArtifact(const NullArtifact&) = delete;
            NullArtifact(NullArtifact&&) = delete;
            NullArtifact& operator=(const NullArtifact&) = delete;
            NullArtifact& operator=(NullArtifact&& c) = delete;
            virtual ~NullArtifact() = default;
        };
    };
} // namespace inno