ICSExtractor.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Exception/CallbackError.h"
#include "enrollment/Export.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/Print/CriticalPoint.h"
#include "enrollment/Print/ExtractedPrint.h"
#include "enrollment/Print/ICSMatcher.h"
#include "enrollment/Print/Minutia.h"
#include "enrollment/Print/Print.h"
#include "enrollment/Print/PrintExecutor.h"
#include "enrollment/Serialization/Writer.h"
#include <array>
#include <functional>
#include <vector>
 
namespace inno
{
    class Logger;

     */
    class ICSExtractor
    {
    public:
         */
        class Artifact
        {
        private:
            virtual void ConfigureExtractionParameters(const std::shared_ptr<Print>& print,
                                                       inno_ICSExtractor_params& params) = 0;
            virtual void OnCreated() = 0;
            virtual void CheckCompatibility(inno_ICSExtractor_params& params) = 0;
 
        public:
            Artifact() = default;
            Artifact(const Artifact&) = delete;
            Artifact(Artifact&&) = delete;
            Artifact& operator=(const Artifact&) = delete;
            Artifact& operator=(Artifact&& c) = delete;
            virtual ~Artifact() = default;
 
            friend class ICSExtractor;
        };

         */
        class Artifacts : public Artifact
        {
        public:
             */
            void Add(Artifact& artifact)
            {
                const std::lock_guard lock(artifactsMux);
 
                if (isExtractionInProgress)
                {
                    throw EnrollmentRuntimeException("cannot add artifact during extraction");
                }
 
                inno_ICSExtractor_params param = {};
 
                for (auto* a : artifacts)
                {
                    a->CheckCompatibility(param);
                }
 
                // when not compatible then it will throw
                artifact.CheckCompatibility(param);
 
                artifacts.emplace_back(&artifact);
            }
 
        private:
            void ConfigureExtractionParameters(const std::shared_ptr<Print>& print,
                                               inno_ICSExtractor_params& params) final
            {
                const std::lock_guard lock(artifactsMux);
 
                for (auto* a : artifacts)
                {
                    a->ConfigureExtractionParameters(print, params);
                }
 
                isExtractionInProgress = true;
            }
            void OnCreated() final
            {
                const std::lock_guard lock(artifactsMux);
 
                for (auto* a : artifacts)
                {
                    a->OnCreated();
                }
 
                isExtractionInProgress = false;
            }

            void CheckCompatibility(inno_ICSExtractor_params& params) final
            {
                const std::lock_guard lock(artifactsMux);
 
                for (auto* a : artifacts)
                {
                    a->CheckCompatibility(params);
                }
            }
 
            std::vector<Artifact*> artifacts;
            std::mutex artifactsMux;
            bool isExtractionInProgress = false;
 
        public:
            Artifacts() = default;
            Artifacts(const Artifacts&) = delete;
            Artifacts(Artifacts&&) = delete;
            Artifacts& operator=(const Artifacts&) = delete;
            Artifacts& operator=(Artifacts&& c) = delete;
            virtual ~Artifacts() = default;
        };

         */
        class SkeletonImage : public Artifact
        {
        public:
             */
            [[nodiscard]] std::shared_ptr<Image> GetImage() const
            {
                if (image == nullptr)
                {
                    throw EnrollmentRuntimeException("skeleton image is not available");
                }
                return image;
            }

             */
            [[nodiscard]] std::shared_ptr<Image> DrawMinutiae(const std::vector<std::shared_ptr<Minutia>>& minutiae,
                                                              const ImageShapeAttributes& attr) const
            {
                return image->DrawShape(MinutiaeShape(minutiae, attr));
            }

             */
            [[nodiscard]] std::shared_ptr<Image> DrawCriticalPoints(
              const std::vector<std::shared_ptr<CriticalPoint>>& points,
              const ImageShapeAttributes& attr) const
            {
                return image->DrawShape(CriticalPointsShape(points, attr));
            }
 
