modified OpenTLD rc

.gitignore

@@ -8,4 +8,4 @@ OpenTLDConfig.cmake
 TODO
 cmake_install.cmake
 *.a
-
+build/

src/libopentld/CMakeLists.txt

@@ -20,6 +20,7 @@ add_library(libopentld
     tld/ForegroundDetector.cpp
     tld/MedianFlowTracker.cpp
     tld/NNClassifier.cpp
+	tld/ShapeClassifier.cpp
     tld/TLD.cpp
     tld/TLDUtil.cpp
     tld/VarianceFilter.cpp
@@ -33,6 +34,7 @@ add_library(libopentld
     tld/DetectionResult.h
     tld/DetectorCascade.h
     tld/EnsembleClassifier.h
+	tld/ShapeClassifier.h
     tld/ForegroundDetector.h
     tld/IntegralImage.h
     tld/MedianFlowTracker.h

src/libopentld/tld/DetectionResult.cpp

@@ -43,6 +43,7 @@ DetectionResult::DetectionResult()
     detectorBB = NULL;
 
     variances = NULL;
+	//similarities = NULL;
     posteriors = NULL;
     featureVectors = NULL;
 }
@@ -56,6 +57,7 @@ void DetectionResult::init(int numWindows, int numTrees)
 {
     variances = new float[numWindows];
     posteriors = new float[numWindows];
+	//similarities = new float[numWindows];
     featureVectors = new int[numWindows * numTrees];
     confidentIndices = new vector<int>();
 
@@ -79,6 +81,8 @@ void DetectionResult::release()
     fgList->clear();
     delete[] variances;
     variances = NULL;
+	//delete[] similarities;
+    //similarities = NULL;
     delete[] posteriors;
     posteriors = NULL;
     delete[] featureVectors;

src/libopentld/tld/DetectionResult.h

@@ -43,6 +43,7 @@ class DetectionResult
     std::vector<int>* confidentIndices;
     int *featureVectors;
     float *variances;
+	//float *similarities;
     int numClusters;
     cv::Rect *detectorBB; //Contains a valid result only if numClusters = 1
 

src/libopentld/tld/DetectorCascade.cpp

@@ -27,11 +27,12 @@
 #include "DetectorCascade.h"
 
 #include <algorithm>
-
+#include <iostream>
 #include "TLDUtil.h"
 
 using namespace cv;
 
+
 namespace tld
 {
 
@@ -59,6 +60,7 @@ DetectorCascade::DetectorCascade()
 
     foregroundDetector = new ForegroundDetector();
     varianceFilter = new VarianceFilter();
+	shapeClassifier = new ShapeClassifier();
     ensembleClassifier = new EnsembleClassifier();
     nnClassifier = new NNClassifier();
     clustering = new Clustering();
@@ -72,6 +74,7 @@ DetectorCascade::~DetectorCascade()
 
     delete foregroundDetector;
     delete varianceFilter;
+	delete shapeClassifier;
     delete ensembleClassifier;
     delete nnClassifier;
     delete detectionResult;
@@ -100,12 +103,14 @@ void DetectorCascade::propagateMembers()
     detectionResult->init(numWindows, numTrees);
 
     varianceFilter->windowOffsets = windowOffsets;
+	shapeClassifier->windowOffsets = windowOffsets;
     ensembleClassifier->windowOffsets = windowOffsets;
     ensembleClassifier->imgWidthStep = imgWidthStep;
     ensembleClassifier->numScales = numScales;
     ensembleClassifier->scales = scales;
     ensembleClassifier->numFeatures = numFeatures;
     ensembleClassifier->numTrees = numTrees;
+	shapeClassifier->windows = windows;
     nnClassifier->windows = windows;
     clustering->windows = windows;
     clustering->numWindows = numWindows;
@@ -114,6 +119,7 @@ void DetectorCascade::propagateMembers()
 
     foregroundDetector->detectionResult = detectionResult;
     varianceFilter->detectionResult = detectionResult;
+	shapeClassifier->detectionResult = detectionResult;
     ensembleClassifier->detectionResult = detectionResult;
     nnClassifier->detectionResult = detectionResult;
     clustering->detectionResult = detectionResult;
@@ -129,6 +135,7 @@ void DetectorCascade::release()
     initialised = false;
 
     foregroundDetector->release();
+	shapeClassifier->release();
     ensembleClassifier->release();
     nnClassifier->release();
 
@@ -281,13 +288,13 @@ void DetectorCascade::detect(const Mat &img)
     //Prepare components
     foregroundDetector->nextIteration(img); //Calculates foreground
     varianceFilter->nextIteration(img); //Calculates integral images
+	shapeClassifier->nextIteration(img);
     ensembleClassifier->nextIteration(img);
 
     #pragma omp parallel for
-
+	
     for(int i = 0; i < numWindows; i++)
     {
-
         int *window = &windows[TLD_WINDOW_SIZE * i];
 
         if(foregroundDetector->isActive())
@@ -319,21 +326,25 @@ void DetectorCascade::detect(const Mat &img)
             continue;
         }
 
-        if(!ensembleClassifier->filter(i))
+		if(!ensembleClassifier->filter(i))
         {
             continue;
         }
 
+		if(!shapeClassifier->filter(i))
+        {
+			continue;
+        }
+
         if(!nnClassifier->filter(img, i))
         {
             continue;
         }
-
+			
         detectionResult->confidentIndices->push_back(i);
 
-
     }
-
+	
     //Cluster
     clustering->clusterConfidentIndices();
 

src/libopentld/tld/DetectorCascade.h

@@ -29,6 +29,7 @@
 #include "DetectionResult.h"
 #include "ForegroundDetector.h"
 #include "VarianceFilter.h"
+#include "ShapeClassifier.h"
 #include "EnsembleClassifier.h"
 #include "Clustering.h"
 #include "NNClassifier.h"
@@ -73,6 +74,7 @@ class DetectorCascade
     //Components of Detector Cascade
     ForegroundDetector *foregroundDetector;
     VarianceFilter *varianceFilter;
+	ShapeClassifier *shapeClassifier;
     EnsembleClassifier *ensembleClassifier;
     Clustering *clustering;
     NNClassifier *nnClassifier;

src/libopentld/tld/ShapeClassifier.cpp

@@ -0,0 +1,127 @@
+/*
+ * ShapeClassifier.h
+ *
+ *  Created on: May 20, 2013
+ *      Author: Maksym Plencler
+ */
+#include "ShapeClassifier.h"
+#include "DetectorCascade.h"
+#include "TLDUtil.h"
+#include <iostream>
+
+using namespace cv;
+
+namespace tld
+{
+
+ShapeClassifier::ShapeClassifier(void)
+{
+	this->img = NULL;
+    enabled = false;
+    similarityThreshold = 0.6f;
+}
+
+ShapeClassifier::~ShapeClassifier(void)
+{
+	release();
+}
+
+void ShapeClassifier::release()
+{
+	positivePatches->clear();
+}
+
+void ShapeClassifier::nextIteration(const Mat &img)
+{
+    if(!enabled) return;
+
+    this->img = img;
+}
+
+bool ShapeClassifier::filter(int i)
+{
+    if(!enabled) return true;
+
+    if(calcSimilarity(i) < similarityThreshold) {
+		//cout << "rejected" << endl;	
+		return false;
+	}
+	return true;
+}
+
+float ShapeClassifier::calcSimilarity(int windowIdx)
+{
+	NormalizedPatch patch;
+
+    int *bbox = &windows[TLD_WINDOW_SIZE * windowIdx];
+    tldExtractNormalizedPatchBB(img, bbox, patch.values);
+
+	return similarityWithModel(&patch);
+}
+
+float similarityOf(Mat patch1, Mat patch2)
+{
+	Mat result;
+	absdiff(patch1, patch2, result);
+
+	float sum = 0;
+    unsigned char *imgData = (unsigned char *)result.data;
+
+    for(int i = 0; i < 15; i++)
+    {
+        for(int j = 0; j < 15; j++)
+        {
+			sum += imgData[j * result.step + i];
+        }
+    }
+	float res = 1 - (sum/(15*15))/255;
+	return res;
+}
+
+float ShapeClassifier::similarityWithModel(NormalizedPatch *patch)
+{
+	if(positivePatches->empty())
+    {
+        return 0;
+    }
+
+	float similarity = 0;
+
+	Mat patchMat = Mat(15, 15, CV_8U, patch);
+	Canny(patchMat, patchMat, 10, 30, 3);
+	//int element_shape = CV_SHAPE_RECT;
+	//IplConvKernel* element = cvCreateStructuringElementEx(2+1, 2+1, 1, 1, element_shape);
+	dilate(patchMat, patchMat, Mat(), Point(-1,-1));
+	//imshow( "propozycja", patchMat );
+
+	Mat modelElemMat;
+	//cout << "PP: " << positivePatches->size() << endl;
+
+	for(size_t i = 0; i < positivePatches->size(); i++)
+    {
+		modelElemMat = Mat(15, 15, CV_8U, positivePatches->at(i).values);
+		Canny(patchMat, patchMat, 10, 30, 3);
+		dilate(patchMat, patchMat, Mat(), Point(-1,-1));
+
+		similarity = similarityOf(modelElemMat, patchMat);
+
+        if(similarity > similarityThreshold)
+        {
+			patchMat.release();
+			modelElemMat.release();
+			return similarity;
+        }
+    }
+
+	patchMat.release();
+	modelElemMat.release();	
+    return similarity;
+}
+
+
+void ShapeClassifier::setPositivePatches(std::vector<NormalizedPatch>* pp)
+{
+	positivePatches = pp;
+}
+
+} /* namespace tld */

src/libopentld/tld/ShapeClassifier.h

@@ -0,0 +1,46 @@
+/*
+ * ShapeClassifier.h
+ *
+ *  Created on: May 20, 2013
+ *      Author: Maksym Plencler
+ */
+
+#ifndef SHAPECLASSIFIER_H_
+#define SHAPECLASSIFIER_H_
+
+#include <opencv/cv.h>
+
+#include "DetectionResult.h"
+#include "NormalizedPatch.h"
+
+namespace tld
+{
+
+class ShapeClassifier
+{
+	std::vector<NormalizedPatch>* positivePatches;
+    cv::Mat img;
+
+
+public:
+    bool enabled;
+	int *windows;
+    int *windowOffsets;
+
+    DetectionResult *detectionResult;
+
+    float similarityThreshold;
+
+    ShapeClassifier();
+    virtual ~ShapeClassifier();
+
+    void release();
+    void nextIteration(const cv::Mat &img);
+    bool filter(int idx);
+    float calcSimilarity(int windowIdx);
+	void setPositivePatches(std::vector<NormalizedPatch>* positivePatches);
+	float similarityWithModel(NormalizedPatch *patch);
+};
+
+} /* namespace tld */
+#endif /* SHAPECLASSIFIER_H_ */