Tracking CSRT and MOSSE

binding.gyp

@@ -88,6 +88,9 @@
 			"cc/modules/tracking/Trackers/TrackerMedianFlow.cc",
 			"cc/modules/tracking/Trackers/TrackerTLD.cc",
 			"cc/modules/tracking/Trackers/TrackerGOTURN.cc",
+			"cc/modules/tracking/Trackers/TrackerCSRT.cc",
+			"cc/modules/tracking/Trackers/TrackerCSRTParams.cc",
+			"cc/modules/tracking/Trackers/TrackerMOSSE.cc",
 			"cc/modules/features2d/features2d.cc",
 			"cc/modules/features2d/KeyPoint.cc",
 			"cc/modules/features2d/KeyPointMatch.cc",

cc/macros.h

@@ -111,6 +111,7 @@ static FF_FUNC_TYPE ff_func = FF_FUNC_TYPE();
 #define FF_SETTER_UINT(clazz, name, prop) FF_SETTER(clazz, name, prop, ff_uint)
 #define FF_SETTER_NUMBER(clazz, name, prop) FF_SETTER(clazz, name, prop, ff_number)
 #define FF_SETTER_BOOL(clazz, name, prop) FF_SETTER(clazz, name, prop, ff_bool)
+#define FF_SETTER_STRING(clazz, name, prop) FF_SETTER(clazz, name, prop, ff_string)
 
 #define FF_SETTER_SIMPLE(clazz, name, prop, converter)  										\
 	NAN_SETTER(name##Set) {																										\

cc/modules/tracking/MultiTracker.cc

@@ -19,6 +19,12 @@ NAN_MODULE_INIT(MultiTracker::Init) {
 	Nan::SetPrototypeMethod(ctor, "addMEDIANFLOW", MultiTracker::AddMEDIANFLOW);
 	Nan::SetPrototypeMethod(ctor, "addTLD", MultiTracker::AddTLD);
 	Nan::SetPrototypeMethod(ctor, "addKCF", MultiTracker::AddKCF);
+#if CV_MINOR_VERSION > 3
+	Nan::SetPrototypeMethod(ctor, "addMOSSE", MultiTracker::AddTLD);
+#endif
+#if CV_MINOR_VERSION > 4 || (CV_MINOR_VERSION == 4 && CV_SUBMINOR_VERSION > 0)
+	Nan::SetPrototypeMethod(ctor, "addCSRT", MultiTracker::AddKCF);
+#endif
 	Nan::SetPrototypeMethod(ctor, "update", MultiTracker::Update);
 
 	target->Set(FF_NEW_STRING("MultiTracker"), ctor->GetFunction());
@@ -114,6 +120,29 @@ NAN_METHOD(MultiTracker::Update) {
 	}
 	FF_RETURN(jsRects);
 }
+#if CV_MINOR_VERSION > 3
+
+NAN_METHOD(MultiTracker::AddMOSSE) {
+	FF_METHOD_CONTEXT("MultiTracker::AddMOSSE");
+	FF_ARG_INSTANCE(0, cv::Mat image, Mat::constructor, FF_UNWRAP_MAT_AND_GET);
+	FF_ARG_INSTANCE(1, cv::Rect2d boundingBox, Rect::constructor, FF_UNWRAP_RECT_AND_GET);
+	cv::Ptr<cv::Tracker> type = cv::TrackerMOSSE::create();
+	bool ret = FF_UNWRAP(info.This(), MultiTracker)->tracker.add(type, image, boundingBox);
+	FF_RETURN(Nan::New(ret));
+}
+
+#endif
+#if CV_MINOR_VERSION > 4 || (CV_MINOR_VERSION == 4 && CV_SUBMINOR_VERSION > 0)
+
+NAN_METHOD(MultiTracker::AddCSRT) {
+	FF_METHOD_CONTEXT("MultiTracker::AddCSRT");
+	FF_ARG_INSTANCE(0, cv::Mat image, Mat::constructor, FF_UNWRAP_MAT_AND_GET);
+	FF_ARG_INSTANCE(1, cv::Rect2d boundingBox, Rect::constructor, FF_UNWRAP_RECT_AND_GET);
+	cv::Ptr<cv::Tracker> type = cv::TrackerCSRT::create();
+	bool ret = FF_UNWRAP(info.This(), MultiTracker)->tracker.add(type, image, boundingBox);
+	FF_RETURN(Nan::New(ret));
+}
+#endif
 
 #endif
 

cc/modules/tracking/MultiTracker.h

@@ -20,6 +20,8 @@ class MultiTracker : public Nan::ObjectWrap {
 	static NAN_METHOD(AddMEDIANFLOW);
 	static NAN_METHOD(AddTLD);
 	static NAN_METHOD(AddKCF);
+	static NAN_METHOD(AddMOSSE);
+	static NAN_METHOD(AddCSRT);
 	static NAN_METHOD(Update);
 
 	static Nan::Persistent<v8::FunctionTemplate> constructor;

cc/modules/tracking/Trackers/TrackerCSRT.cc

@@ -0,0 +1,45 @@
+#ifdef HAVE_TRACKING
+
+#include "TrackerCSRT.h"
+#include "TrackerCSRTParams.h"
+
+#if CV_MINOR_VERSION > 4 || (CV_MINOR_VERSION == 4 && CV_SUBMINOR_VERSION > 0)
+
+Nan::Persistent<v8::FunctionTemplate> TrackerCSRT::constructor;
+
+NAN_MODULE_INIT(TrackerCSRT::Init) {
+	v8::Local<v8::FunctionTemplate> ctor = Nan::New<v8::FunctionTemplate>(TrackerCSRT::New);
+	v8::Local<v8::ObjectTemplate> instanceTemplate = ctor->InstanceTemplate();
+
+	Tracker::Init(ctor);
+	TrackerCSRTParams::Init(target);
+
+	constructor.Reset(ctor);
+	ctor->SetClassName(FF_NEW_STRING("TrackerCSRT"));
+	instanceTemplate->SetInternalFieldCount(1);
+
+	target->Set(FF_NEW_STRING("TrackerCSRT"), ctor->GetFunction());
+};
+
+
+NAN_METHOD(TrackerCSRT::New) {
+	FF_ASSERT_CONSTRUCT_CALL(TrackerCSRT);
+	FF_METHOD_CONTEXT("TrackerCSRT::New");
+
+	FF_ARG_INSTANCE_IFDEF(
+		0,
+		cv::TrackerCSRT::Params params,
+		TrackerCSRTParams::constructor,
+		FF_UNWRAP_TRACKERCSRTPARAMS_AND_GET,
+		cv::TrackerCSRT::Params()
+	);
+
+	TrackerCSRT* self = new TrackerCSRT();
+	self->tracker = cv::TrackerCSRT::create(params);
+	self->Wrap(info.Holder());
+	FF_RETURN(info.Holder());
+};
+
+#endif
+
+#endif

cc/modules/tracking/Trackers/TrackerCSRT.h

@@ -0,0 +1,24 @@
+#include "../Tracker.h"
+
+#if CV_MINOR_VERSION > 4 || (CV_MINOR_VERSION == 4 && CV_SUBMINOR_VERSION > 0)
+
+#ifndef __FF_TRACKERCSRT_H__
+#define __FF_TRACKERCSRT_H__
+
+class TrackerCSRT : public Tracker {
+public:
+	cv::Ptr<cv::TrackerCSRT> tracker;
+
+	static NAN_MODULE_INIT(Init);
+	static NAN_METHOD(New);
+
+	static Nan::Persistent<v8::FunctionTemplate> constructor;
+
+	cv::Ptr<cv::Tracker> getTracker() {
+		return tracker;
+	}
+};
+
+#endif
+
+#endif

cc/modules/tracking/Trackers/TrackerCSRTParams.cc

@@ -0,0 +1,61 @@
+#ifdef HAVE_TRACKING
+
+#include "TrackerCSRTParams.h"
+
+#if CV_MINOR_VERSION > 4 || (CV_MINOR_VERSION == 4 && CV_SUBMINOR_VERSION > 0)
+
+Nan::Persistent<v8::FunctionTemplate> TrackerCSRTParams::constructor;
+
+NAN_MODULE_INIT(TrackerCSRTParams::Init) {
+	v8::Local<v8::FunctionTemplate> ctor = Nan::New<v8::FunctionTemplate>(TrackerCSRTParams::New);
+	v8::Local<v8::ObjectTemplate> instanceTemplate = ctor->InstanceTemplate();
+
+	constructor.Reset(ctor);
+	ctor->SetClassName(FF_NEW_STRING("TrackerCSRTParams"));
+	instanceTemplate->SetInternalFieldCount(1);
+
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("admm_iterations"), admm_iterationsGet, admm_iterationsSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("background_ratio"), background_ratioGet, background_ratioSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("cheb_attenuation"), cheb_attenuationGet, cheb_attenuationSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("filter_lr"), filter_lrGet, filter_lrSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("gsl_sigma"), gsl_sigmaGet, gsl_sigmaSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("histogram_bins"), histogram_binsGet, histogram_binsSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("histogram_lr"), histogram_lrGet, histogram_lrSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("hog_clip"), hog_clipGet, hog_clipSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("hog_orientations"), hog_orientationsGet, hog_orientationsSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("kaiser_alpha"), kaiser_alphaGet, kaiser_alphaSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("num_hog_channels_used"), num_hog_channels_usedGet, num_hog_channels_usedSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("number_of_scales"), number_of_scalesGet, number_of_scalesSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("padding"), paddingGet, paddingSet);
+#if CV_MINOR_VERSION > 4 || (CV_MINOR_VERSION == 4 && CV_SUBMINOR_VERSION > 3)
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("psr_threshold"), psr_thresholdGet, psr_thresholdSet);
+#endif
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("scale_lr"), scale_lrGet, scale_lrSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("scale_model_max_area"), scale_model_max_areaGet, scale_model_max_areaSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("scale_sigma_factor"), scale_sigma_factorGet, scale_sigma_factorSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("scale_step"), scale_stepGet, scale_stepSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("template_size"), template_sizeGet, template_sizeSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("use_channel_weights"), use_channel_weightsGet, use_channel_weightsSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("use_color_names"), use_color_namesGet, use_color_namesSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("use_gray"), use_grayGet, use_graySet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("use_hog"), use_hogGet, use_hogSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("use_rgb"), use_rgbGet, use_rgbSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("use_segmentation"), use_segmentationGet, use_segmentationSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("weights_lr"), weights_lrGet, weights_lrSet);
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("window_function"), window_functionGet, window_functionSet);
+
+	target->Set(FF_NEW_STRING("TrackerCSRTParams"), ctor->GetFunction());
+};
+
+NAN_METHOD(TrackerCSRTParams::New) {
+	FF_ASSERT_CONSTRUCT_CALL(TrackerCSRTParams);
+	FF_METHOD_CONTEXT("TrackerCSRTParams::New");
+	TrackerCSRTParams* self = new TrackerCSRTParams();
+	self->params = cv::TrackerCSRT::Params();
+	self->Wrap(info.Holder());
+	FF_RETURN(info.Holder());
+};
+
+#endif
+
+#endif

