face_sdk_tracker.h

#pragma once

#include <face_sdk_base/export.h>

#include <face_sdk_base/exception.h>
#include <face_sdk_base/license.h>
#include <face_sdk_base/video_stream.h>
#include <face_sdk_alignment/alignment.h>
#include <face_sdk_face_detector/face_detector.h>
#include <face_sdk_tracker/face_recognition.h>
#include <face_sdk_tracker/face_sdk_track.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;

        virtual void on_frame_process_error(
            const face_sdk::exception &exc,
            const std::shared_ptr<face_sdk::video_stream> &stream,
            const std::shared_ptr<face_sdk::video_frame> &frame) = 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;
        int32_t compute_device;

        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,
                       int32_t _compute_device = -1
        )
            : 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)
            , compute_device(_compute_device)
        {}
    };

    class tracker
    {
    public:

        virtual ~tracker() = default;

        virtual std::shared_ptr<face_sdk::video_stream> make_stream(uint32_t stream_id) = 0;

        virtual void free_stream(const std::shared_ptr<face_sdk::video_stream> &stream) = 0;

        virtual void commit_frames() noexcept = 0;

        virtual uint32_t version() const = 0;
    };

    std::shared_ptr<tracker> FACE_SDK_EXPORT make_tracker(const tracker_config &config);

}