Add legacy

contrib/legacy/cgo.go

@@ -0,0 +1,13 @@
+// +build !customenv,!openvino
+
+package legacy
+
+// Changes here should be mirrored in gocv/cgo.go and cuda/cgo.go
+
+/*
+#cgo !windows pkg-config: opencv4
+#cgo CXXFLAGS:   --std=c++11
+#cgo windows  CPPFLAGS:   -IC:/opencv/build/install/include
+#cgo windows  LDFLAGS:    -LC:/opencv/build/install/x64/mingw/lib -lopencv_core452 -lopencv_face452 -lopencv_videoio452 -lopencv_imgproc452 -lopencv_highgui452 -lopencv_imgcodecs452 -lopencv_objdetect452 -lopencv_features2d452 -lopencv_video452 -lopencv_dnn452 -lopencv_xfeatures2d452 -lopencv_plot452 -lopencv_tracking452 -lopencv_img_hash452 -lopencv_calib3d452 -lopencv_bgsegm452
+*/
+import "C"

contrib/legacy/contrib.go

@@ -0,0 +1,6 @@
+// Package contrib is the GoCV wrapper around OpenCV Contrib.
+//
+// For further details, please see:
+// https://github.com/opencv/opencv_contrib
+//
+package legacy // import "gocv.io/x/gocv/contrib/legacy"

contrib/legacy/tracking.cpp

@@ -0,0 +1,76 @@
+#include "tracking.h"
+#include <opencv2/opencv.hpp>
+
+
+bool Tracker_Init(Tracker self, Mat image, Rect boundingBox) {
+    cv::Rect2d bb(boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height);
+
+    bool ret = (*self)->init(*image, bb);
+    return ret;
+}
+
+bool Tracker_Update(Tracker self, Mat image, Rect* boundingBox) {
+    cv::Rect2d bb;
+    bool ret = (*self)->update(*image, bb);
+    boundingBox->x = int(bb.x);
+    boundingBox->y = int(bb.y);
+    boundingBox->width = int(bb.width);
+    boundingBox->height = int(bb.height);
+    return ret;
+}
+
+TrackerMIL TrackerMIL_Create() {
+    return new cv::Ptr<cv::legacy::TrackerMIL>(cv::legacy::TrackerMIL::create());
+}
+
+void TrackerMIL_Close(TrackerMIL self) {
+    delete self;
+}
+
+TrackerBoosting TrackerBoosting_Create() {
+    return new cv::Ptr<cv::legacy::TrackerBoosting>(cv::legacy::TrackerBoosting::create());
+}
+
+void TrackerBoosting_Close(TrackerBoosting self) {
+    delete self;
+}
+
+TrackerMedianFlow TrackerMedianFlow_Create() {
+    return new cv::Ptr<cv::legacy::TrackerMedianFlow>(cv::legacy::TrackerMedianFlow::create());
+}
+
+void TrackerMedianFlow_Close(TrackerMedianFlow self) {
+    delete self;
+}
+
+TrackerTLD TrackerTLD_Create() {
+    return new cv::Ptr<cv::legacy::TrackerTLD>(cv::legacy::TrackerTLD::create());
+}
+
+void TrackerTLD_Close(TrackerTLD self) {
+    delete self;
+}
+
+TrackerKCF TrackerKCF_Create() {
+    return new cv::Ptr<cv::legacy::TrackerKCF>(cv::legacy::TrackerKCF::create());
+}
+
+void TrackerKCF_Close(TrackerKCF self) {
+    delete self;
+}
+
+TrackerMOSSE TrackerMOSSE_Create() {
+    return new cv::Ptr<cv::legacy::TrackerMOSSE>(cv::legacy::TrackerMOSSE::create());
+}
+
+void TrackerMOSSE_Close(TrackerMOSSE self) {
+    delete self;
+}
+
+TrackerCSRT TrackerCSRT_Create() {
+    return new cv::Ptr<cv::legacy::TrackerCSRT>(cv::legacy::TrackerCSRT::create());
+}
+
+void TrackerCSRT_Close(TrackerCSRT self) {
+    delete self;
+}

