modules/gpu/test/test_imgproc.cpp

   1 /*M///////////////////////////////////////////////////////////////////////////////////////\r
   2 //\r
   3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.\r
   4 //\r
   5 //  By downloading, copying, installing or using the software you agree to this license.\r
   6 //  If you do not agree to this license, do not download, install,\r
   7 //  copy or use the software.\r
   8 //\r
   9 //\r
  10 //                        Intel License Agreement\r
  11 //                For Open Source Computer Vision Library\r
  12 //\r
  13 // Copyright (C) 2000, Intel Corporation, all rights reserved.\r
  14 // Third party copyrights are property of their respective owners.\r
  15 //\r
  16 // Redistribution and use in source and binary forms, with or without modification,\r
  17 // are permitted provided that the following conditions are met:\r
  18 //\r
  19 //   * Redistribution's of source code must retain the above copyright notice,\r
  20 //     this list of conditions and the following disclaimer.\r
  21 //\r
  22 //   * Redistribution's in binary form must reproduce the above copyright notice,\r
  23 //     this list of conditions and the following disclaimer in the documentation\r
  24 //     and/or other materials provided with the distribution.\r
  25 //\r
  26 //   * The name of Intel Corporation may not be used to endorse or promote products\r
  27 //     derived from this software without specific prior written permission.\r
  28 //\r
  29 // This software is provided by the copyright holders and contributors "as is" and\r
  30 // any express or implied warranties, including, but not limited to, the implied\r
  31 // warranties of merchantability and fitness for a particular purpose are disclaimed.\r
  32 // In no event shall the Intel Corporation or contributors be liable for any direct,\r
  33 // indirect, incidental, special, exemplary, or consequential damages\r
  34 // (including, but not limited to, procurement of substitute goods or services;\r
  35 // loss of use, data, or profits; or business interruption) however caused\r
  36 // and on any theory of liability, whether in contract, strict liability,\r
  37 // or tort (including negligence or otherwise) arising in any way out of\r
  38 // the use of this software, even if advised of the possibility of such damage.\r
  39 //\r
  40 //M*/\r
  41 \r
  42 #include "test_precomp.hpp"\r
  43 \r
  44 #ifdef HAVE_CUDA\r
  45 \r
  46 namespace {\r
  47 \r
  48 ///////////////////////////////////////////////////////////////////////////////////////////////////////\r
  49 // Integral\r
  50 \r
  51 PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi)\r
  52 {\r
  53     cv::gpu::DeviceInfo devInfo;\r
  54     cv::Size size;\r
  55     bool useRoi;\r
  56 \r
  57     virtual void SetUp()\r
  58     {\r
  59         devInfo = GET_PARAM(0);\r
  60         size = GET_PARAM(1);\r
  61         useRoi = GET_PARAM(2);\r
  62 \r
  63         cv::gpu::setDevice(devInfo.deviceID());\r
  64     }\r
  65 };\r
  66 \r
  67 TEST_P(Integral, Accuracy)\r
  68 {\r
  69     cv::Mat src = randomMat(size, CV_8UC1);\r
  70 \r
  71     cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);\r
  72     cv::gpu::integral(loadMat(src, useRoi), dst);\r
  73 \r
  74     cv::Mat dst_gold;\r
  75     cv::integral(src, dst_gold, CV_32S);\r
  76 \r
  77     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);\r
  78 }\r
  79 \r
  80 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Integral, testing::Combine(\r
  81     ALL_DEVICES,\r
  82     DIFFERENT_SIZES,\r
  83     WHOLE_SUBMAT));\r
  84 \r
  85 ///////////////////////////////////////////////////////////////////////////////////////////////////////\r
  86 // HistEven\r
  87 \r
  88 struct HistEven : testing::TestWithParam<cv::gpu::DeviceInfo>\r
  89 {\r
  90     cv::gpu::DeviceInfo devInfo;\r
  91 \r
  92     virtual void SetUp()\r
  93     {\r
  94         devInfo = GetParam();\r
  95 \r
  96         cv::gpu::setDevice(devInfo.deviceID());\r
  97     }\r
  98 };\r
  99 \r
 100 TEST_P(HistEven, Accuracy)\r
 101 {\r
 102     cv::Mat img = readImage("stereobm/aloe-L.png");\r
 103     ASSERT_FALSE(img.empty());\r
 104 \r
 105     cv::Mat hsv;\r
 106     cv::cvtColor(img, hsv, CV_BGR2HSV);\r
 107 \r
 108     int hbins = 30;\r
 109     float hranges[] = {0.0f, 180.0f};\r
 110 \r
 111     std::vector<cv::gpu::GpuMat> srcs;\r
 112     cv::gpu::split(loadMat(hsv), srcs);\r
 113 \r
 114     cv::gpu::GpuMat hist;\r
 115     cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]);\r
 116 \r
 117     cv::MatND histnd;\r
 118     int histSize[] = {hbins};\r
 119     const float* ranges[] = {hranges};\r
 120     int channels[] = {0};\r
 121     cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges);\r
 122 \r
 123     cv::Mat hist_gold = histnd;\r
 124     hist_gold = hist_gold.t();\r
 125     hist_gold.convertTo(hist_gold, CV_32S);\r
 126 \r
 127     EXPECT_MAT_NEAR(hist_gold, hist, 0.0);\r
 128 }\r
 129 \r
 130 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HistEven, ALL_DEVICES);\r
 131 \r
 132 ///////////////////////////////////////////////////////////////////////////////////////////////////////\r
 133 // CalcHist\r
 134 \r
 135 void calcHistGold(const cv::Mat& src, cv::Mat& hist)\r
 136 {\r
 137     hist.create(1, 256, CV_32SC1);\r
 138     hist.setTo(cv::Scalar::all(0));\r
 139 \r
 140     int* hist_row = hist.ptr<int>();\r
 141     for (int y = 0; y < src.rows; ++y)\r
 142     {\r
 143         const uchar* src_row = src.ptr(y);\r
 144 \r
 145         for (int x = 0; x < src.cols; ++x)\r
 146             ++hist_row[src_row[x]];\r
 147     }\r
 148 }\r
 149 \r
 150 PARAM_TEST_CASE(CalcHist, cv::gpu::DeviceInfo, cv::Size)\r
 151 {\r
 152     cv::gpu::DeviceInfo devInfo;\r
 153 \r
 154     cv::Size size;\r
 155 \r
 156     virtual void SetUp()\r
 157     {\r
 158         devInfo = GET_PARAM(0);\r
 159         size = GET_PARAM(1);\r
 160 \r
 161         cv::gpu::setDevice(devInfo.deviceID());\r
 162     }\r
 163 };\r
 164 \r
 165 TEST_P(CalcHist, Accuracy)\r
 166 {\r
 167     cv::Mat src = randomMat(size, CV_8UC1);\r
 168 \r
 169     cv::gpu::GpuMat hist;\r
 170     cv::gpu::calcHist(loadMat(src), hist);\r
 171 \r
 172     cv::Mat hist_gold;\r
 173     calcHistGold(src, hist_gold);\r
 174 \r
 175     EXPECT_MAT_NEAR(hist_gold, hist, 0.0);\r
 176 }\r
 177 \r
 178 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CalcHist, testing::Combine(\r
 179     ALL_DEVICES,\r
 180     DIFFERENT_SIZES));\r
 181 \r
 182 ///////////////////////////////////////////////////////////////////////////////////////////////////////\r
 183 // EqualizeHist\r
 184 \r
 185 PARAM_TEST_CASE(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)\r
 186 {\r
 187     cv::gpu::DeviceInfo devInfo;\r
 188     cv::Size size;\r
 189 \r
 190     virtual void SetUp()\r
 191     {\r
 192         devInfo = GET_PARAM(0);\r
 193         size = GET_PARAM(1);\r
 194 \r
 195         cv::gpu::setDevice(devInfo.deviceID());\r
 196     }\r
 197 };\r
 198 \r
 199 TEST_P(EqualizeHist, Accuracy)\r
 200 {\r
 201     cv::Mat src = randomMat(size, CV_8UC1);\r
 202 \r
 203     cv::gpu::GpuMat dst;\r
 204     cv::gpu::equalizeHist(loadMat(src), dst);\r
 205 \r
 206     cv::Mat dst_gold;\r
 207     cv::equalizeHist(src, dst_gold);\r
 208 \r
 209     EXPECT_MAT_NEAR(dst_gold, dst, 3.0);\r
 210 }\r
 211 \r
 212 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, EqualizeHist, testing::Combine(\r
 213     ALL_DEVICES,\r
 214     DIFFERENT_SIZES));\r
 215 \r
 216 ////////////////////////////////////////////////////////////////////////\r
 217 // ColumnSum\r
 218 \r
 219 PARAM_TEST_CASE(ColumnSum, cv::gpu::DeviceInfo, cv::Size)\r
 220 {\r
 221     cv::gpu::DeviceInfo devInfo;\r
 222     cv::Size size;\r
 223 \r
 224     virtual void SetUp()\r
 225     {\r
 226         devInfo = GET_PARAM(0);\r
 227         size = GET_PARAM(1);\r
 228 \r
 229         cv::gpu::setDevice(devInfo.deviceID());\r
 230     }\r
 231 };\r
 232 \r
 233 TEST_P(ColumnSum, Accuracy)\r
 234 {\r
 235     cv::Mat src = randomMat(size, CV_32FC1);\r
 236 \r
 237     cv::gpu::GpuMat d_dst;\r
 238     cv::gpu::columnSum(loadMat(src), d_dst);\r
 239 \r
 240     cv::Mat dst(d_dst);\r
 241 \r
 242     for (int j = 0; j < src.cols; ++j)\r
 243     {\r
 244         float gold = src.at<float>(0, j);\r
 245         float res = dst.at<float>(0, j);\r
 246         ASSERT_NEAR(res, gold, 1e-5);\r
 247     }\r
 248 \r
 249     for (int i = 1; i < src.rows; ++i)\r
 250     {\r
 251         for (int j = 0; j < src.cols; ++j)\r
 252         {\r
 253             float gold = src.at<float>(i, j) += src.at<float>(i - 1, j);\r
 254             float res = dst.at<float>(i, j);\r
 255             ASSERT_NEAR(res, gold, 1e-5);\r
 256         }\r
 257     }\r
 258 }\r
 259 \r
 260 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ColumnSum, testing::Combine(\r
 261     ALL_DEVICES,\r
 262     DIFFERENT_SIZES));\r
 263 \r
 264 ////////////////////////////////////////////////////////\r
 265 // Canny\r
 266 \r
 267 IMPLEMENT_PARAM_CLASS(AppertureSize, int);\r
 268 IMPLEMENT_PARAM_CLASS(L2gradient, bool);\r
 269 \r
 270 PARAM_TEST_CASE(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient, UseRoi)\r
 271 {\r
 272     cv::gpu::DeviceInfo devInfo;\r
 273     int apperture_size;\r
 274     bool useL2gradient;\r
 275     bool useRoi;\r
 276 \r
 277     virtual void SetUp()\r
 278     {\r
 279         devInfo = GET_PARAM(0);\r
 280         apperture_size = GET_PARAM(1);\r
 281         useL2gradient = GET_PARAM(2);\r
 282         useRoi = GET_PARAM(3);\r
 283 \r
 284         cv::gpu::setDevice(devInfo.deviceID());\r
 285     }\r
 286 };\r
 287 \r
 288 TEST_P(Canny, Accuracy)\r
 289 {\r
 290     cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
 291     ASSERT_FALSE(img.empty());\r
 292 \r
 293     double low_thresh = 50.0;\r
 294     double high_thresh = 100.0;\r
 295 \r
 296     if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS))\r
 297     {\r
 298         try\r
 299         {\r
 300         cv::gpu::GpuMat edges;\r
 301         cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient);\r
 302         }\r
 303         catch (const cv::Exception& e)\r
 304         {\r
 305             ASSERT_EQ(CV_StsNotImplemented, e.code);\r
 306         }\r
 307     }\r
 308     else\r
 309     {\r
 310         cv::gpu::GpuMat edges;\r
 311         cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient);\r
 312 \r
 313         cv::Mat edges_gold;\r
 314         cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient);\r
 315 \r
 316         EXPECT_MAT_SIMILAR(edges_gold, edges, 1e-2);\r
 317     }\r
 318 }\r
 319 \r
 320 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Canny, testing::Combine(\r
 321     ALL_DEVICES,\r
 322     testing::Values(AppertureSize(3), AppertureSize(5)),\r
 323     testing::Values(L2gradient(false), L2gradient(true)),\r
 324     WHOLE_SUBMAT));\r
 325 \r
 326 ////////////////////////////////////////////////////////////////////////////////\r
 327 // MeanShift\r
 328 \r
 329 struct MeanShift : testing::TestWithParam<cv::gpu::DeviceInfo>\r
 330 {\r
 331     cv::gpu::DeviceInfo devInfo;\r
 332 \r
 333     cv::Mat img;\r
 334 \r
 335     int spatialRad;\r
 336     int colorRad;\r
 337 \r
 338     virtual void SetUp()\r
 339     {\r
 340         devInfo = GetParam();\r
 341 \r
 342         cv::gpu::setDevice(devInfo.deviceID());\r
 343 \r
 344         img = readImageType("meanshift/cones.png", CV_8UC4);\r
 345         ASSERT_FALSE(img.empty());\r
 346 \r
 347         spatialRad = 30;\r
 348         colorRad = 30;\r
 349     }\r
 350 };\r
 351 \r
 352 TEST_P(MeanShift, Filtering)\r
 353 {\r
 354     cv::Mat img_template;\r
 355     if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))\r
 356         img_template = readImage("meanshift/con_result.png");\r
 357     else\r
 358         img_template = readImage("meanshift/con_result_CC1X.png");\r
 359     ASSERT_FALSE(img_template.empty());\r
 360 \r
 361     cv::gpu::GpuMat d_dst;\r
 362     cv::gpu::meanShiftFiltering(loadMat(img), d_dst, spatialRad, colorRad);\r
 363 \r
 364     ASSERT_EQ(CV_8UC4, d_dst.type());\r
 365 \r
 366     cv::Mat dst(d_dst);\r
 367 \r
 368     cv::Mat result;\r
 369     cv::cvtColor(dst, result, CV_BGRA2BGR);\r
 370 \r
 371     EXPECT_MAT_NEAR(img_template, result, 0.0);\r
 372 }\r
 373 \r
 374 TEST_P(MeanShift, Proc)\r
 375 {\r
 376     cv::FileStorage fs;\r
 377     if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))\r
 378         fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);\r
 379     else\r
 380         fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);\r
 381     ASSERT_TRUE(fs.isOpened());\r
 382 \r
 383     cv::Mat spmap_template;\r
 384     fs["spmap"] >> spmap_template;\r
 385     ASSERT_FALSE(spmap_template.empty());\r
 386 \r
 387     cv::gpu::GpuMat rmap_filtered;\r
 388     cv::gpu::meanShiftFiltering(loadMat(img), rmap_filtered, spatialRad, colorRad);\r
 389 \r
 390     cv::gpu::GpuMat rmap;\r
 391     cv::gpu::GpuMat spmap;\r
 392     cv::gpu::meanShiftProc(loadMat(img), rmap, spmap, spatialRad, colorRad);\r
 393 \r
 394     ASSERT_EQ(CV_8UC4, rmap.type());\r
 395 \r
 396     EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);\r
 397     EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);\r
 398 }\r
 399 \r
 400 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShift, ALL_DEVICES);\r
 401 \r
 402 ////////////////////////////////////////////////////////////////////////////////\r
 403 // MeanShiftSegmentation\r
 404 \r
 405 IMPLEMENT_PARAM_CLASS(MinSize, int);\r
 406 \r
 407 PARAM_TEST_CASE(MeanShiftSegmentation, cv::gpu::DeviceInfo, MinSize)\r
 408 {\r
 409     cv::gpu::DeviceInfo devInfo;\r
 410     int minsize;\r
 411 \r
 412     virtual void SetUp()\r
 413     {\r
 414         devInfo = GET_PARAM(0);\r
 415         minsize = GET_PARAM(1);\r
 416 \r
 417         cv::gpu::setDevice(devInfo.deviceID());\r
 418     }\r
 419 };\r
 420 \r
 421 TEST_P(MeanShiftSegmentation, Regression)\r
 422 {\r
 423     cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);\r
 424     ASSERT_FALSE(img.empty());\r
 425 \r
 426     std::ostringstream path;\r
 427     path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;\r
 428     if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))\r
 429         path << ".png";\r
 430     else\r
 431         path << "_CC1X.png";\r
 432     cv::Mat dst_gold = readImage(path.str());\r
 433     ASSERT_FALSE(dst_gold.empty());\r
 434 \r
 435     cv::Mat dst;\r
 436     cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize);\r
 437 \r
 438     cv::Mat dst_rgb;\r
 439     cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);\r
 440 \r
 441     EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);\r
 442 }\r
 443 \r
 444 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShiftSegmentation, testing::Combine(\r
 445     ALL_DEVICES,\r
 446     testing::Values(MinSize(0), MinSize(4), MinSize(20), MinSize(84), MinSize(340), MinSize(1364))));\r
 447 \r
 448 ////////////////////////////////////////////////////////////////////////////\r
 449 // Blend\r
 450 \r
 451 template <typename T>\r
 452 void blendLinearGold(const cv::Mat& img1, const cv::Mat& img2, const cv::Mat& weights1, const cv::Mat& weights2, cv::Mat& result_gold)\r
 453 {\r
 454     result_gold.create(img1.size(), img1.type());\r
 455 \r
 456     int cn = img1.channels();\r
 457 \r
 458     for (int y = 0; y < img1.rows; ++y)\r
 459     {\r
 460         const float* weights1_row = weights1.ptr<float>(y);\r
 461         const float* weights2_row = weights2.ptr<float>(y);\r
 462         const T* img1_row = img1.ptr<T>(y);\r
 463         const T* img2_row = img2.ptr<T>(y);\r
 464         T* result_gold_row = result_gold.ptr<T>(y);\r
 465 \r
 466         for (int x = 0; x < img1.cols * cn; ++x)\r
 467         {\r
 468             float w1 = weights1_row[x / cn];\r
 469             float w2 = weights2_row[x / cn];\r
 470             result_gold_row[x] = static_cast<T>((img1_row[x] * w1 + img2_row[x] * w2) / (w1 + w2 + 1e-5f));\r
 471         }\r
 472     }\r
 473 }\r
 474 \r
 475 PARAM_TEST_CASE(Blend, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)\r
 476 {\r
 477     cv::gpu::DeviceInfo devInfo;\r
 478     cv::Size size;\r
 479     int type;\r
 480     bool useRoi;\r
 481 \r
 482     virtual void SetUp()\r
 483     {\r
 484         devInfo = GET_PARAM(0);\r
 485         size = GET_PARAM(1);\r
 486         type = GET_PARAM(2);\r
 487         useRoi = GET_PARAM(3);\r
 488 \r
 489         cv::gpu::setDevice(devInfo.deviceID());\r
 490     }\r
 491 };\r
 492 \r
 493 TEST_P(Blend, Accuracy)\r
 494 {\r
 495     int depth = CV_MAT_DEPTH(type);\r
 496 \r
 497     cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);\r
 498     cv::Mat img2 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);\r
 499     cv::Mat weights1 = randomMat(size, CV_32F, 0, 1);\r
 500     cv::Mat weights2 = randomMat(size, CV_32F, 0, 1);\r
 501 \r
 502     cv::gpu::GpuMat result;\r
 503     cv::gpu::blendLinear(loadMat(img1, useRoi), loadMat(img2, useRoi), loadMat(weights1, useRoi), loadMat(weights2, useRoi), result);\r
 504 \r
 505     cv::Mat result_gold;\r
 506     if (depth == CV_8U)\r
 507         blendLinearGold<uchar>(img1, img2, weights1, weights2, result_gold);\r
 508     else\r
 509         blendLinearGold<float>(img1, img2, weights1, weights2, result_gold);\r
 510 \r
 511     EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);\r
 512 }\r
 513 \r
 514 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Blend, testing::Combine(\r
 515     ALL_DEVICES,\r
 516     DIFFERENT_SIZES,\r
 517     testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
 518     WHOLE_SUBMAT));\r
 519 \r
 520 ////////////////////////////////////////////////////////\r
 521 // Convolve\r
 522 \r
 523 void convolveDFT(const cv::Mat& A, const cv::Mat& B, cv::Mat& C, bool ccorr = false)\r
 524 {\r
 525     // reallocate the output array if needed\r
 526     C.create(std::abs(A.rows - B.rows) + 1, std::abs(A.cols - B.cols) + 1, A.type());\r
 527     cv::Size dftSize;\r
 528 \r
 529     // compute the size of DFT transform\r
 530     dftSize.width = cv::getOptimalDFTSize(A.cols + B.cols - 1);\r
 531     dftSize.height = cv::getOptimalDFTSize(A.rows + B.rows - 1);\r
 532 \r
 533     // allocate temporary buffers and initialize them with 0s\r
 534     cv::Mat tempA(dftSize, A.type(), cv::Scalar::all(0));\r
 535     cv::Mat tempB(dftSize, B.type(), cv::Scalar::all(0));\r
 536 \r
 537     // copy A and B to the top-left corners of tempA and tempB, respectively\r
 538     cv::Mat roiA(tempA, cv::Rect(0, 0, A.cols, A.rows));\r
 539     A.copyTo(roiA);\r
 540     cv::Mat roiB(tempB, cv::Rect(0, 0, B.cols, B.rows));\r
 541     B.copyTo(roiB);\r
 542 \r
 543     // now transform the padded A & B in-place;\r
 544     // use "nonzeroRows" hint for faster processing\r
 545     cv::dft(tempA, tempA, 0, A.rows);\r
 546     cv::dft(tempB, tempB, 0, B.rows);\r
 547 \r
 548     // multiply the spectrums;\r
 549     // the function handles packed spectrum representations well\r
 550     cv::mulSpectrums(tempA, tempB, tempA, 0, ccorr);\r
 551 \r
 552     // transform the product back from the frequency domain.\r
 553     // Even though all the result rows will be non-zero,\r
 554     // you need only the first C.rows of them, and thus you\r
 555     // pass nonzeroRows == C.rows\r
 556     cv::dft(tempA, tempA, cv::DFT_INVERSE + cv::DFT_SCALE, C.rows);\r
 557 \r
 558     // now copy the result back to C.\r
 559     tempA(cv::Rect(0, 0, C.cols, C.rows)).copyTo(C);\r
 560 }\r
 561 \r
 562 IMPLEMENT_PARAM_CLASS(KSize, int);\r
 563 IMPLEMENT_PARAM_CLASS(Ccorr, bool);\r
 564 \r
 565 PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)\r
 566 {\r
 567     cv::gpu::DeviceInfo devInfo;\r
 568     cv::Size size;\r
 569     int ksize;\r
 570     bool ccorr;\r
 571 \r
 572     virtual void SetUp()\r
 573     {\r
 574         devInfo = GET_PARAM(0);\r
 575         size = GET_PARAM(1);\r
 576         ksize = GET_PARAM(2);\r
 577         ccorr = GET_PARAM(3);\r
 578 \r
 579         cv::gpu::setDevice(devInfo.deviceID());\r
 580     }\r
 581 };\r
 582 \r
 583 TEST_P(Convolve, Accuracy)\r
 584 {\r
 585     cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);\r
 586     cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);\r
 587 \r
 588     cv::gpu::GpuMat dst;\r
 589     cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);\r
 590 \r
 591     cv::Mat dst_gold;\r
 592     convolveDFT(src, kernel, dst_gold, ccorr);\r
 593 \r
 594     EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);\r
 595 }\r
 596 \r
 597 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Convolve, testing::Combine(\r
 598     ALL_DEVICES,\r
 599     DIFFERENT_SIZES,\r
 600     testing::Values(KSize(3), KSize(7), KSize(11), KSize(17), KSize(19), KSize(23), KSize(45)),\r
 601     testing::Values(Ccorr(false), Ccorr(true))));\r
 602 \r
 603 ////////////////////////////////////////////////////////////////////////////////\r
 604 // MatchTemplate8U\r
 605 \r
 606 CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED)\r
 607 #define ALL_TEMPLATE_METHODS testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_SQDIFF_NORMED), TemplateMethod(cv::TM_CCORR), TemplateMethod(cv::TM_CCORR_NORMED), TemplateMethod(cv::TM_CCOEFF), TemplateMethod(cv::TM_CCOEFF_NORMED))\r
 608 \r
 609 IMPLEMENT_PARAM_CLASS(TemplateSize, cv::Size);\r
 610 \r
 611 PARAM_TEST_CASE(MatchTemplate8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)\r
 612 {\r
 613     cv::gpu::DeviceInfo devInfo;\r
 614     cv::Size size;\r
 615     cv::Size templ_size;\r
 616     int cn;\r
 617     int method;\r
 618 \r
 619     virtual void SetUp()\r
 620     {\r
 621         devInfo = GET_PARAM(0);\r
 622         size = GET_PARAM(1);\r
 623         templ_size = GET_PARAM(2);\r
 624         cn = GET_PARAM(3);\r
 625         method = GET_PARAM(4);\r
 626 \r
 627         cv::gpu::setDevice(devInfo.deviceID());\r
 628     }\r
 629 };\r
 630 \r
 631 TEST_P(MatchTemplate8U, Accuracy)\r
 632 {\r
 633     cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));\r
 634     cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));\r
 635 \r
 636     cv::gpu::GpuMat dst;\r
 637     cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);\r
 638 \r
 639     cv::Mat dst_gold;\r
 640     cv::matchTemplate(image, templ, dst_gold, method);\r
 641 \r
 642     EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);\r
 643 }\r
 644 \r
 645 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate8U, testing::Combine(\r
 646     ALL_DEVICES,\r
 647     DIFFERENT_SIZES,\r
 648     testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),\r
 649     testing::Values(Channels(1), Channels(3), Channels(4)),\r
 650     ALL_TEMPLATE_METHODS));\r
 651 \r
 652 ////////////////////////////////////////////////////////////////////////////////\r
 653 // MatchTemplate32F\r
 654 \r
 655 PARAM_TEST_CASE(MatchTemplate32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)\r
 656 {\r
 657     cv::gpu::DeviceInfo devInfo;\r
 658     cv::Size size;\r
 659     cv::Size templ_size;\r
 660     int cn;\r
 661     int method;\r
 662 \r
 663     int n, m, h, w;\r
 664 \r
 665     virtual void SetUp()\r
 666     {\r
 667         devInfo = GET_PARAM(0);\r
 668         size = GET_PARAM(1);\r
 669         templ_size = GET_PARAM(2);\r
 670         cn = GET_PARAM(3);\r
 671         method = GET_PARAM(4);\r
 672 \r
 673         cv::gpu::setDevice(devInfo.deviceID());\r
 674     }\r
 675 };\r
 676 \r
 677 TEST_P(MatchTemplate32F, Regression)\r
 678 {\r
 679     cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));\r
 680     cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));\r
 681 \r
 682     cv::gpu::GpuMat dst;\r
 683     cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);\r
 684 \r
 685     cv::Mat dst_gold;\r
 686     cv::matchTemplate(image, templ, dst_gold, method);\r
 687 \r
 688     EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);\r
 689 }\r
 690 \r
 691 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate32F, testing::Combine(\r
 692     ALL_DEVICES,\r
 693     DIFFERENT_SIZES,\r
 694     testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),\r
 695     testing::Values(Channels(1), Channels(3), Channels(4)),\r
 696     testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))));\r
 697 \r
 698 ////////////////////////////////////////////////////////////////////////////////\r
 699 // MatchTemplateBlackSource\r
 700 \r
 701 PARAM_TEST_CASE(MatchTemplateBlackSource, cv::gpu::DeviceInfo, TemplateMethod)\r
 702 {\r
 703     cv::gpu::DeviceInfo devInfo;\r
 704     int method;\r
 705 \r
 706     virtual void SetUp()\r
 707     {\r
 708         devInfo = GET_PARAM(0);\r
 709         method = GET_PARAM(1);\r
 710 \r
 711         cv::gpu::setDevice(devInfo.deviceID());\r
 712     }\r
 713 };\r
 714 \r
 715 TEST_P(MatchTemplateBlackSource, Accuracy)\r
 716 {\r
 717     cv::Mat image = readImage("matchtemplate/black.png");\r
 718     ASSERT_FALSE(image.empty());\r
 719 \r
 720     cv::Mat pattern = readImage("matchtemplate/cat.png");\r
 721     ASSERT_FALSE(pattern.empty());\r
 722 \r
 723     cv::gpu::GpuMat d_dst;\r
 724     cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, method);\r
 725 \r
 726     cv::Mat dst(d_dst);\r
 727 \r
 728     double maxValue;\r
 729     cv::Point maxLoc;\r
 730     cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc);\r
 731 \r
 732     cv::Point maxLocGold = cv::Point(284, 12);\r
 733 \r
 734     ASSERT_EQ(maxLocGold, maxLoc);\r
 735 }\r
 736 \r
 737 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplateBlackSource, testing::Combine(\r
 738     ALL_DEVICES,\r
 739     testing::Values(TemplateMethod(cv::TM_CCOEFF_NORMED), TemplateMethod(cv::TM_CCORR_NORMED))));\r
 740 \r
 741 ////////////////////////////////////////////////////////////////////////////////\r
 742 // MatchTemplate_CCOEF_NORMED\r
 743 \r
 744 PARAM_TEST_CASE(MatchTemplate_CCOEF_NORMED, cv::gpu::DeviceInfo, std::pair<std::string, std::string>)\r
 745 {\r
 746     cv::gpu::DeviceInfo devInfo;\r
 747     std::string imageName;\r
 748     std::string patternName;\r
 749 \r
 750     virtual void SetUp()\r
 751     {\r
 752         devInfo = GET_PARAM(0);\r
 753         imageName = GET_PARAM(1).first;\r
 754         patternName = GET_PARAM(1).second;\r
 755 \r
 756         cv::gpu::setDevice(devInfo.deviceID());\r
 757     }\r
 758 };\r
 759 \r
 760 TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)\r
 761 {\r
 762     cv::Mat image = readImage(imageName);\r
 763     ASSERT_FALSE(image.empty());\r
 764 \r
 765     cv::Mat pattern = readImage(patternName);\r
 766     ASSERT_FALSE(pattern.empty());\r
 767 \r
 768     cv::gpu::GpuMat d_dst;\r
 769     cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, CV_TM_CCOEFF_NORMED);\r
 770 \r
 771     cv::Mat dst(d_dst);\r
 772 \r
 773     cv::Point minLoc, maxLoc;\r
 774     double minVal, maxVal;\r
 775     cv::minMaxLoc(dst, &minVal, &maxVal, &minLoc, &maxLoc);\r
 776 \r
 777     cv::Mat dstGold;\r
 778     cv::matchTemplate(image, pattern, dstGold, CV_TM_CCOEFF_NORMED);\r
 779 \r
 780     double minValGold, maxValGold;\r
 781     cv::Point minLocGold, maxLocGold;\r
 782     cv::minMaxLoc(dstGold, &minValGold, &maxValGold, &minLocGold, &maxLocGold);\r
 783 \r
 784     ASSERT_EQ(minLocGold, minLoc);\r
 785     ASSERT_EQ(maxLocGold, maxLoc);\r
 786     ASSERT_LE(maxVal, 1.0);\r
 787     ASSERT_GE(minVal, -1.0);\r
 788 }\r
 789 \r
 790 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CCOEF_NORMED, testing::Combine(\r
 791     ALL_DEVICES,\r
 792     testing::Values(std::make_pair(std::string("matchtemplate/source-0.png"), std::string("matchtemplate/target-0.png")))));\r
 793 \r
 794 ////////////////////////////////////////////////////////////////////////////////\r
 795 // MatchTemplate_CanFindBigTemplate\r
 796 \r
 797 struct MatchTemplate_CanFindBigTemplate : testing::TestWithParam<cv::gpu::DeviceInfo>\r
 798 {\r
 799     cv::gpu::DeviceInfo devInfo;\r
 800 \r
 801     virtual void SetUp()\r
 802     {\r
 803         devInfo = GetParam();\r
 804 \r
 805         cv::gpu::setDevice(devInfo.deviceID());\r
 806     }\r
 807 };\r
 808 \r
 809 TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)\r
 810 {\r
 811     cv::Mat scene = readImage("matchtemplate/scene.jpg");\r
 812     ASSERT_FALSE(scene.empty());\r
 813 \r
 814     cv::Mat templ = readImage("matchtemplate/template.jpg");\r
 815     ASSERT_FALSE(templ.empty());\r
 816 \r
 817     cv::gpu::GpuMat d_result;\r
 818     cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF_NORMED);\r
 819 \r
 820     cv::Mat result(d_result);\r
 821 \r
 822     double minVal;\r
 823     cv::Point minLoc;\r
 824     cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);\r
 825 \r
 826     ASSERT_GE(minVal, 0);\r
 827     ASSERT_LT(minVal, 1e-3);\r
 828     ASSERT_EQ(344, minLoc.x);\r
 829     ASSERT_EQ(0, minLoc.y);\r
 830 }\r
 831 \r
 832 TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)\r
 833 {\r
 834     cv::Mat scene = readImage("matchtemplate/scene.jpg");\r
 835     ASSERT_FALSE(scene.empty());\r
 836 \r
 837     cv::Mat templ = readImage("matchtemplate/template.jpg");\r
 838     ASSERT_FALSE(templ.empty());\r
 839 \r
 840     cv::gpu::GpuMat d_result;\r
 841     cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF);\r
 842 \r
 843     cv::Mat result(d_result);\r
 844 \r
 845     double minVal;\r
 846     cv::Point minLoc;\r
 847     cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);\r
 848 \r
 849     ASSERT_GE(minVal, 0);\r
 850     ASSERT_EQ(344, minLoc.x);\r
 851     ASSERT_EQ(0, minLoc.y);\r
 852 }\r
 853 \r
 854 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CanFindBigTemplate, ALL_DEVICES);\r
 855 \r
 856 ////////////////////////////////////////////////////////////////////////////\r
 857 // MulSpectrums\r
 858 \r
 859 CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)\r
 860 \r
 861 PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)\r
 862 {\r
 863     cv::gpu::DeviceInfo devInfo;\r
 864     cv::Size size;\r
 865     int flag;\r
 866 \r
 867     cv::Mat a, b;\r
 868 \r
 869     virtual void SetUp()\r
 870     {\r
 871         devInfo = GET_PARAM(0);\r
 872         size = GET_PARAM(1);\r
 873         flag = GET_PARAM(2);\r
 874 \r
 875         cv::gpu::setDevice(devInfo.deviceID());\r
 876 \r
 877         a = randomMat(size, CV_32FC2);\r
 878         b = randomMat(size, CV_32FC2);\r
 879     }\r
 880 };\r
 881 \r
 882 TEST_P(MulSpectrums, Simple)\r
 883 {\r
 884     cv::gpu::GpuMat c;\r
 885     cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);\r
 886 \r
 887     cv::Mat c_gold;\r
 888     cv::mulSpectrums(a, b, c_gold, flag, false);\r
 889 \r
 890     EXPECT_MAT_NEAR(c_gold, c, 1e-2);\r
 891 }\r
 892 \r
 893 TEST_P(MulSpectrums, Scaled)\r
 894 {\r
 895     float scale = 1.f / size.area();\r
 896 \r
 897     cv::gpu::GpuMat c;\r
 898     cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);\r
 899 \r
 900     cv::Mat c_gold;\r
 901     cv::mulSpectrums(a, b, c_gold, flag, false);\r
 902     c_gold.convertTo(c_gold, c_gold.type(), scale);\r
 903 \r
 904     EXPECT_MAT_NEAR(c_gold, c, 1e-2);\r
 905 }\r
 906 \r
 907 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MulSpectrums, testing::Combine(\r
 908     ALL_DEVICES,\r
 909     DIFFERENT_SIZES,\r
 910     testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));\r
 911 \r
 912 ////////////////////////////////////////////////////////////////////////////\r
 913 // Dft\r
 914 \r
 915 struct Dft : testing::TestWithParam<cv::gpu::DeviceInfo>\r
 916 {\r
 917     cv::gpu::DeviceInfo devInfo;\r
 918 \r
 919     virtual void SetUp()\r
 920     {\r
 921         devInfo = GetParam();\r
 922 \r
 923         cv::gpu::setDevice(devInfo.deviceID());\r
 924     }\r
 925 };\r
 926 \r
 927 void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplace)\r
 928 {\r
 929     SCOPED_TRACE(hint);\r
 930 \r
 931     cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC2, 0.0, 10.0);\r
 932 \r
 933     cv::Mat b_gold;\r
 934     cv::dft(a, b_gold, flags);\r
 935 \r
 936     cv::gpu::GpuMat d_b;\r
 937     cv::gpu::GpuMat d_b_data;\r
 938     if (inplace)\r
 939     {\r
 940         d_b_data.create(1, a.size().area(), CV_32FC2);\r
 941         d_b = cv::gpu::GpuMat(a.rows, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());\r
 942     }\r
 943     cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), flags);\r
 944 \r
 945     EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());\r
 946     ASSERT_EQ(CV_32F, d_b.depth());\r
 947     ASSERT_EQ(2, d_b.channels());\r
 948     EXPECT_MAT_NEAR(b_gold, cv::Mat(d_b), rows * cols * 1e-4);\r
 949 }\r
 950 \r
 951 TEST_P(Dft, C2C)\r
 952 {\r
 953     int cols = randomInt(2, 100);\r
 954     int rows = randomInt(2, 100);\r
 955 \r
 956     for (int i = 0; i < 2; ++i)\r
 957     {\r
 958         bool inplace = i != 0;\r
 959 \r
 960         testC2C("no flags", cols, rows, 0, inplace);\r
 961         testC2C("no flags 0 1", cols, rows + 1, 0, inplace);\r
 962         testC2C("no flags 1 0", cols, rows + 1, 0, inplace);\r
 963         testC2C("no flags 1 1", cols + 1, rows, 0, inplace);\r
 964         testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);\r
 965         testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);\r
 966         testC2C("single col", 1, rows, 0, inplace);\r
 967         testC2C("single row", cols, 1, 0, inplace);\r
 968         testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);\r
 969         testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);\r
 970         testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);\r
 971         testC2C("size 1 2", 1, 2, 0, inplace);\r
 972         testC2C("size 2 1", 2, 1, 0, inplace);\r
 973     }\r
 974 }\r
 975 \r
 976 void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)\r
 977 {\r
 978     SCOPED_TRACE(hint);\r
 979 \r
 980     cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC1, 0.0, 10.0);\r
 981 \r
 982     cv::gpu::GpuMat d_b, d_c;\r
 983     cv::gpu::GpuMat d_b_data, d_c_data;\r
 984     if (inplace)\r
 985     {\r
 986         if (a.cols == 1)\r
 987         {\r
 988             d_b_data.create(1, (a.rows / 2 + 1) * a.cols, CV_32FC2);\r
 989             d_b = cv::gpu::GpuMat(a.rows / 2 + 1, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());\r
 990         }\r
 991         else\r
 992         {\r
 993             d_b_data.create(1, a.rows * (a.cols / 2 + 1), CV_32FC2);\r
 994             d_b = cv::gpu::GpuMat(a.rows, a.cols / 2 + 1, CV_32FC2, d_b_data.ptr(), (a.cols / 2 + 1) * d_b_data.elemSize());\r
 995         }\r
 996         d_c_data.create(1, a.size().area(), CV_32F);\r
 997         d_c = cv::gpu::GpuMat(a.rows, a.cols, CV_32F, d_c_data.ptr(), a.cols * d_c_data.elemSize());\r
 998     }\r
 999 \r
