tracker.cpp

#include <face_sdk_tracker/face_sdk_tracker.h>
#include <face_sdk_base/exception.h>
 
#include <boost/filesystem.hpp>
 
#include <iostream>
#include <fstream>
 
namespace fs = boost::filesystem;
 
std::vector< std::shared_ptr<face_sdk::video_frame> > load_frames(const std::string &directory, uint32_t max_frames = std::numeric_limits<uint32_t>::max())
{
    int32_t fps = 0;
    {
        fs::path fps_file_path = fs::path(directory) / "fps";
 
        std::ifstream stream;
        stream.exceptions(std::ios::badbit | std::ios::failbit);
        stream.open(fps_file_path.string());
        stream >> fps;
    }
 
    std::vector< std::shared_ptr<face_sdk::video_frame> > frames;
 
    auto dir_it = fs::directory_iterator(fs::path(directory));
    while (dir_it != fs::directory_iterator()) {
        auto entry = *dir_it;
        if (fs::extension(entry.path()) == ".jpg") {
            auto image = face_sdk::load_image_from_file(entry.path().string());
            uint32_t frame_id = std::stol(entry.path().filename().string());
            auto frame = face_sdk::make_video_frame(frame_id, std::chrono::milliseconds(frame_id * (1000 / fps)), image);
            frames.push_back(frame);
 
            if (max_frames <= frames.size()) {
                break;
            }
        }
        dir_it++;
    }
 
    std::sort(
        frames.begin(),
        frames.end(),
        [](const  std::shared_ptr<face_sdk::video_frame> &f, const  std::shared_ptr<face_sdk::video_frame> f1) -> bool { return f->frame_id() < f1->frame_id(); });
 
    return frames;
}
 
class events_handler : public face_sdk::itracker_events
{
public:
 
    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) override
    {
        std::cout << "--- on_track_appeared ---" << std::endl;
        std::cout << "    stream_id = " << stream->stream_id() << std::endl;
        std::cout << "    track_id  = " << track->track_id() << std::endl;
        std::cout << "    frame     = " << frame->frame_id() << std::endl;
        std::cout << "    face      = [ x = " << face->x()
                                  << ", y = " << face->y()
                                  << ", width =  " << face->width()
                                  << ", height " << face->height()
                                  << "]" << std::endl << std::endl;
 
        // you can save the track object to examine all frames and faces in the track later
    }
 
    virtual void on_track_disappeared(
        const std::shared_ptr<face_sdk::video_stream>& stream,
        const std::shared_ptr<face_sdk::track>& track) override
    {
        std::cout << "--- on_track_disappeared ---" << std::endl;
        std::cout << "    stream_id = " << stream->stream_id() << std::endl;
        std::cout << "    track_id  = " << track->track_id() << std::endl << std::endl;
    }
 
    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) override
    {
        std::cout << "--- on_track_updated ---" << std::endl;
        std::cout << "    stream_id = " << stream->stream_id() << std::endl;
        std::cout << "    track_id  = " << track->track_id() << std::endl;
        std::cout << "    frame     = " << frame->frame_id() << std::endl;
        std::cout << "    face      = [ x = " << face->x()
            << ", y = " << face->y()
            << ", width =  " << face->width()
            << ", height " << face->height()
            << "]" << std::endl << std::endl;
    }
 
    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) override
    {
        std::cout << "--- on_track_best_frame ---" << std::endl;
        std::cout << "    stream_id = " << stream->stream_id() << std::endl;
        std::cout << "    track_id  = " << track->track_id() << std::endl;
        std::cout << "    frame     = " << frame->frame_id() << std::endl;
        std::cout << "    face      = [ x = " << face->x()
            << ", y = " << face->y()
            << ", width =  " << face->width()
            << ", height " << face->height()
            << "]" << std::endl << std::endl;
    }
 
};
 
int main(int argc, char **argv)
{
    std::shared_ptr<face_sdk::tracker> tracker = nullptr;
    std::shared_ptr<events_handler> handler = std::make_shared<events_handler>();
 
    try {
        // make a tracker object
        // ...
        // also you can make face_detector manually to use GPU in batch mode:
        // auto detector = face_sdk::make_face_detector(103, 32, 0);
        // face_sdk::make_tracker(100, handler, detector);
        tracker = face_sdk::make_tracker(100, handler);
    }
    catch (const face_sdk::exception &exp) {
 
        // print the stack of nested exceptions ...
        std::cerr << face_sdk::format_exception(exp) << std::endl;
 
        // ... or handle more detailed exceptions
        try {
            std::rethrow_if_nested(exp);
        }
        catch (const face_sdk::version_not_available_exception &nested) {
            // ...
            std::cerr << nested.what() << std::endl;
        }
        catch (const face_sdk::license_exception &nested) {
            // ...
            std::cerr << nested.what() << std::endl;
        }
        catch (const std::exception &nested) {
            // ...
            std::cerr << nested.what() << std::endl;
        }
 
        return 1;
    }
 
    // make a stream object
    std::shared_ptr<face_sdk::video_stream> stream = tracker->make_stream(0);
    // ...
    // also you can make many stream objects at the same time:
    // std::shared_ptr<face_sdk::video_stream> stream1 = tracker->make_stream(1);
    // std::shared_ptr<face_sdk::video_stream> stream2 = tracker->make_stream(2);
 
 
    // load frames from directory
    // ...
    // you can decode a number of frames from video stream:
    // auto frames = decode_new_frames(...);
    auto frames = load_frames(std::string(argv[1]));
 
    for (auto frame : frames) {
 
        try {
            // push and commit each frame
            // ...
            // or
            // you can push many frames to many streams before call commit_frames.
            // it might be more efficient if you use GPU in batch mode.
            //
            // for (auto frame : frames) {
            //    stream->push_frame(frame);
            // }
            // tracker->commit_frames();
            //
            stream->push_frame(frame);
            tracker->commit_frames();
        }
        catch (const face_sdk::exception &exp) {
 
            // print the stack of nested exceptions ...
            std::cerr << face_sdk::format_exception(exp) << std::endl;
 
            // ... or handle more detailed exceptions
            try {
                std::rethrow_if_nested(exp);
            }
            catch (const face_sdk::version_not_available_exception &nested) {
                // ...
                std::cerr << nested.what() << std::endl;
            }
            catch (const face_sdk::license_exception &nested) {
                // ...
                std::cerr << nested.what() << std::endl;
            }
            catch (const std::exception &nested) {
                // ...
                std::cerr << nested.what() << std::endl;
            }
 
            tracker->free_stream(stream);
            return 2;
        }
 
    }
 
    // when all frames are processed you must call free_stream() to free resources
    tracker->free_stream(stream);
 
    return 0;
}