PrintDetector.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Exception/CallbackError.h"
#include "enrollment/Export.h"
#include "enrollment/Image/Image.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/Print/Print.h"
#include "enrollment/Print/PrintCapture.h"
#include "enrollment/Print/PrintExecutor.h"
#include "enrollment/Print/PrintSegment.h"
#include "enrollment/Serialization/Writer.h"
#include <memory>
#include <vector>
 
namespace inno
{
     */
    class PrintDetectorConfig : public Serializable
    {
    public:
         */
        void SetNarrowFingerPreference(bool expectNarrow)
        {
            expectNarrowFinger = expectNarrow;
        }

         */
        [[nodiscard]] bool GetNarrowFingerPreference() const
        {
            return expectNarrowFinger;
        }

         */
        void WriteTo(Writer& writer) const override
        {
            writer.Write("enf", static_cast<int>(expectNarrowFinger));
        }

        PrintDetectorConfig() = default;
        PrintDetectorConfig(const PrintDetectorConfig&) = default;
        PrintDetectorConfig(PrintDetectorConfig&&) = default;
        PrintDetectorConfig& operator=(const PrintDetectorConfig&) = default;
        PrintDetectorConfig& operator=(PrintDetectorConfig&&) = default;
        virtual ~PrintDetectorConfig() = default;
 
    private:
        bool expectNarrowFinger = true;
    };

     */
    class PrintDetector : public PrintCaptureSegmentation
    {
    public:
         */
        std::vector<std::shared_ptr<PrintSegment>> Segment(const std::shared_ptr<PrintCapture>& capture) final
        {
 
            auto r = DoDetect(exec, capture->image, log);
 
            std::vector<std::shared_ptr<PrintSegment>> res;
 
            // We want to hide specific implementation of segmentation with all its details like types of 3rd-party
            // libraries and its headers (Do not want to include it here and expose details). And we want to use the
            // function in DLL where we cannot pass stl vector. Therefore the function will copy data.
            for (unsigned int i = 0; i < r.count; i++)
            {
                const Rectangle roundingBox = {
                    { r.topLeftX[i], r.topLeftY[i] },      // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
                    { r.topRightX[i], r.topRightY[i] },    // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
                    { r.bottomRightX[i],                   // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
                      r.bottomRightY[i] },                 // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
                    { r.bottomLeftX[i], r.bottomLeftY[i] } // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
                };
                res.emplace_back(std::make_shared<PrintSegment>(
                  capture,
                  capture->printAttributes,
                  roundingBox,
                  r.angle[i],     // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
                  r.positions[i], // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
                  exec));
            }
            log.LogInfo("Print segmentation result %v", res);
 
            return res;
        }

         */
        PrintDetector()
          : log(GlobalLogger::Get())
          , exec(GlobalPrintExecutor::Get())
        {
        }

         */
        explicit PrintDetector(std::shared_ptr<PrintExecutor> executor)
          : log(GlobalLogger::Get())
          , exec(std::move(executor))
 
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
        }
 
        PrintDetector(const PrintDetector&) = delete;
        PrintDetector(PrintDetector&&) = delete;
        PrintDetector& operator=(const PrintDetector&) = delete;
        PrintDetector& operator=(PrintDetector&&) = delete;
        virtual ~PrintDetector() = default;
 
    protected:
        virtual inno_PrintDetector_result DoDetect(const std::shared_ptr<PrintExecutor>& executor,
                                                   const std::shared_ptr<Image>& image,
                                                   FormattingLogger& logger) = 0;
 