1000     cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), 0);\r
1001     cv::gpu::dft(d_b, d_c, cv::Size(cols, rows), cv::DFT_REAL_OUTPUT | cv::DFT_SCALE);\r
1002 \r
1003     EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());\r
1004     EXPECT_TRUE(!inplace || d_c.ptr() == d_c_data.ptr());\r
1005     ASSERT_EQ(CV_32F, d_c.depth());\r
1006     ASSERT_EQ(1, d_c.channels());\r
1007 \r
1008     cv::Mat c(d_c);\r
1009     EXPECT_MAT_NEAR(a, c, rows * cols * 1e-5);\r
1010 }\r
1011 \r
1012 TEST_P(Dft, R2CThenC2R)\r
1013 {\r
1014     int cols = randomInt(2, 100);\r
1015     int rows = randomInt(2, 100);\r
1016 \r
1017     testR2CThenC2R("sanity", cols, rows, false);\r
1018     testR2CThenC2R("sanity 0 1", cols, rows + 1, false);\r
1019     testR2CThenC2R("sanity 1 0", cols + 1, rows, false);\r
1020     testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);\r
1021     testR2CThenC2R("single col", 1, rows, false);\r
1022     testR2CThenC2R("single col 1", 1, rows + 1, false);\r
1023     testR2CThenC2R("single row", cols, 1, false);\r
1024     testR2CThenC2R("single row 1", cols + 1, 1, false);\r
1025 \r
1026     testR2CThenC2R("sanity", cols, rows, true);\r
1027     testR2CThenC2R("sanity 0 1", cols, rows + 1, true);\r
1028     testR2CThenC2R("sanity 1 0", cols + 1, rows, true);\r
1029     testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);\r
1030     testR2CThenC2R("single row", cols, 1, true);\r
1031     testR2CThenC2R("single row 1", cols + 1, 1, true);\r
1032 }\r
1033 \r
1034 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Dft, ALL_DEVICES);\r
1035 \r
1036 ///////////////////////////////////////////////////////////////////////////////////////////////////////\r
1037 // CornerHarris\r
1038 \r
1039 IMPLEMENT_PARAM_CLASS(BlockSize, int);\r
1040 IMPLEMENT_PARAM_CLASS(ApertureSize, int);\r
1041 \r
1042 PARAM_TEST_CASE(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderType, BlockSize, ApertureSize)\r
1043 {\r
1044     cv::gpu::DeviceInfo devInfo;\r
1045     int type;\r
1046     int borderType;\r
1047     int blockSize;\r
1048     int apertureSize;\r
1049 \r
1050     virtual void SetUp()\r
1051     {\r
1052         devInfo = GET_PARAM(0);\r
1053         type = GET_PARAM(1);\r
1054         borderType = GET_PARAM(2);\r
1055         blockSize = GET_PARAM(3);\r
1056         apertureSize = GET_PARAM(4);\r
1057 \r
1058         cv::gpu::setDevice(devInfo.deviceID());\r
1059     }\r
1060 };\r
1061 \r
1062 TEST_P(CornerHarris, Accuracy)\r
1063 {\r
1064     cv::Mat src = readImageType("stereobm/aloe-L.png", type);\r
1065     ASSERT_FALSE(src.empty());\r
1066 \r
1067     double k = randomDouble(0.1, 0.9);\r
1068 \r
1069     cv::gpu::GpuMat dst;\r
1070     cv::gpu::cornerHarris(loadMat(src), dst, blockSize, apertureSize, k, borderType);\r
1071 \r
1072     cv::Mat dst_gold;\r
1073     cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);\r
1074 \r
1075     EXPECT_MAT_NEAR(dst_gold, dst, 0.02);\r
1076 }\r
1077 \r
1078 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerHarris, testing::Combine(\r
1079     ALL_DEVICES,\r
1080     testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),\r
1081     testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT)),\r
1082     testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),\r
1083     testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));\r
1084 \r
1085 ///////////////////////////////////////////////////////////////////////////////////////////////////////\r
1086 // cornerMinEigen\r
1087 \r
1088 PARAM_TEST_CASE(CornerMinEigen, cv::gpu::DeviceInfo, MatType, BorderType, BlockSize, ApertureSize)\r
1089 {\r
1090     cv::gpu::DeviceInfo devInfo;\r
1091     int type;\r
1092     int borderType;\r
1093     int blockSize;\r
1094     int apertureSize;\r
1095 \r
1096     virtual void SetUp()\r
1097     {\r
1098         devInfo = GET_PARAM(0);\r
1099         type = GET_PARAM(1);\r
1100         borderType = GET_PARAM(2);\r
1101         blockSize = GET_PARAM(3);\r
1102         apertureSize = GET_PARAM(4);\r
1103 \r
1104         cv::gpu::setDevice(devInfo.deviceID());\r
1105     }\r
1106 };\r
1107 \r
1108 TEST_P(CornerMinEigen, Accuracy)\r
1109 {\r
1110     cv::Mat src = readImageType("stereobm/aloe-L.png", type);\r
1111     ASSERT_FALSE(src.empty());\r
1112 \r
1113     cv::gpu::GpuMat dst;\r
1114     cv::gpu::cornerMinEigenVal(loadMat(src), dst, blockSize, apertureSize, borderType);\r
1115 \r
1116     cv::Mat dst_gold;\r
1117     cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);\r
1118 \r
1119     EXPECT_MAT_NEAR(dst_gold, dst, 0.02);\r
1120 }\r
1121 \r
1122 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerMinEigen, testing::Combine(\r
1123     ALL_DEVICES,\r
1124     testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),\r
1125     testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT)),\r
1126     testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),\r
1127     testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));\r
1128 \r
1129 } // namespace\r
1130 \r
1131 #endif // HAVE_CUDA\r