ModalitiesICSTemplate.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Exception/CallbackError.h"
#include "enrollment/Export.h"
#include "enrollment/Face/Face.h"
#include "enrollment/Iris/Iris.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/ModalitiesMatcher.h"
#include "enrollment/MultiModality/MultiModalityExecutor.h"
#include "enrollment/Print/ICSTemplate.h"
#include "enrollment/Print/PrintAttributes/PrintPosition.h"
#include "enrollment/Serialization/Writer.h"
#include <vector>
 
namespace inno
{
    extern "C"
    {
        using inno_ICSTemplateBuilder = void (*)(void*, const inno_Template&, ErrorCallbacks);
        INNO_ENROLLMENT_API void inno_local_DeserializeModalitiesICSTemplate(const unsigned char* serializedData,
                                                                             size_t serializedDataSize,
                                                                             inno_ICSTemplateBuilder printFactory,
                                                                             void* printContainer,
                                                                             inno_ICSTemplateBuilder faceFactory,
                                                                             void* faceContainer,
                                                                             inno_ICSTemplateBuilder irisFactory,
                                                                             void* irisContainer,
                                                                             ErrorCallbacks errorCallbacks);
    }
     */
    class ModalitiesICSTemplate : public Serializable
    {
    public:
         */
        [[nodiscard]] std::vector<std::shared_ptr<FaceTemplate>> GetFaceTemplates() const
        {
            return fs;
        }
         */
        [[nodiscard]] std::vector<std::shared_ptr<IrisTemplate>> GetIrisTemplates() const
        {
            return is;
        }
         */
        [[nodiscard]] std::vector<std::shared_ptr<ICSTemplate>> GetICSTemplates() const
        {
            return ps;
        }
         */
        [[nodiscard]] std::vector<uint8_t> GetModalitiesICSTemplateData() const
        {
            auto ft = inno_Template::FromTemplates(fs);
            auto it = inno_Template::FromTemplates(is);
            auto pt = inno_Template::FromTemplates(ps);
 
            std::vector<uint8_t> userRecord;
            auto userRecordAllocator = +[](void* container, size_t length) -> uint8_t*
            {
                // It is "safe" cast because we forward pointer to vector created in "user cpp space"
                // (the space where this header is compiled) and the "own cpp space" (out compiled shared library)
                // wil provide it back for us to the same "user cpp space". We have all spaces under control.
                // It is used to do not have unecessary copy data from "own cpp space" into "user cpp space".
                std::vector<uint8_t>& vec = *static_cast<std::vector<uint8_t>*>(container);
                vec.resize(length);
                return vec.data();
            };
 
            auto log = GlobalLogger::Get();
            exec->CreateUserRecord(log,
                                   pt.data(),
                                   pt.size(),
                                   ft.data(),
                                   ft.size(),
                                   it.data(),
                                   it.size(),
                                   userRecordAllocator,
                                   &userRecord,
                                   ThrowOnError{});
            return userRecord;
        }

         */
        explicit ModalitiesICSTemplate(std::vector<uint8_t> data)
          : ModalitiesICSTemplate(std::move(data), GlobalMultiModalityExecutor::Get())
        {
        }
         */
        explicit ModalitiesICSTemplate(std::vector<uint8_t> data, std::shared_ptr<MultiModalityExecutor> executor)
          : exec(std::move(executor))
        {
            auto printBuilder = +[](void* container, const inno_Template& tmpl, ErrorCallbacks err) -> void
            {
                ForwardExceptionToCallbacks(err,
                                            [&]()
                                            {
                                                auto* printContainer =
                                                  static_cast<std::vector<std::shared_ptr<ICSTemplate>>*>(container);
                                                printContainer->push_back(inno_Template::ToICSTemplate(tmpl));
                                            });
            };
            auto faceBuilder = +[](void* container, const inno_Template& tmpl, ErrorCallbacks err) -> void
            {
                ForwardExceptionToCallbacks(err,
                                            [&]()
                                            {
                                                auto* faceContainer =
                                                  static_cast<std::vector<std::shared_ptr<FaceTemplate>>*>(container);
                                                faceContainer->push_back(inno_Template::ToFaceTemplate(tmpl));
                                            });
            };
            auto irisBuilder = +[](void* container, const inno_Template& tmpl, ErrorCallbacks err) -> void
            {
                ForwardExceptionToCallbacks(err,
                                            [&]()
                                            {
                                                auto* irisContainer =
                                                  static_cast<std::vector<std::shared_ptr<IrisTemplate>>*>(container);
                                                irisContainer->push_back(inno_Template::ToIrisTemplate(tmpl));
                                            });
            };
 
            inno_local_DeserializeModalitiesICSTemplate(
              data.data(), data.size(), printBuilder, &ps, faceBuilder, &fs, irisBuilder, &is, ThrowOnError{});
        }

         */
        ModalitiesICSTemplate(std::vector<std::shared_ptr<ICSTemplate>> icsTemplates,
                              std::vector<std::shared_ptr<FaceTemplate>> faceTemplates,
                              std::vector<std::shared_ptr<IrisTemplate>> irisTemplates)
          : ModalitiesICSTemplate(std::move(icsTemplates),
                                  std::move(faceTemplates),
                                  std::move(irisTemplates),
                                  GlobalMultiModalityExecutor::Get())
        {
        }

         */
        ModalitiesICSTemplate(std::vector<std::shared_ptr<ICSTemplate>> icsTemplates,
                              std::vector<std::shared_ptr<FaceTemplate>> faceTemplates,
                              std::vector<std::shared_ptr<IrisTemplate>> irisTemplates,
                              std::shared_ptr<MultiModalityExecutor> executor)
          : exec(std::move(executor))
          , ps(std::move(icsTemplates))
          , fs(std::move(faceTemplates))
          , is(std::move(irisTemplates))
        {
        }
 
        void WriteTo(Writer& w) const override
        {
            w.WriteArray("d", GetModalitiesICSTemplateData());
        }
 
        ModalitiesICSTemplate(const ModalitiesICSTemplate&) = default;
        ModalitiesICSTemplate(ModalitiesICSTemplate&&) = default;
        ModalitiesICSTemplate& operator=(const ModalitiesICSTemplate&) = default;
        ModalitiesICSTemplate& operator=(ModalitiesICSTemplate&&) = default;
        ModalitiesICSTemplate() = default;
        virtual ~ModalitiesICSTemplate() = default;
        bool operator==(const ModalitiesICSTemplate& right) const
        {
            return GetModalitiesICSTemplateData() == right.GetModalitiesICSTemplateData();
        }
        bool operator!=(const ModalitiesICSTemplate& right) const
        {
            return !((*this) == right);
        }
 
    private:
        std::shared_ptr<MultiModalityExecutor> exec;
        std::vector<std::shared_ptr<ICSTemplate>> ps;
        std::vector<std::shared_ptr<FaceTemplate>> fs;
        std::vector<std::shared_ptr<IrisTemplate>> is;
    };
} // namespace inno