IdentificationEmbeddingExtractor.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Export.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/Print/EmbeddingExtractor.h"
#include "enrollment/Print/ExtractedPrintEmbedding.h"
#include "enrollment/Serialization/Writer.h"
#include <vector>
 
namespace inno
{
    class Logger;

     */
    class IdentificationEmbeddingExtractor : public EmbeddingExtractor
    {
    public:
         */
        [[nodiscard]] std::shared_ptr<ExtractedPrintEmbedding> Extract(const std::shared_ptr<Print>& print) const final
        {
            if (print == nullptr)
            {
                throw NullArgumentException("Print can not be null");
            }
 
            log.LogInfo("Print embedding extraction for %v ...", print);
 
            auto rawImage = print->image->AsRawImage();
 
            std::vector<uint8_t> tmplData;
            auto tmplAllocator = +[](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();
            };
 
            exec->IFingerCreateEmbedding(module.get(),
                                         rawImage.Data().data(),
                                         rawImage.type,
                                         rawImage.width,
                                         rawImage.height,
                                         static_cast<int>(static_cast<unsigned int>(rawImage.dpi)),
                                         tmplAllocator,
                                         &tmplData,
                                         ThrowOnError{});
 
            auto extractedPrintEmbedding = std::make_shared<ExtractedPrintEmbedding>(std::move(tmplData), print, exec);
 
            log.LogInfo("Print embedding extraction result %v", extractedPrintEmbedding);
 
            return extractedPrintEmbedding;
        }

         */
        IdentificationEmbeddingExtractor()
          : log(GlobalLogger::Get())
          , exec(GlobalPrintExecutor::Get())
          , module(Initialize())
        {
        }

         */
        explicit IdentificationEmbeddingExtractor(std::shared_ptr<PrintExecutor> executor)
          : log(GlobalLogger::Get())
          , exec(std::move(executor))
          , module(Initialize())
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
        }
        IdentificationEmbeddingExtractor(const IdentificationEmbeddingExtractor&) = delete;
        IdentificationEmbeddingExtractor(IdentificationEmbeddingExtractor&&) = delete;
        IdentificationEmbeddingExtractor& operator=(const IdentificationEmbeddingExtractor&) = delete;
        IdentificationEmbeddingExtractor& operator=(IdentificationEmbeddingExtractor&&) = delete;
        virtual ~IdentificationEmbeddingExtractor() = default;
 
    private:
        std::unique_ptr<void, inno_Deleter> Initialize()
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
 
            inno_Deleter moduleDeleter = nullptr;
            auto* mod = exec->IFingerCreateIdentificationModule(&moduleDeleter, ThrowOnError{});
            std::unique_ptr<void, inno_Deleter> identificationModule(mod, moduleDeleter);
 
            return identificationModule;
        }
 
        FormattingLogger log;
        std::shared_ptr<PrintExecutor> exec;
        std::unique_ptr<void, inno_Deleter> module;
    };
} // namespace inno