ModalitiesGallery.h

Go to the documentation of this file.

 
#pragma once
#include "enrollment/Export.h"
#include "enrollment/IndexedModalitiesGallery.h"
#include "enrollment/ModalitiesTemplate.h"
#include "enrollment/ModalitiesVerifyMatcher.h"
#include "enrollment/Print/PrintExecutor.h"
#include "enrollment/SimilarityScore.h"
#include <shared_mutex>
#include <unordered_map>
 
namespace inno
{
     */
    class ModalitiesGalleryReference
    {
    public:
        [[nodiscard]] virtual std::shared_ptr<ModalitiesTemplate> GetModalitiesTemplates() const = 0;

        [[nodiscard]] virtual size_t GetIndex() const = 0;
 
        ModalitiesGalleryReference() = default;
        virtual ~ModalitiesGalleryReference() = default;
        ModalitiesGalleryReference(const ModalitiesGalleryReference&) = default;
        ModalitiesGalleryReference(ModalitiesGalleryReference&&) = default;
        ModalitiesGalleryReference& operator=(const ModalitiesGalleryReference&) = default;
        ModalitiesGalleryReference& operator=(ModalitiesGalleryReference&&) = default;
    };

     */
    class ModalitiesGalleryIndexedTemplate : public ModalitiesGalleryReference
    {
    public:
         */
        [[nodiscard]] size_t GetIndex() const final
        {
            return i;
        }
         */
        [[nodiscard]] std::shared_ptr<ModalitiesTemplate> GetModalitiesTemplates() const final
        {
            return c;
        }

         */
        static std::shared_ptr<ModalitiesGalleryIndexedTemplate> Downcast(
          std::shared_ptr<ModalitiesGalleryReference>& reference)
        {
            return std::dynamic_pointer_cast<ModalitiesGalleryIndexedTemplate>(reference);
        }

         */
        ModalitiesGalleryIndexedTemplate(size_t index, std::shared_ptr<ModalitiesTemplate> reference)
          : i(index)
          , c(std::move(reference))
        {
        }
 
    private:
        size_t i = {};
        std::shared_ptr<ModalitiesTemplate> c;
    };

     */
    enum class ModalitiesGalleryType : uint8_t
    {
        PRINT_ICS_TEMPLATE = 0,
        PRINT_EMBEDDING = 1
 
    };

     */
    class ModalitiesGalleryConfig : public Serializable
    {
    public:
         */
        void SetThreadsCount(unsigned int value)
        {
            if (value == 0)
            {
                throw EnrollmentInvalidArgumentException("Number of gallery threads MUST be > 0");
            }
            threads = value;
        }

         */
        [[nodiscard]] unsigned int GetThreadCount() const
        {
            return threads;
        }

         */
        void SetGalleryType(ModalitiesGalleryType value)
        {
            switch (value)
            {
            case ModalitiesGalleryType::PRINT_ICS_TEMPLATE:
            case ModalitiesGalleryType::PRINT_EMBEDDING:
                type = value;
                return;
            }
            throw EnrollmentInvalidArgumentException("Type " + std::to_string(static_cast<int>(value)) +
                                                     " of Modalities Gallery is unknown");
        }

         */
        [[nodiscard]] ModalitiesGalleryType GetGalleryType() const
        {
            return type;
        }

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("tc", threads);
            writer.Write("t", static_cast<int>(type));
        }
         */
        [[nodiscard]] IndexedModalitiesGalleryConfig ToIndexedModalitiesGalleryConfig() const
        {
            IndexedModalitiesGalleryConfig cfg;
            switch (type)
            {
            case ModalitiesGalleryType::PRINT_ICS_TEMPLATE:
                cfg.SetGalleryType(IndexedModalitiesGalleryType::PRINT_ICS_TEMPLATE);
                break;
            case ModalitiesGalleryType::PRINT_EMBEDDING:
                cfg.SetGalleryType(IndexedModalitiesGalleryType::PRINT_EMBEDDING);
                break;
            }
            cfg.SetThreadsCount(threads);
            return cfg;
        }

        ModalitiesGalleryConfig() = default;
 