            SkeletonImage() = default;
            SkeletonImage(const SkeletonImage&) = delete;
            SkeletonImage(SkeletonImage&&) = delete;
            SkeletonImage& operator=(const SkeletonImage&) = delete;
            SkeletonImage& operator=(SkeletonImage&& c) = delete;
            virtual ~SkeletonImage() = default;
 
        private:
            ImageWidth width = 0;
            ImageHeight height = 0;
            ImageDpi dpi = DefaultDpi;
            std::shared_ptr<ImageEncoder> encoder;
            std::vector<uint8_t> data;
            std::shared_ptr<Image> image;
 
            void ConfigureExtractionParameters(const std::shared_ptr<Print>& print,
                                               inno_ICSExtractor_params& params) final
            {
                width = print->image->Width();
                height = print->image->Height();
                dpi = print->image->Dpi();
                encoder = print->image->OriginalEncoder();
 
                data.resize(static_cast<size_t>(height) * static_cast<size_t>(width));
 
                params.skeletonImage = data.data();
            }
 
            void OnCreated() final
            {
                image =
                  Image::DecodeRawImage(RawImage{ width, height, dpi, RawImage::GRAYSCALE, std::move(data) }, encoder);
            }
            void CheckCompatibility(inno_ICSExtractor_params& params) final
            {
                if (params.skeletonImage != nullptr)
                {
                    throw EnrollmentRuntimeException("skeleton artifact is already enabled");
                }
                static unsigned char c = 0;
                params.skeletonImage = &c;
            }
        };

         */
        class FilteredImage : public Artifact
        {
        public:
             */
            [[nodiscard]] std::shared_ptr<Image> GetImage() const
            {
                if (image == nullptr)
                {
                    throw EnrollmentRuntimeException("filtered image is not available");
                }
                return image;
            }
 
            FilteredImage() = default;
            FilteredImage(const FilteredImage&) = delete;
            FilteredImage(FilteredImage&&) = delete;
            FilteredImage& operator=(const FilteredImage&) = delete;
            FilteredImage& operator=(FilteredImage&& c) = delete;
            virtual ~FilteredImage() = default;
 
        private:
            ImageWidth width = 0;
            ImageHeight height = 0;
            ImageDpi dpi = DefaultDpi;
            std::shared_ptr<ImageEncoder> encoder;
            std::vector<uint8_t> data;
            std::shared_ptr<Image> image;
 
            void ConfigureExtractionParameters(const std::shared_ptr<Print>& print,
                                               inno_ICSExtractor_params& params) final
            {
                width = print->image->Width();
                height = print->image->Height();
                dpi = print->image->Dpi();
                encoder = print->image->OriginalEncoder();
 
                data.resize(static_cast<size_t>(height) * static_cast<size_t>(width));
 
                params.filteredImage = data.data();
            }
 
            void OnCreated() final
            {
                image =
                  Image::DecodeRawImage(RawImage{ width, height, dpi, RawImage::GRAYSCALE, std::move(data) }, encoder);
            }
 
            void CheckCompatibility(inno_ICSExtractor_params& params) final
            {
                if (params.filteredImage != nullptr)
                {
                    throw EnrollmentRuntimeException("filtered artifact is already enabled");
                }
 
                static unsigned char c = 0;
                params.filteredImage = &c;
            }
        };

         */
        class BinarizedImage : public Artifact
        {
        public:
             */
            [[nodiscard]] std::shared_ptr<Image> GetImage() const
            {
                if (image == nullptr)
                {
                    throw EnrollmentRuntimeException("binarized image is not available");
                }
                return image;
            }
 
            BinarizedImage() = default;
            BinarizedImage(const BinarizedImage&) = delete;
            BinarizedImage(BinarizedImage&&) = delete;
            BinarizedImage& operator=(const BinarizedImage&) = delete;
            BinarizedImage& operator=(BinarizedImage&& c) = delete;
            virtual ~BinarizedImage() = default;
 
        private:
            ImageWidth width = 0;
            ImageHeight height = 0;
            ImageDpi dpi = DefaultDpi;
            std::shared_ptr<ImageEncoder> encoder;
            std::vector<uint8_t> data;
            std::shared_ptr<Image> image;
 
