IrisDetector.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/Iris/Iris.h"
#include "enrollment/Iris/IrisExecutor.h"
#include "enrollment/Iris/IrisSegment.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/Serialization/Writer.h"
#include <memory>
#include <vector>
 
namespace inno
{
     */
    class IrisDetector
    {
    public:
         */
        class Config : public Serializable
        {
        public:
             */
            enum class Type : uint8_t
            {
                ACCURATE,
                FAST,
            };
             */
            void SetDetector(Type value)
            {
                type = value;
            }
             */
            [[nodiscard]] Type GetDetector() const
            {
                return type;
            }
             */
            void SetMaxDetectionSize(float value)
            {
                maxDetectionSize = value;
            }
             */
            [[nodiscard]] float GetMaxDetectionSize() const
            {
                return maxDetectionSize;
            }
             */
            void SetMinDetectionSize(float value)
            {
                minDetectionSize = value;
            }
             */
            [[nodiscard]] float GetMinDetectionSize() const
            {
                return minDetectionSize;
            }

             */
            void WriteTo(Writer& writer) const final
            {
                writer.Write("t", static_cast<unsigned int>(type));
                writer.Write("i", minDetectionSize);
                writer.Write("x", maxDetectionSize);
            }

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

            Config() = default;
            Config(const Config& c) = default;
            Config(Config&&) = default;
            Config& operator=(const Config&) = default;
            Config& operator=(Config&&) = default;
            virtual ~Config() = default;
 
        private:
            Type type = Type::ACCURATE;
            float minDetectionSize = DefaultMinDetectionSize;
            float maxDetectionSize = DefaultMaxDetectionSize;
            static constexpr float DefaultMinDetectionSize = 0.05F;
            static constexpr float DefaultMaxDetectionSize = 0.95F;
        };

         */
        [[nodiscard]] std::shared_ptr<IrisSegment> Detect(const std::shared_ptr<Image>& image,
                                                          const IrisPosition& position,
                                                          const IrisAttributes& ia = IrisAttributes()) const
        {
            log.LogInfo("Iris detection for %v  with cfg %v ...", image, cfg);
            auto bgr = image->AsRawBGR();
 
            auto r = exec->Detect(log.GetLogger(),
                                  bgr.height,
                                  bgr.width,
                                  static_cast<unsigned int>(bgr.dpi),
                                  bgr.Data().data(),
                                  cfg.GetMinDetectionSize(),
                                  cfg.GetMaxDetectionSize(),
                                  static_cast<unsigned int>(cfg.GetDetector()),
                                  ThrowOnError{});
 
            if (r.irises[0] == nullptr)
            {
                throw EnrollmentRuntimeException("No iris is detected");
            }
 
            if (r.irises[1] != nullptr)
            {
                // release all iris handlers, because more than one iris is found.
                // The function has only one return value, so we have to release all iris handlers.
                for (auto& iris : r.irises)
                {
                    if (iris != nullptr)
                    {
                        exec->DestroyImpl()(iris);
                    }
                }
 
                throw EnrollmentRuntimeException("More than one iris is detected");
            }
            const auto& firstIrisBB = r.irisRoundingBoxes[0];
            const Rectangle irisRect = { { firstIrisBB.topLeftX, firstIrisBB.topLeftY },
                                         { firstIrisBB.topRightX, firstIrisBB.topLeftY },
                                         { firstIrisBB.bottomRightX, firstIrisBB.bottomRightY },
                                         { firstIrisBB.bottomLeftX, firstIrisBB.bottomLeftY } };
 
            const auto& firstPupilBB = r.pupilRoundingBoxes[0];
            const Rectangle pupilRect = { { firstPupilBB.topLeftX, firstPupilBB.topLeftY },
                                          { firstPupilBB.topRightX, firstPupilBB.topLeftY },
                                          { firstPupilBB.bottomRightX, firstPupilBB.bottomRightY },
                                          { firstPupilBB.bottomLeftX, firstPupilBB.bottomLeftY } };
 
            auto segment = IrisSegment::Create(Iris::Create(image,
                                                            r.confidences[0],
                                                            position,
                                                            std::shared_ptr<void>(r.irises[0], exec->DestroyImpl()),
                                                            irisRect,
                                                            pupilRect,
                                                            log.GetLogger(),
                                                            exec,
                                                            ia),
                                               image->RectangleIntersection(irisRect) == Image::Intersection::INSIDE,
                                               pupilRect,
                                               irisRect);
 
            log.LogInfo("Iris detection result %v", segment);
            return segment;
        }

         */
        IrisDetector()
          : log(GlobalLogger::Get())
          , exec(GlobalIrisExecutor::Get())
          , cfg(Config::Default())
        {
        }

         */
        explicit IrisDetector(Config config)
          : log(GlobalLogger::Get())
          , exec(GlobalIrisExecutor::Get())
          , cfg(std::move(config))
        {
        }
         */
        IrisDetector(Config config, std::shared_ptr<IrisExecutor> executor)
          : log(GlobalLogger::Get())
          , exec(std::move(executor))
          , cfg(std::move(config))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
        }

         */
        explicit IrisDetector(std::shared_ptr<IrisExecutor> executor)
          : log(GlobalLogger::Get())
          , exec(std::move(executor))
          , cfg(Config::Default())
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
        }
 
        IrisDetector(const IrisDetector&) = delete;
        IrisDetector(IrisDetector&&) = delete;
        IrisDetector& operator=(const IrisDetector&) = delete;
        IrisDetector& operator=(IrisDetector&&) = delete;
        virtual ~IrisDetector() = default;
 
    private:
        FormattingLogger log;
        std::shared_ptr<IrisExecutor> exec;
        Config cfg;
    };
} // namespace inno