contrib/legacy/tracking.go

@@ -0,0 +1,236 @@
+package legacy
+
+/*
+#include "tracking.h"
+*/
+import "C"
+import (
+	"image"
+
+	"gocv.io/x/gocv"
+)
+
+// TrackerBoosting is a real-time object tracker based
+// on a novel on-line version of the AdaBoost algorithm.
+//
+// For further details, please see:
+// https://docs.opencv.org/master/db/df1/classcv_1_1legacy_1_1TrackerBoosting.html
+//
+type TrackerBoosting struct {
+	p C.TrackerBoosting
+}
+
+// NewTrackerBoosting returns a new TrackerBoosting.
+func NewTrackerBoosting() gocv.Tracker {
+	return TrackerBoosting{p: C.TrackerBoosting_Create()}
+}
+
+// Close closes the TrackerBoosting.
+func (trk TrackerBoosting) Close() error {
+	C.TrackerBoosting_Close(trk.p)
+	trk.p = nil
+	return nil
+}
+
+// Init initializes the Tracker.
+func (trk TrackerBoosting) Init(img gocv.Mat, boundingBox image.Rectangle) bool {
+	return trackerInit(C.Tracker(trk.p), img, boundingBox)
+}
+
+// Update updates the Tracker.
+func (trk TrackerBoosting) Update(img gocv.Mat) (image.Rectangle, bool) {
+	return trackerUpdate(C.Tracker(trk.p), img)
+}
+
+// TrackerCSRT is an implementation of Discriminative Correlation Filter Tracker
+// with Channel and Spatial Reliability.
+//
+// For further details, please see:
+// https://docs.opencv.org/master/d7/d8f/classcv_1_1legacy_1_1TrackerCSRT.html
+//
+type TrackerCSRT struct {
+	p C.TrackerCSRT
+}
+
+// NewTrackerCSRT returns a new TrackerCSRT.
+func NewTrackerCSRT() Tracker {
+	return TrackerCSRT{p: C.TrackerCSRT_Create()}
+}
+
+// Close closes this Tracker.
+func (trk TrackerCSRT) Close() error {
+	C.TrackerCSRT_Close(trk.p)
+	trk.p = nil
+	return nil
+}
+
+// Init initializes this Tracker.
+func (trk TrackerCSRT) Init(img gocv.Mat, boundingBox image.Rectangle) bool {
+	return trackerInit(C.Tracker(trk.p), img, boundingBox)
+}
+
+// Update updates this Tracker.
+func (trk TrackerCSRT) Update(img gocv.Mat) (image.Rectangle, bool) {
+	return trackerUpdate(C.Tracker(trk.p), img)
+}
+
+// TrackerKCF is a Tracker based on KCF, which is a novel tracking framework that
+// utilizes properties of circulant matrix to enhance the processing speed.
+//
+// For further details, please see:
+// https://docs.opencv.org/master/d5/d6a/classcv_1_1legacy_1_1TrackerKCF.html
+//
+type TrackerKCF struct {
+	p C.TrackerKCF
+}
+
+// NewTrackerKCF returns a new TrackerKCF.
+func NewTrackerKCF() gocv.Tracker {
+	return TrackerKCF{p: C.TrackerKCF_Create()}
+}
+
+// Close closes this Tracker.
+func (trk TrackerKCF) Close() error {
+	C.TrackerKCF_Close(trk.p)
+	trk.p = nil
+	return nil
+}
+
+// Init initializes this Tracker.
+func (trk TrackerKCF) Init(img gocv.Mat, boundingBox image.Rectangle) bool {
+	return trackerInit(C.Tracker(trk.p), img, boundingBox)
+}
+
+// Update updates this Tracker.
+func (trk TrackerKCF) Update(img gocv.Mat) (image.Rectangle, bool) {
+	return trackerUpdate(C.Tracker(trk.p), img)
+}
+
+// TrackerMedianFlow is a Tracker implementation suitable for very smooth and predictable movements
+// when the object is visible throughout the whole sequence.
+//
+// For further details, please see:
+// https://docs.opencv.org/master/dd/d94/classcv_1_1legacy_1_1TrackerMedianFlow.html
+//
+type TrackerMedianFlow struct {
+	p C.TrackerMedianFlow
+}
+
+// NewTrackerMedianFlow returns a new TrackerMedianFlow.
+func NewTrackerMedianFlow() gocv.Tracker {
+	return TrackerMedianFlow{p: C.TrackerMedianFlow_Create()}
+}
+
+// Close closes the Tracker.
+func (trk TrackerMedianFlow) Close() error {
+	C.TrackerMedianFlow_Close(trk.p)
+	trk.p = nil
+	return nil
+}
+
+// Init initializes the Tracker.
+func (trk TrackerMedianFlow) Init(img gocv.Mat, boundingBox image.Rectangle) bool {
+	return trackerInit(C.Tracker(trk.p), img, boundingBox)
+}
+
+// Update updates the Tracker.
+func (trk TrackerMedianFlow) Update(img gocv.Mat) (image.Rectangle, bool) {
+	return trackerUpdate(C.Tracker(trk.p), img)
+}
+
+// TrackerMIL is a Tracker that uses the MIL algorithm. MIL trains a classifier in an online manner
+// to separate the object from the background.
+// Multiple Instance Learning avoids the drift problem for a robust tracking.
+//
+// For further details, please see:
+// https://docs.opencv.org/master/d9/dbc/classcv_1_1legacy_1_1TrackerMIL.html
+//
+type TrackerMIL struct {
+	p C.TrackerMIL
+}
+
+// NewTrackerMIL returns a new TrackerMIL.
+func NewTrackerMIL() gocv.Tracker {
+	return TrackerMIL{p: C.TrackerMIL_Create()}
+}
+
+// Close closes the TrackerMIL.
+func (trk TrackerMIL) Close() error {
+	C.TrackerMIL_Close(trk.p)
+	trk.p = nil
+	return nil
+}
+
+// Init initializes the TrackerMIL.
+func (trk TrackerMIL) Init(img gocv.Mat, boundingBox image.Rectangle) bool {
+	return trackerInit(C.Tracker(trk.p), img, boundingBox)
+}
+
+// Update updates the TrackerMIL.
+func (trk TrackerMIL) Update(img gocv.Mat) (image.Rectangle, bool) {
+	return trackerUpdate(C.Tracker(trk.p), img)
+}
+
+// TrackerMOSSE uses Visual Object Tracking using Adaptive Correlation Filters.
+// Note, that this tracker only works on graysccale images.
+//
+// For further details, please see:
+// https://docs.opencv.org/master/d0/d20/classcv_1_1legacy_1_1TrackerMOSSE.html
+//
+type TrackerMOSSE struct {
+	p C.TrackerMOSSE
+}
+
+// NewTrackerMOSSE returns a new TrackerMOSSE.
+func NewTrackerMOSSE() gocv.Tracker {
+	return TrackerMOSSE{p: C.TrackerMOSSE_Create()}
+}
+
+// Close closes this Tracker.
+func (trk TrackerMOSSE) Close() error {
+	C.TrackerMOSSE_Close(trk.p)
+	trk.p = nil
+	return nil
+}
+
+// Init initializes this Tracker.
+func (trk TrackerMOSSE) Init(img gocv.Mat, boundingBox image.Rectangle) bool {
+	return trackerInit(C.Tracker(trk.p), img, boundingBox)
+}
+
+// Update updates this Tracker.
+func (trk TrackerMOSSE) Update(img gocv.Mat) (image.Rectangle, bool) {
+	return trackerUpdate(C.Tracker(trk.p), img)
+}
+
+// TrackerTLD is a novel tracking framework that explicitly decomposes
+// the long-term tracking task into tracking, learning and detection.
+//
+// For further details, please see:
+// https://docs.opencv.org/master/d1/da6/classcv_1_1legacy_1_1TrackerTLD.html
+//
+type TrackerTLD struct {
+	p C.TrackerTLD
+}
+
+// NewTrackerTLD returns a new TrackerTLD.
+func NewTrackerTLD() gocv.Tracker {
+	return TrackerTLD{p: C.TrackerTLD_Create()}
+}
+
+// Close closes this Tracker.
+func (trk TrackerTLD) Close() error {
+	C.TrackerTLD_Close(trk.p)
+	trk.p = nil
+	return nil
+}
+
+// Init initializes this Tracker.
+func (trk TrackerTLD) Init(img gocv.Mat, boundingBox image.Rectangle) bool {
+	return trackerInit(C.Tracker(trk.p), img, boundingBox)
+}
+
+// Update updates this Tracker.
+func (trk TrackerTLD) Update(img gocv.Mat) (image.Rectangle, bool) {
+	return trackerUpdate(C.Tracker(trk.p), img)
+}