    private:
        static constexpr unsigned int DefaultThreads = 1;
        unsigned int threads = DefaultThreads;
        static constexpr ModalitiesGalleryType DefaultType = ModalitiesGalleryType::PRINT_ICS_TEMPLATE;
        ModalitiesGalleryType type = DefaultType;
    };

     */
    class ModalitiesGallery
    {
    public:
         */
        static std::shared_ptr<ModalitiesGallery> Create()
        {
            return std::shared_ptr<ModalitiesGallery>(new ModalitiesGallery(IndexedModalitiesGallery::Create({})));
        }

         */
        static std::shared_ptr<ModalitiesGallery> Create(ModalitiesGalleryType type)
        {
            auto config = ModalitiesGalleryConfig{};
            config.SetGalleryType(type);
            return std::shared_ptr<ModalitiesGallery>(
              new ModalitiesGallery(IndexedModalitiesGallery::Create(config.ToIndexedModalitiesGalleryConfig())));
        }

         */
        static std::shared_ptr<ModalitiesGallery> Create(const ModalitiesGalleryConfig& config)
        {
            return std::shared_ptr<ModalitiesGallery>(
              new ModalitiesGallery(IndexedModalitiesGallery::Create(config.ToIndexedModalitiesGalleryConfig())));
        }

         */
        void Add(std::shared_ptr<ModalitiesGalleryReference> reference)
        {
            if (reference == nullptr)
            {
                throw NullArgumentException("Reference cannot be null");
            }
 
            const auto id = reference->GetIndex();
 
            // Next operations must be exclusively locked to do not modify gallery during find operations
            // Lock MUST be here to ensure that this gallery and underlying gallery has same reference
            const std::unique_lock lock(mux);
            gallery->Add(id, reference->GetModalitiesTemplates());
            references[id] = std::move(reference);
        }

         */
        void Remove(size_t index)
        {
            // Next operations must be exclusively locked to do not modify gallery during find operations
            // Lock MUST be here to ensure that this gallery and underlying gallery has same reference
            const std::unique_lock lock(mux);
            gallery->Remove(index);
            references.erase(index);
        }

         */
        class ModalitiesCandidates
        {
        public:
             */
            [[nodiscard]] std::vector<std::shared_ptr<ModalitiesGalleryReference>> GetPrintCandidates() const
            {
                return prints;
            }
             */
            [[nodiscard]] std::vector<std::shared_ptr<ModalitiesGalleryReference>> GetFaceCandidates() const
            {
                return faces;
            }
             */
            [[nodiscard]] std::vector<std::shared_ptr<ModalitiesGalleryReference>> GetIrisCandidates() const
            {
                return irises;
            }
             */
            [[nodiscard]] std::shared_ptr<ModalitiesTemplate> GetProbe() const
            {
                return p;
            }
 
            ModalitiesCandidates(std::vector<std::shared_ptr<ModalitiesGalleryReference>> ps,
                                 std::vector<std::shared_ptr<ModalitiesGalleryReference>> fs,
                                 std::vector<std::shared_ptr<ModalitiesGalleryReference>> is,
                                 std::shared_ptr<ModalitiesTemplate> probe)
              : prints(std::move(ps))
              , faces(std::move(fs))
              , irises(std::move(is))
              , p(std::move(probe))
            {
            }
            ModalitiesCandidates() = delete;
            ~ModalitiesCandidates() = default;
            ModalitiesCandidates(const ModalitiesCandidates&) = default;
            ModalitiesCandidates(ModalitiesCandidates&&) = default;
            ModalitiesCandidates& operator=(const ModalitiesCandidates&) = default;
            ModalitiesCandidates& operator=(ModalitiesCandidates&&) = default;
 
        private:
            std::vector<std::shared_ptr<ModalitiesGalleryReference>> prints;
            std::vector<std::shared_ptr<ModalitiesGalleryReference>> faces;
            std::vector<std::shared_ptr<ModalitiesGalleryReference>> irises;
            std::shared_ptr<ModalitiesTemplate> p;
        };

         */
        [[nodiscard]] std::shared_ptr<ModalitiesCandidates> IdentifyModalities(
          const std::shared_ptr<ModalitiesTemplate>& probe,
          size_t maxCandidates) const
        {
            // Next operations must be shared locked to not allow modification of gallery, but allow calling this
            // function from more threads without locking
            const std::shared_lock lock(mux);
 
            auto modalityIdentifiers = gallery->IdentifyModalities(probe, maxCandidates);
            const auto& printIds = modalityIdentifiers->GetPrintIdentifiers();
            std::vector<std::shared_ptr<ModalitiesGalleryReference>> pc(printIds.size());
            std::transform(
              printIds.begin(), printIds.end(), pc.begin(), [&](const auto& t) { return references.at(t); });
            const auto& faceIds = modalityIdentifiers->GetFaceIdentifiers();
            std::vector<std::shared_ptr<ModalitiesGalleryReference>> fc(faceIds.size());
            std::transform(faceIds.begin(), faceIds.end(), fc.begin(), [&](const auto& t) { return references.at(t); });
            const auto& irisIds = modalityIdentifiers->GetIrisIdentifiers();
            std::vector<std::shared_ptr<ModalitiesGalleryReference>> ic(irisIds.size());
            std::transform(irisIds.begin(), irisIds.end(), ic.begin(), [&](const auto& t) { return references.at(t); });
 
            return std::make_shared<ModalitiesCandidates>(std::move(pc), std::move(fc), std::move(ic), probe);
        }

         */
        class Candidate
        {
        public:
             */
            [[nodiscard]] std::shared_ptr<ModalitiesGalleryReference> GetCandidate() const
            {
                return c;
            }
             */
            [[nodiscard]] ModalityScore GetScore() const
            {
                return s;
            }
 
            Candidate() = default;
            Candidate(std::shared_ptr<ModalitiesGalleryReference> candidate, ModalityScore score)
              : c(std::move(candidate))
              , s(std::move(score))
            {
            }
            ~Candidate() = default;
            Candidate(const Candidate&) = default;
            Candidate(Candidate&&) = default;
            Candidate& operator=(const Candidate&) = default;
            Candidate& operator=(Candidate&&) = default;
 
        private:
            std::shared_ptr<ModalitiesGalleryReference> c;
            ModalityScore s;
        };

         */
        static std::vector<Candidate> Consolidate(
          const std::shared_ptr<ModalitiesCandidates>& identifiedModalityCandidates,
          size_t maxCandidates)
        {
            const ModalitiesVerifyMatcher::Config cfg = {};
            const ModalitiesVerifyMatcher matcher = { cfg,
                                                      GlobalMultiModalityExecutor::Get(),
                                                      // Disable logging to make consolidation faster
                                                      std::make_shared<NullLogger>() };
 
            const auto& probe = identifiedModalityCandidates->GetProbe();
            const auto& probePrints = probe->GetPrintTemplates();
            if (!std::all_of(probePrints.begin(),
                             probePrints.end(),
                             [](const auto& print) { return print->HasIcsRepresentation(); }))
            {
                throw EnrollmentRuntimeException("All prints of the probe must contain ICS representation");
            }
            for (const auto& c : identifiedModalityCandidates->GetPrintCandidates())
            {
                const auto& candidate = c->GetModalitiesTemplates();
                const auto& candidatePrints = candidate->GetPrintTemplates();
                if (std::any_of(candidatePrints.begin(),
                                candidatePrints.end(),
                                [](const auto& print) { return !print->HasIcsRepresentation(); }))
                {
                    throw EnrollmentRuntimeException("All candidates prints must contain ICS representation");
                }
            }
 
            return Consolidate(identifiedModalityCandidates, maxCandidates, matcher);
        }
         */
        static std::vector<Candidate> Consolidate(
          const std::shared_ptr<ModalitiesCandidates>& identifiedModalityCandidates,
          size_t maxCandidates,
          const ModalitiesMatcher& matcher)
        {
            std::unordered_map<size_t, std::shared_ptr<ModalitiesGalleryReference>> uniqueCandidates;
 
            for (const auto& c : identifiedModalityCandidates->GetPrintCandidates())
            {
                uniqueCandidates[c->GetIndex()] = c;
            }
            for (const auto& c : identifiedModalityCandidates->GetFaceCandidates())
            {
                uniqueCandidates[c->GetIndex()] = c;
            }
            for (const auto& c : identifiedModalityCandidates->GetIrisCandidates())
            {
                uniqueCandidates[c->GetIndex()] = c;
            }
 
            const auto& probe = identifiedModalityCandidates->GetProbe();
 
            std::vector<Candidate> result;
            for (const auto& [_, c] : uniqueCandidates)
            {
                const auto& candidate = c->GetModalitiesTemplates();
                auto score = probe->SimilarWith(*candidate, matcher);
                result.emplace_back(c, score);
            }
 
            std::sort(
              result.begin(),
              result.end(),
              [](const auto& a, const auto& b)
              {
                  auto as = a.GetScore();
                  auto bs = b.GetScore();
                  constexpr unsigned int FaceNormalizerConstant = 10;
                  return std::max(
                           { as.GetPrintScore(), as.GetFaceScore() * FaceNormalizerConstant, as.GetIrisScore() }) >
                         std::max(
                           { bs.GetPrintScore(), bs.GetFaceScore() * FaceNormalizerConstant, bs.GetIrisScore() });
              });
 
            if (result.size() > maxCandidates)
            {
                result.resize(maxCandidates);
            }
 
            return result;
        }

         */
        [[nodiscard]] std::vector<Candidate> Identify(const std::shared_ptr<ModalitiesTemplate>& probe,
                                                      size_t maxCandidates) const
        {
            auto modalitiesCandidates = IdentifyModalities(probe, maxCandidates);
            return Consolidate(modalitiesCandidates, maxCandidates, consolidateMatcher);
        }
 
        ModalitiesGallery(const ModalitiesGallery&) = delete;
        ModalitiesGallery(ModalitiesGallery&&) = delete;
        ModalitiesGallery& operator=(const ModalitiesGallery&) = delete;
        ModalitiesGallery& operator=(ModalitiesGallery&&) = delete;
        virtual ~ModalitiesGallery() = default;
 
    private:
        mutable std::shared_mutex mux;
        std::shared_ptr<IndexedModalitiesGallery> gallery;
 
        explicit ModalitiesGallery(std::shared_ptr<IndexedModalitiesGallery> g)
          : gallery(std::move(g))
        {
        }
 
        std::unordered_map<size_t, std::shared_ptr<ModalitiesGalleryReference>> references;
        ModalitiesVerifyMatcher::Config matcherConfig;
        ModalitiesVerifyMatcher consolidateMatcher = { matcherConfig,
                                                       GlobalMultiModalityExecutor::Get(),
                                                       // Disable logging to make consolidation faster
                                                       std::make_shared<NullLogger>() };
    };
} // namespace inno