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