IDetector.h

Go to the documentation of this file.

#pragma once

#include "IObject.h"
#include "Face.h"
#include "Human.h"
#include "FSDKError.h"
#include "Types.h"
#include "IResultBatch.h"

#include <functional>

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

    enum RecognitionMode {
        RM_RGB = 0,     
        RM_INFRA_RED    
    };

    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_CONFIDANCE = 0,         
        DCT_CENTER,                 
        DCT_CENTER_AND_CONFIDANCE,  
        DCT_SIZE,                   
        DCT_COUNT
    };

    enum DetectionType {
        dtBBox          = 0,     
        dt5Landmarks    = 1<<0,  
        dt68Landmarks   = 1<<1,  
        dtAll           = 0xffff 
    };
    
    inline DetectionType operator | (DetectionType a, DetectionType b)
        { return static_cast<DetectionType>(static_cast<int>(a) | static_cast<int>(b)); }

    enum HumanDetectionType {
        DCT_BOX    = 0,     
        DCT_POINTS = 1<<0,  
        DCT_ALL    = 0xffff 
    };

    inline HumanDetectionType operator | (HumanDetectionType a, HumanDetectionType b) { 
        return static_cast<HumanDetectionType>(static_cast<int>(a) | static_cast<int>(b));
    }

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

    struct IDetector : IRefCounted {
        virtual ResultValue<FSDKError, Ref<IResultBatch<Face>>> detect(
            const Span<const Image> images,
            const Span<const Rect> rectangles,
            int detectionPerImageNum,
            DetectionType type = dtBBox) noexcept = 0;

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

        virtual void setDetectionComparer(DetectionComparerType comparerType) noexcept = 0;

        virtual void setCustomDetectionComparer(const IDetectionComparer* comparer) noexcept = 0;
        virtual ResultValue<FSDKError, bool>
        redetectOne(
            Face& face,
            DetectionType type = dtBBox) noexcept = 0;
        
        virtual fsdk::ResultValue<fsdk::FSDKError, fsdk::Face>
        redetectOne(
            const fsdk::Image& image,
            const fsdk::FloatRect& rect,
            fsdk::DetectionType type = fsdk::dtBBox) noexcept = 0;
        
        virtual Result<FSDKError>
        FSDK_DEPRECATED("This call is deprecated since v.3.9.3. Consider "
            "redetect(\n"
            "\tconst Span<Face>& faces,\n"
            "\tDetectionType type,\n"
            "\tconst Span<Result<FSDKError>>& outErrors) call.\n")
        redetect(
            const Span<Face>& faces,
            DetectionType type = dtBBox,
            const Span<FSDKError>* outErrors = nullptr) noexcept = 0;
        
        virtual Result<FSDKError>
        redetect(
            const fsdk::Span<fsdk::Face>& faces,
            fsdk::DetectionType type,
            const fsdk::Span<fsdk::Result<fsdk::FSDKError>>& outErrors) noexcept = 0;
        
        virtual fsdk::ResultValue<fsdk::FSDKError, fsdk::OrientationType>
        estimateOrientation(const Image &image) noexcept = 0;
    };

    struct IHumanDetector : IRefCounted {
        /*
         * @brief Batched detect of human bodies
         * @param images input images span; format must be R8G8B8.
         * @param rectangles input rectangles of interest span.
         * @param detectionPerImageNum max number of detections per input image.
         * @return ResultValue with error code and collections of Detection objects (contains bbox and score).
         * @note all spans should be based on user owned continuous collections.
         * @note all spans should be equal size.
         */
        virtual ResultValue<FSDKError, Ref<IResultBatch<Human>>>
        detect(
            const Span<const Image>& image,
            const Span<const Rect>& rect,
            uint32_t detectionPerImageNum,
            HumanDetectionType type = DCT_BOX) const noexcept = 0;

        /*
         * @brief redetect one person from input image;
         * @param human fsdk::Human structure with valid image and bbox inside;
         * @return ResultValue with ErrorCode and bool (true - if detection found);
         * @note human structure will be overriden once redetect finish it's job.
         **/
        virtual ResultValue<FSDKError, bool>
        redetectOne(Human& human) const noexcept = 0;
    };

}