MultiModalityExecutor.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Face/Face.h"
#include "enrollment/Iris/Iris.h"
#include "enrollment/Logger/Logger.h"
#include "enrollment/Print/ICSTemplate.h"
#include "enrollment/Print/PrintTemplate.h"
#include <algorithm>
#include <cstdint>
#include <memory>
#include <vector>
 
namespace inno
{
// See doc/Main.markdown "Header and Binary parts" for reason why we use pragma pack 1
#pragma pack(push, 1)
    struct INNO_ENROLLMENT_API inno_Template
    {
        static constexpr int NotExistingPosition = 0;
 
        static std::vector<inno_Template> FromTemplates(const std::vector<std::shared_ptr<FaceTemplate>>& ft)
        {
            std::vector<inno_Template> transformedTemplates(ft.size());
            std::transform(
              ft.begin(),
              ft.end(),
              transformedTemplates.begin(),
              [](const auto& t)
              {
                  if (t == nullptr)
                  {
                      return inno_Template{ 0, nullptr, inno_Template::NotExistingPosition };
                  }
                  return inno_Template{ t->data.size(), t->data.data(), inno_Template::NotExistingPosition };
              });
            return transformedTemplates;
        }
        static std::vector<inno_Template> FromTemplates(const std::vector<std::shared_ptr<IrisTemplate>>& it)
        {
            std::vector<inno_Template> transformedTemplates(it.size());
            std::transform(
              it.begin(),
              it.end(),
              transformedTemplates.begin(),
              [](const auto& t)
              {
                  if (t == nullptr)
                  {
                      return inno_Template{ 0, nullptr, inno_Template::NotExistingPosition };
                  }
                  return inno_Template{ t->data.size(),
                                        t->data.data(),
                                        t->IsIrisTemplateBiometricPositionKnown()
                                          ? IrisPositionToIsoPosition(t->GetIrisTemplateBiometricPosition())
                                          : NotExistingPosition };
              });
            return transformedTemplates;
        }
        static std::vector<inno_Template> FromTemplates(const std::vector<std::shared_ptr<ICSTemplate>>& pt)
        {
            std::vector<inno_Template> transformedTemplates(pt.size());
            std::transform(pt.begin(),
                           pt.end(),
                           transformedTemplates.begin(),
                           [](const auto& t)
                           {
                               if (t == nullptr)
                               {
                                   return inno_Template{ 0, nullptr, inno_Template::NotExistingPosition };
                               }
                               return inno_Template{ t->icsTemplateData.size(),
                                                     t->icsTemplateData.data(),
                                                     t->IsICSTemplateBiometricPositionKnown()
                                                       ? PrintToIsoPosition(t->GetICSTemplateBiometricPosition())
                                                       : NotExistingPosition };
                           });
            return transformedTemplates;
        }
        static std::vector<inno_Template> FromTemplates(const std::vector<std::shared_ptr<EmbeddingTemplate>>& pt)
        {
            std::vector<inno_Template> transformedTemplates(pt.size());
            std::transform(pt.begin(),
                           pt.end(),
                           transformedTemplates.begin(),
                           [](const auto& t)
                           {
                               if (t == nullptr)
                               {
                                   return inno_Template{ 0, nullptr, inno_Template::NotExistingPosition };
                               }
                               return inno_Template{ t->embeddingTemplateData.size(),
                                                     t->embeddingTemplateData.data(),
                                                     t->IsEmbeddingTemplateBiometricPositionKnown()
                                                       ? PrintToIsoPosition(t->GetEmbeddingTemplateBiometricPosition())
                                                       : NotExistingPosition };
                           });
            return transformedTemplates;
        }
 
        static const uint8_t* GetEnd(const uint8_t* begin, const size_t length)
        {
            const auto* end = begin;
            std::advance(end, length);
            return end;
        }
 
        static std::shared_ptr<FaceTemplate> ToFaceTemplate(const inno_Template& ft)
        {
            return std::make_shared<FaceTemplate>(std::vector<uint8_t>{ ft.data, GetEnd(ft.data, ft.length) });
        }
 
        static std::shared_ptr<IrisTemplate> ToIrisTemplate(const inno_Template& it)
        {
            if (it.position == inno_Template::NotExistingPosition)
            {
                return std::make_shared<IrisTemplate>(std::vector<uint8_t>{ it.data, GetEnd(it.data, it.length) });
            }
            return std::make_shared<IrisTemplate>(std::vector<uint8_t>{ it.data, GetEnd(it.data, it.length) },
                                                  IsoToIrisPosition(it.position));
        }
 