cc/modules/tracking/Trackers/TrackerCSRTParams.h

@@ -0,0 +1,83 @@
+#include "macros.h"
+#include <opencv2/tracking.hpp>
+
+#if CV_MINOR_VERSION > 4 || (CV_MINOR_VERSION == 4 && CV_SUBMINOR_VERSION > 0)
+
+#ifndef __FF_TRACKERCSRTPARAMS_H__
+#define __FF_TRACKERCSRTPARAMS_H__
+
+class TrackerCSRTParams : public Nan::ObjectWrap {
+public:
+	cv::TrackerCSRT::Params params;
+
+  static NAN_MODULE_INIT(Init);
+  static NAN_METHOD(New);
+
+	static FF_GETTER(TrackerCSRTParams, admm_iterationsGet, params.admm_iterations);
+	static FF_SETTER_INT(TrackerCSRTParams, admm_iterations, params.admm_iterations);
+	static FF_GETTER(TrackerCSRTParams, background_ratioGet, params.background_ratio);
+	static FF_SETTER_INT(TrackerCSRTParams, background_ratio, params.background_ratio);
+	static FF_GETTER(TrackerCSRTParams, cheb_attenuationGet, params.cheb_attenuation);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, cheb_attenuation, params.cheb_attenuation);
+	static FF_GETTER(TrackerCSRTParams, filter_lrGet, params.filter_lr);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, filter_lr, params.filter_lr);
+	static FF_GETTER(TrackerCSRTParams, gsl_sigmaGet, params.gsl_sigma);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, gsl_sigma, params.gsl_sigma);
+	static FF_GETTER(TrackerCSRTParams, histogram_binsGet, params.histogram_bins);
+	static FF_SETTER_INT(TrackerCSRTParams, histogram_bins, params.histogram_bins);
+	static FF_GETTER(TrackerCSRTParams, histogram_lrGet, params.histogram_lr);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, histogram_lr, params.histogram_lr);
+	static FF_GETTER(TrackerCSRTParams, hog_clipGet, params.hog_clip);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, hog_clip, params.hog_clip);
+	static FF_GETTER(TrackerCSRTParams, hog_orientationsGet, params.hog_orientations);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, hog_orientations, params.hog_orientations);
+	static FF_GETTER(TrackerCSRTParams, kaiser_alphaGet, params.kaiser_alpha);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, kaiser_alpha, params.kaiser_alpha);
+	static FF_GETTER(TrackerCSRTParams, num_hog_channels_usedGet, params.num_hog_channels_used);
+	static FF_SETTER_INT(TrackerCSRTParams, num_hog_channels_used, params.num_hog_channels_used);
+	static FF_GETTER(TrackerCSRTParams, number_of_scalesGet, params.number_of_scales);
+	static FF_SETTER_INT(TrackerCSRTParams, number_of_scales, params.number_of_scales);
+	static FF_GETTER(TrackerCSRTParams, paddingGet, params.padding);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, padding, params.padding);
+
+#if CV_MINOR_VERSION > 4 || (CV_MINOR_VERSION == 4 && CV_SUBMINOR_VERSION > 3)
+	static FF_GETTER(TrackerCSRTParams, psr_thresholdGet, params.psr_threshold);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, psr_threshold, params.psr_threshold);
+#endif
+
+	static FF_GETTER(TrackerCSRTParams, scale_lrGet, params.scale_lr);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, scale_lr, params.scale_lr);
+	static FF_GETTER(TrackerCSRTParams, scale_model_max_areaGet, params.scale_model_max_area);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, scale_model_max_area, params.scale_model_max_area);
+	static FF_GETTER(TrackerCSRTParams, scale_sigma_factorGet, params.scale_sigma_factor);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, scale_sigma_factor, params.scale_sigma_factor);
+	static FF_GETTER(TrackerCSRTParams, scale_stepGet, params.scale_step);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, scale_step, params.scale_step);
+	static FF_GETTER(TrackerCSRTParams, template_sizeGet, params.template_size);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, template_size, params.template_size);
+	static FF_GETTER(TrackerCSRTParams, use_channel_weightsGet, params.use_channel_weights);
+	static FF_SETTER_BOOL(TrackerCSRTParams, use_channel_weights, params.use_channel_weights);
+	static FF_GETTER(TrackerCSRTParams, use_color_namesGet, params.use_color_names);
+	static FF_SETTER_BOOL(TrackerCSRTParams, use_color_names, params.use_color_names);
+	static FF_GETTER(TrackerCSRTParams, use_grayGet, params.use_gray);
+	static FF_SETTER_BOOL(TrackerCSRTParams, use_gray, params.use_gray);
+	static FF_GETTER(TrackerCSRTParams, use_hogGet, params.use_hog);
+	static FF_SETTER_BOOL(TrackerCSRTParams, use_hog, params.use_hog);
+	static FF_GETTER(TrackerCSRTParams, use_rgbGet, params.use_rgb);
+	static FF_SETTER_BOOL(TrackerCSRTParams, use_rgb, params.use_rgb);
+	static FF_GETTER(TrackerCSRTParams, use_segmentationGet, params.use_segmentation);
+	static FF_SETTER_BOOL(TrackerCSRTParams, use_segmentation, params.use_segmentation);
+	static FF_GETTER(TrackerCSRTParams, weights_lrGet, params.weights_lr);
+	static FF_SETTER_NUMBER(TrackerCSRTParams, weights_lr, params.weights_lr);	
+	static FF_GETTER_SIMPLE(TrackerCSRTParams, window_functionGet, params.window_function, StringConverter);
+	static FF_SETTER_STRING(TrackerCSRTParams, window_function, params.window_function);
+
+	static Nan::Persistent<v8::FunctionTemplate> constructor;
+};
+
+#define FF_UNWRAP_TRACKERCSRTPARAMS(obj) FF_UNWRAP(obj, TrackerCSRTParams)
+#define FF_UNWRAP_TRACKERCSRTPARAMS_AND_GET(obj) FF_UNWRAP_TRACKERCSRTPARAMS(obj)->params
+
+#endif
+
+#endif

