Merge remote-tracking branch 'upstream/3.4' into merge-3.4

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();

modules/bioinspired/src/retina_ocl.cpp

@@ -391,7 +391,6 @@ bool RetinaOCLImpl::convertToColorPlanes(const UMat& input, UMat &output)
     else
     {
         CV_Error(-1, "Retina ocl only support 1, 3, 4 channel input");
-        return false;
     }
 }
 void RetinaOCLImpl::convertToInterleaved(const UMat& input, bool colorMode, UMat &output)
@@ -449,8 +448,8 @@ void RetinaOCLImpl::getMagnoRAW(OutputArray retinaOutput_magno)
 
 // unimplemented interfaces:
 void RetinaOCLImpl::applyFastToneMapping(InputArray /*inputImage*/, OutputArray /*outputToneMappedImage*/) { NOT_IMPLEMENTED; }
-const Mat RetinaOCLImpl::getMagnoRAW() const { NOT_IMPLEMENTED; return Mat(); }
-const Mat RetinaOCLImpl::getParvoRAW() const { NOT_IMPLEMENTED; return Mat(); }
+const Mat RetinaOCLImpl::getMagnoRAW() const { NOT_IMPLEMENTED; }
+const Mat RetinaOCLImpl::getParvoRAW() const { NOT_IMPLEMENTED; }
 
 ///////////////////////////////////////
 ///////// BasicRetinaFilter ///////////

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();

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);

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();

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);

modules/ovis/CMakeLists.txt

@@ -16,7 +16,7 @@ elseif(OGRE_VERSION VERSION_GREATER 1.10) # we need C++11 for OGRE 1.11
   endif()
 endif()
 
-include_directories(${OGRE_INCLUDE_DIRS}})
+include_directories(${OGRE_INCLUDE_DIRS})
 link_directories(${OGRE_LIBRARY_DIRS})
 
 ocv_define_module(ovis opencv_core opencv_imgproc opencv_calib3d WRAP python)

modules/surface_matching/src/hash_murmur86.hpp

