From 8719073735e4716bac86f8a80439f604b2413ee5 Mon Sep 17 00:00:00 2001 From: Vladimir Date: Mon, 22 Jun 2015 21:14:43 +0900 Subject: [PATCH 1/7] Added OCL versions of Sr and Sc functions --- modules/tracking/src/opencl/tldDetector.cl | 69 +++++++ modules/tracking/src/precomp.hpp | 1 + modules/tracking/src/tldDetector.cpp | 229 ++++++++++++++++++++- modules/tracking/src/tldDetector.hpp | 6 + modules/tracking/src/tldModel.cpp | 30 ++- modules/tracking/src/tldModel.hpp | 2 + 6 files changed, 334 insertions(+), 3 deletions(-) create mode 100644 modules/tracking/src/opencl/tldDetector.cl diff --git a/modules/tracking/src/opencl/tldDetector.cl b/modules/tracking/src/opencl/tldDetector.cl new file mode 100644 index 000000000..9610bd72c --- /dev/null +++ b/modules/tracking/src/opencl/tldDetector.cl @@ -0,0 +1,69 @@ +// 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. + +// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved. +// Third party copyrights are property of their respective owners. + + + +__kernel void NCC(__global const uchar *patch, + __global const uchar *positiveSamples, + __global const uchar *negativeSamples, + __global float *ncc, + int posNum, + int negNum) +{ + int id = get_global_id(0); + if (id >= 1000) return; + bool posFlg; + + if (id < 500) + posFlg = true; + if (id >= 500) + { + //Negative index + id = id - 500; + posFlg = false; + } + + //Variables + int s1 = 0, s2 = 0, n1 = 0, n2 = 0, prod = 0; + float sq1 = 0, sq2 = 0, ares = 0; + int N = 225; + //NCC with positive patch + if (posFlg && id < posNum) + { + for (int i = 0; i < N; i++) + { + + s1 += positiveSamples[id * N + i]; + s2 += patch[i]; + n1 += positiveSamples[id * N + i] * positiveSamples[id * N + i]; + n2 += patch[i] * patch[i]; + prod += positiveSamples[id * N + i] * patch[i]; + } + sq1 = sqrt(max(0.0, n1 - 1.0 * s1 * s1 / N)); + sq2 = sqrt(max(0.0, n2 - 1.0 * s2 * s2 / N)); + ares = (sq2 == 0) ? sq1 / fabs(sq1) : (prod - s1 * s2 / N) / sq1 / sq2; + ncc[id] = ares; + } + + //NCC with negative patch + if (!posFlg && id < negNum) + { + for (int i = 0; i < N; i++) + { + + s1 += negativeSamples[id * N + i]; + s2 += patch[i]; + n1 += negativeSamples[id * N + i] * negativeSamples[id * N + i]; + n2 += patch[i] * patch[i]; + prod += negativeSamples[id * N + i] * patch[i]; + } + sq1 = sqrt(max(0.0, n1 - 1.0 * s1 * s1 / N)); + sq2 = sqrt(max(0.0, n2 - 1.0 * s2 * s2 / N)); + ares = (sq2 == 0) ? sq1 / fabs(sq1) : (prod - s1 * s2 / N) / sq1 / sq2; + ncc[id+500] = ares; + } +} diff --git a/modules/tracking/src/precomp.hpp b/modules/tracking/src/precomp.hpp index 98fbce135..c2c415835 100644 --- a/modules/tracking/src/precomp.hpp +++ b/modules/tracking/src/precomp.hpp @@ -44,5 +44,6 @@ #include "opencv2/tracking.hpp" #include "opencv2/core/utility.hpp" +#include "opencv2/core/ocl.hpp" #endif diff --git a/modules/tracking/src/tldDetector.cpp b/modules/tracking/src/tldDetector.cpp index 714d1330e..b98f9356d 100644 --- a/modules/tracking/src/tldDetector.cpp +++ b/modules/tracking/src/tldDetector.cpp @@ -65,11 +65,119 @@ namespace cv // Calculate Relative similarity of the patch (NN-Model) double TLDDetector::Sr(const Mat_& patch) { + /* + int64 e1, e2; + float t; + e1 = getTickCount(); double splus = 0.0, sminus = 0.0; for (int i = 0; i < (int)(*positiveExamples).size(); i++) splus = std::max(splus, 0.5 * (NCC((*positiveExamples)[i], patch) + 1.0)); for (int i = 0; i < (int)(*negativeExamples).size(); i++) sminus = std::max(sminus, 0.5 * (NCC((*negativeExamples)[i], patch) + 1.0)); + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + printf("Sr: %f\n", t); + if (splus + sminus == 0.0) + return 0.0; + return splus / (sminus + splus); + */ + int64 e1, e2; + float t; + e1 = getTickCount(); + double splus = 0.0, sminus = 0.0; + Mat_ modelSample(STANDARD_PATCH_SIZE, STANDARD_PATCH_SIZE); + for (int i = 0; i < *posNum; i++) + { + modelSample.data = &(posExp->data[i * 225]); + splus = std::max(splus, 0.5 * (NCC(modelSample, patch) + 1.0)); + } + for (int i = 0; i < *negNum; i++) + { + modelSample.data = &(negExp->data[i * 225]); + sminus = std::max(sminus, 0.5 * (NCC(modelSample, patch) + 1.0)); + } + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + printf("Sr CPU: %f\n", t); + if (splus + sminus == 0.0) + return 0.0; + return splus / (sminus + splus); + } + + double TLDDetector::ocl_Sr(const Mat_& patch) + { + int64 e1, e2, e3, e4; + float t; + e1 = getTickCount(); + double splus = 0.0, sminus = 0.0; + + e3 = getTickCount(); + + UMat devPatch = patch.getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); + UMat devPositiveSamples = posExp->getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); + UMat devNegativeSamples = negExp->getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); + UMat devNCC(1, 2*MAX_EXAMPLES_IN_MODEL, CV_32FC1, ACCESS_RW, USAGE_ALLOCATE_DEVICE_MEMORY); + + + ocl::Kernel k; + ocl::ProgramSource src = ocl::tracking::tldDetector_oclsrc; + String error; + ocl::Program prog(src, NULL, error); + k.create("NCC", prog); + if (k.empty()) + printf("Kernel create failed!!!\n"); + k.args( + ocl::KernelArg::PtrReadOnly(devPatch), + ocl::KernelArg::PtrReadOnly(devPositiveSamples), + ocl::KernelArg::PtrReadOnly(devNegativeSamples), + ocl::KernelArg::PtrWriteOnly(devNCC), + (int)posNum, + (int)negNum); + + e4 = getTickCount(); + t = (e4 - e3) / getTickFrequency()*1000.0; + //printf("Mem Cpy GPU: %f\n", t); + + size_t globSize = 1000; + size_t localSize = 128; + e3 = getTickCount(); + if (!k.run(1, &globSize, &localSize, true)) + printf("Kernel Run Error!!!"); + e4 = getTickCount(); + t = (e4 - e3) / getTickFrequency()*1000.0; + //printf("Kernel Run GPU: %f\n", t); + + e3 = getTickCount(); + Mat resNCC = devNCC.getMat(ACCESS_READ); + e4 = getTickCount(); + t = (e4 - e3) / getTickFrequency()*1000.0; + //printf("Read Mem GPU: %f\n", t); + + ////Compare + //Mat_ modelSample(STANDARD_PATCH_SIZE, STANDARD_PATCH_SIZE); + //for (int i = 0; i < 200; i+=17) + //{ + // modelSample.data = &(posExp->data[i * 225]); + // printf("%f\t%f\n\n", resNCC.at(i), NCC(modelSample, patch)); + //} + + //for (int i = 0; i < 200; i+=23) + //{ + // modelSample.data = &(negExp->data[i * 225]); + // printf("%f\t%f\n", resNCC.at(500+i), NCC(modelSample, patch)); + //} + + + for (int i = 0; i < *posNum; i++) + splus = std::max(splus, 0.5 * (resNCC.at(i) + 1.0)); + + for (int i = 0; i < *negNum; i++) + sminus = std::max(sminus, 0.5 * (resNCC.at(i+500) +1.0)); + + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + //printf("Sr GPU: %f\n\n", t); + if (splus + sminus == 0.0) return 0.0; return splus / (sminus + splus); @@ -78,6 +186,10 @@ namespace cv // Calculate Conservative similarity of the patch (NN-Model) double TLDDetector::Sc(const Mat_& patch) { + /* + int64 e1, e2; + float t; + e1 = getTickCount(); double splus = 0.0, sminus = 0.0; int med = getMedian((*timeStampsPositive)); for (int i = 0; i < (int)(*positiveExamples).size(); i++) @@ -87,6 +199,118 @@ namespace cv } for (int i = 0; i < (int)(*negativeExamples).size(); i++) sminus = std::max(sminus, 0.5 * (NCC((*negativeExamples)[i], patch) + 1.0)); + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + printf("Sc: %f\n", t); + if (splus + sminus == 0.0) + return 0.0; + + return splus / (sminus + splus); + */ + + int64 e1, e2; + float t; + e1 = getTickCount(); + double splus = 0.0, sminus = 0.0; + Mat_ modelSample(STANDARD_PATCH_SIZE, STANDARD_PATCH_SIZE); + int med = getMedian((*timeStampsPositive)); + for (int i = 0; i < *posNum; i++) + { + if ((int)(*timeStampsPositive)[i] <= med) + { + modelSample.data = &(posExp->data[i * 225]); + splus = std::max(splus, 0.5 * (NCC(modelSample, patch) + 1.0)); + } + } + for (int i = 0; i < *negNum; i++) + { + modelSample.data = &(negExp->data[i * 225]); + sminus = std::max(sminus, 0.5 * (NCC(modelSample, patch) + 1.0)); + } + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + printf("Sc: %f\n", t); + if (splus + sminus == 0.0) + return 0.0; + + return splus / (sminus + splus); + } + + double TLDDetector::ocl_Sc(const Mat_& patch) + { + int64 e1, e2, e3, e4; + float t; + e1 = getTickCount(); + double splus = 0.0, sminus = 0.0; + + e3 = getTickCount(); + + UMat devPatch = patch.getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); + UMat devPositiveSamples = posExp->getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); + UMat devNegativeSamples = negExp->getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); + UMat devNCC(1, 2 * MAX_EXAMPLES_IN_MODEL, CV_32FC1, ACCESS_RW, USAGE_ALLOCATE_DEVICE_MEMORY); + + + ocl::Kernel k; + ocl::ProgramSource src = ocl::tracking::tldDetector_oclsrc; + String error; + ocl::Program prog(src, NULL, error); + k.create("NCC", prog); + if (k.empty()) + printf("Kernel create failed!!!\n"); + k.args( + ocl::KernelArg::PtrReadOnly(devPatch), + ocl::KernelArg::PtrReadOnly(devPositiveSamples), + ocl::KernelArg::PtrReadOnly(devNegativeSamples), + ocl::KernelArg::PtrWriteOnly(devNCC), + (int)posNum, + (int)negNum); + + e4 = getTickCount(); + t = (e4 - e3) / getTickFrequency()*1000.0; + //printf("Mem Cpy GPU: %f\n", t); + + size_t globSize = 1000; + size_t localSize = 128; + e3 = getTickCount(); + if (!k.run(1, &globSize, &localSize, true)) + printf("Kernel Run Error!!!"); + e4 = getTickCount(); + t = (e4 - e3) / getTickFrequency()*1000.0; + //printf("Kernel Run GPU: %f\n", t); + + e3 = getTickCount(); + Mat resNCC = devNCC.getMat(ACCESS_READ); + e4 = getTickCount(); + t = (e4 - e3) / getTickFrequency()*1000.0; + //printf("Read Mem GPU: %f\n", t); + + ////Compare + //Mat_ modelSample(STANDARD_PATCH_SIZE, STANDARD_PATCH_SIZE); + //for (int i = 0; i < 200; i+=17) + //{ + // modelSample.data = &(posExp->data[i * 225]); + // printf("%f\t%f\n\n", resNCC.at(i), NCC(modelSample, patch)); + //} + + //for (int i = 0; i < 200; i+=23) + //{ + // modelSample.data = &(negExp->data[i * 225]); + // printf("%f\t%f\n", resNCC.at(500+i), NCC(modelSample, patch)); + //} + + int med = getMedian((*timeStampsPositive)); + for (int i = 0; i < *posNum; i++) + if ((int)(*timeStampsPositive)[i] <= med) + splus = std::max(splus, 0.5 * (resNCC.at(i) +1.0)); + + for (int i = 0; i < *negNum; i++) + sminus = std::max(sminus, 0.5 * (resNCC.at(i + 500) + 1.0)); + + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + //printf("Sc GPU: %f\n\n", t); + if (splus + sminus == 0.0) return 0.0; return splus / (sminus + splus); @@ -167,7 +391,8 @@ namespace cv labPatch.rect = Rect2d(dx * i * scale, dy * j * scale, initSize.width * scale, initSize.height * scale); resample(resized_img, Rect2d(Point(dx * i, dy * j), initSize), standardPatch); - tmp = Sr(standardPatch); + + tmp = ocl_Sr(standardPatch); ////To fix: Check the paper, probably this cause wrong learning // @@ -185,7 +410,7 @@ namespace cv { npos++; } - tmp = Sc(standardPatch); + tmp = ocl_Sc(standardPatch); if (tmp > maxSc) { maxSc = tmp; diff --git a/modules/tracking/src/tldDetector.hpp b/modules/tracking/src/tldDetector.hpp index f675fd2a6..f86e7e804 100644 --- a/modules/tracking/src/tldDetector.hpp +++ b/modules/tracking/src/tldDetector.hpp @@ -43,6 +43,7 @@ #define OPENCV_TLD_DETECTOR #include "precomp.hpp" +#include "opencl_kernels_tracking.hpp" #include "tldEnsembleClassifier.hpp" #include "tldUtils.hpp" @@ -74,9 +75,13 @@ namespace cv inline double ensembleClassifierNum(const uchar* data); inline void prepareClassifiers(int rowstep); double Sr(const Mat_& patch); + double ocl_Sr(const Mat_& patch); double Sc(const Mat_& patch); + double ocl_Sc(const Mat_& patch); std::vector classifiers; + Mat *posExp, *negExp; + int *posNum, *negNum; std::vector > *positiveExamples, *negativeExamples; std::vector *timeStampsPositive, *timeStampsNegative; double *originalVariancePtr; @@ -88,6 +93,7 @@ namespace cv bool isObject, shouldBeIntegrated; }; bool detect(const Mat& img, const Mat& imgBlurred, Rect2d& res, std::vector& patches, Size initSize); + bool ocl_detect(const Mat& img, const Mat& imgBlurred, Rect2d& res, std::vector& patches, Size initSize); protected: diff --git a/modules/tracking/src/tldModel.cpp b/modules/tracking/src/tldModel.cpp index 2bc10a76b..6c926d706 100644 --- a/modules/tracking/src/tldModel.cpp +++ b/modules/tracking/src/tldModel.cpp @@ -56,7 +56,16 @@ namespace cv detector = Ptr(new TLDDetector()); //Propagate data to Detector - detector->positiveExamples = &positiveExamples; + posNum = 0; + negNum = 0; + posExp = Mat(Size(225, 500), CV_8UC1); + negExp = Mat(Size(225, 500), CV_8UC1); + detector->posNum = &posNum; + detector->negNum = &negNum; + detector->posExp = &posExp; + detector->negExp = &negExp; + + detector->positiveExamples = &positiveExamples; detector->negativeExamples = &negativeExamples; detector->timeStampsPositive = &timeStampsPositive; detector->timeStampsNegative = &timeStampsNegative; @@ -78,6 +87,7 @@ namespace cv //Generate initial positive samples and put them to the model positiveExamples.reserve(200); + for (int i = 0; i < (int)closest.size(); i++) { for (int j = 0; j < 20; j++) @@ -239,12 +249,30 @@ namespace cv std::vector* proxyT; if (positive) { + if (posNum < 500) + { + uchar *patchPtr = example.data; + uchar *modelPtr = posExp.data; + for (int i = 0; i < STANDARD_PATCH_SIZE*STANDARD_PATCH_SIZE; i++) + modelPtr[posNum*STANDARD_PATCH_SIZE*STANDARD_PATCH_SIZE + i] = patchPtr[i]; + posNum++; + } + proxyV = &positiveExamples; proxyN = &timeStampPositiveNext; proxyT = &timeStampsPositive; } else { + if (negNum < 500) + { + uchar *patchPtr = example.data; + uchar *modelPtr = negExp.data; + for (int i = 0; i < STANDARD_PATCH_SIZE*STANDARD_PATCH_SIZE; i++) + modelPtr[negNum*STANDARD_PATCH_SIZE*STANDARD_PATCH_SIZE + i] = patchPtr[i]; + negNum++; + } + proxyV = &negativeExamples; proxyN = &timeStampNegativeNext; proxyT = &timeStampsNegative; diff --git a/modules/tracking/src/tldModel.hpp b/modules/tracking/src/tldModel.hpp index 3a1e5149a..67746745b 100644 --- a/modules/tracking/src/tldModel.hpp +++ b/modules/tracking/src/tldModel.hpp @@ -67,6 +67,8 @@ namespace cv Ptr detector; std::vector > positiveExamples, negativeExamples; + Mat posExp, negExp; + int posNum, negNum; std::vector timeStampsPositive, timeStampsNegative; int timeStampPositiveNext, timeStampNegativeNext; double originalVariance_; From d4011aaea709891b2179b4e07d4a5821df6ed5a1 Mon Sep 17 00:00:00 2001 From: Vladimir Date: Mon, 29 Jun 2015 08:10:30 +0900 Subject: [PATCH 2/7] 2-nd level of parallelization + detector remake 1. Added 2-nd level of parallelization of NN on OpenCL 2. Restructured detector - now all filters work independently: Variance Filter->Ensemble->NN, through "buffers" --- modules/tracking/samples/tld_test.cpp | 6 +- modules/tracking/src/opencl/tldDetector.cl | 72 +++- modules/tracking/src/tldDetector.cpp | 374 ++++++++++++++++++--- modules/tracking/src/tldDetector.hpp | 7 +- modules/tracking/src/tldTracker.cpp | 10 +- modules/tracking/src/tldUtils.cpp | 2 +- 6 files changed, 403 insertions(+), 68 deletions(-) diff --git a/modules/tracking/samples/tld_test.cpp b/modules/tracking/samples/tld_test.cpp index 472d2c92d..6db5e7a08 100644 --- a/modules/tracking/samples/tld_test.cpp +++ b/modules/tracking/samples/tld_test.cpp @@ -48,8 +48,8 @@ using namespace std; using namespace cv; -#define NUM_TEST_FRAMES 500 -#define TEST_VIDEO_INDEX 1 //TLD Dataset Video Index from 1-10 +#define NUM_TEST_FRAMES 100 +#define TEST_VIDEO_INDEX 7 //TLD Dataset Video Index from 1-10 //#define RECORD_VIDEO_FLG static Mat image; @@ -118,7 +118,7 @@ int main() // VideoCapture cap(0); // if( !cap.isOpened() ) // { - // cout << "Video stream error"; + // cout << "Video stream error"; // return; // } //cap >> frame; diff --git a/modules/tracking/src/opencl/tldDetector.cl b/modules/tracking/src/opencl/tldDetector.cl index 9610bd72c..da28e6826 100644 --- a/modules/tracking/src/opencl/tldDetector.cl +++ b/modules/tracking/src/opencl/tldDetector.cl @@ -31,12 +31,11 @@ __kernel void NCC(__global const uchar *patch, int s1 = 0, s2 = 0, n1 = 0, n2 = 0, prod = 0; float sq1 = 0, sq2 = 0, ares = 0; int N = 225; - //NCC with positive patch + //NCC with positive sample if (posFlg && id < posNum) { for (int i = 0; i < N; i++) { - s1 += positiveSamples[id * N + i]; s2 += patch[i]; n1 += positiveSamples[id * N + i] * positiveSamples[id * N + i]; @@ -46,10 +45,10 @@ __kernel void NCC(__global const uchar *patch, sq1 = sqrt(max(0.0, n1 - 1.0 * s1 * s1 / N)); sq2 = sqrt(max(0.0, n2 - 1.0 * s2 * s2 / N)); ares = (sq2 == 0) ? sq1 / fabs(sq1) : (prod - s1 * s2 / N) / sq1 / sq2; - ncc[id] = ares; + ncc[id] = ares; } - //NCC with negative patch + //NCC with negative sample if (!posFlg && id < negNum) { for (int i = 0; i < N; i++) @@ -67,3 +66,68 @@ __kernel void NCC(__global const uchar *patch, ncc[id+500] = ares; } } + +__kernel void batchNCC(__global const uchar *patches, + __global const uchar *positiveSamples, + __global const uchar *negativeSamples, + __global float *posNcc, + __global float *negNcc, + int posNum, + int negNum, + int patchNum) +{ + int id = get_global_id(0); + bool posFlg; + + if (id < 500*patchNum) + posFlg = true; + if (id >= 500*patchNum) + { + //Negative index + id = id - 500*patchNum; + posFlg = false; + } + + int modelSampleID = id % 500; + int patchID = id / 500; + + //Variables + int s1 = 0, s2 = 0, n1 = 0, n2 = 0, prod = 0; + float sq1 = 0, sq2 = 0, ares = 0; + int N = 225; + + //NCC with positive sample + if (posFlg && modelSampleID < posNum) + { + for (int i = 0; i < N; i++) + { + s1 += positiveSamples[modelSampleID * N + i]; + s2 += patches[patchID*N + i]; + n1 += positiveSamples[modelSampleID * N + i] * positiveSamples[modelSampleID * N + i]; + n2 += patches[patchID*N + i] * patches[patchID*N + i]; + prod += positiveSamples[modelSampleID * N + i] * patches[patchID*N + i]; + } + sq1 = sqrt(max(0.0, n1 - 1.0 * s1 * s1 / N)); + sq2 = sqrt(max(0.0, n2 - 1.0 * s2 * s2 / N)); + ares = (sq2 == 0) ? sq1 / fabs(sq1) : (prod - s1 * s2 / N) / sq1 / sq2; + posNcc[id] = ares; + } + + //NCC with negative sample + if (!posFlg && modelSampleID < negNum) + { + for (int i = 0; i < N; i++) + { + + s1 += negativeSamples[modelSampleID * N + i]; + s2 += patches[patchID*N + i]; + n1 += negativeSamples[modelSampleID * N + i] * negativeSamples[modelSampleID * N + i]; + n2 += patches[patchID*N + i] * patches[patchID*N + i]; + prod += negativeSamples[modelSampleID * N + i] * patches[patchID*N + i]; + } + sq1 = sqrt(max(0.0, n1 - 1.0 * s1 * s1 / N)); + sq2 = sqrt(max(0.0, n2 - 1.0 * s2 * s2 / N)); + ares = (sq2 == 0) ? sq1 / fabs(sq1) : (prod - s1 * s2 / N) / sq1 / sq2; + negNcc[id] = ares; + } +} diff --git a/modules/tracking/src/tldDetector.cpp b/modules/tracking/src/tldDetector.cpp index b98f9356d..1b7a866b3 100644 --- a/modules/tracking/src/tldDetector.cpp +++ b/modules/tracking/src/tldDetector.cpp @@ -98,7 +98,7 @@ namespace cv } e2 = getTickCount(); t = (e2 - e1) / getTickFrequency()*1000.0; - printf("Sr CPU: %f\n", t); + //printf("Sr CPU: %f\n", t); if (splus + sminus == 0.0) return 0.0; return splus / (sminus + splus); @@ -109,16 +109,16 @@ namespace cv int64 e1, e2, e3, e4; float t; e1 = getTickCount(); - double splus = 0.0, sminus = 0.0; - e3 = getTickCount(); + double splus = 0.0, sminus = 0.0; + UMat devPatch = patch.getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); UMat devPositiveSamples = posExp->getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); UMat devNegativeSamples = negExp->getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); UMat devNCC(1, 2*MAX_EXAMPLES_IN_MODEL, CV_32FC1, ACCESS_RW, USAGE_ALLOCATE_DEVICE_MEMORY); - + ocl::Kernel k; ocl::ProgramSource src = ocl::tracking::tldDetector_oclsrc; String error; @@ -139,7 +139,7 @@ namespace cv //printf("Mem Cpy GPU: %f\n", t); size_t globSize = 1000; - size_t localSize = 128; + size_t localSize = 128; e3 = getTickCount(); if (!k.run(1, &globSize, &localSize, true)) printf("Kernel Run Error!!!"); @@ -152,7 +152,7 @@ namespace cv e4 = getTickCount(); t = (e4 - e3) / getTickFrequency()*1000.0; //printf("Read Mem GPU: %f\n", t); - + ////Compare //Mat_ modelSample(STANDARD_PATCH_SIZE, STANDARD_PATCH_SIZE); //for (int i = 0; i < 200; i+=17) @@ -167,7 +167,7 @@ namespace cv // printf("%f\t%f\n", resNCC.at(500+i), NCC(modelSample, patch)); //} - + for (int i = 0; i < *posNum; i++) splus = std::max(splus, 0.5 * (resNCC.at(i) + 1.0)); @@ -183,6 +183,110 @@ namespace cv return splus / (sminus + splus); } + void TLDDetector::ocl_batchSrSc(const Mat_& patches, double *resultSr, double *resultSc, int numOfPatches) + { + int64 e1, e2, e3, e4; + float t; + e1 = getTickCount(); + e3 = getTickCount(); + + UMat devPatches = patches.getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); + UMat devPositiveSamples = posExp->getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); + UMat devNegativeSamples = negExp->getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); + UMat devPosNCC(MAX_EXAMPLES_IN_MODEL, numOfPatches, CV_32FC1, ACCESS_RW, USAGE_ALLOCATE_DEVICE_MEMORY); + UMat devNegNCC(MAX_EXAMPLES_IN_MODEL, numOfPatches, CV_32FC1, ACCESS_RW, USAGE_ALLOCATE_DEVICE_MEMORY); + + ocl::Kernel k; + ocl::ProgramSource src = ocl::tracking::tldDetector_oclsrc; + String error; + ocl::Program prog(src, NULL, error); + k.create("batchNCC", prog); + if (k.empty()) + printf("Kernel create failed!!!\n"); + k.args( + ocl::KernelArg::PtrReadOnly(devPatches), + ocl::KernelArg::PtrReadOnly(devPositiveSamples), + ocl::KernelArg::PtrReadOnly(devNegativeSamples), + ocl::KernelArg::PtrWriteOnly(devPosNCC), + ocl::KernelArg::PtrWriteOnly(devNegNCC), + posNum, + negNum, + numOfPatches); + + e4 = getTickCount(); + t = (e4 - e3) / getTickFrequency()*1000.0; + //printf("Mem Cpy GPU: %f\n", t); + + // 2 -> Pos&Neg + size_t globSize = 2 * numOfPatches*MAX_EXAMPLES_IN_MODEL; + size_t localSize = 1024; + e3 = getTickCount(); + if (!k.run(1, &globSize, &localSize, true)) + printf("Kernel Run Error!!!"); + e4 = getTickCount(); + t = (e4 - e3) / getTickFrequency()*1000.0; + //printf("Kernel Run GPU: %f\n", t); + + e3 = getTickCount(); + Mat posNCC = devPosNCC.getMat(ACCESS_READ); + Mat negNCC = devNegNCC.getMat(ACCESS_READ); + e4 = getTickCount(); + t = (e4 - e3) / getTickFrequency()*1000.0; + //printf("Read Mem GPU: %f\n", t); + + //Calculate Srs + for (int k = 0; k < numOfPatches; k++) + { + double spr = 0.0, smr = 0.0, spc = 0.0, smc = 0; + int med = getMedian((*timeStampsPositive)); + for (int i = 0; i < *posNum; i++) + { + spr = std::max(spr, 0.5 * (posNCC.at(k * 500 + i) + 1.0)); + if ((int)(*timeStampsPositive)[i] <= med) + spc = std::max(spr, 0.5 * (posNCC.at(k * 500 + i) + 1.0)); + } + for (int i = 0; i < *negNum; i++) + smc = smr = std::max(smr, 0.5 * (negNCC.at(k * 500 + i) + 1.0)); + + if (spr + smr == 0.0) + resultSr[k] = 0.0; + else + resultSr[k] = spr / (smr + spr); + + if (spc + smc == 0.0) + resultSc[k] = 0.0; + else + resultSc[k] = spc / (smc + spc); + } + + ////Compare positive NCCs + /*Mat_ modelSample(STANDARD_PATCH_SIZE, STANDARD_PATCH_SIZE); + Mat_ patch(STANDARD_PATCH_SIZE, STANDARD_PATCH_SIZE); + for (int j = 0; j < numOfPatches; j++) + { + for (int i = 0; i < 1; i++) + { + modelSample.data = &(posExp->data[i * 225]); + patch.data = &(patches.data[j * 225]); + printf("%f\t%f\n", resultSr[j], Sr(patch)); + printf("%f\t%f\n", resultSc[j], Sc(patch)); + } + }*/ + + //for (int i = 0; i < 200; i+=23) + //{ + // modelSample.data = &(negExp->data[i * 225]); + // printf("%f\t%f\n", resNCC.at(500+i), NCC(modelSample, patch)); + //} + + + + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + //printf("Sr GPU: %f\n\n", t); + } + + // Calculate Conservative similarity of the patch (NN-Model) double TLDDetector::Sc(const Mat_& patch) { @@ -204,7 +308,7 @@ namespace cv printf("Sc: %f\n", t); if (splus + sminus == 0.0) return 0.0; - + return splus / (sminus + splus); */ @@ -229,7 +333,7 @@ namespace cv } e2 = getTickCount(); t = (e2 - e1) / getTickFrequency()*1000.0; - printf("Sc: %f\n", t); + //printf("Sc: %f\n", t); if (splus + sminus == 0.0) return 0.0; @@ -353,78 +457,244 @@ namespace cv } //Detection - returns most probable new target location (Max Sc) + bool TLDDetector::detect(const Mat& img, const Mat& imgBlurred, Rect2d& res, std::vector& patches, Size initSize) { patches.clear(); - - Mat resized_img, blurred_img; Mat_ standardPatch(STANDARD_PATCH_SIZE, STANDARD_PATCH_SIZE); - img.copyTo(resized_img); - imgBlurred.copyTo(blurred_img); + Mat tmp; int dx = initSize.width / 10, dy = initSize.height / 10; Size2d size = img.size(); double scale = 1.0; int total = 0, pass = 0; int npos = 0, nneg = 0; - double tmp = 0, maxSc = -5.0; + double maxSc = -5.0; Rect2d maxScRect; + int scaleID; + std::vector resized_imgs, blurred_imgs; + std::vector varBuffer, ensBuffer; + std::vector varScaleIDs, ensScaleIDs; + int64 e1, e2; + double t; + e1 = cvGetTickCount(); //Detection part - //To fix: use precalculated BB + //Generate windows and filter by variance + scaleID = 0; + resized_imgs.push_back(img); + blurred_imgs.push_back(imgBlurred); do { Mat_ intImgP, intImgP2; - computeIntegralImages(resized_img, intImgP, intImgP2); - - prepareClassifiers((int)blurred_img.step[0]); - for (int i = 0, imax = cvFloor((0.0 + resized_img.cols - initSize.width) / dx); i < imax; i++) + computeIntegralImages(resized_imgs[scaleID], intImgP, intImgP2); + for (int i = 0, imax = cvFloor((0.0 + resized_imgs[scaleID].cols - initSize.width) / dx); i < imax; i++) { - for (int j = 0, jmax = cvFloor((0.0 + resized_img.rows - initSize.height) / dy); j < jmax; j++) + for (int j = 0, jmax = cvFloor((0.0 + resized_imgs[scaleID].rows - initSize.height) / dy); j < jmax; j++) { - LabeledPatch labPatch; - total++; if (!patchVariance(intImgP, intImgP2, originalVariancePtr, Point(dx * i, dy * j), initSize)) continue; - if (ensembleClassifierNum(&blurred_img.at(dy * j, dx * i)) <= ENSEMBLE_THRESHOLD) - continue; - pass++; + varBuffer.push_back(Point(dx * i, dy * j)); + varScaleIDs.push_back(scaleID); + } + } + scaleID++; + size.width /= SCALE_STEP; + size.height /= SCALE_STEP; + scale *= SCALE_STEP; + resize(img, tmp, size, 0, 0, DOWNSCALE_MODE); + resized_imgs.push_back(tmp); + GaussianBlur(resized_imgs[scaleID], tmp, GaussBlurKernelSize, 0.0f); + blurred_imgs.push_back(tmp); + } while (size.width >= initSize.width && size.height >= initSize.height); + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + //printf("Variance: %d\t%f\n", varBuffer.size(), t); + + //Encsemble classification + e1 = cvGetTickCount(); + for (int i = 0; i < varBuffer.size(); i++) + { + prepareClassifiers((int)blurred_imgs[varScaleIDs[i]].step[0]); + if (ensembleClassifierNum(&blurred_imgs[varScaleIDs[i]].at(varBuffer[i].y, varBuffer[i].x)) <= ENSEMBLE_THRESHOLD) + continue; + ensBuffer.push_back(varBuffer[i]); + ensScaleIDs.push_back(varScaleIDs[i]); + } + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + //printf("Ensemble: %d\t%f\n", ensBuffer.size(), t); + + //NN classification + e1 = getTickCount(); + for (int i = 0; i < ensBuffer.size(); i++) + { + LabeledPatch labPatch; + double curScale = pow(SCALE_STEP, ensScaleIDs[i]); + labPatch.rect = Rect2d(ensBuffer[i].x*curScale, ensBuffer[i].y*curScale, initSize.width * curScale, initSize.height * curScale); + resample(resized_imgs[ensScaleIDs[i]], Rect2d(ensBuffer[i], initSize), standardPatch); + + double srValue, scValue; + srValue = Sr(standardPatch); + + ////To fix: Check the paper, probably this cause wrong learning + // + labPatch.isObject = srValue > THETA_NN; + labPatch.shouldBeIntegrated = abs(srValue - THETA_NN) < 0.1; + patches.push_back(labPatch); + // + + if (!labPatch.isObject) + { + nneg++; + continue; + } + else + { + npos++; + } + scValue = Sc(standardPatch); + if (scValue > maxSc) + { + maxSc = scValue; + maxScRect = labPatch.rect; + } + } + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + //printf("NN: %d\t%f\n", patches.size(), t); - labPatch.rect = Rect2d(dx * i * scale, dy * j * scale, initSize.width * scale, initSize.height * scale); - resample(resized_img, Rect2d(Point(dx * i, dy * j), initSize), standardPatch); - - tmp = ocl_Sr(standardPatch); + if (maxSc < 0) + return false; + res = maxScRect; + return true; + } - ////To fix: Check the paper, probably this cause wrong learning - // - labPatch.isObject = tmp > THETA_NN; - labPatch.shouldBeIntegrated = abs(tmp - THETA_NN) < 0.1; - patches.push_back(labPatch); - // + bool TLDDetector::ocl_detect(const Mat& img, const Mat& imgBlurred, Rect2d& res, std::vector& patches, Size initSize) + { + patches.clear(); + Mat_ standardPatch(STANDARD_PATCH_SIZE, STANDARD_PATCH_SIZE); + Mat tmp; + int dx = initSize.width / 10, dy = initSize.height / 10; + Size2d size = img.size(); + double scale = 1.0; + int total = 0, pass = 0; + int npos = 0, nneg = 0; + double maxSc = -5.0; + Rect2d maxScRect; + int scaleID; + std::vector resized_imgs, blurred_imgs; + std::vector varBuffer, ensBuffer; + std::vector varScaleIDs, ensScaleIDs; + int64 e1, e2; + double t; - if (!labPatch.isObject) - { - nneg++; + e1 = cvGetTickCount(); + //Detection part + //Generate windows and filter by variance + scaleID = 0; + resized_imgs.push_back(img); + blurred_imgs.push_back(imgBlurred); + do + { + Mat_ intImgP, intImgP2; + computeIntegralImages(resized_imgs[scaleID], intImgP, intImgP2); + for (int i = 0, imax = cvFloor((0.0 + resized_imgs[scaleID].cols - initSize.width) / dx); i < imax; i++) + { + for (int j = 0, jmax = cvFloor((0.0 + resized_imgs[scaleID].rows - initSize.height) / dy); j < jmax; j++) + { + if (!patchVariance(intImgP, intImgP2, originalVariancePtr, Point(dx * i, dy * j), initSize)) continue; - } - else - { - npos++; - } - tmp = ocl_Sc(standardPatch); - if (tmp > maxSc) - { - maxSc = tmp; - maxScRect = labPatch.rect; - } + varBuffer.push_back(Point(dx * i, dy * j)); + varScaleIDs.push_back(scaleID); } } - + scaleID++; size.width /= SCALE_STEP; size.height /= SCALE_STEP; scale *= SCALE_STEP; - resize(img, resized_img, size, 0, 0, DOWNSCALE_MODE); - GaussianBlur(resized_img, blurred_img, GaussBlurKernelSize, 0.0f); + resize(img, tmp, size, 0, 0, DOWNSCALE_MODE); + resized_imgs.push_back(tmp); + GaussianBlur(resized_imgs[scaleID], tmp, GaussBlurKernelSize, 0.0f); + blurred_imgs.push_back(tmp); } while (size.width >= initSize.width && size.height >= initSize.height); + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + //printf("Variance: %d\t%f\n", varBuffer.size(), t); + + //Encsemble classification + e1 = cvGetTickCount(); + for (int i = 0; i < varBuffer.size(); i++) + { + prepareClassifiers((int)blurred_imgs[varScaleIDs[i]].step[0]); + if (ensembleClassifierNum(&blurred_imgs[varScaleIDs[i]].at(varBuffer[i].y, varBuffer[i].x)) <= ENSEMBLE_THRESHOLD) + continue; + ensBuffer.push_back(varBuffer[i]); + ensScaleIDs.push_back(varScaleIDs[i]); + } + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + //printf("Ensemble: %d\t%f\n", ensBuffer.size(), t); + + //NN classification + e1 = getTickCount(); + //Prepare batch of patches + int numOfPatches = ensBuffer.size(); + Mat_ stdPatches(numOfPatches, 225); + double *resultSr = new double[numOfPatches]; + double *resultSc = new double[numOfPatches]; + + uchar *patchesData = stdPatches.data; + for (int i = 0; i < ensBuffer.size(); i++) + { + resample(resized_imgs[ensScaleIDs[i]], Rect2d(ensBuffer[i], initSize), standardPatch); + uchar *stdPatchData = standardPatch.data; + for (int j = 0; j < 225; j++) + patchesData[225*i+j] = stdPatchData[j]; + } + //Calculate Sr and Sc batches + ocl_batchSrSc(stdPatches, resultSr, resultSc, numOfPatches); + + + for (int i = 0; i < ensBuffer.size(); i++) + { + LabeledPatch labPatch; + standardPatch.data = &stdPatches.data[225 * i]; + double curScale = pow(SCALE_STEP, ensScaleIDs[i]); + labPatch.rect = Rect2d(ensBuffer[i].x*curScale, ensBuffer[i].y*curScale, initSize.width * curScale, initSize.height * curScale); + + double srValue, scValue; + + srValue = resultSr[i]; + + //srValue = Sr(standardPatch); + //printf("%f\t%f\t\n", srValue, resultSr[i]); + + ////To fix: Check the paper, probably this cause wrong learning + // + labPatch.isObject = srValue > THETA_NN; + labPatch.shouldBeIntegrated = abs(srValue - THETA_NN) < 0.1; + patches.push_back(labPatch); + // + + if (!labPatch.isObject) + { + nneg++; + continue; + } + else + { + npos++; + } + scValue = resultSc[i]; + if (scValue > maxSc) + { + maxSc = scValue; + maxScRect = labPatch.rect; + } + } + e2 = getTickCount(); + t = (e2 - e1) / getTickFrequency()*1000.0; + //printf("NN: %d\t%f\n", patches.size(), t); if (maxSc < 0) return false; diff --git a/modules/tracking/src/tldDetector.hpp b/modules/tracking/src/tldDetector.hpp index f86e7e804..d109131c4 100644 --- a/modules/tracking/src/tldDetector.hpp +++ b/modules/tracking/src/tldDetector.hpp @@ -71,13 +71,14 @@ namespace cv public: TLDDetector(){} ~TLDDetector(){} - + inline double ensembleClassifierNum(const uchar* data); inline void prepareClassifiers(int rowstep); double Sr(const Mat_& patch); double ocl_Sr(const Mat_& patch); double Sc(const Mat_& patch); double ocl_Sc(const Mat_& patch); + void ocl_batchSrSc(const Mat_& patches, double *resultSr, double *resultSc, int numOfPatches); std::vector classifiers; Mat *posExp, *negExp; @@ -95,8 +96,8 @@ namespace cv bool detect(const Mat& img, const Mat& imgBlurred, Rect2d& res, std::vector& patches, Size initSize); bool ocl_detect(const Mat& img, const Mat& imgBlurred, Rect2d& res, std::vector& patches, Size initSize); protected: - - + + friend class MyMouseCallbackDEBUG; void computeIntegralImages(const Mat& img, Mat_& intImgP, Mat_& intImgP2){ integral(img, intImgP, intImgP2, CV_64F); } diff --git a/modules/tracking/src/tldTracker.cpp b/modules/tracking/src/tldTracker.cpp index 962a0f7c4..f95b3e2f1 100644 --- a/modules/tracking/src/tldTracker.cpp +++ b/modules/tracking/src/tldTracker.cpp @@ -89,7 +89,7 @@ bool TrackerTLDImpl::initImpl(const Mat& image, const Rect2d& boundingBox) myBoundingBox.width *= scale; myBoundingBox.height *= scale; } - model = Ptr(new TrackerTLDModel(params, image_gray, myBoundingBox, data->getMinSize())); + model = Ptr(new TrackerTLDModel(params, image_gray, myBoundingBox, data->getMinSize())); data->confident = false; data->failedLastTime = false; @@ -119,8 +119,8 @@ bool TrackerTLDImpl::updateImpl(const Mat& image, Rect2d& boundingBox) for( int i = 0; i < 2; i++ ) { Rect2d tmpCandid = boundingBox; - if( ( (i == 0) && !data->failedLastTime && trackerProxy->update(image, tmpCandid) ) || - ((i == 1) && (tldModel->detector->detect(imageForDetector, image_blurred, tmpCandid, detectorResults, tldModel->getMinSize())))) + if( ( (i == 0) && !data->failedLastTime && trackerProxy->update(image, tmpCandid) ) || + ((i == 1) && (tldModel->detector->ocl_detect(imageForDetector, image_blurred, tmpCandid, detectorResults, tldModel->getMinSize())))) { candidates.push_back(tmpCandid); if( i == 0 ) @@ -292,6 +292,6 @@ void Data::printme(FILE* port) dfprintf((port, "\tminSize = %dx%d\n", minSize.width, minSize.height)); } -} +} -} +} diff --git a/modules/tracking/src/tldUtils.cpp b/modules/tracking/src/tldUtils.cpp index 291e5f2d5..5b03c700d 100644 --- a/modules/tracking/src/tldUtils.cpp +++ b/modules/tracking/src/tldUtils.cpp @@ -42,7 +42,7 @@ #include "tldUtils.hpp" -namespace cv +namespace cv { namespace tld { From 17dbe91ac9f9b9f7dfbecfd18337e830aa3ce318 Mon Sep 17 00:00:00 2001 From: Vladimir Date: Tue, 30 Jun 2015 21:46:50 +0900 Subject: [PATCH 3/7] Warnings Fix #1 --- modules/tracking/src/tldDetector.cpp | 58 ++++++++++++++-------------- 1 file changed, 28 insertions(+), 30 deletions(-) diff --git a/modules/tracking/src/tldDetector.cpp b/modules/tracking/src/tldDetector.cpp index 1b7a866b3..0b510ad5f 100644 --- a/modules/tracking/src/tldDetector.cpp +++ b/modules/tracking/src/tldDetector.cpp @@ -81,9 +81,9 @@ namespace cv return 0.0; return splus / (sminus + splus); */ - int64 e1, e2; - float t; - e1 = getTickCount(); + //int64 e1, e2; + //float t; + //e1 = getTickCount(); double splus = 0.0, sminus = 0.0; Mat_ modelSample(STANDARD_PATCH_SIZE, STANDARD_PATCH_SIZE); for (int i = 0; i < *posNum; i++) @@ -96,8 +96,8 @@ namespace cv modelSample.data = &(negExp->data[i * 225]); sminus = std::max(sminus, 0.5 * (NCC(modelSample, patch) + 1.0)); } - e2 = getTickCount(); - t = (e2 - e1) / getTickFrequency()*1000.0; + //e2 = getTickCount(); + //t = (e2 - e1) / getTickFrequency()*1000.0; //printf("Sr CPU: %f\n", t); if (splus + sminus == 0.0) return 0.0; @@ -107,7 +107,7 @@ namespace cv double TLDDetector::ocl_Sr(const Mat_& patch) { int64 e1, e2, e3, e4; - float t; + double t; e1 = getTickCount(); e3 = getTickCount(); double splus = 0.0, sminus = 0.0; @@ -131,8 +131,8 @@ namespace cv ocl::KernelArg::PtrReadOnly(devPositiveSamples), ocl::KernelArg::PtrReadOnly(devNegativeSamples), ocl::KernelArg::PtrWriteOnly(devNCC), - (int)posNum, - (int)negNum); + posNum, + negNum); e4 = getTickCount(); t = (e4 - e3) / getTickFrequency()*1000.0; @@ -186,7 +186,7 @@ namespace cv void TLDDetector::ocl_batchSrSc(const Mat_& patches, double *resultSr, double *resultSc, int numOfPatches) { int64 e1, e2, e3, e4; - float t; + double t; e1 = getTickCount(); e3 = getTickCount(); @@ -235,28 +235,28 @@ namespace cv //printf("Read Mem GPU: %f\n", t); //Calculate Srs - for (int k = 0; k < numOfPatches; k++) + for (int id = 0; id < numOfPatches; id++) { double spr = 0.0, smr = 0.0, spc = 0.0, smc = 0; int med = getMedian((*timeStampsPositive)); for (int i = 0; i < *posNum; i++) { - spr = std::max(spr, 0.5 * (posNCC.at(k * 500 + i) + 1.0)); + spr = std::max(spr, 0.5 * (posNCC.at(id * 500 + i) + 1.0)); if ((int)(*timeStampsPositive)[i] <= med) - spc = std::max(spr, 0.5 * (posNCC.at(k * 500 + i) + 1.0)); + spc = std::max(spr, 0.5 * (posNCC.at(id * 500 + i) + 1.0)); } for (int i = 0; i < *negNum; i++) - smc = smr = std::max(smr, 0.5 * (negNCC.at(k * 500 + i) + 1.0)); + smc = smr = std::max(smr, 0.5 * (negNCC.at(id * 500 + i) + 1.0)); if (spr + smr == 0.0) - resultSr[k] = 0.0; + resultSr[id] = 0.0; else - resultSr[k] = spr / (smr + spr); + resultSr[id] = spr / (smr + spr); if (spc + smc == 0.0) - resultSc[k] = 0.0; + resultSc[id] = 0.0; else - resultSc[k] = spc / (smc + spc); + resultSc[id] = spc / (smc + spc); } ////Compare positive NCCs @@ -367,8 +367,8 @@ namespace cv ocl::KernelArg::PtrReadOnly(devPositiveSamples), ocl::KernelArg::PtrReadOnly(devNegativeSamples), ocl::KernelArg::PtrWriteOnly(devNCC), - (int)posNum, - (int)negNum); + posNum, + negNum); e4 = getTickCount(); t = (e4 - e3) / getTickFrequency()*1000.0; @@ -466,7 +466,6 @@ namespace cv int dx = initSize.width / 10, dy = initSize.height / 10; Size2d size = img.size(); double scale = 1.0; - int total = 0, pass = 0; int npos = 0, nneg = 0; double maxSc = -5.0; Rect2d maxScRect; @@ -477,7 +476,7 @@ namespace cv int64 e1, e2; double t; - e1 = cvGetTickCount(); + e1 = getTickCount(); //Detection part //Generate windows and filter by variance scaleID = 0; @@ -511,8 +510,8 @@ namespace cv //printf("Variance: %d\t%f\n", varBuffer.size(), t); //Encsemble classification - e1 = cvGetTickCount(); - for (int i = 0; i < varBuffer.size(); i++) + e1 = getTickCount(); + for (int i = 0; i < (int)varBuffer.size(); i++) { prepareClassifiers((int)blurred_imgs[varScaleIDs[i]].step[0]); if (ensembleClassifierNum(&blurred_imgs[varScaleIDs[i]].at(varBuffer[i].y, varBuffer[i].x)) <= ENSEMBLE_THRESHOLD) @@ -526,7 +525,7 @@ namespace cv //NN classification e1 = getTickCount(); - for (int i = 0; i < ensBuffer.size(); i++) + for (int i = 0; i < (int)ensBuffer.size(); i++) { LabeledPatch labPatch; double curScale = pow(SCALE_STEP, ensScaleIDs[i]); @@ -577,7 +576,6 @@ namespace cv int dx = initSize.width / 10, dy = initSize.height / 10; Size2d size = img.size(); double scale = 1.0; - int total = 0, pass = 0; int npos = 0, nneg = 0; double maxSc = -5.0; Rect2d maxScRect; @@ -588,7 +586,7 @@ namespace cv int64 e1, e2; double t; - e1 = cvGetTickCount(); + e1 = getTickCount(); //Detection part //Generate windows and filter by variance scaleID = 0; @@ -622,8 +620,8 @@ namespace cv //printf("Variance: %d\t%f\n", varBuffer.size(), t); //Encsemble classification - e1 = cvGetTickCount(); - for (int i = 0; i < varBuffer.size(); i++) + e1 = getTickCount(); + for (int i = 0; i < (int)varBuffer.size(); i++) { prepareClassifiers((int)blurred_imgs[varScaleIDs[i]].step[0]); if (ensembleClassifierNum(&blurred_imgs[varScaleIDs[i]].at(varBuffer[i].y, varBuffer[i].x)) <= ENSEMBLE_THRESHOLD) @@ -644,7 +642,7 @@ namespace cv double *resultSc = new double[numOfPatches]; uchar *patchesData = stdPatches.data; - for (int i = 0; i < ensBuffer.size(); i++) + for (int i = 0; i < (int)ensBuffer.size(); i++) { resample(resized_imgs[ensScaleIDs[i]], Rect2d(ensBuffer[i], initSize), standardPatch); uchar *stdPatchData = standardPatch.data; @@ -655,7 +653,7 @@ namespace cv ocl_batchSrSc(stdPatches, resultSr, resultSc, numOfPatches); - for (int i = 0; i < ensBuffer.size(); i++) + for (int i = 0; i < (int)ensBuffer.size(); i++) { LabeledPatch labPatch; standardPatch.data = &stdPatches.data[225 * i]; From d39fbb7608050632ea28ca7eb302faea43e5c6ce Mon Sep 17 00:00:00 2001 From: Vladimir Date: Tue, 30 Jun 2015 22:24:13 +0900 Subject: [PATCH 4/7] Fixing Warnings #2 --- modules/tracking/src/tldDetector.cpp | 112 +++++++++--------- .../tracking/src/tldEnsembleClassifier.cpp | 15 ++- .../tracking/src/tldEnsembleClassifier.hpp | 2 - modules/tracking/src/tldModel.cpp | 13 +- modules/tracking/src/tldModel.hpp | 8 +- modules/tracking/src/tldTracker.hpp | 4 +- 6 files changed, 68 insertions(+), 86 deletions(-) diff --git a/modules/tracking/src/tldDetector.cpp b/modules/tracking/src/tldDetector.cpp index 0b510ad5f..9f9bdb627 100644 --- a/modules/tracking/src/tldDetector.cpp +++ b/modules/tracking/src/tldDetector.cpp @@ -53,7 +53,7 @@ namespace cv } // Calculate posterior probability, that the patch belongs to the current EC model - double TLDDetector::ensembleClassifierNum(const uchar* data) + double TLDDetector::ensembleClassifierNum(const uchar* data) { double p = 0; for (int k = 0; k < (int)classifiers.size(); k++) @@ -106,10 +106,10 @@ namespace cv double TLDDetector::ocl_Sr(const Mat_& patch) { - int64 e1, e2, e3, e4; - double t; - e1 = getTickCount(); - e3 = getTickCount(); + //int64 e1, e2, e3, e4; + //double t; + //e1 = getTickCount(); + //e3 = getTickCount(); double splus = 0.0, sminus = 0.0; @@ -134,23 +134,23 @@ namespace cv posNum, negNum); - e4 = getTickCount(); - t = (e4 - e3) / getTickFrequency()*1000.0; + //e4 = getTickCount(); + //t = (e4 - e3) / getTickFrequency()*1000.0; //printf("Mem Cpy GPU: %f\n", t); size_t globSize = 1000; size_t localSize = 128; - e3 = getTickCount(); + //e3 = getTickCount(); if (!k.run(1, &globSize, &localSize, true)) printf("Kernel Run Error!!!"); - e4 = getTickCount(); - t = (e4 - e3) / getTickFrequency()*1000.0; + //e4 = getTickCount(); + //t = (e4 - e3) / getTickFrequency()*1000.0; //printf("Kernel Run GPU: %f\n", t); - e3 = getTickCount(); + //e3 = getTickCount(); Mat resNCC = devNCC.getMat(ACCESS_READ); - e4 = getTickCount(); - t = (e4 - e3) / getTickFrequency()*1000.0; + //e4 = getTickCount(); + //t = (e4 - e3) / getTickFrequency()*1000.0; //printf("Read Mem GPU: %f\n", t); ////Compare @@ -174,8 +174,8 @@ namespace cv for (int i = 0; i < *negNum; i++) sminus = std::max(sminus, 0.5 * (resNCC.at(i+500) +1.0)); - e2 = getTickCount(); - t = (e2 - e1) / getTickFrequency()*1000.0; + //e2 = getTickCount(); + //t = (e2 - e1) / getTickFrequency()*1000.0; //printf("Sr GPU: %f\n\n", t); if (splus + sminus == 0.0) @@ -185,10 +185,10 @@ namespace cv void TLDDetector::ocl_batchSrSc(const Mat_& patches, double *resultSr, double *resultSc, int numOfPatches) { - int64 e1, e2, e3, e4; - double t; - e1 = getTickCount(); - e3 = getTickCount(); + //int64 e1, e2, e3, e4; + //double t; + //e1 = getTickCount(); + //e3 = getTickCount(); UMat devPatches = patches.getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); UMat devPositiveSamples = posExp->getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); @@ -213,25 +213,25 @@ namespace cv negNum, numOfPatches); - e4 = getTickCount(); - t = (e4 - e3) / getTickFrequency()*1000.0; + //e4 = getTickCount(); + //t = (e4 - e3) / getTickFrequency()*1000.0; //printf("Mem Cpy GPU: %f\n", t); // 2 -> Pos&Neg size_t globSize = 2 * numOfPatches*MAX_EXAMPLES_IN_MODEL; size_t localSize = 1024; - e3 = getTickCount(); + //e3 = getTickCount(); if (!k.run(1, &globSize, &localSize, true)) printf("Kernel Run Error!!!"); - e4 = getTickCount(); - t = (e4 - e3) / getTickFrequency()*1000.0; + //e4 = getTickCount(); + //t = (e4 - e3) / getTickFrequency()*1000.0; //printf("Kernel Run GPU: %f\n", t); - e3 = getTickCount(); + //e3 = getTickCount(); Mat posNCC = devPosNCC.getMat(ACCESS_READ); Mat negNCC = devNegNCC.getMat(ACCESS_READ); - e4 = getTickCount(); - t = (e4 - e3) / getTickFrequency()*1000.0; + //e4 = getTickCount(); + //t = (e4 - e3) / getTickFrequency()*1000.0; //printf("Read Mem GPU: %f\n", t); //Calculate Srs @@ -281,8 +281,8 @@ namespace cv - e2 = getTickCount(); - t = (e2 - e1) / getTickFrequency()*1000.0; + //e2 = getTickCount(); + //t = (e2 - e1) / getTickFrequency()*1000.0; //printf("Sr GPU: %f\n\n", t); } @@ -312,9 +312,9 @@ namespace cv return splus / (sminus + splus); */ - int64 e1, e2; - float t; - e1 = getTickCount(); + //int64 e1, e2; + //double t; + //e1 = getTickCount(); double splus = 0.0, sminus = 0.0; Mat_ modelSample(STANDARD_PATCH_SIZE, STANDARD_PATCH_SIZE); int med = getMedian((*timeStampsPositive)); @@ -331,8 +331,8 @@ namespace cv modelSample.data = &(negExp->data[i * 225]); sminus = std::max(sminus, 0.5 * (NCC(modelSample, patch) + 1.0)); } - e2 = getTickCount(); - t = (e2 - e1) / getTickFrequency()*1000.0; + //e2 = getTickCount(); + //t = (e2 - e1) / getTickFrequency()*1000.0; //printf("Sc: %f\n", t); if (splus + sminus == 0.0) return 0.0; @@ -473,10 +473,10 @@ namespace cv std::vector resized_imgs, blurred_imgs; std::vector varBuffer, ensBuffer; std::vector varScaleIDs, ensScaleIDs; - int64 e1, e2; - double t; + //int64 e1, e2; + //double t; - e1 = getTickCount(); + //e1 = getTickCount(); //Detection part //Generate windows and filter by variance scaleID = 0; @@ -505,12 +505,12 @@ namespace cv GaussianBlur(resized_imgs[scaleID], tmp, GaussBlurKernelSize, 0.0f); blurred_imgs.push_back(tmp); } while (size.width >= initSize.width && size.height >= initSize.height); - e2 = getTickCount(); - t = (e2 - e1) / getTickFrequency()*1000.0; + //e2 = getTickCount(); + //t = (e2 - e1) / getTickFrequency()*1000.0; //printf("Variance: %d\t%f\n", varBuffer.size(), t); //Encsemble classification - e1 = getTickCount(); + //e1 = getTickCount(); for (int i = 0; i < (int)varBuffer.size(); i++) { prepareClassifiers((int)blurred_imgs[varScaleIDs[i]].step[0]); @@ -519,12 +519,12 @@ namespace cv ensBuffer.push_back(varBuffer[i]); ensScaleIDs.push_back(varScaleIDs[i]); } - e2 = getTickCount(); - t = (e2 - e1) / getTickFrequency()*1000.0; + //e2 = getTickCount(); + //t = (e2 - e1) / getTickFrequency()*1000.0; //printf("Ensemble: %d\t%f\n", ensBuffer.size(), t); //NN classification - e1 = getTickCount(); + //e1 = getTickCount(); for (int i = 0; i < (int)ensBuffer.size(); i++) { LabeledPatch labPatch; @@ -558,8 +558,8 @@ namespace cv maxScRect = labPatch.rect; } } - e2 = getTickCount(); - t = (e2 - e1) / getTickFrequency()*1000.0; + //e2 = getTickCount(); + //t = (e2 - e1) / getTickFrequency()*1000.0; //printf("NN: %d\t%f\n", patches.size(), t); if (maxSc < 0) @@ -583,10 +583,10 @@ namespace cv std::vector resized_imgs, blurred_imgs; std::vector varBuffer, ensBuffer; std::vector varScaleIDs, ensScaleIDs; - int64 e1, e2; - double t; + //int64 e1, e2; + //double t; - e1 = getTickCount(); + //e1 = getTickCount(); //Detection part //Generate windows and filter by variance scaleID = 0; @@ -615,12 +615,12 @@ namespace cv GaussianBlur(resized_imgs[scaleID], tmp, GaussBlurKernelSize, 0.0f); blurred_imgs.push_back(tmp); } while (size.width >= initSize.width && size.height >= initSize.height); - e2 = getTickCount(); - t = (e2 - e1) / getTickFrequency()*1000.0; + //e2 = getTickCount(); + //t = (e2 - e1) / getTickFrequency()*1000.0; //printf("Variance: %d\t%f\n", varBuffer.size(), t); //Encsemble classification - e1 = getTickCount(); + //e1 = getTickCount(); for (int i = 0; i < (int)varBuffer.size(); i++) { prepareClassifiers((int)blurred_imgs[varScaleIDs[i]].step[0]); @@ -629,12 +629,12 @@ namespace cv ensBuffer.push_back(varBuffer[i]); ensScaleIDs.push_back(varScaleIDs[i]); } - e2 = getTickCount(); - t = (e2 - e1) / getTickFrequency()*1000.0; + //e2 = getTickCount(); + //t = (e2 - e1) / getTickFrequency()*1000.0; //printf("Ensemble: %d\t%f\n", ensBuffer.size(), t); //NN classification - e1 = getTickCount(); + //e1 = getTickCount(); //Prepare batch of patches int numOfPatches = ensBuffer.size(); Mat_ stdPatches(numOfPatches, 225); @@ -690,8 +690,8 @@ namespace cv maxScRect = labPatch.rect; } } - e2 = getTickCount(); - t = (e2 - e1) / getTickFrequency()*1000.0; + //e2 = getTickCount(); + //t = (e2 - e1) / getTickFrequency()*1000.0; //printf("NN: %d\t%f\n", patches.size(), t); if (maxSc < 0) diff --git a/modules/tracking/src/tldEnsembleClassifier.cpp b/modules/tracking/src/tldEnsembleClassifier.cpp index 32286928e..1d72b3e81 100644 --- a/modules/tracking/src/tldEnsembleClassifier.cpp +++ b/modules/tracking/src/tldEnsembleClassifier.cpp @@ -55,15 +55,14 @@ namespace cv measurements.assign(meas.begin() + beg, meas.begin() + end); offset.assign(mpc, Point2i(0, 0)); } - - // Calculate measure locations from 15x15 grid on minSize patches + // Calculate measure locations from 15x15 grid on minSize patches void TLDEnsembleClassifier::stepPrefSuff(std::vector& arr, int pos, int len, int gridSize) { -#if 0 + #if 0 int step = len / (gridSize - 1), pref = (len - step * (gridSize - 1)) / 2; for (int i = 0; i < (int)(sizeof(x1) / sizeof(x1[0])); i++) arr[i] = pref + arr[i] * step; -#else + #else int total = len - gridSize; int quo = total / (gridSize - 1), rem = total % (gridSize - 1); int smallStep = quo, bigStep = quo + 1; @@ -92,7 +91,7 @@ namespace cv } #endif } - + // Calculate offsets for classifier void TLDEnsembleClassifier::prepareClassifier(int rowstep) { @@ -106,7 +105,7 @@ namespace cv } } } - + // Integrate patch into the Ensemble Classifier model void TLDEnsembleClassifier::integrate(const Mat_& patch, bool isPositive) { @@ -137,7 +136,7 @@ namespace cv return posNum / (posNum + negNum); } - // Calculate the 13-bit fern index + // Calculate the 13-bit fern index int TLDEnsembleClassifier::codeFast(const uchar* data) const { int position = 0; @@ -188,7 +187,7 @@ namespace cv stepPrefSuff(measurements, 2, size.height, gridSize); stepPrefSuff(measurements, 3, size.height, gridSize); - //Compile fern classifiers + //Compile fern classifiers for (int i = 0, howMany = (int)measurements.size() / measurePerClassifier; i < howMany; i++) classifiers.push_back(TLDEnsembleClassifier(measurements, i * measurePerClassifier, (i + 1) * measurePerClassifier)); diff --git a/modules/tracking/src/tldEnsembleClassifier.hpp b/modules/tracking/src/tldEnsembleClassifier.hpp index 2725700e6..97221372d 100644 --- a/modules/tracking/src/tldEnsembleClassifier.hpp +++ b/modules/tracking/src/tldEnsembleClassifier.hpp @@ -64,7 +64,5 @@ namespace cv std::vector offset; int lastStep_; }; - - } } \ No newline at end of file diff --git a/modules/tracking/src/tldModel.cpp b/modules/tracking/src/tldModel.cpp index 6c926d706..59b621845 100644 --- a/modules/tracking/src/tldModel.cpp +++ b/modules/tracking/src/tldModel.cpp @@ -65,7 +65,7 @@ namespace cv detector->posExp = &posExp; detector->negExp = &negExp; - detector->positiveExamples = &positiveExamples; + detector->positiveExamples = &positiveExamples; detector->negativeExamples = &negativeExamples; detector->timeStampsPositive = &timeStampsPositive; detector->timeStampsNegative = &timeStampsNegative; @@ -73,21 +73,18 @@ namespace cv //Calculate the variance in initial BB originalVariance_ = variance(image(boundingBox)); - //Find the scale double scale = scaleAndBlur(image, cvRound(log(1.0 * boundingBox.width / (minSize.width)) / log(SCALE_STEP)), scaledImg, blurredImg, GaussBlurKernelSize, SCALE_STEP); GaussianBlur(image, image_blurred, GaussBlurKernelSize, 0.0); TLDDetector::generateScanGrid(image.rows, image.cols, minSize_, scanGrid); - getClosestN(scanGrid, Rect2d(boundingBox.x / scale, boundingBox.y / scale, boundingBox.width / scale, - boundingBox.height / scale), 10, closest); - + getClosestN(scanGrid, Rect2d(boundingBox.x / scale, boundingBox.y / scale, boundingBox.width / scale, boundingBox.height / scale), 10, closest); Mat_ blurredPatch(minSize); TLDEnsembleClassifier::makeClassifiers(minSize, MEASURES_PER_CLASSIFIER, GRIDSIZE, detector->classifiers); //Generate initial positive samples and put them to the model positiveExamples.reserve(200); - + for (int i = 0; i < (int)closest.size(); i++) { for (int j = 0; j < 20; j++) @@ -297,9 +294,5 @@ namespace cv dfprintf((port, "\tpositiveExamples.size() = %d\n", (int)positiveExamples.size())); dfprintf((port, "\tnegativeExamples.size() = %d\n", (int)negativeExamples.size())); } - - - - } } \ No newline at end of file diff --git a/modules/tracking/src/tldModel.hpp b/modules/tracking/src/tldModel.hpp index 67746745b..ea11d17d8 100644 --- a/modules/tracking/src/tldModel.hpp +++ b/modules/tracking/src/tldModel.hpp @@ -50,10 +50,6 @@ namespace cv { namespace tld { - - - - class TrackerTLDModel : public TrackerModel { public: @@ -77,14 +73,12 @@ namespace cv protected: Size minSize_; - TrackerTLD::Params params_; void pushIntoModel(const Mat_& example, bool positive); void modelEstimationImpl(const std::vector& /*responses*/){} void modelUpdateImpl(){} - Rect2d boundingBox_; + Rect2d boundingBox_; RNG rng; - }; } diff --git a/modules/tracking/src/tldTracker.hpp b/modules/tracking/src/tldTracker.hpp index de2622383..e04926d5d 100644 --- a/modules/tracking/src/tldTracker.hpp +++ b/modules/tracking/src/tldTracker.hpp @@ -49,7 +49,7 @@ #include #include -namespace cv +namespace cv { TrackerTLD::Params::Params(){} @@ -60,8 +60,6 @@ void TrackerTLD::Params::write(cv::FileStorage& /*fs*/) const {} namespace tld { - - class TrackerProxy { public: From fcd1a682e77d932ea3b1ee8d0d45a79d3b2ce4fd Mon Sep 17 00:00:00 2001 From: Vladimir Date: Tue, 30 Jun 2015 22:54:41 +0900 Subject: [PATCH 5/7] Fixing Warnings #3 --- modules/tracking/src/tldDetector.cpp | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/modules/tracking/src/tldDetector.cpp b/modules/tracking/src/tldDetector.cpp index 9f9bdb627..90cf6d824 100644 --- a/modules/tracking/src/tldDetector.cpp +++ b/modules/tracking/src/tldDetector.cpp @@ -342,12 +342,12 @@ namespace cv double TLDDetector::ocl_Sc(const Mat_& patch) { - int64 e1, e2, e3, e4; - float t; - e1 = getTickCount(); + //int64 e1, e2, e3, e4; + //float t; + //e1 = getTickCount(); double splus = 0.0, sminus = 0.0; - e3 = getTickCount(); + //e3 = getTickCount(); UMat devPatch = patch.getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); UMat devPositiveSamples = posExp->getUMat(ACCESS_READ, USAGE_ALLOCATE_DEVICE_MEMORY); @@ -370,23 +370,23 @@ namespace cv posNum, negNum); - e4 = getTickCount(); - t = (e4 - e3) / getTickFrequency()*1000.0; + //e4 = getTickCount(); + //t = (e4 - e3) / getTickFrequency()*1000.0; //printf("Mem Cpy GPU: %f\n", t); size_t globSize = 1000; size_t localSize = 128; - e3 = getTickCount(); + //e3 = getTickCount(); if (!k.run(1, &globSize, &localSize, true)) printf("Kernel Run Error!!!"); - e4 = getTickCount(); - t = (e4 - e3) / getTickFrequency()*1000.0; + //e4 = getTickCount(); + //t = (e4 - e3) / getTickFrequency()*1000.0; //printf("Kernel Run GPU: %f\n", t); - e3 = getTickCount(); + //e3 = getTickCount(); Mat resNCC = devNCC.getMat(ACCESS_READ); - e4 = getTickCount(); - t = (e4 - e3) / getTickFrequency()*1000.0; + //e4 = getTickCount(); + //t = (e4 - e3) / getTickFrequency()*1000.0; //printf("Read Mem GPU: %f\n", t); ////Compare @@ -411,8 +411,8 @@ namespace cv for (int i = 0; i < *negNum; i++) sminus = std::max(sminus, 0.5 * (resNCC.at(i + 500) + 1.0)); - e2 = getTickCount(); - t = (e2 - e1) / getTickFrequency()*1000.0; + //e2 = getTickCount(); + //t = (e2 - e1) / getTickFrequency()*1000.0; //printf("Sc GPU: %f\n\n", t); if (splus + sminus == 0.0) From 4483a0bc676f0e5655a624da4e62ddf19d35f725 Mon Sep 17 00:00:00 2001 From: Vladimir Date: Tue, 30 Jun 2015 23:21:57 +0900 Subject: [PATCH 6/7] Fixing Warnings #4 --- modules/tracking/src/tldDetector.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/modules/tracking/src/tldDetector.cpp b/modules/tracking/src/tldDetector.cpp index 90cf6d824..719332b78 100644 --- a/modules/tracking/src/tldDetector.cpp +++ b/modules/tracking/src/tldDetector.cpp @@ -513,7 +513,7 @@ namespace cv //e1 = getTickCount(); for (int i = 0; i < (int)varBuffer.size(); i++) { - prepareClassifiers((int)blurred_imgs[varScaleIDs[i]].step[0]); + prepareClassifiers(static_cast (blurred_imgs[varScaleIDs[i]].step[0])); if (ensembleClassifierNum(&blurred_imgs[varScaleIDs[i]].at(varBuffer[i].y, varBuffer[i].x)) <= ENSEMBLE_THRESHOLD) continue; ensBuffer.push_back(varBuffer[i]); @@ -582,7 +582,7 @@ namespace cv int scaleID; std::vector resized_imgs, blurred_imgs; std::vector varBuffer, ensBuffer; - std::vector varScaleIDs, ensScaleIDs; + std::vector varScaleIDs, ensScaleIDs; //int64 e1, e2; //double t; @@ -636,7 +636,7 @@ namespace cv //NN classification //e1 = getTickCount(); //Prepare batch of patches - int numOfPatches = ensBuffer.size(); + int numOfPatches = (int)ensBuffer.size(); Mat_ stdPatches(numOfPatches, 225); double *resultSr = new double[numOfPatches]; double *resultSc = new double[numOfPatches]; From 3473d9343fe2d33ae1ce3888064e4112278905b8 Mon Sep 17 00:00:00 2001 From: Vladimir Date: Tue, 30 Jun 2015 23:32:50 +0900 Subject: [PATCH 7/7] Fixing Warnings #5 --- modules/tracking/src/tldDetector.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/tracking/src/tldDetector.cpp b/modules/tracking/src/tldDetector.cpp index 719332b78..18a6168a9 100644 --- a/modules/tracking/src/tldDetector.cpp +++ b/modules/tracking/src/tldDetector.cpp @@ -472,7 +472,7 @@ namespace cv int scaleID; std::vector resized_imgs, blurred_imgs; std::vector varBuffer, ensBuffer; - std::vector varScaleIDs, ensScaleIDs; + std::vector varScaleIDs, ensScaleIDs; //int64 e1, e2; //double t;