cc/modules/tracking/Trackers/TrackerKCFParams.cc

@@ -27,7 +27,9 @@ NAN_MODULE_INIT(TrackerKCFParams::Init) {
 	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("compressed_size"), compressed_sizeGet, compressed_sizeSet);
 	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("desc_pca"), desc_pcaGet, desc_pcaSet);
 	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("desc_npca"), desc_npcaGet, desc_npcaSet);
-
+#if CV_MINOR_VERSION > 2
+	Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("detect_thresh"), detect_threshGet, detect_threshSet);
+#endif
 	target->Set(FF_NEW_STRING("TrackerKCFParams"), ctor->GetFunction());
 };
 

cc/modules/tracking/Trackers/TrackerKCFParams.h

@@ -23,6 +23,7 @@ class TrackerKCFParams : public Nan::ObjectWrap {
 	static FF_SETTER_NUMBER(TrackerKCFParams, output_sigma_factor, params.output_sigma_factor);
 	static FF_GETTER(TrackerKCFParams, pca_learning_rateGet, params.pca_learning_rate);
 	static FF_SETTER_NUMBER(TrackerKCFParams, pca_learning_rate, params.pca_learning_rate);
+
 	static FF_GETTER(TrackerKCFParams, resizeGet, params.resize);
 	static FF_SETTER_BOOL(TrackerKCFParams, resize, params.resize);
 	static FF_GETTER(TrackerKCFParams, split_coeffGet, params.split_coeff);
@@ -39,6 +40,11 @@ class TrackerKCFParams : public Nan::ObjectWrap {
 	static FF_SETTER_UINT(TrackerKCFParams, desc_pca, params.desc_pca);
 	static FF_GETTER(TrackerKCFParams, desc_npcaGet, params.desc_npca);
 	static FF_SETTER_UINT(TrackerKCFParams, desc_npca, params.desc_npca);
+
+#if CV_MINOR_VERSION > 2
+	static FF_GETTER(TrackerKCFParams, detect_threshGet, params.detect_thresh);
+	static FF_SETTER_NUMBER(TrackerKCFParams, detect_thresh, params.detect_thresh);
+#endif
 
 	static Nan::Persistent<v8::FunctionTemplate> constructor;
 };

cc/modules/tracking/Trackers/TrackerMOSSE.cc

@@ -0,0 +1,35 @@
+#ifdef HAVE_TRACKING
+
+#include "TrackerMOSSE.h"
+
+#if CV_MINOR_VERSION > 3
+
+Nan::Persistent<v8::FunctionTemplate> TrackerMOSSE::constructor;
+
+NAN_MODULE_INIT(TrackerMOSSE::Init) {
+	v8::Local<v8::FunctionTemplate> ctor = Nan::New<v8::FunctionTemplate>(TrackerMOSSE::New);
+	v8::Local<v8::ObjectTemplate> instanceTemplate = ctor->InstanceTemplate();
+
+	Tracker::Init(ctor);
+
+	constructor.Reset(ctor);
+	ctor->SetClassName(FF_NEW_STRING("TrackerMOSSE"));
+	instanceTemplate->SetInternalFieldCount(1);
+
+	target->Set(FF_NEW_STRING("TrackerMOSSE"), ctor->GetFunction());
+};
+
+
+NAN_METHOD(TrackerMOSSE::New) {
+	FF_ASSERT_CONSTRUCT_CALL(TrackerMOSSE);
+	FF_METHOD_CONTEXT("TrackerMOSSE::New");
+
+	TrackerMOSSE* self = new TrackerMOSSE();
+	self->tracker = cv::TrackerMOSSE::create();
+	self->Wrap(info.Holder());
+	FF_RETURN(info.Holder());
+};
+
+#endif
+
+#endif

cc/modules/tracking/Trackers/TrackerMOSSE.h

@@ -0,0 +1,24 @@
+#include "../Tracker.h"
+
+#if CV_MINOR_VERSION > 3
+
+#ifndef __FF_TRACKERMOSSE_H__
+#define __FF_TRACKERMOSSE_H__
+
+class TrackerMOSSE : public Tracker {
+public:
+	cv::Ptr<cv::TrackerMOSSE> tracker;
+
+	static NAN_MODULE_INIT(Init);
+	static NAN_METHOD(New);
+
+	static Nan::Persistent<v8::FunctionTemplate> constructor;
+
+	cv::Ptr<cv::Tracker> getTracker() {
+		return tracker;
+	}
+};
+
+#endif
+
+#endif