IndexedModalitiesGallery.h

Go to the documentation of this file.

 
#pragma once
#include "enrollment/Export.h"
#include "enrollment/ModalitiesTemplate.h"
#include <shared_mutex>
#include <unordered_map>
 
namespace inno
{
    extern "C"
    {
        INNO_ENROLLMENT_API void* inno_local_IndexedModalitiesGallery_Create(inno_Deleter* deleter,
                                                                             uint8_t type,
                                                                             uint64_t threadsCount,
                                                                             ErrorCallbacks errorCallbacks);
        INNO_ENROLLMENT_API void inno_local_IndexedModalitiesGallery_CheckPrintTemplate(void* gallery,
                                                                                        inno_Template print,
                                                                                        ErrorCallbacks errorCallbacks);
        INNO_ENROLLMENT_API void inno_local_IndexedModalitiesGallery_CheckFaceTemplate(void* gallery,
                                                                                       inno_Template face,
                                                                                       ErrorCallbacks errorCallbacks);
        INNO_ENROLLMENT_API void inno_local_IndexedModalitiesGallery_CheckIrisTemplate(void* gallery,
                                                                                       inno_Template iris,
                                                                                       ErrorCallbacks errorCallbacks);
        INNO_ENROLLMENT_API void inno_local_IndexedModalitiesGallery_ReferenceAdd(void* gallery,
                                                                                  size_t id,
                                                                                  inno_Template* prints,
                                                                                  size_t printsSize,
                                                                                  inno_Template* faces,
                                                                                  size_t facesSize,
                                                                                  inno_Template* irises,
                                                                                  size_t irisesSize,
                                                                                  ErrorCallbacks errorCallbacks);
        INNO_ENROLLMENT_API void inno_local_IndexedModalitiesGallery_ReferenceRemove(void* gallery,
                                                                                     size_t id,
                                                                                     ErrorCallbacks errorCallbacks);
        using inno_AllocateIds = size_t* (*)(void*, size_t);
        INNO_ENROLLMENT_API void inno_local_IndexedModalitiesGallery_CandidateFind(void* gallery,
                                                                                   inno_Template* prints,
                                                                                   size_t printsSize,
                                                                                   inno_Template* faces,
                                                                                   size_t facesSize,
                                                                                   inno_Template* irises,
                                                                                   size_t irisesSize,
                                                                                   inno_AllocateIds allocator,
                                                                                   void* printsCandidates,
                                                                                   void* facesCandidates,
                                                                                   void* irisesCandidates,
                                                                                   size_t bestCandidatesCount,
                                                                                   ErrorCallbacks errorCallbacks);
    }

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