    private:
        FormattingLogger log;
        std::shared_ptr<PrintExecutor> exec;
    };

     */
    class AlgorithmicSegmentation final : public PrintDetector
    {
    public:
         */
        class Config : public PrintDetectorConfig
        {
        public:
             */
            void WriteTo(Writer& writer) const final
            {
                writer.Write("mr", maxRotation);
                writer.Write("rn", static_cast<int>(reduceNoise));
                PrintDetectorConfig::WriteTo(writer);
            }

             */
            void SetMaxRotation(unsigned int value)
            {
                static constexpr unsigned int MaxRotation = 45;
                if (value > MaxRotation)
                {
                    throw EnrollmentInvalidArgumentException(
                      "Max rotation of fingers for AlgorithmicSegmentation MUST be in range <0,45>");
                }
                maxRotation = value;
            }

             */
            [[nodiscard]] unsigned int GetMaxRotation() const
            {
                return maxRotation;
            }

             */
            void EnableNoiseReduction()
            {
                reduceNoise = true;
            }

             */
            [[nodiscard]] bool IsNoiseReduction() const
            {
                return reduceNoise;
            }

             */
            static Config Default()
            {
                static const Config Cfg;
                return Cfg;
            }

            Config() = default;
            Config(const Config&) = default;
            Config(Config&&) = default;
            Config& operator=(const Config&) = default;
            Config& operator=(Config&&) = default;
            virtual ~Config() = default;
 
        private:
            static constexpr unsigned int DefaultMaxRotation = 45;
            unsigned int maxRotation = DefaultMaxRotation;
            bool reduceNoise = false;
        };

         */
        explicit AlgorithmicSegmentation(Config config)
          : cfg(std::move(config))
        {
        }

        AlgorithmicSegmentation() = default;

         */
        AlgorithmicSegmentation(Config config, std::shared_ptr<PrintExecutor> executor)
          : PrintDetector(std::move(executor))
          , cfg(std::move(config))
 
        {
        }

         */
        explicit AlgorithmicSegmentation(std::shared_ptr<PrintExecutor> executor)
          : PrintDetector(std::move(executor))
          , cfg(Config::Default())
 
        {
        }
 
        AlgorithmicSegmentation(const AlgorithmicSegmentation&) = delete;
        AlgorithmicSegmentation(AlgorithmicSegmentation&&) = delete;
        AlgorithmicSegmentation& operator=(const AlgorithmicSegmentation&) = delete;
        AlgorithmicSegmentation& operator=(AlgorithmicSegmentation&&) = delete;
        virtual ~AlgorithmicSegmentation() = default;
 
    private:
        Config cfg = Config::Default();
 
        inno_PrintDetector_result DoDetect(const std::shared_ptr<PrintExecutor>& executor,
                                           const std::shared_ptr<Image>& image,
                                           FormattingLogger& logger) final
        {
            logger.LogInfo("Algorithmic segmentation of image %v and config %v", image, cfg);
            auto gs = image->AsRawGrayscale();
            return executor->AlgoSegment(gs.height,
                                         gs.width,
                                         static_cast<unsigned int>(gs.dpi),
                                         gs.Data().data(),
                                         cfg.GetMaxRotation(),
                                         cfg.IsNoiseReduction(),
                                         cfg.GetNarrowFingerPreference(),
                                         ThrowOnError{});
        }
    };

     */
    class NeuralSegmentation final : public PrintDetector
    {
    public:
         */
        class Config : public PrintDetectorConfig
        {
        public:
             */
            void WriteTo(Writer& writer) const final
            {
                writer.Write("mr", maxRotation);
                writer.Write("ct", confidenceThreshold);
                PrintDetectorConfig::WriteTo(writer);
            }

             */
            void SetMaxRotation(unsigned int value)
            {
                static constexpr unsigned int MaxRotation = 45;
                if (value > MaxRotation)
                {
                    throw EnrollmentInvalidArgumentException(
                      "Max rotation of fingers for NeuralSegmentation MUST be in range <0,45>");
                }
                maxRotation = value;
            }

             */
            [[nodiscard]] unsigned int GetMaxRotation() const
            {
                return maxRotation;
            }

             */
            void SetConfidenceThreshold(unsigned int value)
            {
                static constexpr unsigned int MaxConfidenceThreshold = 10000;
                if (value > MaxConfidenceThreshold)
                {
                    throw EnrollmentInvalidArgumentException(
                      "Confidence threshold for NeuralSegmentation MUST be in range [0-10000]");
                }
                confidenceThreshold = value;
            }

             */
            [[nodiscard]] unsigned int GetConfidenceThreshold() const
            {
                return confidenceThreshold;
            }

             */
            static Config Default()
            {
                static const Config Cfg;
                return Cfg;
            }

            Config() = default;
            Config(const Config&) = default;
            Config(Config&&) = default;
            Config& operator=(const Config&) = default;
            Config& operator=(Config&&) = default;
            virtual ~Config() = default;
 
        private:
            static constexpr unsigned int DefaultMaxRotation = 45;
            unsigned int maxRotation = DefaultMaxRotation;
            static constexpr unsigned int DefaultConfidenceThreshold = 9000;
            unsigned int confidenceThreshold = DefaultConfidenceThreshold;
        };

         */
        explicit NeuralSegmentation(Config config)
          : cfg(std::move(config))
        {
        }

         */
        NeuralSegmentation()
          : cfg(Config::Default())
        {
        }

         */
        NeuralSegmentation(Config config, std::shared_ptr<PrintExecutor> executor)
          : PrintDetector(std::move(executor))
          , cfg(std::move(config))
        {
        }

         */
        explicit NeuralSegmentation(std::shared_ptr<PrintExecutor> executor)
          : PrintDetector(std::move(executor))
          , cfg(Config::Default())
        {
        }
 
        NeuralSegmentation(const NeuralSegmentation&) = delete;
        NeuralSegmentation(NeuralSegmentation&&) = delete;
        NeuralSegmentation& operator=(const NeuralSegmentation&) = delete;
        NeuralSegmentation& operator=(NeuralSegmentation&&) = delete;
        virtual ~NeuralSegmentation() = default;
 
    private:
        Config cfg;
 
        inno_PrintDetector_result DoDetect(const std::shared_ptr<PrintExecutor>& executor,
                                           const std::shared_ptr<Image>& image,
                                           FormattingLogger& logger) final
        {
            logger.LogInfo("Neural segmentation of image %v and config %v", image, cfg);
            auto gs = image->AsRawGrayscale();
            return executor->NeuralSegment(gs.height,
                                           gs.width,
                                           static_cast<unsigned int>(gs.dpi),
                                           gs.Data().data(),
                                           cfg.GetMaxRotation(),
                                           cfg.GetConfidenceThreshold(),
                                           cfg.GetNarrowFingerPreference(),
                                           ThrowOnError{});
        }
    };
} // namespace inno