IDetector.h

Go to the documentation of this file.

#pragma once

#include "FSDKError.h"
#include "IFaceDetectionBatch.h"
#include "IObject.h"
#include "Types.h"
#include "Types/Face.h"

#include <fsdk/vlc/future.h>

#include <functional>

namespace fsdk {
    
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    DECLARE_SMARTPTR(IDetector);
#endif

    enum class SensorType {
        Visible = 0,   
        NIR            
    };

    enum ObjectDetectorClassType {
        FACE_DET_DEFAULT = 0,   
        FACE_DET_V1 = 4,        
        FACE_DET_V2 = 5,        
        FACE_DET_V3 = 6,        
        FACE_DET_COUNT = 7,     
    };
    
    enum DetectionComparerType {
        DCT_CONFIDENCE = 0,         
        DCT_CENTER,                 
        DCT_CENTER_AND_CONFIDENCE,  
        DCT_SIZE,                   
        DCT_COUNT
    };

    enum DetectionType {
        DT_BBOX          = 0,     
        DT_LANDMARKS5    = 1<<0,  
        DT_LANDMARKS68   = 1<<1,  
        DT_ALL           = 0xffff 
    };
    
    inline DetectionType operator | (DetectionType a, DetectionType b)
        { return static_cast<DetectionType>(static_cast<int>(a) | static_cast<int>(b)); }

    class IDetectionComparer {
    public:
        virtual bool compare(const Image& img, const Detection& a, const Detection& b) const = 0;
        virtual ~IDetectionComparer() = default;
    };
    
    class FunctionDetectionComparer : public IDetectionComparer {
    public:
        typedef std::function<bool(const Image& img, const Detection&, const Detection&)> Function;
        explicit FunctionDetectionComparer(const Function& function) : func(function)
            {}
        bool compare(const Image& img, const Detection& a, const Detection& b) const
            { return func(img, a, b); }
    private:
        Function func;
    };

    struct IDetector : IRefCounted {
        virtual ResultValue<FSDKError, Ref<IFaceDetectionBatch>>
        detect(
            Span<const Image> images,
            Span<const Rect> ROIs,
            uint32_t perImageNum,
            DetectionType type = DT_BBOX
        ) noexcept = 0;

        virtual ResultValue<FSDKError, Face>
        detectOne(
            const Image& image,
            const Rect& rect,
            DetectionType type = DT_BBOX) noexcept = 0;

        virtual ResultValue<FSDKError, Ref<IFaceDetectionBatch>>
        redetect(
            Span<const Image> images,
            Ref<IFaceDetectionBatch> detectionBatch,
            DetectionType type = DT_BBOX
        ) noexcept = 0;

        virtual ResultValue<FSDKError, Ref<IFaceDetectionBatch>>
        redetect(
            Span<const Image> images,
            Span<Span<const Detection>> detections,
            DetectionType type = DT_BBOX
        ) noexcept = 0;

        virtual ResultValue<FSDKError, Face>
        redetectOne(
            const Image& image,
            const Detection& detection,
            DetectionType type = DT_BBOX) noexcept = 0;
        
        virtual void setDetectionComparer(DetectionComparerType comparerType) noexcept = 0;

        virtual void setCustomDetectionComparer(const IDetectionComparer* comparer) noexcept = 0;

        virtual Result<FSDKError>
        validate(
            Span<const Image> images,
            Span<Span<const Detection>> detections,
            Span<Span<Result<FSDKError>>> errors) const noexcept = 0;

        virtual Result<FSDKError>
        validate(
            Span<const Image> images,
            Span<const Rect> rects,
            uint32_t detectionPerImageNum,
            Span<Result<FSDKError>> outErrors) const noexcept = 0;
        
        virtual Result<FSDKError>
        validate(
            Span<const Image> images,
            Ref<IFaceDetectionBatch> detectionBatch,
            Span<Result<FSDKError>> outErrors) const noexcept = 0;

        using FaceBatchResult = ResultValue<FSDKError, IFaceDetectionBatchPtr>;
        using FaceBatchFuture = vlc::future<IFaceDetectionBatchPtr>;

        virtual FaceBatchFuture detectAsync(
            Span<const Image> images,
            Span<const Rect> rectangles,
            uint32_t perImageNum,
            DetectionType type = DT_BBOX) const = 0;

        virtual FaceBatchFuture redetectAsync(
            Span<const Image> images,
            IFaceDetectionBatchPtr detectionBatch,
            DetectionType type = DT_BBOX) const = 0;
    };

}