        static std::shared_ptr<ICSTemplate> ToICSTemplate(const inno_Template& pt)
        {
            if (pt.position == inno_Template::NotExistingPosition)
            {
                return std::make_shared<ICSTemplate>(std::vector<uint8_t>{ pt.data, GetEnd(pt.data, pt.length) });
            }
            return std::make_shared<ICSTemplate>(std::vector<uint8_t>{ pt.data, GetEnd(pt.data, pt.length) },
                                                 IsoToPrintPosition(pt.position));
        }
 
        static std::shared_ptr<EmbeddingTemplate> ToEmbeddingTemplate(const inno_Template& pt)
        {
            if (pt.position == inno_Template::NotExistingPosition)
            {
                return std::make_shared<EmbeddingTemplate>(std::vector<uint8_t>{ pt.data, GetEnd(pt.data, pt.length) });
            }
            return std::make_shared<EmbeddingTemplate>(std::vector<uint8_t>{ pt.data, GetEnd(pt.data, pt.length) },
                                                       IsoToPrintPosition(pt.position));
        }
 
        bool operator==(const inno_Template& r) const
        {
            return length == r.length && data == r.data && position == r.position;
        }
 
        size_t length;
        const uint8_t* data;
        int position;
    };
    struct INNO_ENROLLMENT_API inno_PrintTemplate
    {
        static inno_PrintTemplate FromTemplate(const std::shared_ptr<PrintTemplate>& t)
        {
            inno_Template icsTemplate{ 0, nullptr, inno_Template::NotExistingPosition };
            if (t->HasIcsRepresentation())
            {
                auto i = t->GetICSRepresentation();
                icsTemplate = inno_Template{ i->icsTemplateData.size(),
                                             i->icsTemplateData.data(),
                                             i->IsICSTemplateBiometricPositionKnown()
                                               ? PrintToIsoPosition(i->GetICSTemplateBiometricPosition())
                                               : inno_Template::NotExistingPosition };
            }
 
            inno_Template embeddingTemplate{ 0, nullptr, inno_Template::NotExistingPosition };
            if (t->HasEmbeddingRepresentation())
            {
                auto em = t->GetEmbeddingRepresentation();
                embeddingTemplate = inno_Template{ em->embeddingTemplateData.size(),
                                                   em->embeddingTemplateData.data(),
                                                   em->IsEmbeddingTemplateBiometricPositionKnown()
                                                     ? PrintToIsoPosition(em->GetEmbeddingTemplateBiometricPosition())
                                                     : inno_Template::NotExistingPosition };
            }
            return inno_PrintTemplate{ icsTemplate, embeddingTemplate };
        }
 
        static std::vector<inno_PrintTemplate> FromTemplates(const std::vector<std::shared_ptr<PrintTemplate>>& pt)
        {
            std::vector<inno_PrintTemplate> transformedTemplates(pt.size());
            std::transform(
              pt.begin(), pt.end(), transformedTemplates.begin(), [](const auto& t) { return FromTemplate(t); });
            return transformedTemplates;
        }
 
        static std::shared_ptr<PrintTemplate> ToTemplate(const inno_PrintTemplate& pt)
        {
            if (nullptr != pt.ics.data && nullptr != pt.embedding.data)
            {
                return std::make_shared<PrintTemplate>(inno_Template::ToICSTemplate(pt.ics),
                                                       inno_Template::ToEmbeddingTemplate(pt.embedding));
            }
            if (nullptr != pt.ics.data)
            {
                return std::make_shared<PrintTemplate>(inno_Template::ToICSTemplate(pt.ics));
            }
            return std::make_shared<PrintTemplate>(inno_Template::ToEmbeddingTemplate(pt.embedding));
        }
 
        inno_Template ics;
        inno_Template embedding;
    };
#pragma pack(pop)
    using inno_AllocateData = uint8_t* (*)(void*, size_t);
 
    class MultiModalityExecutor
    {
    public:
        static constexpr size_t MaxErrorMessage = 200;
        virtual void CreateUserRecord(const std::shared_ptr<Logger>& log,
                                      const inno_Template* prints,
                                      size_t printsSize,
                                      const inno_Template* faces,
                                      size_t facesSize,
                                      const inno_Template* irises,
                                      size_t irisesSize,
                                      inno_AllocateData allocator,
                                      void* container,
                                      ErrorCallbacks errorCallbacks) = 0;
 