contrib/legacy/tracking.h

@@ -0,0 +1,62 @@
+#ifndef _OPENCV3_LEGACY_TRACKING_H_
+#define _OPENCV3_LEGACY_TRACKING_H_
+
+#include "../../core.h"
+
+#ifdef __cplusplus
+#include <opencv2/tracking/tracking_legacy.hpp>
+
+extern "C" {
+#endif
+
+
+#ifdef __cplusplus
+typedef cv::Ptr<cv::legacy::Tracker>* Tracker;
+typedef cv::Ptr<cv::legacy::TrackerMIL>* TrackerMIL;
+typedef cv::Ptr<cv::legacy::TrackerBoosting>* TrackerBoosting;
+typedef cv::Ptr<cv::legacy::TrackerMedianFlow>* TrackerMedianFlow;
+typedef cv::Ptr<cv::legacy::TrackerTLD>* TrackerTLD;
+typedef cv::Ptr<cv::legacy::TrackerKCF>* TrackerKCF;
+typedef cv::Ptr<cv::legacy::TrackerMOSSE>* TrackerMOSSE;
+typedef cv::Ptr<cv::legacy::TrackerCSRT>* TrackerCSRT;
+#else
+typedef void* Tracker;
+typedef void* TrackerMIL;
+typedef void* TrackerBoosting;
+typedef void* TrackerMedianFlow;
+typedef void* TrackerTLD;
+typedef void* TrackerKCF;
+typedef void* TrackerMOSSE;
+typedef void* TrackerCSRT;
+#endif
+
+bool Tracker_Init(Tracker self, Mat image, Rect boundingBox);
+bool Tracker_Update(Tracker self, Mat image, Rect* boundingBox);
+
+TrackerMIL TrackerMIL_Create();
+void TrackerMIL_Close(TrackerMIL self);
+
+TrackerBoosting TrackerBoosting_Create();
+void TrackerBoosting_Close(TrackerBoosting self);
+
+TrackerMedianFlow TrackerMedianFlow_Create();
+void TrackerMedianFlow_Close(TrackerMedianFlow self);
+
+TrackerTLD TrackerTLD_Create();
+void TrackerTLD_Close(TrackerTLD self);
+
+TrackerKCF TrackerKCF_Create();
+void TrackerKCF_Close(TrackerKCF self);
+
+TrackerMOSSE TrackerMOSSE_Create();
+void TrackerMOSSE_Close(TrackerMOSSE self);
+
+TrackerCSRT TrackerCSRT_Create();
+void TrackerCSRT_Close(TrackerCSRT self);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_OPENCV3_LEGACY_TRACKING_H_