Merge pull request #4 from Auron-X/TLD/VOT-2015-Dataset-Support

Tld/vot 2015 dataset support

Author: Auron-X

modules/tracking/include/opencv2/tracking/tldDataset.hpp

@@ -48,7 +48,7 @@ namespace cv
 {
 	namespace tld
 	{
-		CV_EXPORTS cv::Rect2d tld_InitDataset(int datasetInd, const char* rootPath = "TLD_dataset");
+		CV_EXPORTS cv::Rect2d tld_InitDataset(int videoInd, const char* rootPath = "TLD_dataset", int datasetInd = 0);
 		CV_EXPORTS cv::Mat tld_getNextDatasetFrame();
 	}
 }

modules/tracking/include/opencv2/tracking/tracker.hpp

@@ -49,6 +49,7 @@
 #include "onlineBoosting.hpp"
 #include <iostream>
 
+
 #define BOILERPLATE_CODE(name,classname) \
     static Ptr<classname> createTracker(const classname::Params &parameters=classname::Params());\
     virtual ~classname(){};
@@ -564,6 +565,11 @@ class CV_EXPORTS_W Tracker : public virtual Algorithm
   virtual void read( const FileNode& fn )=0;
   virtual void write( FileStorage& fs ) const=0;
 
+  Ptr<TrackerModel> getModel()
+  {
+	  return model;
+  }
+
  protected:
 
   virtual bool initImpl( const Mat& image, const Rect2d& boundingBox ) = 0;
@@ -576,6 +582,7 @@ class CV_EXPORTS_W Tracker : public virtual Algorithm
   Ptr<TrackerModel> model;
 };
 
+
 /************************************ Specific TrackerStateEstimator Classes ************************************/
 
 /** @brief TrackerStateEstimator based on Boosting
@@ -1243,6 +1250,85 @@ class CV_EXPORTS_W TrackerKCF : public Tracker
   BOILERPLATE_CODE("KCF",TrackerKCF);
 };
 
+/************************************ Multi-Tracker Classes ************************************/
+
+/** @brief Base abstract class for the long-term Multi Object Trackers:
+
+@sa Tracker, MultiTrackerTLD
+*/
+class CV_EXPORTS_W MultiTracker
+{
+public:
+	/** @brief Constructor for Multitracker
+	*/
+	MultiTracker()
+	{
+		targetNum = 0;
+	}
+
+	/** @brief Add a new target to a tracking-list and initialize the tracker with a know bounding box that surrounding the target
+	@param image The initial frame
+	@param boundingBox The initial boundig box of target
+	@param tracker_algorithm_name Multi-tracker algorithm name
+
+	@return True if new target initialization went succesfully, false otherwise
+	*/
+	bool addTarget(const Mat& image, const Rect2d& boundingBox, char* tracker_algorithm_name);
+
+	/** @brief Update all trackers from the tracking-list, find a new most likely bounding boxes for the targets
+	@param image The current frame
+
+	@return True means that all targets were located and false means that tracker couldn't locate one of the targets in
+	current frame. Note, that latter *does not* imply that tracker has failed, maybe target is indeed
+	missing from the frame (say, out of sight)
+	*/
+	bool update(const Mat& image);
+
+	/** @brief Current number of targets in tracking-list
+	*/
+	int targetNum;
+
+	/** @brief Trackers list for Multi-Object-Tracker
+	*/
+	std::vector <Ptr<Tracker> > trackers;
+
+	/** @brief Bounding Boxes list for Multi-Object-Tracker
+	*/
+	std::vector <Rect2d> boundingBoxes;
+	/** @brief List of randomly generated colors for bounding boxes display
+	*/
+	std::vector<Scalar> colors;
+};
+
+/** @brief Multi Object Tracker for TLD. TLD is a novel tracking framework that explicitly decomposes
+the long-term tracking task into tracking, learning and detection.
+
+The tracker follows the object from frame to frame. The detector localizes all appearances that
+have been observed so far and corrects the tracker if necessary. The learning estimates detector’s
+errors and updates it to avoid these errors in the future. The implementation is based on @cite TLD .
+
+The Median Flow algorithm (see cv::TrackerMedianFlow) was chosen as a tracking component in this
+implementation, following authors. Tracker is supposed to be able to handle rapid motions, partial
+occlusions, object absence etc.
+
+@sa Tracker, MultiTracker, TrackerTLD
+*/
+class CV_EXPORTS_W MultiTrackerTLD : public MultiTracker
+{
+public:
+	/** @brief Update all trackers from the tracking-list, find a new most likely bounding boxes for the targets by
+	optimized update method using some techniques to speedup calculations specifically for MO TLD. The only limitation
+	is that	all target bounding boxes should have approximately same aspect ratios. Speed boost is around 20%
+
+	@param image The current frame.
+
+	@return True means that all targets were located and false means that tracker couldn't locate one of the targets in
+	current frame. Note, that latter *does not* imply that tracker has failed, maybe target is indeed
+	missing from the frame (say, out of sight)
+	*/
+	bool update_opt(const Mat& image);
+};
+
 //! @}
 
 } /* namespace cv */

modules/tracking/samples/multiTracker_test.cpp

