inference-engine/thirdparty/fluid/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp

   1 // This file is part of OpenCV project.
   2 // It is subject to the license terms in the LICENSE file found in the top-level directory
   3 // of this distribution and at http://opencv.org/license.html.
   4 //
   5 // Copyright (C) 2018-2019 Intel Corporation
   6
   7
   8 #include "../test_precomp.hpp"
   9 #include "../common/gapi_core_tests.hpp"
  10
  11 namespace opencv_test
  12 {
  13
  14 #define CORE_FLUID cv::gapi::core::fluid::kernels()
  15
  16
  17 // FIXME: Windows accuracy problems after recent update!
  18 INSTANTIATE_TEST_CASE_P(MathOpTestFluid, MathOpTest,
  19                         Combine(Values(ADD, SUB, DIV, MUL),
  20                                 testing::Bool(),
  21                                 Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
  22                                 Values(1.0),
  23                                 Values(cv::Size(1920, 1080),
  24                                        cv::Size(1280, 720),
  25                                        cv::Size(640, 480),
  26                                        cv::Size(128, 128)),
  27                                 Values(-1, CV_8U, CV_32F),
  28                                 testing::Bool(),
  29                                 testing::Bool(),
  30                                 Values(cv::compile_args(CORE_FLUID))),
  31                         opencv_test::PrintMathOpCoreParams());
  32
  33 INSTANTIATE_TEST_CASE_P(MulSTestFluid, MulDoubleTest,
  34                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
  35                                 Values(cv::Size(1280, 720),
  36                                        cv::Size(640, 480),
  37                                        cv::Size(128, 128)),
  38                                 Values(-1), // FIXME: extend with more types
  39                                 testing::Bool(),
  40                                 Values(cv::compile_args(CORE_FLUID))));
  41
  42 INSTANTIATE_TEST_CASE_P(DivCTestFluid, DivCTest,
  43                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
  44                                 Values(cv::Size(1280, 720),
  45                                        cv::Size(640, 480),
  46                                        cv::Size(128, 128)),
  47                                 Values(CV_8U, CV_32F),
  48                                 testing::Bool(),
  49                                 Values(cv::compile_args(CORE_FLUID))));
  50
  51 INSTANTIATE_TEST_CASE_P(AbsDiffTestFluid, AbsDiffTest,
  52                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
  53                                 Values(cv::Size(1280, 720),
  54                                        cv::Size(640, 480),
  55                                        cv::Size(128, 128)),
  56                                 testing::Bool(),
  57                                 Values(cv::compile_args(CORE_FLUID))));
  58
  59 INSTANTIATE_TEST_CASE_P(AbsDiffCTestFluid, AbsDiffCTest,
  60                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
  61                                 Values(cv::Size(1280, 720),
  62                                        cv::Size(640, 480),
  63                                        cv::Size(128, 128)),
  64                                 testing::Bool(),
  65                                 Values(cv::compile_args(CORE_FLUID))));
  66
  67 INSTANTIATE_TEST_CASE_P(BitwiseTestFluid, BitwiseTest,
  68                         Combine(Values(AND, OR, XOR),
  69                                 Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
  70                                 Values(cv::Size(1920, 1080),
  71                                        cv::Size(1280, 720),
  72                                        cv::Size(640, 480),
  73                                        cv::Size(128, 128)),
  74                                 testing::Bool(),
  75                                 Values(cv::compile_args(CORE_FLUID))),
  76                         opencv_test::PrintBWCoreParams());
  77
  78 INSTANTIATE_TEST_CASE_P(BitwiseNotTestFluid, NotTest,
  79                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
  80                                 Values(cv::Size(1920, 1080),
  81                                        cv::Size(1280, 720),
  82                                        cv::Size(640, 480),
  83                                        cv::Size(128, 128)),
  84                                 testing::Bool(),
  85                                 Values(cv::compile_args(CORE_FLUID))));
  86
  87 INSTANTIATE_TEST_CASE_P(MinTestFluid, MinTest,
  88                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
  89                                 Values(cv::Size(1920, 1080),
  90                                        cv::Size(1280, 720),
  91                                        cv::Size(640, 480),
  92                                        cv::Size(128, 128)),
  93                                 testing::Bool(),
  94                                 Values(cv::compile_args(CORE_FLUID))));
  95
  96 INSTANTIATE_TEST_CASE_P(MaxTestFluid, MaxTest,
  97                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
  98                                 Values(cv::Size(1920, 1080),
  99                                        cv::Size(1280, 720),
 100                                        cv::Size(640, 480),
 101                                        cv::Size(128, 128)),
 102                                 testing::Bool(),
 103                                 Values(cv::compile_args(CORE_FLUID))));
 104
 105 INSTANTIATE_TEST_CASE_P(CompareTestFluid, CmpTest,
 106                         Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
 107                                 testing::Bool(),
 108                                 Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
 109                                 Values(cv::Size(1920, 1080),
 110                                        cv::Size(1280, 720),
 111                                        cv::Size(640, 480),
 112                                        cv::Size(128, 128)),
 113                                 testing::Bool(),
 114                                 Values(cv::compile_args(CORE_FLUID))),
 115                         opencv_test::PrintCmpCoreParams());
 116
 117 INSTANTIATE_TEST_CASE_P(AddWeightedTestFluid, AddWeightedTest,
 118                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 119                                 Values(cv::Size(1280, 720),
 120                                        cv::Size(640, 480),
 121                                        cv::Size(128, 128)),
 122                                 Values(-1, CV_8U, CV_32F),
 123                                 testing::Bool(),
 124                                 Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()),
 125                                 //Values(0.5000005),
 126                                 Values(cv::compile_args(CORE_FLUID))));
 127
 128 INSTANTIATE_TEST_CASE_P(LUTTestFluid, LUTTest,
 129                         Combine(Values(CV_8UC1, CV_8UC3),
 130                                 Values(CV_8UC1),
 131                                 Values(cv::Size(1920, 1080),
 132                                        cv::Size(1280, 720),
 133                                        cv::Size(640, 480),
 134                                        cv::Size(128, 128)),
 135                                 testing::Bool(),
 136                                 Values(cv::compile_args(CORE_FLUID))));
 137
 138 INSTANTIATE_TEST_CASE_P(ConvertToFluid, ConvertToTest,
 139                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_32FC1),
 140                                 Values(CV_8U, CV_16U, CV_32F),
 141                                 Values(cv::Size(1920, 1080),
 142                                        cv::Size(1280, 720),
 143                                        cv::Size(640, 480),
 144                                        cv::Size(128, 128)),
 145                                 Values(cv::compile_args(CORE_FLUID))));
 146
 147 INSTANTIATE_TEST_CASE_P(Split3TestFluid, Split3Test,
 148                         Combine(Values(cv::Size(1280, 720),
 149                                        cv::Size(640, 480),
 150                                        cv::Size(128, 128)),
 151                                 Values(cv::compile_args(CORE_FLUID))));
 152
 153 INSTANTIATE_TEST_CASE_P(Split4TestFluid, Split4Test,
 154                         Combine(Values(cv::Size(1280, 720),
 155                                        cv::Size(640, 480),
 156                                        cv::Size(128, 128)),
 157                                 Values(cv::compile_args(CORE_FLUID))));
 158
 159 INSTANTIATE_TEST_CASE_P(Merge3TestFluid, Merge3Test,
 160                         Combine(Values(cv::Size(1920, 1080),
 161                                        cv::Size(1280, 720),
 162                                        cv::Size(640, 480),
 163                                        cv::Size(128, 128)),
 164                                 Values(cv::compile_args(CORE_FLUID))));
 165
 166 INSTANTIATE_TEST_CASE_P(Merge4TestFluid, Merge4Test,
 167                         Combine(Values(cv::Size(1920, 1080),
 168                                        cv::Size(1280, 720),
 169                                        cv::Size(640, 480),
 170                                        cv::Size(128, 128)),
 171                                 Values(cv::compile_args(CORE_FLUID))));
 172
 173 INSTANTIATE_TEST_CASE_P(SelectTestFluid, SelectTest,
 174                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
 175                                 Values(cv::Size(1920, 1080),
 176                                        cv::Size(1280, 720),
 177                                        cv::Size(640, 480),
 178                                        cv::Size(128, 128)),
 179                                 testing::Bool(),
 180                                 Values(cv::compile_args(CORE_FLUID))));
 181
 182 INSTANTIATE_TEST_CASE_P(Polar2CartFluid, Polar2CartTest,
 183                         Combine(Values(cv::Size(1280, 720),
 184                                        cv::Size(640, 480),
 185                                        cv::Size(128, 128)),
 186                                 testing::Bool(),
 187                                 Values(cv::compile_args(CORE_FLUID))));
 188
 189 INSTANTIATE_TEST_CASE_P(Cart2PolarFluid, Cart2PolarTest,
 190                         Combine(Values(cv::Size(1280, 720),
 191                                        cv::Size(640, 480),
 192                                        cv::Size(128, 128)),
 193                                 testing::Bool(),
 194                                 Values(cv::compile_args(CORE_FLUID))));
 195
 196 INSTANTIATE_TEST_CASE_P(PhaseFluid, PhaseTest,
 197                         Combine(Values(CV_32F, CV_32FC3),
 198                                 Values(cv::Size(1280, 720),
 199                                        cv::Size(640, 480),
 200                                        cv::Size(128, 128)),
 201                                 testing::Bool(),
 202                                 Values(cv::compile_args(CORE_FLUID))));
 203
 204 INSTANTIATE_TEST_CASE_P(SqrtFluid, SqrtTest,
 205                         Combine(Values(CV_32F, CV_32FC3),
 206                                 Values(cv::Size(1280, 720),
 207                                        cv::Size(640, 480),
 208                                        cv::Size(128, 128)),
 209                                 Values(cv::compile_args(CORE_FLUID))));
 210
 211 INSTANTIATE_TEST_CASE_P(ThresholdTestFluid, ThresholdTest,
 212                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
 213                                 Values(cv::Size(1920, 1080),
 214                                        cv::Size(1280, 720),
 215                                        cv::Size(640, 480),
 216                                        cv::Size(128, 128)),
 217                                 Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV,
 218                                        cv::THRESH_TRUNC,
 219                                        cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV),
 220                                 testing::Bool(),
 221                                 Values(cv::compile_args(CORE_FLUID))));
 222
 223 INSTANTIATE_TEST_CASE_P(InRangeTestFluid, InRangeTest,
 224                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
 225                                 Values(cv::Size(1920, 1080),
 226                                        cv::Size(1280, 720),
 227                                        cv::Size(640, 480),
 228                                        cv::Size(128, 128)),
 229                                 testing::Bool(),
 230                                 Values(cv::compile_args(CORE_FLUID))));
 231
 232 INSTANTIATE_TEST_CASE_P(
 233                         ResizeTestFluid, ResizeTest,
 234                         Combine(Values(AbsExact().to_compare_f()),
 235                                 Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/),
 236                                 Values(/*cv::INTER_NEAREST,*/ cv::INTER_LINEAR/*, cv::INTER_AREA*/),
 237                                 Values(cv::Size(1280, 720),
 238                                        cv::Size(640, 480),
 239                                        cv::Size(128, 128),
 240                                        cv::Size(64, 64),
 241                                        cv::Size(30, 30)),
 242                                 Values(cv::Size(1280, 720),
 243                                        cv::Size(640, 480),
 244                                        cv::Size(128, 128),
 245                                        cv::Size(64, 64),
 246                                        cv::Size(30, 30)),
 247                                 Values(cv::compile_args(CORE_FLUID))));
 248
 249 //----------------------------------------------------------------------
 250 // FIXME: Clean-up test configurations which are enabled already
 251 #if 0
 252 INSTANTIATE_TEST_CASE_P(MathOpTestCPU, MathOpTest,
 253                         Combine(Values(ADD, DIV, MUL),
 254                                 testing::Bool(),
 255                                 Values(CV_8UC1, CV_16SC1, CV_32FC1),
 256                                 Values(cv::Size(1280, 720),
 257                                        cv::Size(640, 480),
 258                                        cv::Size(128, 128)),
 259                                 Values(-1, CV_8U, CV_32F),
 260 /*init output matrices or not*/ testing::Bool(),
 261                                 Values(false)),
 262                         opencv_test::PrintMathOpCoreParams());
 263
 264 INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest,
 265                         Combine(Values(SUB),
 266                                 testing::Bool(),
 267                                 Values(CV_8UC1, CV_16SC1 , CV_32FC1),
 268                                 Values(cv::Size(1280, 720),
 269                                        cv::Size(640, 480),
 270                                        cv::Size(128, 128)),
 271                                 Values(-1, CV_8U, CV_32F),
 272 /*init output matrices or not*/ testing::Bool(),
 273                                 testing::Bool()),
 274                         opencv_test::PrintMathOpCoreParams());
 275
 276 INSTANTIATE_TEST_CASE_P(MulSTestCPU, MulSTest,
 277                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
 278                                 Values(cv::Size(1280, 720),
 279                                        cv::Size(640, 480),
 280                                        cv::Size(128, 128)),
 281 /*init output matrices or not*/ testing::Bool()));
 282
 283 INSTANTIATE_TEST_CASE_P(DivCTestCPU, DivCTest,
 284                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
 285                                 Values(cv::Size(1280, 720),
 286                                        cv::Size(640, 480),
 287                                        cv::Size(128, 128)),
 288                                 Values(CV_8U, CV_32F),
 289 /*init output matrices or not*/ testing::Bool()));
 290
 291 INSTANTIATE_TEST_CASE_P(MeanTestCPU, MeanTest,
 292                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 293                                 Values(cv::Size(1280, 720),
 294                                        cv::Size(640, 480),
 295                                        cv::Size(128, 128)),
 296 /*init output matrices or not*/ testing::Bool()));
 297
 298 INSTANTIATE_TEST_CASE_P(SelectTestCPU, SelectTest,
 299                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 300                                 Values(cv::Size(1280, 720),
 301                                        cv::Size(640, 480),
 302                                        cv::Size(128, 128)),
 303 /*init output matrices or not*/ testing::Bool()));
 304
 305 INSTANTIATE_TEST_CASE_P(Polar2CartCPU, Polar2CartTest,
 306                         Combine(Values(cv::Size(1280, 720),
 307                                        cv::Size(640, 480),
 308                                        cv::Size(128, 128)),
 309 /*init output matrices or not*/ testing::Bool()));
 310
 311 INSTANTIATE_TEST_CASE_P(Cart2PolarCPU, Cart2PolarTest,
 312                         Combine(Values(cv::Size(1280, 720),
 313                                        cv::Size(640, 480),
 314                                        cv::Size(128, 128)),
 315 /*init output matrices or not*/ testing::Bool()));
 316
 317 INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest,
 318                         Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
 319                                 testing::Bool(),
 320                                 Values(CV_8UC1, CV_16SC1, CV_32FC1),
 321                                 Values(cv::Size(1280, 720),
 322                                        cv::Size(640, 480),
 323                                        cv::Size(128, 128)),
 324 /*init output matrices or not*/ testing::Bool()),
 325                         opencv_test::PrintCmpCoreParams());
 326
 327 INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
 328                         Combine(Values(AND, OR, XOR),
 329                                 Values(CV_8UC1, CV_16UC1, CV_16SC1),
 330                                 Values(cv::Size(1280, 720),
 331                                        cv::Size(640, 480),
 332                                        cv::Size(128, 128)),
 333 /*init output matrices or not*/ testing::Bool()),
 334                         opencv_test::PrintBWCoreParams());
 335
 336 INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest,
 337                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 338                                 Values(cv::Size(1280, 720),
 339                                        cv::Size(640, 480),
 340                                        cv::Size(128, 128)),
 341  /*init output matrices or not*/ testing::Bool()));
 342
 343 INSTANTIATE_TEST_CASE_P(MinTestCPU, MinTest,
 344                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 345                                 Values(cv::Size(1280, 720),
 346                                        cv::Size(640, 480),
 347                                        cv::Size(128, 128)),
 348 /*init output matrices or not*/ testing::Bool()));
 349
 350 INSTANTIATE_TEST_CASE_P(MaxTestCPU, MaxTest,
 351                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 352                                 Values(cv::Size(1280, 720),
 353                                        cv::Size(640, 480),
 354                                        cv::Size(128, 128)),
 355 /*init output matrices or not*/ testing::Bool()));
 356
 357 INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
 358                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 359                                 Values(cv::Size(1280, 720),
 360                                        cv::Size(640, 480),
 361                                        cv::Size(128, 128)),
 362 /*init output matrices or not*/ testing::Bool())
 363                                 Values(0.0),
 364                        );
 365
 366 INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest,
 367                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 368                                 Values(cv::Size(1280, 720),
 369                                        cv::Size(640, 480),
 370                                        cv::Size(128, 128)),
 371 /*init output matrices or not*/ testing::Bool()));
 372
 373 INSTANTIATE_TEST_CASE_P(AbsDiffCTestCPU, AbsDiffCTest,
 374                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 375                                 Values(cv::Size(1280, 720),
 376                                        cv::Size(640, 480),
 377                                        cv::Size(128, 128)),
 378 /*init output matrices or not*/ testing::Bool()));
 379
 380 INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest,
 381                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 382                                 Values(cv::Size(1280, 720),
 383                                        cv::Size(640, 480),
 384                                        cv::Size(128, 128)),
 385                                 Values(-1, CV_8U, CV_32F),
 386 /*init output matrices or not*/ testing::Bool()));
 387
 388 INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
 389                         Combine(Values(NORM_INF, NORM_L1, NORM_L2),
 390                                 Values(CV_8UC1, CV_16UC1, CV_16SC1),
 391                                 Values(cv::Size(1280, 720),
 392                                        cv::Size(640, 480),
 393                                        cv::Size(128, 128))),
 394                                 Values(0.0),
 395                         opencv_test::PrintNormCoreParams());
 396
 397 INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest,
 398                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 399                                 Values(cv::Size(1280, 720),
 400                                        cv::Size(640, 480),
 401                                        cv::Size(128, 128))));
 402
 403 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest,
 404                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 405                                 Values(cv::Size(1280, 720),
 406                                        cv::Size(640, 480),
 407                                        cv::Size(128, 128)),
 408                                 Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV),
 409 /*init output matrices or not*/ testing::Bool()));
 410
 411 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdOTTest,
 412                         Combine(Values(CV_8UC1),
 413                                 Values(cv::Size(1280, 720),
 414                                        cv::Size(640, 480),
 415                                        cv::Size(128, 128)),
 416                                 Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE),
 417 /*init output matrices or not*/ testing::Bool()));
 418
 419
 420 INSTANTIATE_TEST_CASE_P(InRangeTestCPU, InRangeTest,
 421                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 422                                 Values(cv::Size(1280, 720),
 423                                        cv::Size(640, 480),
 424                                        cv::Size(128, 128)),
 425 /*init output matrices or not*/ testing::Bool()));
 426
 427 INSTANTIATE_TEST_CASE_P(Split3TestCPU, Split3Test,
 428                         (Values(cv::Size(1280, 720),
 429                                 cv::Size(640, 480),
 430                                 cv::Size(128, 128))));
 431
 432 INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test,
 433                         (Values(cv::Size(1280, 720),
 434                                 cv::Size(640, 480),
 435                                 cv::Size(128, 128))));
 436
 437 INSTANTIATE_TEST_CASE_P(Merge3TestCPU, Merge3Test,
 438                         (Values(cv::Size(1280, 720),
 439                                        cv::Size(640, 480),
 440                                        cv::Size(128, 128))));
 441
 442 INSTANTIATE_TEST_CASE_P(Merge4TestCPU, Merge4Test,
 443                         (Values(cv::Size(1280, 720),
 444                                        cv::Size(640, 480),
 445                                        cv::Size(128, 128))));
 446
 447 INSTANTIATE_TEST_CASE_P(RemapTestCPU, RemapTest,
 448                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 449                                 Values(cv::Size(1280, 720),
 450                                        cv::Size(640, 480),
 451                                        cv::Size(128, 128)),
 452 /*init output matrices or not*/ testing::Bool()));
 453
 454 INSTANTIATE_TEST_CASE_P(FlipTestCPU, FlipTest,
 455                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 456                                 Values(0,1,-1),
 457                                 Values(cv::Size(1280, 720),
 458                                        cv::Size(640, 480),
 459                                        cv::Size(128, 128)),
 460 /*init output matrices or not*/ testing::Bool()));
 461
 462 INSTANTIATE_TEST_CASE_P(CropTestCPU, CropTest,
 463                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 464                                 Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)),
 465                                 Values(cv::Size(1280, 720),
 466                                        cv::Size(640, 480),
 467                                        cv::Size(128, 128)),
 468 /*init output matrices or not*/ testing::Bool()));
 469
 470 INSTANTIATE_TEST_CASE_P(LUTTestCPU, LUTTest,
 471                         Combine(Values(CV_8UC1, CV_8UC3),
 472                                 Values(CV_8UC1),
 473                                 Values(cv::Size(1280, 720),
 474                                        cv::Size(640, 480),
 475                                        cv::Size(128, 128)),
 476 /*init output matrices or not*/ testing::Bool()));
 477
 478 INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest,
 479                         Combine(Values(CV_8UC3),
 480                                 Values(CV_8UC3),
 481                                 Values(cv::Size(1280, 720),
 482                                        cv::Size(640, 480),
 483                                        cv::Size(128, 128)),
 484 /*init output matrices or not*/ testing::Bool()));
 485
 486 INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest,
 487                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_32FC1),
 488                                 Values(CV_8U, CV_16U, CV_32F),
 489                                 Values(cv::Size(1280, 720),
 490                                        cv::Size(640, 480),
 491                                        cv::Size(128, 128))));
 492
 493 INSTANTIATE_TEST_CASE_P(ConcatHorTestCPU, ConcatHorTest,
 494                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 495                                 Values(cv::Size(1280, 720),
 496                                        cv::Size(640, 480),
 497                                        cv::Size(128, 128))));
 498 INSTANTIATE_TEST_CASE_P(ConcatVertTestCPU, ConcatVertTest,
 499                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 500                                 Values(cv::Size(1280, 720),
 501                                        cv::Size(640, 480),
 502                                        cv::Size(128, 128))));
 503
 504 //----------------------------------------------------------------------
 505 #endif // 0
 506
 507 }