ModalitiesTemplate.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/ModalitiesICSTemplateDefaultFactory.h"
#include "enrollment/ModalitiesMatcher.h"
#include "enrollment/MultiModality/MultiModalityExecutor.h"
#include "enrollment/Print/PrintTemplate.h"
#include "enrollment/Serialization/Writer.h"
#include <memory>
#include <vector>
 
namespace inno
{
    extern "C"
    {
        INNO_ENROLLMENT_API void inno_local_SerializeModalitiesTemplate(const inno_PrintTemplate* 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);
        using inno_PrintTemplateBuilder = void (*)(void*, const inno_PrintTemplate&, ErrorCallbacks);
        using inno_TemplateBuilder = void (*)(void*, const inno_Template&);
        INNO_ENROLLMENT_API void inno_local_DeserializeModalitiesTemplate(const unsigned char* serializedData,
                                                                          size_t serializedDataSize,
                                                                          inno_PrintTemplateBuilder printFactory,
                                                                          void* printContainer,
                                                                          inno_TemplateBuilder faceFactory,
                                                                          void* faceContainer,
                                                                          inno_TemplateBuilder irisFactory,
                                                                          void* irisContainer,
                                                                          ErrorCallbacks errorCallbacks);
    }
     */
    class ModalitiesTemplate : 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<PrintTemplate>> GetPrintTemplates() const
        {
            return ps;
        }
         */
        [[nodiscard]] std::vector<uint8_t> GetModalitiesTemplateData() const
        {
            auto ft = inno_Template::FromTemplates(fs);
            auto it = inno_Template::FromTemplates(is);
            auto pt = inno_PrintTemplate::FromTemplates(ps);
 
            std::vector<uint8_t> templateData;
            auto dataAllocator = +[](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();
            };
            inno_local_SerializeModalitiesTemplate(pt.data(),
                                                   pt.size(),
                                                   ft.data(),
                                                   ft.size(),
                                                   it.data(),
                                                   it.size(),
                                                   dataAllocator,
                                                   &templateData,
                                                   ThrowOnError{});
 
            return templateData;
        }

         */
        static std::shared_ptr<ModalitiesTemplate> Create(const std::vector<uint8_t>& data)
        {
            return std::shared_ptr<ModalitiesTemplate>(new ModalitiesTemplate(data));
        }

         */
        static std::shared_ptr<ModalitiesTemplate> Create(std::vector<std::shared_ptr<PrintTemplate>> prints,
                                                          std::vector<std::shared_ptr<FaceTemplate>> faces,
                                                          std::vector<std::shared_ptr<IrisTemplate>> irises)
        {
            return std::shared_ptr<ModalitiesTemplate>(
              new ModalitiesTemplate(std::move(prints), std::move(faces), std::move(irises)));
        }

         */
        [[nodiscard]] std::shared_ptr<ModalitiesICSTemplate> ToModalitiesICSTemplate() const
        {
            const ModalitiesICSTemplateDefaultFactory factory;
            return ToModalitiesICSTemplate(factory);
        }

         */
        [[nodiscard]] std::shared_ptr<ModalitiesICSTemplate> ToModalitiesICSTemplate(
          const ModalitiesICSTemplateFactory& factory) const
        {
            return factory.CreateModalitiesICSTemplate(PrintTemplate::ToICSTemplates(ps), fs, is);
        }

         */
        [[nodiscard]] ModalityScore SimilarWith(const ModalitiesTemplate& gallery,
                                                const ModalitiesMatcher& matcher) const
        {
            return matcher.Match(*this, gallery);
        }
 
        void WriteTo(Writer& w) const override
        {
            w.WriteArray("p", ps);
            w.WriteArray("f", fs);
            w.WriteArray("i", is);
        }
 
        ModalitiesTemplate(const ModalitiesTemplate&) = default;
        ModalitiesTemplate(ModalitiesTemplate&&) = default;
        ModalitiesTemplate& operator=(const ModalitiesTemplate&) = default;
        ModalitiesTemplate& operator=(ModalitiesTemplate&&) = default;
        ModalitiesTemplate() = default;
        virtual ~ModalitiesTemplate() = default;
 
    private:
        std::vector<std::shared_ptr<PrintTemplate>> ps;
        std::vector<std::shared_ptr<FaceTemplate>> fs;
        std::vector<std::shared_ptr<IrisTemplate>> is;
 
        explicit ModalitiesTemplate(const std::vector<uint8_t>& d)
        {
 
            auto printBuilder = +[](void* container, const inno_PrintTemplate& tmpl, ErrorCallbacks err) -> void
            {
                ForwardExceptionToCallbacks(err,
                                            [&]()
                                            {
                                                auto* printContainer =
                                                  static_cast<std::vector<std::shared_ptr<PrintTemplate>>*>(container);
                                                printContainer->push_back(inno_PrintTemplate::ToTemplate(tmpl));
                                            });
            };
            auto faceBuilder = +[](void* container, const inno_Template& tmpl) -> void
            {
                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) -> void
            {
                auto* irisContainer = static_cast<std::vector<std::shared_ptr<IrisTemplate>>*>(container);
                irisContainer->push_back(inno_Template::ToIrisTemplate(tmpl));
            };
 
            inno_local_DeserializeModalitiesTemplate(
              d.data(), d.size(), printBuilder, &ps, faceBuilder, &fs, irisBuilder, &is, ThrowOnError{});
        }

        explicit ModalitiesTemplate(std::vector<std::shared_ptr<PrintTemplate>> prints,
                                    std::vector<std::shared_ptr<FaceTemplate>> faces,
                                    std::vector<std::shared_ptr<IrisTemplate>> irises)
          : ps(std::move(prints))
          , fs(std::move(faces))
          , is(std::move(irises))
        {
        }
    };
} // namespace inno