FaceDetector.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/Face/FaceCapture.h"
#include "enrollment/Face/FaceCropConfiguration.h"
#include "enrollment/Face/FaceExecutor.h"
#include "enrollment/Image/Image.h"
#include "enrollment/Logger/FormattingLogger.h"
#include "enrollment/Serialization/Writer.h"
#include <ciso646>
#include <memory>
#include <vector>
 
namespace inno
{
     */
    class FaceDetector : public FaceCaptureSegmentation
    {
    public:
         */
        class Config : public Serializable
        {
        public:
             */
            enum class Type : uint8_t
            {
                ACCURATE,
                BALANCED,
                FAST,
                ACCURATE_SERVER
            };
             */
            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&) = default;
            Config(Config&&) = default;
            Config& operator=(const Config&) = default;
            Config& operator=(Config&&) = delete;
            virtual ~Config() = default;
 
        private:
            Type type = Type::BALANCED;
            float minDetectionSize = DefaultMinDetectionSize;
            float maxDetectionSize = DefaultMaxDetectionSize;
            static constexpr float DefaultMinDetectionSize = 0.05F;
            static constexpr float DefaultMaxDetectionSize = 0.95F;
        };

         */
        std::vector<std::shared_ptr<Face>> Detect(std::shared_ptr<FaceCapture> capture) final
        {
            log.LogInfo("Face detection for %v with cfg %v ...", capture->image, cfg);
 
            auto bgr = capture->image->AsRawBGR();
            auto r = exec->Detect(log.GetLogger(),
                                  bgr.height,
                                  bgr.width,
                                  static_cast<unsigned int>(bgr.dpi),
                                  bgr.Data().data(),
                                  bgr.Data().size(),
                                  cfg.GetMinDetectionSize(),
                                  cfg.GetMaxDetectionSize(),
                                  static_cast<unsigned int>(cfg.GetDetector()),
                                  ThrowOnError{});
 
            // 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.
            std::vector<std::shared_ptr<Face>> res;
            for (auto& face : r.faces)
            {
                if (face.item != nullptr)
                {
                    const Rectangle boundingBox = { { face.roundingBox.topLeftX, face.roundingBox.topLeftY },
                                                    { face.roundingBox.topRightX, face.roundingBox.topRightY },
                                                    { face.roundingBox.bottomRightX, face.roundingBox.bottomRightY },
                                                    { face.roundingBox.bottomLeftX, face.roundingBox.bottomLeftY } };
                    res.emplace_back(Face::Create(capture,
                                                  std::shared_ptr<void>(face.item, exec->DestroyImpl()),
                                                  boundingBox,
                                                  face.confidence,
                                                  exec));
                }
            }
 
            log.LogInfo("Face detection result %v", res);
            return res;
        }

         */
        FaceDetector()
          : log(GlobalLogger::Get())
          , cfg(Config::Default())
          , exec(GlobalFaceExecutor::Get())
        {
        }

         */
        explicit FaceDetector(Config config)
          : log(GlobalLogger::Get())
          , cfg(std::move(config))
          , exec(GlobalFaceExecutor::Get())
        {
        }

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

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