@@ -0,0 +1,226 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <opencv2/core/utility.hpp>
+#include <opencv2/tracking.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+#define NUM_TEST_FRAMES 100
+#define TEST_VIDEO_INDEX 15		//TLD Dataset Video Index from 1-10 for TLD and 1-60 for VOT
+//#define RECORD_VIDEO_FLG
+
+static Mat image;
+static bool paused;
+static bool selectObject = false;
+static bool startSelection = false;
+Rect2d boundingBox;
+
+static void onMouse(int event, int x, int y, int, void*)
+{
+	if (!selectObject)
+	{
+		switch (event)
+		{
+		case EVENT_LBUTTONDOWN:
+			//set origin of the bounding box
+			startSelection = true;
+			boundingBox.x = x;
+			boundingBox.y = y;
+			boundingBox.width = boundingBox.height = 0;
+			break;
+		case EVENT_LBUTTONUP:
+			//sei with and height of the bounding box
+			boundingBox.width = std::abs(x - boundingBox.x);
+			boundingBox.height = std::abs(y - boundingBox.y);
+			paused = false;
+			selectObject = true;
+			break;
+		case EVENT_MOUSEMOVE:
+
+			if (startSelection && !selectObject)
+			{
+				//draw the bounding box
+				Mat currentFrame;
+				image.copyTo(currentFrame);
+				rectangle(currentFrame, Point((int)boundingBox.x, (int)boundingBox.y), Point(x, y), Scalar(255, 0, 0), 2, 1);
+				imshow("Tracking API", currentFrame);
+			}
+			break;
+		}
+	}
+}
+
+int main()
+{
+	//
+	//  "MIL", "BOOSTING", "MEDIANFLOW", "TLD"
+	//
+	char* tracker_algorithm_name = (char*)"TLD";
+
+	Mat frame;
+	paused = false;
+	namedWindow("Tracking API", 0);
+	setMouseCallback("Tracking API", onMouse, 0);
+
+	MultiTrackerTLD mt;
+
+	//Get the first frame
+	////Open the capture
+	//  VideoCapture cap(0);
+	//  if( !cap.isOpened() )
+	//  {
+	// cout << "Video stream error";
+	//    return;
+	//  }
+	//cap >> frame;
+
+	//From TLD dataset
+	selectObject = true;
+	Rect2d boundingBox1 = tld::tld_InitDataset(TEST_VIDEO_INDEX, "D:/opencv/VOT 2015", 1);
+	Rect2d boundingBox2(470, 490, 50, 120);
+
+	frame = tld::tld_getNextDatasetFrame();
+	frame.copyTo(image);
+
+	// Setup output video
+#ifdef RECORD_VIDEO_FLG
+	String outputFilename = "test.avi";
+	VideoWriter outputVideo;
+	outputVideo.open(outputFilename, -1, 15, Size(image.cols, image.rows));
+
+	if (!outputVideo.isOpened())
+	{
+		std::cout << "!!! Output video could not be opened" << std::endl;
+		getchar();
+		return 0;
+
+	}
+#endif
+
+	rectangle(image, boundingBox, Scalar(255, 0, 0), 2, 1);
+	imshow("Tracking API", image);
+
+
+	bool initialized = false;
+	int frameCounter = 0;
+
+	//Time measurment
+	int64 e3 = getTickCount();
+
+	for (;;)
+	{
+		//Time measurment
+		int64 e1 = getTickCount();
+		//Frame num
+		frameCounter++;
+		if (frameCounter == NUM_TEST_FRAMES) break;
+
+		char c = (char)waitKey(2);
+		if (c == 'q' || c == 27)
+			break;
+		if (c == 'p')
+			paused = !paused;
+
+		if (!paused)
+		{
+			//cap >> frame;
+			frame = tld::tld_getNextDatasetFrame();
+			if (frame.empty())
+			{
+				break;
+			}
+			frame.copyTo(image);
+
+			if (selectObject)
+			{
+				if (!initialized)
+				{
+					//initializes the tracker
+					mt.addTarget(frame, boundingBox1, tracker_algorithm_name);
+					rectangle(frame, boundingBox1, mt.colors[0], 2, 1);
+
+
+					mt.addTarget(frame, boundingBox2, tracker_algorithm_name);
+					rectangle(frame, boundingBox2, mt.colors[1], 2, 1);
+					initialized = true;
+				}
+				else
+				{
+					//updates the tracker
+					if (mt.update(frame))
+					{
+						for (int i = 0; i < mt.targetNum; i++)
+							rectangle(frame, mt.boundingBoxes[i], mt.colors[i], 2, 1);
+					}
+				}
+			}
+			imshow("Tracking API", frame);
+
+#ifdef RECORD_VIDEO_FLG
+			outputVideo << frame;
+#endif
+
+
+			//Time measurment
+			int64 e2 = getTickCount();
+			double t1 = (e2 - e1) / getTickFrequency();
+			cout << frameCounter << "\tframe :  " << t1 * 1000.0 << "ms" << endl;
+
+			//waitKey(0);
+		}
+	}
+
+	//Time measurment
+	int64 e4 = getTickCount();
+	double t2 = (e4 - e3) / getTickFrequency();
+	cout << "Average Time for Frame:  " << t2 * 1000.0 / frameCounter << "ms" << endl;
+	cout << "Average FPS:  " << 1.0 / t2*frameCounter << endl;
+
+
+	waitKey(0);
+
+	return 0;
+}