            void ConfigureExtractionParameters(const std::shared_ptr<Print>& print,
                                               inno_ICSExtractor_params& params) final
            {
                width = print->image->Width();
                height = print->image->Height();
                dpi = print->image->Dpi();
                encoder = print->image->OriginalEncoder();
 
                data.resize(static_cast<size_t>(height) * static_cast<size_t>(width));
 
                params.binarizedImage = data.data();
            }
 
            void OnCreated() final
            {
                image =
                  Image::DecodeRawImage(RawImage{ width, height, dpi, RawImage::GRAYSCALE, std::move(data) }, encoder);
            }
 
            void CheckCompatibility(inno_ICSExtractor_params& params) final
            {
                if (params.binarizedImage != nullptr)
                {
                    throw EnrollmentRuntimeException("binarized artifact is already enabled");
                }
 
                static unsigned char c = 0;
                params.binarizedImage = &c;
            }
        };

         */
        std::shared_ptr<ExtractedPrint> Extract(std::shared_ptr<Print> print, Artifact& artifact)
        {
            if (print == nullptr)
            {
                throw NullArgumentException("Print can not be null");
            }
 
            log.LogInfo("Print extraction for %v ...", print);
 
            uint8_t* outTemplate = nullptr;
            unsigned int outTemplateSize = 0;
            const CallbackLogger slog(log.GetLogger());
            inno_ICSExtractor_params params = {};
            auto gs = print->image->AsRawGrayscale();
            params.height = gs.height;
            params.width = gs.width;
            params.data = gs.Data().data();
            params.dpi = static_cast<unsigned int>(gs.dpi);
 
            artifact.ConfigureExtractionParameters(print, params);
 
            exec->Extract(&params, slog.GetCallbacks(), &outTemplate, &outTemplateSize, ThrowOnError{});
 
            artifact.OnCreated();
 
            std::vector<uint8_t> templateData(outTemplate, std::next(outTemplate, outTemplateSize));
            exec->FreeTemplate(outTemplate, outTemplateSize);
 
            auto extractedPrint = std::make_shared<ExtractedPrint>(std::move(templateData), std::move(print), exec);
            log.LogInfo("Print extraction result %v", extractedPrint);
 
            return extractedPrint;
        }

         */
        std::shared_ptr<ExtractedPrint> Extract(const std::shared_ptr<Print>& print)
        {
            auto nullArtifact = NullArtifact();
            return Extract(print, nullArtifact);
        }
         */
        ICSExtractor()
          : log(GlobalLogger::Get())
          , exec(GlobalPrintExecutor::Get())
        {
        }

         */
        explicit ICSExtractor(std::shared_ptr<PrintExecutor> executor)
          : log(GlobalLogger::Get())
          , exec(std::move(executor))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
        }
        ICSExtractor(const ICSExtractor&) = delete;
        ICSExtractor(ICSExtractor&&) = delete;
        ICSExtractor& operator=(const ICSExtractor&) = delete;
        ICSExtractor& operator=(ICSExtractor&&) = delete;
        virtual ~ICSExtractor() = default;
 
    private:
        class NullArtifact final : public Artifact
        {
        private:
            void ConfigureExtractionParameters(const std::shared_ptr<Print>& /*print*/,
                                               inno_ICSExtractor_params& /*params*/) final
            {
            }
            void OnCreated() final
            {
            }
            void CheckCompatibility(inno_ICSExtractor_params& /*params*/) final
            {
            }
 
        public:
            NullArtifact() = default;
            NullArtifact(const NullArtifact&) = delete;
            NullArtifact(NullArtifact&&) = delete;
            NullArtifact& operator=(const NullArtifact&) = delete;
            NullArtifact& operator=(NullArtifact&& c) = delete;
            virtual ~NullArtifact() = default;
        };
 
        FormattingLogger log;
        std::shared_ptr<PrintExecutor> exec;
    };
} // namespace inno