@@ -78,59 +78,30 @@ void hashMurmurx86 ( const void * key, const int len, const uint seed, void * ou
 * ROTL32(x,r)      Rotate x left by r bits
 */
 
-/* Convention is to define __BYTE_ORDER == to one of these values */
-#if !defined(__BIG_ENDIAN)
-#define __BIG_ENDIAN 4321
-#endif
-#if !defined(__LITTLE_ENDIAN)
-#define __LITTLE_ENDIAN 1234
-#endif
-
-/* I386 */
-#if defined(_M_IX86) || defined(__i386__) || defined(__i386) || defined(i386)
-#define __BYTE_ORDER __LITTLE_ENDIAN
-#define UNALIGNED_SAFE
-#endif
-
-/* gcc 'may' define __LITTLE_ENDIAN__ or __BIG_ENDIAN__ to 1 (Note the trailing __),
-* or even _LITTLE_ENDIAN or _BIG_ENDIAN (Note the single _ prefix) */
-#if !defined(__BYTE_ORDER)
-#if defined(__LITTLE_ENDIAN__) && __LITTLE_ENDIAN__==1 || defined(_LITTLE_ENDIAN) && _LITTLE_ENDIAN==1
-#define __BYTE_ORDER __LITTLE_ENDIAN
-#elif defined(__BIG_ENDIAN__) && __BIG_ENDIAN__==1 || defined(_BIG_ENDIAN) && _BIG_ENDIAN==1
-#define __BYTE_ORDER __BIG_ENDIAN
-#endif
+#if (defined(_M_IX86) || defined(__i386__) || defined(__i386) || defined(i386))
+# define UNALIGNED_SAFE 1
 #endif
 
-/* gcc (usually) defines xEL/EB macros for ARM and MIPS endianess */
-#if !defined(__BYTE_ORDER)
-#if defined(__ARMEL__) || defined(__MIPSEL__)
-#define __BYTE_ORDER __LITTLE_ENDIAN
-#endif
-#if defined(__ARMEB__) || defined(__MIPSEB__)
-#define __BYTE_ORDER __BIG_ENDIAN
-#endif
+#ifndef UNALIGNED_SAFE
+# define UNALIGNED_SAFE 1
+#elif defined(UNALIGNED_SAFE) && !UNALIGNED_SAFE == 0
+# undef UNALIGNED_SAFE
 #endif
 
 /* Now find best way we can to READ_UINT32 */
-#if __BYTE_ORDER==__LITTLE_ENDIAN
-/* CPU endian matches murmurhash algorithm, so read 32-bit word directly */
-#define READ_UINT32(ptr)   (*((uint32_t*)(ptr)))
-#elif __BYTE_ORDER==__BIG_ENDIAN
-/* TODO: Add additional cases below where a compiler provided bswap32 is available */
-#if defined(__GNUC__) && (__GNUC__>4 || (__GNUC__==4 && __GNUC_MINOR__>=3))
-#define READ_UINT32(ptr)   (__builtin_bswap32(*((uint32_t*)(ptr))))
-#else
-/* Without a known fast bswap32 we're just as well off doing this */
-#define READ_UINT32(ptr)   (ptr[0]|ptr[1]<<8|ptr[2]<<16|ptr[3]<<24)
-#define UNALIGNED_SAFE
+#if (defined(_M_IX86) || defined(__i386__) || defined(__i386) || defined(i386)) \
+    || (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+# define READ_UINT32(ptr)   (*((uint32_t*)(ptr)))
+#elif (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+    && defined(__GNUC__) && (__GNUC__>4 || (__GNUC__==4 && __GNUC_MINOR__>=3))
+# define READ_UINT32(ptr)   (__builtin_bswap32(*((uint32_t*)(ptr))))
 #endif
-#else
-/* Unknown endianess so last resort is to read individual bytes */
-#define READ_UINT32(ptr)   (ptr[0]|ptr[1]<<8|ptr[2]<<16|ptr[3]<<24)
 
-/* Since we're not doing word-reads we can skip the messing about with realignment */
-#define UNALIGNED_SAFE
+#ifndef READ_UINT32
+/* Unknown endianess so last resort is to read individual bytes */
+# define READ_UINT32(ptr)   (ptr[0]|ptr[1]<<8|ptr[2]<<16|ptr[3]<<24)
+# undef UNALIGNED_SAFE
+# define UNALIGNED_SAFE 1
 #endif
 
 /*-----------------------------------------------------------------------------

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) {

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;

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)
     {

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);

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);

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);

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);

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);

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);

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)
     {

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);

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)

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);
 

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();

modules/ximgproc/src/selectivesearchsegmentation.cpp

@@ -58,6 +58,8 @@ namespace cv {
                     double rank;
                     Rect bounding_box;
 
+                    Region() : id(0), level(0), merged_to(0), rank(0) {}
+
                     friend std::ostream& operator<<(std::ostream& os, const Region& n);
 
                     bool operator <(const Region& n) const {

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);
 

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);
 

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);
 

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);

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);
 

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);

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);
 

modules/ximgproc/test/test_l0_smooth.cpp

@@ -57,12 +57,15 @@ TEST_P(L0SmoothTest, MultiThreadReproducibility)
         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(0.01, 0.05);
         double kappa  = rng.uniform(1.5, 5.0);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         l0Smooth(src, resMultiThread, lambda, kappa);
 

modules/ximgproc/test/test_rolling_guidance_filter.cpp

@@ -104,12 +104,15 @@ TEST_P(RollingGuidanceFilterTest, 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++)
     {
         int iterNum = int(rnd.uniform(1.0, 5.0));
         double sigmaC = rnd.uniform(1.0, 255.0);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         rollingGuidanceFilter(src, resMultiThread, -1, sigmaC, sigmaS, iterNum);
 
@@ -150,8 +153,6 @@ TEST_P(RollingGuidanceFilterTest_BilateralRef, Accuracy)
     RNG rnd(0);
     double sigmaC = rnd.uniform(0.0, 255.0);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-
     Mat resRef;
     bilateralFilter(src, resRef, 0, sigmaC, sigmaS);
 

modules/ximgproc/test/test_sparse_match_interpolator.cpp

@@ -81,7 +81,6 @@ TEST(InterpolatorTest, ReferenceAccuracy)
         to_points.push_back(Point2f(to_x,to_y));
     }
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res_flow;
 
     Ptr<EdgeAwareInterpolator> interpolator = createEdgeAwareInterpolator();
@@ -123,6 +122,9 @@ TEST_P(InterpolatorTest, MultiThreadReproducibility)
         to_points.push_back(Point2f(rng.uniform(0.01f,(float)size.width-1.01f),rng.uniform(0.01f,(float)size.height-1.01f)));
     }
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         int K = rng.uniform(4,512);
@@ -137,7 +139,7 @@ TEST_P(InterpolatorTest, MultiThreadReproducibility)
         interpolator->setFGSLambda(FGSlambda);
         interpolator->setFGSSigma(FGSsigma);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         interpolator->interpolate(from,from_points,Mat(),to_points,resMultiThread);
 

modules/ximgproc/test/test_weighted_median_filter.cpp

@@ -52,7 +52,6 @@ TEST(WeightedMedianFilterTest, ReferenceAccuracy)
     ASSERT_FALSE(src.empty());
     ASSERT_FALSE(ref.empty());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res;
     weightedMedianFilter(src, src, res, 7);