tracking_by_matching.hpp

// This file is part of OpenCV project.




// It is subject to the license terms in the LICENSE file found in the top-level directory




// of this distribution and at http://opencv.org/license.html.








#ifndef __OPENCV_TRACKING_TRACKING_BY_MATCHING_HPP__




#define __OPENCV_TRACKING_TRACKING_BY_MATCHING_HPP__








#include <deque>




#include <iostream>




#include <string>




#include <unordered_map>




#include <vector>




#include <memory>




#include <map>




#include <tuple>




#include <set>








#include "opencv2/core.hpp"




#include "opencv2/imgproc.hpp"












namespace

cv
{



namespace
detail {



inline
namespace
tracking {











namespace
tbm {
//Tracking-by-Matching





struct
CV_EXPORTS
TrackedObject
{



cv::Rect
rect;




double
confidence;




int
frame_idx;




int
object_id;




uint64_t
timestamp;








TrackedObject()



: confidence(-1),



frame_idx(-1),



object_id(-1),



timestamp(0) {}







TrackedObject(const
cv::Rect
&rect,
float
confidence,
int
frame_idx,



int
object_id)



: rect(rect),



confidence(confidence),



frame_idx(frame_idx),



object_id(object_id),



timestamp(0) {}


};







using
TrackedObjects = std::deque<TrackedObject>;







bool
operator==(const
TrackedObject& first,
const
TrackedObject& second);



bool
operator!=(const
TrackedObject& first,
const
TrackedObject& second);



using
ObjectTracks = std::unordered_map<int, TrackedObjects>;







class
CV_EXPORTS
IImageDescriptor
{



public:



virtual
cv::Size
size()
const
= 0;







virtual
void
compute(const
cv::Mat
&mat, CV_OUT
cv::Mat& descr) = 0;







virtual
void
compute(const
std::vector<cv::Mat> &mats,



CV_OUT std::vector<cv::Mat>& descrs) = 0;







virtual
~IImageDescriptor() {}


};











class
CV_EXPORTS
ResizedImageDescriptor
:
public
IImageDescriptor
{



public:



explicit
ResizedImageDescriptor(const
cv::Size
&descr_size,



const
cv::InterpolationFlags
interpolation)



: descr_size_(descr_size), interpolation_(interpolation) {



CV_Assert(descr_size.width
> 0);



CV_Assert(descr_size.height
> 0);



}







cv::Size
size()
const override
{
return
descr_size_; }







void
compute(const
cv::Mat
&mat, CV_OUT
cv::Mat& descr)
override
{



CV_Assert(!mat.empty());



cv::resize(mat, descr, descr_size_, 0, 0, interpolation_);



}







//




void
compute(const
std::vector<cv::Mat> &mats,



CV_OUT std::vector<cv::Mat>& descrs)
override
{



descrs.resize(mats.size());



for
(size_t
i = 0; i < mats.size(); i++)  {



compute(mats[i], descrs[i]);



}



}







private:



cv::Size
descr_size_;







cv::InterpolationFlags
interpolation_;


};











class
CV_EXPORTS
IDescriptorDistance
{



public:



virtual
float
compute(const
cv::Mat
&descr1,
const
cv::Mat
&descr2) = 0;







virtual
std::vector<float>
compute(const
std::vector<cv::Mat> &descrs1,



const
std::vector<cv::Mat> &descrs2) = 0;







virtual
~IDescriptorDistance() {}


};







class
CV_EXPORTS
CosDistance
:
public
IDescriptorDistance
{



public:



explicit
CosDistance(const
cv::Size
&descriptor_size);







float
compute(const
cv::Mat
&descr1,
const
cv::Mat
&descr2)
override;







std::vector<float>
compute(



const
std::vector<cv::Mat> &descrs1,



const
std::vector<cv::Mat> &descrs2)
override;







private:



cv::Size
descriptor_size_;


};











class
CV_EXPORTS
MatchTemplateDistance
:
public
IDescriptorDistance
{



public:



MatchTemplateDistance(int
type =
cv::TemplateMatchModes::TM_CCORR_NORMED,



float
scale = -1,
float
offset = 1)



: type_(type), scale_(scale), offset_(offset) {}



float
compute(const
cv::Mat
&descr1,
const
cv::Mat
&descr2)
override;



std::vector<float>
compute(const
std::vector<cv::Mat> &descrs1,



const
std::vector<cv::Mat> &descrs2)
override;



virtual
~MatchTemplateDistance() {}







private:



int
type_;




float
scale_;




float
offset_;



};







struct
CV_EXPORTS
TrackerParams
{



size_t
min_track_duration;








size_t
forget_delay;








float
aff_thr_fast;








float
aff_thr_strong;








float
shape_affinity_w;








float
motion_affinity_w;








float
time_affinity_w;








float
min_det_conf;








cv::Vec2f
bbox_aspect_ratios_range;








cv::Vec2f
bbox_heights_range;








int
predict;








float
strong_affinity_thr;








float
reid_thr;








bool
drop_forgotten_tracks;








int
max_num_objects_in_track;








TrackerParams();


};







class
CV_EXPORTS
Track
{



public:



Track(const
TrackedObjects &objs,
const
cv::Mat
&last_image,



const
cv::Mat
&descriptor_fast,
const
cv::Mat
&descriptor_strong)



: objects(objs),



predicted_rect(!objs.empty() ? objs.back().rect :
cv::Rect()),



last_image(last_image),



descriptor_fast(descriptor_fast),



descriptor_strong(descriptor_strong),



lost(0),



length(1) {



CV_Assert(!objs.empty());



first_object = objs[0];



}







bool
empty()
const
{
return
objects.empty(); }







size_t
size()
const
{
return
objects.size(); }







const
TrackedObject
&operator[](size_t
i)
const
{
return
objects[i]; }







TrackedObject
&operator[](size_t
i) {
return
objects[i]; }







const
TrackedObject
&back()
const
{



CV_Assert(!empty());



return
objects.back();



}







TrackedObject
&back() {



CV_Assert(!empty());



return
objects.back();



}







TrackedObjects
objects;




cv::Rect
predicted_rect;




cv::Mat
last_image;




cv::Mat
descriptor_fast;




cv::Mat
descriptor_strong;




size_t
lost;








TrackedObject
first_object;




size_t
length;



};







class
CV_EXPORTS
ITrackerByMatching
{



public:



using
Descriptor = std::shared_ptr<IImageDescriptor>;



using
Distance = std::shared_ptr<IDescriptorDistance>;







virtual
~ITrackerByMatching() {}







virtual
void
process(const
cv::Mat
&frame,
const
TrackedObjects &detections,



uint64_t timestamp) = 0;







virtual
const
TrackerParams
&params()
const
= 0;







virtual
void
setParams(const
TrackerParams
&params) = 0;







virtual
const
Descriptor &descriptorFast()
const
= 0;







virtual
void
setDescriptorFast(const
Descriptor &val) = 0;







virtual
const
Descriptor &descriptorStrong()
const
= 0;







virtual
void
setDescriptorStrong(const
Descriptor &val) = 0;







virtual
const
Distance &distanceFast()
const
= 0;







virtual
void
setDistanceFast(const
Distance &val) = 0;







virtual
const
Distance &distanceStrong()
const
= 0;







virtual
void
setDistanceStrong(const
Distance &val) = 0;







virtual
size_t
count()
const
= 0;







virtual
std::unordered_map<size_t, std::vector<cv::Point> >
getActiveTracks()
const
= 0;







virtual
TrackedObjects
trackedDetections()
const
= 0;







virtual
cv::Mat
drawActiveTracks(const
cv::Mat
&frame) = 0;







virtual
bool
isTrackForgotten(size_t
id)
const
= 0;







virtual
const
std::unordered_map<size_t, Track> &tracks()
const
= 0;







virtual
bool
isTrackValid(size_t
track_id)
const
= 0;







virtual
void
dropForgottenTracks() = 0;







virtual
void
dropForgottenTrack(size_t
track_id) = 0;


};






CV_EXPORTS
cv::Ptr<ITrackerByMatching>
createTrackerByMatching(const
TrackerParams
&params =
TrackerParams());






}
// namespace tbm











}}}
// namespace




#endif

// #ifndef __OPENCV_TRACKING_TRACKING_BY_MATCHING_HPP__