face_sdk_tracker.h

Go to the documentation of this file.

 
#ifndef FACE_SDK_TRACKER_H
#define FACE_SDK_TRACKER_H
 
#include <face_sdk_alignment/alignment.h>
#include <face_sdk_base/export.h>
#include <face_sdk_base/license.h>
#include <face_sdk_base/video_stream.h>
#include <face_sdk_face_detector/face_detector.h>
#include <face_sdk_tracker/face_sdk_track.h>
#include <face_sdk_tracker/face_recognition.h>
 
namespace face_sdk
{
    class itracker_events
    {
    public:
        virtual ~itracker_events() = default;
 
        virtual void on_track_appeared(
            const std::shared_ptr<face_sdk::video_stream> &stream,
            const std::shared_ptr<face_sdk::track> &track,
            const std::shared_ptr<face_sdk::video_frame> &frame,
            const std::shared_ptr<face_sdk::face> &face) = 0;
 
        virtual void on_track_disappeared(
            const std::shared_ptr<face_sdk::video_stream> &stream,
            const std::shared_ptr<face_sdk::track> &track) = 0;
 
        virtual void on_track_updated(
            const std::shared_ptr<face_sdk::video_stream> &stream,
            const std::shared_ptr<face_sdk::track> &track,
            const std::shared_ptr<face_sdk::video_frame> &frame,
            const std::shared_ptr<face_sdk::face> &face) = 0;
 
        virtual void on_track_best_frame(
            const std::shared_ptr<face_sdk::video_stream> &stream,
            const std::shared_ptr<face_sdk::track> &track,
            const std::shared_ptr<face_sdk::video_frame> &frame,
            const std::shared_ptr<face_sdk::face> &face) = 0;
    };
 
    struct tracker_config
    {
        uint32_t version;
        std::shared_ptr<itracker_events> events_handler;
        std::shared_ptr<face_sdk::license> license;
        std::shared_ptr<face_sdk::face_detector> detector;
        std::shared_ptr<face_sdk::alignment> alignment;
        std::shared_ptr<face_sdk::face_recognition> face_recognition;
        float detector_confidence;
        uint32_t frame_frequency;
        float rigid_threshold;
        uint32_t min_detected_scale;
        float alpha;
        uint64_t max_track_length;
 
        tracker_config(uint32_t _version,
                       const std::shared_ptr<itracker_events> &_events_handler,
                       const std::shared_ptr<face_sdk::license> &_license,
                       const std::shared_ptr<face_sdk::face_detector> &_detector,
                       const std::shared_ptr<face_sdk::alignment> &_alignment,
                       const std::shared_ptr<face_sdk::face_recognition> &_face_recognition,
                       float _detector_confidence,
                       uint32_t _frame_frequency,
                       float _rigid_threshold,
                       uint32_t _min_detected_scale,
                       float _alpha,
                       uint64_t _max_track_length = 20
        )
            : version(_version)
            , events_handler(_events_handler)
            , license(_license)
            , detector(_detector)
            , alignment(_alignment)
            , face_recognition(_face_recognition)
            , detector_confidence(_detector_confidence)
            , frame_frequency(_frame_frequency)
            , rigid_threshold(_rigid_threshold)
            , min_detected_scale(_min_detected_scale)
            , alpha(_alpha)
            , max_track_length(_max_track_length)
        {}
    };
 
    class tracker
    {
    public:
 
        virtual ~tracker() = default;
 
        virtual std::shared_ptr<face_sdk::video_stream> make_stream(uint32_t track_id) = 0;
 
        virtual void free_stream(const std::shared_ptr<face_sdk::video_stream> &stream) = 0;
 
        virtual void commit_frames() = 0;
 
        virtual uint32_t version() const = 0;
    };
 
    std::shared_ptr<tracker> FACE_SDK_EXPORT make_tracker(const tracker_config &config);
 
}
 
#endif // FACE_SDK_TRACKER_H