     */
    class IndexedModalitiesGalleryConfig : 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(IndexedModalitiesGalleryType value)
        {
            switch (value)
            {
            case IndexedModalitiesGalleryType::PRINT_ICS_TEMPLATE:
            case IndexedModalitiesGalleryType::PRINT_EMBEDDING:
                type = value;
                return;
            }
            throw EnrollmentInvalidArgumentException("Type " + std::to_string(static_cast<int>(value)) +
                                                     " of IndexedModalitiesGallery is unknown");
        }

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

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("tc", threads);
            writer.Write("t", static_cast<int>(type));
        }

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

     */
    class IndexedModalitiesGallery
    {
    public:
        using Identifier = size_t;
         */
        static std::shared_ptr<IndexedModalitiesGallery> Create(IndexedModalitiesGalleryConfig config)
        {
            return std::shared_ptr<IndexedModalitiesGallery>(new IndexedModalitiesGallery(std::move(config)));
        }

         */
        virtual void Add(Identifier identifier, const std::shared_ptr<ModalitiesTemplate>& templ)
        {
            if (templ == nullptr)
            {
                throw NullArgumentException("Reference template cannot be null");
            }
 
            auto [prints, faces, irises] = ConvertToInnoTemplates(templ);
 
            inno_local_IndexedModalitiesGallery_ReferenceAdd(impl.get(),
                                                             identifier,
                                                             prints.data(),
                                                             prints.size(),
                                                             faces.data(),
                                                             faces.size(),
                                                             irises.data(),
                                                             irises.size(),
                                                             ThrowOnError{});
        }

         */
        virtual void Remove(Identifier identifier)
        {
            inno_local_IndexedModalitiesGallery_ReferenceRemove(impl.get(), identifier, ThrowOnError{});
        }

         */
        class ModalitiesIdentifiers
        {
        public:
             */
            [[nodiscard]] std::vector<Identifier> GetPrintIdentifiers() const
            {
                return prints;
            }
             */
            [[nodiscard]] std::vector<Identifier> GetFaceIdentifiers() const
            {
                return faces;
            }
             */
            [[nodiscard]] std::vector<Identifier> GetIrisIdentifiers() const
            {
                return irises;
            }
 
            ModalitiesIdentifiers(std::vector<Identifier> ps, std::vector<Identifier> fs, std::vector<Identifier> is)
              : prints(std::move(ps))
              , faces(std::move(fs))
              , irises(std::move(is))
            {
            }
            ModalitiesIdentifiers() = delete;
 
        private:
            std::vector<Identifier> prints;
            std::vector<Identifier> faces;
            std::vector<Identifier> irises;
        };

         */
        [[nodiscard]] virtual std::shared_ptr<ModalitiesIdentifiers> IdentifyModalities(
          const std::shared_ptr<ModalitiesTemplate>& probe,
          size_t maxCandidates) const
        {
            auto [prints, faces, irises] = ConvertToInnoTemplates(probe);
 
            std::vector<Identifier> printIds;
            std::vector<Identifier> faceIds;
            std::vector<Identifier> irisIds;
            auto idsAllocator = +[](void* container, size_t length) -> size_t*
            {
                std::vector<Identifier>& vec = *static_cast<std::vector<Identifier>*>(container);
                vec.resize(length);
                return vec.data();
            };
 
            inno_local_IndexedModalitiesGallery_CandidateFind(impl.get(),
                                                              prints.data(),
                                                              prints.size(),
                                                              faces.data(),
                                                              faces.size(),
                                                              irises.data(),
                                                              irises.size(),
                                                              idsAllocator,
                                                              &printIds,
                                                              &faceIds,
                                                              &irisIds,
                                                              maxCandidates,
                                                              ThrowOnError{});
 
            return std::make_shared<ModalitiesIdentifiers>(std::move(printIds), std::move(faceIds), std::move(irisIds));
        }
 
        IndexedModalitiesGallery(const IndexedModalitiesGallery&) = delete;
        IndexedModalitiesGallery(IndexedModalitiesGallery&&) = delete;
        IndexedModalitiesGallery& operator=(const IndexedModalitiesGallery&) = delete;
        IndexedModalitiesGallery& operator=(IndexedModalitiesGallery&&) = delete;
        virtual ~IndexedModalitiesGallery() = default;
 
    private:
        IndexedModalitiesGalleryConfig c;
 
        explicit IndexedModalitiesGallery(IndexedModalitiesGalleryConfig config)
          : c(std::move(config))
          , impl(CreateImpl(c.GetGalleryType(), c.GetThreadCount()))
 
        {
        }
 
        [[nodiscard]] std::tuple<std::vector<inno_Template>, std::vector<inno_Template>, std::vector<inno_Template>>
        ConvertToInnoTemplates(const std::shared_ptr<ModalitiesTemplate>& tmpl) const
        {
            if (tmpl == nullptr)
            {
                throw NullArgumentException("Null template cannot be processed by gallery");
            }
            auto printTemplates = tmpl->GetPrintTemplates();
            auto prints = c.GetGalleryType() == IndexedModalitiesGalleryType::PRINT_EMBEDDING
                            ? inno_Template::FromTemplates(PrintTemplate::ToEmbeddingTemplates(printTemplates))
                            : inno_Template::FromTemplates(PrintTemplate::ToICSTemplates(printTemplates));
            std::for_each(prints.begin(),
                          prints.end(),
                          [&](auto& t)
                          { inno_local_IndexedModalitiesGallery_CheckPrintTemplate(impl.get(), t, ThrowOnError{}); });
 
            auto faceTemplates = tmpl->GetFaceTemplates();
            auto faces = inno_Template::FromTemplates(faceTemplates);
            std::for_each(faces.begin(),
                          faces.end(),
                          [&](auto& t)
                          { inno_local_IndexedModalitiesGallery_CheckFaceTemplate(impl.get(), t, ThrowOnError{}); });
 
            auto irisTemplates = tmpl->GetIrisTemplates();
            auto irises = inno_Template::FromTemplates(irisTemplates);
            std::for_each(irises.begin(),
                          irises.end(),
                          [&](auto& t)
                          { inno_local_IndexedModalitiesGallery_CheckIrisTemplate(impl.get(), t, ThrowOnError{}); });
 
            return { prints, faces, irises };
        }
 
        static std::unique_ptr<void, inno_Deleter> CreateImpl(IndexedModalitiesGalleryType type, size_t threadsCount)
        {
            inno_Deleter deleter = {};
 
            auto* i = inno_local_IndexedModalitiesGallery_Create(
              &deleter, static_cast<uint8_t>(type), static_cast<uint64_t>(threadsCount), ThrowOnError{});
 
            return { i, deleter };
        }
 
        std::unique_ptr<void, inno_Deleter> impl;
    };
} // namespace inno