        virtual void Verify(const std::shared_ptr<Logger>& log,
                            const uint8_t* probe,
                            size_t probeSize,
                            const uint8_t* gallery,
                            size_t gallerySize,
                            unsigned int maxRotation,
                            int* printScore,
                            int* faceScore,
                            int* irisScore,
                            ErrorCallbacks errorCallbacks) = 0;
 
        MultiModalityExecutor() = default;
        virtual ~MultiModalityExecutor() = default;
        MultiModalityExecutor(const MultiModalityExecutor&) = delete;
        MultiModalityExecutor(MultiModalityExecutor&&) = delete;
        MultiModalityExecutor& operator=(const MultiModalityExecutor&) = delete;
        MultiModalityExecutor& operator=(MultiModalityExecutor&&) = delete;
    };
 
    extern "C"
    {
        INNO_ENROLLMENT_API void inno_local_CreateUserRecord(LoggerCallBacks logCallbacks,
                                                             const inno_Template* prints,
                                                             size_t printsSize,
                                                             const inno_Template* faces,
                                                             size_t facesSize,
                                                             const inno_Template* irises,
                                                             size_t irisesSize,
                                                             inno_AllocateData allocator,
                                                             void* container,
                                                             ErrorCallbacks errorCallbacks);
        INNO_ENROLLMENT_API void inno_local_MultiVerify(LoggerCallBacks logCallbacks,
                                                        const uint8_t* probe,
                                                        const uint8_t* gallery,
                                                        unsigned int maxRotation,
                                                        int* printScore,
                                                        int* faceScore,
                                                        int* irisScore,
                                                        ErrorCallbacks errorCallbacks);
    }
 
    class LocalMultiModalityExecutor : public MultiModalityExecutor
    {
    public:
        void CreateUserRecord(const std::shared_ptr<Logger>& log,
                              const inno_Template* prints,
                              size_t printsSize,
                              const inno_Template* faces,
                              size_t facesSize,
                              const inno_Template* irises,
                              size_t irisesSize,
                              inno_AllocateData allocator,
                              void* container,
                              ErrorCallbacks errorCallbacks) final
        {
            const CallbackLogger slog(log);
            inno_local_CreateUserRecord(slog.GetCallbacks(),
                                        prints,
                                        printsSize,
                                        faces,
                                        facesSize,
                                        irises,
                                        irisesSize,
                                        allocator,
                                        container,
                                        errorCallbacks);
        }
 
        void Verify(const std::shared_ptr<Logger>& log,
                    const uint8_t* probe,
                    size_t /* probeSize */,
                    const uint8_t* gallery,
                    size_t /* gallerySize */,
                    unsigned int maxRotation,
                    int* printScore,
                    int* faceScore,
                    int* irisScore,
                    ErrorCallbacks errorCallbacks) final
        {
            const CallbackLogger slog(log);
            inno_local_MultiVerify(
              slog.GetCallbacks(), probe, gallery, maxRotation, printScore, faceScore, irisScore, errorCallbacks);
        }
 
        LocalMultiModalityExecutor() = default;
        virtual ~LocalMultiModalityExecutor() = default;
        LocalMultiModalityExecutor(const LocalMultiModalityExecutor&) = delete;
        LocalMultiModalityExecutor(LocalMultiModalityExecutor&&) = delete;
        LocalMultiModalityExecutor& operator=(const LocalMultiModalityExecutor&) = delete;
        LocalMultiModalityExecutor& operator=(LocalMultiModalityExecutor&&) = delete;
    };
 
    extern "C"
    {
        struct inno_grcp_MultiModalityChannel;
 
        INNO_ENROLLMENT_API inno_grcp_MultiModalityChannel* inno_grpc_MultiModality_Channel_Create(
          const char* endpoint);
        INNO_ENROLLMENT_API void inno_grpc_MultiModality_Channel_Destroy(inno_grcp_MultiModalityChannel* channel);
        INNO_ENROLLMENT_API void inno_grpc_CreateUserRecord(inno_grcp_MultiModalityChannel* channel,
                                                            LoggerCallBacks logCallbacks,
                                                            const inno_Template* prints,
                                                            size_t printsSize,
                                                            const inno_Template* faces,
                                                            size_t facesSize,
                                                            const inno_Template* irises,
                                                            size_t irisesSize,
                                                            inno_AllocateData allocator,
                                                            void* container,
                                                            ErrorCallbacks errorCallbacks);
        INNO_ENROLLMENT_API void inno_grpc_MultiVerify(inno_grcp_MultiModalityChannel* channel,
                                                       LoggerCallBacks logCallbacks,
                                                       const uint8_t* probe,
                                                       size_t probeSize,
                                                       const uint8_t* gallery,
                                                       size_t gallerySize,
                                                       unsigned int maxRotation,
                                                       int* printScore,
                                                       int* faceScore,
                                                       int* irisScore,
                                                       ErrorCallbacks errorCallbacks);
    }
 
