cleanup unnecessary setNumThreads() calls

alalek · alalek · commit b8de57f8bd4c · 2018-04-28T14:53:50.000+03:00
diff --git a/modules/bgsegm/samples/bgfg.cpp b/modules/bgsegm/samples/bgfg.cpp
@@ -37,9 +37,6 @@ static Ptr<BackgroundSubtractor> createBGSubtractorByName(const String& algoName
 
 int main(int argc, char** argv)
 {
-    setUseOptimized(true);
-    setNumThreads(8);
-
     CommandLineParser parser(argc, argv, keys);
     parser.about(about);
     parser.printMessage();
diff --git a/modules/optflow/perf/perf_deepflow.cpp b/modules/optflow/perf/perf_deepflow.cpp
@@ -20,7 +20,6 @@ PERF_TEST_P(DenseOpticalFlow_DeepFlow, perf, Values(szVGA, sz720p))
     randu(frame1, 0, 255);
     randu(frame2, 0, 255);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(1)
     {
         Ptr<DenseOpticalFlow> algo = createOptFlow_DeepFlow();
diff --git a/modules/optflow/perf/perf_disflow.cpp b/modules/optflow/perf/perf_disflow.cpp
@@ -32,7 +32,6 @@ PERF_TEST_P(DenseOpticalFlow_DIS, perf,
 
     MakeArtificialExample(frame1, frame2);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(10)
     {
         Ptr<DenseOpticalFlow> algo = createOptFlow_DIS(preset);
diff --git a/modules/optflow/perf/perf_variational_refinement.cpp b/modules/optflow/perf/perf_variational_refinement.cpp
@@ -23,7 +23,6 @@ PERF_TEST_P(DenseOpticalFlow_VariationalRefinement, perf, Combine(Values(szQVGA,
     randu(frame2, 0, 255);
     flow.setTo(0.0f);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(10)
     {
         Ptr<VariationalRefinement> var = createVariationalFlowRefinement();
diff --git a/modules/optflow/test/test_OF_reproducibility.cpp b/modules/optflow/test/test_OF_reproducibility.cpp
@@ -57,6 +57,9 @@ TEST_P(DenseOpticalFlow_DIS, MultithreadReproducibility)
     OFParams params = GetParam();
     Size size = get<0>(params);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         Mat frame1(size, CV_8U);
@@ -79,7 +82,7 @@ TEST_P(DenseOpticalFlow_DIS, MultithreadReproducibility)
         algo->setUseMeanNormalization(use_mean_normalization);
         algo->setUseSpatialPropagation(use_spatial_propagation);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         algo->calc(frame1, frame2, resMultiThread);
 
@@ -111,6 +114,9 @@ TEST_P(DenseOpticalFlow_VariationalRefinement, MultithreadReproducibility)
     OFParams params = GetParam();
     Size size = get<0>(params);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         Mat frame1(size, CV_8U);
@@ -128,7 +134,7 @@ TEST_P(DenseOpticalFlow_VariationalRefinement, MultithreadReproducibility)
         var->setFixedPointIterations(rng.uniform(1, 20));
         var->setOmega(rng.uniform(1.01f, 1.99f));
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         flow.copyTo(resMultiThread);
         var->calc(frame1, frame2, resMultiThread);
diff --git a/modules/tracking/src/trackerCSRT.cpp b/modules/tracking/src/trackerCSRT.cpp
@@ -506,8 +506,6 @@ bool TrackerCSRTImpl::updateImpl(const Mat& image_, Rect2d& boundingBox)
 // *********************************************************************
 bool TrackerCSRTImpl::initImpl(const Mat& image_, const Rect2d& boundingBox)
 {
-    cv::setNumThreads(getNumThreads());
-
     //treat gray image as color image
     Mat image;
     if(image_.channels() == 1) {
diff --git a/modules/ximgproc/perf/perf_adaptive_manifold.cpp b/modules/ximgproc/perf/perf_adaptive_manifold.cpp
@@ -29,9 +29,7 @@ PERF_TEST_P( AdaptiveManifoldPerfTest, perf,
     Mat src(sz, CV_MAKE_TYPE(depth, srcCnNum));
     Mat dst(sz, CV_MAKE_TYPE(depth, srcCnNum));
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-
-    declare.in(joint, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(joint, src, WARMUP_RNG).out(dst);
 
     double sigma_s = 16;
     double sigma_r = 0.5;
diff --git a/modules/ximgproc/perf/perf_bilateral_texture_filter.cpp b/modules/ximgproc/perf/perf_bilateral_texture_filter.cpp
@@ -29,8 +29,7 @@ PERF_TEST_P(BilateralTextureFilterTest, perf,
     Mat src(sz, CV_MAKE_TYPE(depth,srcCn));
     Mat dst(sz, src.type());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-    declare.in(src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(src, WARMUP_RNG).out(dst);
 
     TEST_CYCLE_N(1)
     {
diff --git a/modules/ximgproc/perf/perf_disparity_wls_filter.cpp b/modules/ximgproc/perf/perf_disparity_wls_filter.cpp
@@ -41,7 +41,6 @@ PERF_TEST_P( DisparityWLSFilterPerfTest, perf, Combine(GuideTypes::all(), SrcTyp
         ROI = Rect(ROI.x/2,ROI.y/2,ROI.width/2,ROI.height/2);
     }
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(10)
     {
         Ptr<DisparityWLSFilter> wls_filter = createDisparityWLSFilterGeneric(use_conf);
diff --git a/modules/ximgproc/perf/perf_domain_transform.cpp b/modules/ximgproc/perf/perf_domain_transform.cpp
@@ -34,9 +34,8 @@ PERF_TEST_P( DomainTransformTest, perf,
     Mat src(size, srcType);
     Mat dst(size, srcType);
 
-    declare.in(guide, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(guide, src, WARMUP_RNG).out(dst);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(5)
     {
         dtFilter(guide, src, dst, sigmaSpatial, sigmaColor, dtfType);
diff --git a/modules/ximgproc/perf/perf_fgs_filter.cpp b/modules/ximgproc/perf/perf_fgs_filter.cpp
@@ -24,9 +24,8 @@ PERF_TEST_P( FGSFilterPerfTest, perf, Combine(GuideTypes::all(), SrcTypes::all()
     Mat src(sz, srcType);
     Mat dst(sz, srcType);
 
-    declare.in(guide, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(guide, src, WARMUP_RNG).out(dst);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(10)
     {
         double lambda = rng.uniform(500.0, 10000.0);
diff --git a/modules/ximgproc/perf/perf_guided_filter.cpp b/modules/ximgproc/perf/perf_guided_filter.cpp
@@ -24,9 +24,8 @@ PERF_TEST_P( GuidedFilterPerfTest, perf, Combine(GuideTypes::all(), SrcTypes::al
     Mat src(sz, srcType);
     Mat dst(sz, srcType);
 
-    declare.in(guide, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(guide, src, WARMUP_RNG).out(dst);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(3)
     {
         int radius = rng.uniform(5, 30);
diff --git a/modules/ximgproc/perf/perf_l0_smooth.cpp b/modules/ximgproc/perf/perf_l0_smooth.cpp
@@ -23,8 +23,7 @@ PERF_TEST_P(L0SmoothTest, perf,
     Mat src(sz, CV_MAKE_TYPE(depth, srcCn));
     Mat dst(sz, src.type());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-    declare.in(src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(src, WARMUP_RNG).out(dst);
 
     RNG rnd(sz.height + depth + srcCn);
     double lambda = rnd.uniform(0.01, 0.05);
diff --git a/modules/ximgproc/perf/perf_rolling_guidance_filter.cpp b/modules/ximgproc/perf/perf_rolling_guidance_filter.cpp
@@ -25,8 +25,7 @@ PERF_TEST_P(RollingGuidanceFilterTest, perf,
     Mat src(sz, CV_MAKE_TYPE(depth, srcCn));
     Mat dst(sz, src.type());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-    declare.in(src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(src, WARMUP_RNG).out(dst);
 
     RNG rnd(cvRound(10*sigmaS) + sz.height + depth + srcCn);
     double sigmaC = rnd.uniform(1.0, 255.0);
diff --git a/modules/ximgproc/perf/perf_weighted_median_filter.cpp b/modules/ximgproc/perf/perf_weighted_median_filter.cpp
@@ -34,8 +34,7 @@ PERF_TEST_P(WeightedMedianFilterTest, perf,
     Mat src(sz, CV_MAKE_TYPE(srcDepth, srcCn));
     Mat dst(sz, src.type());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-    declare.in(joint, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(joint, src, WARMUP_RNG).out(dst);
 
     TEST_CYCLE_N(1)
     {
diff --git a/modules/ximgproc/perf/pref_joint_bilateral_filter.cpp b/modules/ximgproc/perf/pref_joint_bilateral_filter.cpp
@@ -29,8 +29,7 @@ PERF_TEST_P(JointBilateralFilterTest, perf,
     Mat src(sz, CV_MAKE_TYPE(depth, srcCn));
     Mat dst(sz, src.type());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-    declare.in(joint, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(joint, src, WARMUP_RNG).out(dst);
 
     RNG rnd(cvRound(10*sigmaS) + sz.height + depth + jCn + srcCn);
     double sigmaC = rnd.uniform(1.0, 255.0);
diff --git a/modules/ximgproc/samples/graphsegmentation_demo.cpp b/modules/ximgproc/samples/graphsegmentation_demo.cpp
@@ -91,9 +91,6 @@ int main(int argc, char** argv) {
         return -1;
     }
 
-    setUseOptimized(true);
-    setNumThreads(8);
-
     Ptr<GraphSegmentation> gs = createGraphSegmentation();
 
     if (argc > 3)
diff --git a/modules/ximgproc/samples/live_demo.cpp b/modules/ximgproc/samples/live_demo.cpp
@@ -158,7 +158,6 @@ void changeModeCallback(int state, void *filter)
 void changeNumberOfCpuCallback(int count, void*)
 {
     count = std::max(1, count);
-    cv::setNumThreads(count);
     g_numberOfCPUs = count;
 }
 
@@ -188,7 +187,6 @@ int main()
     displayOverlay("Demo", "Press Ctrl+P to show property window", 5000);
     
     //Thread trackbar
-    cv::setNumThreads(g_numberOfCPUs); //speedup filtering
     createTrackbar("Threads", String(), &g_numberOfCPUs, cv::getNumberOfCPUs(), changeNumberOfCpuCallback);
 
     //Buttons to choose different modes
@@ -219,6 +217,8 @@ int main()
             cap >> rawFrame;
         } while (rawFrame.empty());
 
+        cv::setNumThreads(g_numberOfCPUs); //speedup filtering
+
         splitScreen(rawFrame, outputFrame, srcFrame, processedFrame);
         g_filterOp(srcFrame, processedFrame);
 
diff --git a/modules/ximgproc/samples/selectivesearchsegmentation_demo.cpp b/modules/ximgproc/samples/selectivesearchsegmentation_demo.cpp
@@ -59,11 +59,6 @@ int main(int argc, char** argv) {
         return -1;
     }
 
-    setUseOptimized(true);
-    setNumThreads(8);
-
-    std::srand((int)std::time(0));
-
     Mat img = imread(argv[1]);
 
     Ptr<SelectiveSearchSegmentation> gs = createSelectiveSearchSegmentation();
diff --git a/modules/ximgproc/test/test_adaptive_manifold.cpp b/modules/ximgproc/test/test_adaptive_manifold.cpp
@@ -29,8 +29,6 @@ TEST(AdaptiveManifoldTest, SplatSurfaceAccuracy)
 {
     RNG rnd(0);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-
     for (int i = 0; i < 5; i++)
     {
         Size sz(rnd.uniform(512, 1024), rnd.uniform(512, 1024));
@@ -90,8 +88,6 @@ TEST(AdaptiveManifoldTest, AuthorsReferenceAccuracy)
     Mat srcImg = imread(getOpenCVExtraDir() + srcImgPath);
     ASSERT_TRUE(!srcImg.empty());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-
     for (int i = 0; i < 3; i++)
     {
         Mat refRes = imread(getOpenCVExtraDir() + refPaths[i]);
@@ -148,13 +144,16 @@ TEST_P(AdaptiveManifoldRefImplTest, RefImplAccuracy)
     resize(guide, guide, dstSize, 0, 0, INTER_LINEAR_EXACT);
     resize(src, src, dstSize, 0, 0, INTER_LINEAR_EXACT);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter < 4; iter++)
     {
         double sigma_s = rnd.uniform(1.0, 50.0);
         double sigma_r = rnd.uniform(0.1, 0.9);
         bool adjust_outliers = (iter % 2 == 0);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat res;
         amFilter(guide, src, res, sigma_s, sigma_r, adjust_outliers);
 
diff --git a/modules/ximgproc/test/test_bilateral_texture_filter.cpp b/modules/ximgproc/test/test_bilateral_texture_filter.cpp
@@ -66,9 +66,12 @@ TEST_P(BilateralTextureFilterTest, MultiThreadReproducibility)
     else
         randu(src, 0.0f, 1.0f);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         bilateralTextureFilter(src, resMultiThread, fr, 1, sigmaAlpha, sigmaAvg);
 
diff --git a/modules/ximgproc/test/test_disparity_wls_filter.cpp b/modules/ximgproc/test/test_disparity_wls_filter.cpp
@@ -39,7 +39,6 @@ TEST(DisparityWLSFilterTest, ReferenceAccuracy)
     double ref_MSE = (double)reference_res["MSE_after"];
     double ref_BadPercent = (double)reference_res["BadPercent_after"];
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res;
 
     Ptr<DisparityWLSFilter> wls_filter = createDisparityWLSFilterGeneric(true);
@@ -88,6 +87,9 @@ TEST_P(DisparityWLSFilterTest, MultiThreadReproducibility)
         ROI = Rect(ROI.x/2,ROI.y/2,ROI.width/2,ROI.height/2);
     }
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         double lambda = rng.uniform(100.0, 10000.0);
@@ -97,7 +99,7 @@ TEST_P(DisparityWLSFilterTest, MultiThreadReproducibility)
         wls_filter->setLambda(lambda);
         wls_filter->setSigmaColor(sigma);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         wls_filter->filter(left_disp,left,resMultiThread,right_disp,ROI);
 
diff --git a/modules/ximgproc/test/test_domain_transform.cpp b/modules/ximgproc/test/test_domain_transform.cpp
@@ -100,12 +100,15 @@ TEST_P(DomainTransformTest, MultiThreadReproducibility)
     Mat guide = convertTypeAndSize(original, guideType, size);
     Mat src = convertTypeAndSize(original, srcType, size);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         double ss = rng.uniform(0.0, 100.0);
         double sc = rng.uniform(0.0, 100.0);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultithread;
         dtFilter(guide, src, resMultithread, ss, sc, mode);
 
@@ -194,7 +197,6 @@ TEST(DomainTransformTest, AuthorReferenceAccuracy)
     ASSERT_FALSE(ref_IC.empty());
     ASSERT_FALSE(ref_RF.empty());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res_NC, res_IC, res_RF;
     dtFilter(src, src, res_NC, ss, sc, DTF_NC);
     dtFilter(src, src, res_IC, ss, sc, DTF_IC);
diff --git a/modules/ximgproc/test/test_fgs_filter.cpp b/modules/ximgproc/test/test_fgs_filter.cpp
@@ -55,7 +55,6 @@ TEST(FastGlobalSmootherTest, ReferenceAccuracy)
     ASSERT_FALSE(src.empty());
     ASSERT_FALSE(ref.empty());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res;
     fastGlobalSmootherFilter(src,src,res,1000.0,10.0);
 
@@ -90,12 +89,15 @@ TEST_P(FastGlobalSmootherTest, MultiThreadReproducibility)
     else
         randu(src, -100000.0f, 100000.0f);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         double lambda = rng.uniform(100.0, 10000.0);
         double sigma  = rng.uniform(1.0, 100.0);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         fastGlobalSmootherFilter(guide, src, resMultiThread, lambda, sigma);
 
diff --git a/modules/ximgproc/test/test_guided_filter.cpp b/modules/ximgproc/test/test_guided_filter.cpp
@@ -324,12 +324,15 @@ TEST_P(GuidedFilterTest, accuracy)
     guide = convertTypeAndSize(guide, CV_MAKE_TYPE(guide.depth(), guideCnNum), dstSize);
     src = convertTypeAndSize(src, CV_MAKE_TYPE(src.depth(), srcCnNum), dstSize);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter < 2; iter++)
     {
         int radius = rng.uniform(0, 50);
         double eps = rng.uniform(0.0, SQR(255.0));
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat res;
         Ptr<GuidedFilter> gf = createGuidedFilter(guide, radius, eps);
         gf->filter(src, res);
diff --git a/modules/ximgproc/test/test_joint_bilateral_filter.cpp b/modules/ximgproc/test/test_joint_bilateral_filter.cpp
@@ -192,10 +192,8 @@ TEST_P(JointBilateralFilterTest_NaiveRef, Accuracy)
     Mat resNaive;
     jointBilateralFilterNaive(joint, src, resNaive, 0, sigmaC, sigmaS);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res;
     jointBilateralFilter(joint, src, res, 0, sigmaC, sigmaS);
-    cv::setNumThreads(1);
 
     checkSimilarity(res, resNaive);
 }
@@ -226,8 +224,6 @@ TEST_P(JointBilateralFilterTest_BilateralRef, Accuracy)
     RNG rnd(cvRound(10*sigmaS) + srcPath.length() + srcType + src.rows);
     double sigmaC = rnd.uniform(0.0, 255.0);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-
     Mat resRef;
     bilateralFilter(src, resRef, 0, sigmaC, sigmaS);
 
diff --git a/modules/ximgproc/test/test_l0_smooth.cpp b/modules/ximgproc/test/test_l0_smooth.cpp
diff --git a/modules/ximgproc/test/test_rolling_guidance_filter.cpp b/modules/ximgproc/test/test_rolling_guidance_filter.cpp
diff --git a/modules/ximgproc/test/test_sparse_match_interpolator.cpp b/modules/ximgproc/test/test_sparse_match_interpolator.cpp
diff --git a/modules/ximgproc/test/test_weighted_median_filter.cpp b/modules/ximgproc/test/test_weighted_median_filter.cpp

Original file line number	Diff line number	Diff line change
`@@ -37,9 +37,6 @@ static Ptr<BackgroundSubtractor> createBGSubtractorByName(const String& algoName`
`37`	`37`
`38`	`38`	`int main(int argc, char** argv)`
`39`	`39`	`{`
`40`		`- setUseOptimized(true);`
`41`		`- setNumThreads(8);`
`42`		`-`
`43`	`40`	`CommandLineParser parser(argc, argv, keys);`
`44`	`41`	`parser.about(about);`
`45`	`42`	`parser.printMessage();`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@ PERF_TEST_P(DenseOpticalFlow_DeepFlow, perf, Values(szVGA, sz720p))`
`20`	`20`	`randu(frame1, 0, 255);`
`21`	`21`	`randu(frame2, 0, 255);`
`22`	`22`
`23`		`- cv::setNumThreads(cv::getNumberOfCPUs());`
`24`	`23`	`TEST_CYCLE_N(1)`
`25`	`24`	`{`
`26`	`25`	`Ptr<DenseOpticalFlow> algo = createOptFlow_DeepFlow();`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,6 @@ PERF_TEST_P(DenseOpticalFlow_DIS, perf,`
`32`	`32`
`33`	`33`	`MakeArtificialExample(frame1, frame2);`
`34`	`34`
`35`		`- cv::setNumThreads(cv::getNumberOfCPUs());`
`36`	`35`	`TEST_CYCLE_N(10)`
`37`	`36`	`{`
`38`	`37`	`Ptr<DenseOpticalFlow> algo = createOptFlow_DIS(preset);`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,6 @@ PERF_TEST_P(DenseOpticalFlow_VariationalRefinement, perf, Combine(Values(szQVGA,`
`23`	`23`	`randu(frame2, 0, 255);`
`24`	`24`	`flow.setTo(0.0f);`
`25`	`25`
`26`		`- cv::setNumThreads(cv::getNumberOfCPUs());`
`27`	`26`	`TEST_CYCLE_N(10)`
`28`	`27`	`{`
`29`	`28`	`Ptr<VariationalRefinement> var = createVariationalFlowRefinement();`
Original file line number	Diff line number	Diff line change
`@@ -506,8 +506,6 @@ bool TrackerCSRTImpl::updateImpl(const Mat& image_, Rect2d& boundingBox)`
`506`	`506`	`// *********************************************************************`
`507`	`507`	`bool TrackerCSRTImpl::initImpl(const Mat& image_, const Rect2d& boundingBox)`
`508`	`508`	`{`
`509`		`- cv::setNumThreads(getNumThreads());`
`510`		`-`
`511`	`509`	`//treat gray image as color image`
`512`	`510`	`Mat image;`
`513`	`511`	`if(image_.channels() == 1) {`
Original file line number	Diff line number	Diff line change
`@@ -29,8 +29,7 @@ PERF_TEST_P(BilateralTextureFilterTest, perf,`
`29`	`29`	`Mat src(sz, CV_MAKE_TYPE(depth,srcCn));`
`30`	`30`	`Mat dst(sz, src.type());`
`31`	`31`
`32`		`- cv::setNumThreads(cv::getNumberOfCPUs());`
`33`		`- declare.in(src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());`
	`32`	`+ declare.in(src, WARMUP_RNG).out(dst);`
`34`	`33`
`35`	`34`	`TEST_CYCLE_N(1)`
`36`	`35`	`{`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,6 @@ PERF_TEST_P( DisparityWLSFilterPerfTest, perf, Combine(GuideTypes::all(), SrcTyp`
`41`	`41`	`ROI = Rect(ROI.x/2,ROI.y/2,ROI.width/2,ROI.height/2);`
`42`	`42`	`}`
`43`	`43`
`44`		`- cv::setNumThreads(cv::getNumberOfCPUs());`
`45`	`44`	`TEST_CYCLE_N(10)`
`46`	`45`	`{`
`47`	`46`	`Ptr<DisparityWLSFilter> wls_filter = createDisparityWLSFilterGeneric(use_conf);`
Original file line number	Diff line number	Diff line change
`@@ -34,9 +34,8 @@ PERF_TEST_P( DomainTransformTest, perf,`
`34`	`34`	`Mat src(size, srcType);`
`35`	`35`	`Mat dst(size, srcType);`
`36`	`36`
`37`		`- declare.in(guide, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());`
	`37`	`+ declare.in(guide, src, WARMUP_RNG).out(dst);`
`38`	`38`
`39`		`- cv::setNumThreads(cv::getNumberOfCPUs());`
`40`	`39`	`TEST_CYCLE_N(5)`
`41`	`40`	`{`
`42`	`41`	`dtFilter(guide, src, dst, sigmaSpatial, sigmaColor, dtfType);`