    class GrpcMultiModalityExecutor : public MultiModalityExecutor
    {
    public:
        void CreateUserRecord(const std::shared_ptr<Logger>& log,
                              const inno_Template* prints,
                              size_t printsSize,
                              const inno_Template* faces,
                              size_t facesSize,
                              const inno_Template* irises,
                              size_t irisesSize,
                              inno_AllocateData allocator,
                              void* container,
                              ErrorCallbacks errorCallbacks) final
        {
            const CallbackLogger slog(log);
            inno_grpc_CreateUserRecord(grpc.get(),
                                       slog.GetCallbacks(),
                                       prints,
                                       printsSize,
                                       faces,
                                       facesSize,
                                       irises,
                                       irisesSize,
                                       allocator,
                                       container,
                                       errorCallbacks);
        }
 
        void Verify(const std::shared_ptr<Logger>& log,
                    const uint8_t* probe,
                    size_t probeSize,
                    const uint8_t* gallery,
                    size_t gallerySize,
                    unsigned int maxRotation,
                    int* printScore,
                    int* faceScore,
                    int* irisScore,
                    ErrorCallbacks errorCallbacks) final
        {
            const CallbackLogger slog(log);
            inno_grpc_MultiVerify(grpc.get(),
                                  slog.GetCallbacks(),
                                  probe,
                                  probeSize,
                                  gallery,
                                  gallerySize,
                                  maxRotation,
                                  printScore,
                                  faceScore,
                                  irisScore,
                                  errorCallbacks);
        }

        explicit GrpcMultiModalityExecutor(const std::string& endPoint)
          : grpc(inno_grpc_MultiModality_Channel_Create(endPoint.c_str()), inno_grpc_MultiModality_Channel_Destroy)
        {
        }
 
        GrpcMultiModalityExecutor() = delete;
        virtual ~GrpcMultiModalityExecutor() = default;
        GrpcMultiModalityExecutor(const GrpcMultiModalityExecutor&) = delete;
        GrpcMultiModalityExecutor(GrpcMultiModalityExecutor&&) = delete;
        GrpcMultiModalityExecutor& operator=(const GrpcMultiModalityExecutor&) = delete;
        GrpcMultiModalityExecutor& operator=(GrpcMultiModalityExecutor&&) = delete;
 
    private:
        std::unique_ptr<inno_grcp_MultiModalityChannel, void (*)(inno_grcp_MultiModalityChannel*)> grpc;
    };

     */
    class GlobalMultiModalityExecutor
    {
    public:
         */
        static std::shared_ptr<MultiModalityExecutor> Get()
        {
            return GlobalMultiModalityExecutor::Instance().GetInternal();
        }

         */
        static void Set(std::shared_ptr<MultiModalityExecutor> executor)
        {
            if (executor == nullptr)
            {
                throw EnrollmentInvalidArgumentException("executor can not be null");
            }
 
            GlobalMultiModalityExecutor::Instance().SetInternal(std::move(executor));
        }
 
        GlobalMultiModalityExecutor() = delete;
        virtual ~GlobalMultiModalityExecutor() = default;
        GlobalMultiModalityExecutor(const GlobalMultiModalityExecutor&) = delete;
        GlobalMultiModalityExecutor(GlobalMultiModalityExecutor&&) = delete;
        GlobalMultiModalityExecutor& operator=(const GlobalMultiModalityExecutor&) = delete;
        GlobalMultiModalityExecutor& operator=(GlobalMultiModalityExecutor&&) = delete;
 
    private:
        std::shared_ptr<MultiModalityExecutor> pe;
        std::mutex peMux;
 
        std::shared_ptr<MultiModalityExecutor> GetInternal()
        {
            const std::scoped_lock lock(peMux);
            return pe;
        }
 
        static GlobalMultiModalityExecutor& Instance()
        {
            static GlobalMultiModalityExecutor e(std::make_shared<LocalMultiModalityExecutor>());
            return e;
        }
 
        void SetInternal(std::shared_ptr<MultiModalityExecutor> executor)
        {
            const std::scoped_lock lock(peMux);
            pe = std::move(executor);
        }
 
        explicit GlobalMultiModalityExecutor(std::shared_ptr<MultiModalityExecutor> e)
          : pe(std::move(e))
        {
        }
    };
} // namespace inno