modules/gapi/test/cpu/gapi_core_tests_cpu.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-2020 Intel Corporation
   6
   7
   8 #include "../test_precomp.hpp"
   9 #include "../common/gapi_core_tests.hpp"
  10 #include <opencv2/gapi/cpu/core.hpp>
  11
  12 namespace
  13 {
  14 #define CORE_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::cpu::kernels()}); }
  15 }  // anonymous namespace
  16
  17 namespace opencv_test
  18 {
  19
  20 // FIXME: Wut? See MulTestCPU/MathOpTest below (duplicate?)
  21 INSTANTIATE_TEST_CASE_P(AddTestCPU, MathOpTest,
  22                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  23                                 Values(cv::Size(1280, 720),
  24                                        cv::Size(640, 480),
  25                                        cv::Size(128, 128)),
  26                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  27                                 Values(CORE_CPU),
  28                                 Values(ADD, MUL),
  29                                 testing::Bool(),
  30                                 Values(1.0),
  31                                 Values(false)));
  32
  33 INSTANTIATE_TEST_CASE_P(MulTestCPU, MathOpTest,
  34                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  35                                 Values(cv::Size(1280, 720),
  36                                        cv::Size(640, 480),
  37                                        cv::Size(128, 128)),
  38                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  39                                 Values(CORE_CPU),
  40                                 Values(MUL),
  41                                 testing::Bool(),
  42                                 Values(1.0, 0.5, 2.0),
  43                                 Values(false)));
  44
  45 INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest,
  46                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  47                                 Values(cv::Size(1280, 720),
  48                                        cv::Size(640, 480),
  49                                        cv::Size(128, 128)),
  50                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  51                                 Values(CORE_CPU),
  52                                 Values(SUB),
  53                                 testing::Bool(),
  54                                 Values (1.0),
  55                                 testing::Bool()));
  56
  57 INSTANTIATE_TEST_CASE_P(DivTestCPU, MathOpTest,
  58                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  59                                 Values(cv::Size(1280, 720),
  60                                        cv::Size(640, 480),
  61                                        cv::Size(128, 128)),
  62                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  63                                 Values(CORE_CPU),
  64                                 Values(DIV),
  65                                 testing::Bool(),
  66                                 Values (1.0, 0.5, 2.0),
  67                                 testing::Bool()));
  68
  69 INSTANTIATE_TEST_CASE_P(MulTestCPU, MulDoubleTest,
  70                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  71                                 Values(cv::Size(1280, 720),
  72                                        cv::Size(640, 480),
  73                                        cv::Size(128, 128)),
  74                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  75                                 Values(CORE_CPU)));
  76
  77 INSTANTIATE_TEST_CASE_P(DivTestCPU, DivTest,
  78                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  79                                 Values(cv::Size(1280, 720),
  80                                        cv::Size(640, 480),
  81                                        cv::Size(128, 128)),
  82                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  83                                 Values(CORE_CPU)));
  84
  85 INSTANTIATE_TEST_CASE_P(DivCTestCPU, DivCTest,
  86                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  87                                 Values(cv::Size(1280, 720),
  88                                        cv::Size(640, 480),
  89                                        cv::Size(128, 128)),
  90                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  91                                 Values(CORE_CPU)));
  92
  93 INSTANTIATE_TEST_CASE_P(MeanTestCPU, MeanTest,
  94                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  95                                 Values(cv::Size(1280, 720),
  96                                        cv::Size(640, 480),
  97                                        cv::Size(128, 128)),
  98                                 Values(-1),
  99                                 Values(CORE_CPU)));
 100
 101 INSTANTIATE_TEST_CASE_P(MaskTestCPU, MaskTest,
 102                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 103                                 Values(cv::Size(1280, 720),
 104                                        cv::Size(640, 480),
 105                                        cv::Size(128, 128)),
 106                                 Values(-1),
 107                                 Values(CORE_CPU)));
 108
 109 INSTANTIATE_TEST_CASE_P(SelectTestCPU, SelectTest,
 110                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 111                                 Values(cv::Size(1280, 720),
 112                                        cv::Size(640, 480),
 113                                        cv::Size(128, 128)),
 114                                 Values(-1),
 115                                 Values(CORE_CPU)));
 116
 117 INSTANTIATE_TEST_CASE_P(Polar2CartCPU, Polar2CartTest,
 118                         Combine(Values(CV_32FC1),
 119                                 Values(cv::Size(1280, 720),
 120                                        cv::Size(640, 480),
 121                                        cv::Size(128, 128)),
 122                                 Values(CV_32FC1),
 123                                 Values(CORE_CPU)));
 124
 125 INSTANTIATE_TEST_CASE_P(Cart2PolarCPU, Cart2PolarTest,
 126                         Combine(Values(CV_32FC1),
 127                                 Values(cv::Size(1280, 720),
 128                                        cv::Size(640, 480),
 129                                        cv::Size(128, 128)),
 130                                 Values(CV_32FC1),
 131                                 Values(CORE_CPU)));
 132
 133 INSTANTIATE_TEST_CASE_P(PhaseCPU, PhaseTest,
 134                         Combine(Values(CV_32F, CV_32FC3),
 135                                 Values(cv::Size(1280, 720),
 136                                        cv::Size(640, 480),
 137                                        cv::Size(128, 128)),
 138                                 Values(-1),
 139                                 Values(CORE_CPU),
 140          /* angle_in_degrees */ testing::Bool()));
 141
 142 INSTANTIATE_TEST_CASE_P(SqrtCPU, SqrtTest,
 143                         Combine(Values(CV_32F, CV_32FC3),
 144                                 Values(cv::Size(1280, 720),
 145                                        cv::Size(640, 480),
 146                                        cv::Size(128, 128)),
 147                                 Values(-1),
 148                                 Values(CORE_CPU)));
 149
 150 INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest,
 151                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 152                                 Values(cv::Size(1280, 720),
 153                                        cv::Size(640, 480),
 154                                        cv::Size(128, 128)),
 155                                 Values(CV_8U),
 156                                 Values(CORE_CPU),
 157                                 Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
 158                                 testing::Bool(),
 159                                 Values(AbsExact().to_compare_obj())));
 160
 161 INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
 162                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
 163                                 Values(cv::Size(1280, 720),
 164                                        cv::Size(640, 480),
 165                                        cv::Size(128, 128)),
 166                                 Values(-1),
 167                                 Values(CORE_CPU),
 168                                 Values(AND, OR, XOR),
 169                                 testing::Bool()));
 170
 171 INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest,
 172                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
 173                                 Values(cv::Size(1280, 720),
 174                                        cv::Size(640, 480),
 175                                        cv::Size(128, 128)),
 176                                 Values(-1),
 177                                 Values(CORE_CPU)));
 178
 179 INSTANTIATE_TEST_CASE_P(MinTestCPU, MinTest,
 180                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 181                                 Values(cv::Size(1280, 720),
 182                                        cv::Size(640, 480),
 183                                        cv::Size(128, 128)),
 184                                 Values(-1),
 185                                 Values(CORE_CPU)));
 186
 187 INSTANTIATE_TEST_CASE_P(MaxTestCPU, MaxTest,
 188                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 189                                 Values(cv::Size(1280, 720),
 190                                        cv::Size(640, 480),
 191                                        cv::Size(128, 128)),
 192                                 Values(-1),
 193                                 Values(CORE_CPU)));
 194
 195 INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
 196                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 197                                 Values(cv::Size(1280, 720),
 198                                        cv::Size(640, 480),
 199                                        cv::Size(128, 128)),
 200                                 Values(-1),
 201                                 //Values(1e-5),
 202                                 Values(CORE_CPU),
 203                                 Values(AbsToleranceScalar(1e-5).to_compare_obj())));
 204
 205 INSTANTIATE_TEST_CASE_P(CountNonZeroTestCPU, CountNonZeroTest,
 206                         Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
 207                                 Values(cv::Size(1280, 720),
 208                                        cv::Size(640, 480),
 209                                        cv::Size(128, 128)),
 210                                 Values(-1),
 211                                 Values(CORE_CPU),
 212                                 Values(AbsToleranceScalar(1e-5).to_compare_obj())));
 213
 214 INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest,
 215                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 216                                 Values(cv::Size(1280, 720),
 217                                        cv::Size(640, 480),
 218                                        cv::Size(128, 128)),
 219                                 Values(-1),
 220                                 Values(CORE_CPU)));
 221
 222 INSTANTIATE_TEST_CASE_P(AbsDiffCTestCPU, AbsDiffCTest,
 223                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 224                                 Values(cv::Size(1280, 720),
 225                                        cv::Size(640, 480),
 226                                        cv::Size(128, 128)),
 227                                 Values(-1),
 228                                 Values(CORE_CPU)));
 229
 230 INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest,
 231                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 232                                 Values(cv::Size(1280, 720),
 233                                        cv::Size(640, 480),
 234                                        cv::Size(128, 128)),
 235                                 Values( -1, CV_8U, CV_16U, CV_32F ),
 236                                 Values(CORE_CPU),
 237                                 Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_obj())));
 238
 239 INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
 240                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 241                                 Values(cv::Size(1280, 720),
 242                                        cv::Size(640, 480),
 243                                        cv::Size(128, 128)),
 244                                 Values(-1),
 245                                 Values(CORE_CPU),
 246                                 Values(AbsToleranceScalar(1e-5).to_compare_obj()),
 247                                 Values(NORM_INF, NORM_L1, NORM_L2)));
 248
 249 INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest,
 250                         Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
 251                                 Values(cv::Size(1280, 720),
 252                                        cv::Size(640, 480),
 253                                        cv::Size(128, 128)),
 254                                 Values(-1),
 255                                 Values(CORE_CPU)));
 256
 257 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest,
 258                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 259                                 Values(cv::Size(1280, 720),
 260                                        cv::Size(640, 480),
 261                                        cv::Size(128, 128)),
 262                                 Values(-1),
 263                                 Values(CORE_CPU),
 264                                 Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC,
 265                                        cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV),
 266                                 Values(cv::Scalar(0, 0, 0, 0),
 267                                        cv::Scalar(100, 100, 100, 100),
 268                                        cv::Scalar(255, 255, 255, 255))));
 269
 270 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdOTTest,
 271                         Combine(Values(CV_8UC1),
 272                                 Values(cv::Size(1280, 720),
 273                                        cv::Size(640, 480),
 274                                        cv::Size(128, 128)),
 275                                 Values(-1),
 276                                 Values(CORE_CPU),
 277                                 Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
 278
 279
 280 INSTANTIATE_TEST_CASE_P(InRangeTestCPU, InRangeTest,
 281                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
 282                                 Values(cv::Size(1280, 720),
 283                                        cv::Size(640, 480),
 284                                        cv::Size(128, 128)),
 285                                 Values(-1),
 286                                 Values(CORE_CPU)));
 287
 288 INSTANTIATE_TEST_CASE_P(Split3TestCPU, Split3Test,
 289                         Combine(Values(CV_8UC3),
 290                                 Values(cv::Size(1280, 720),
 291                                        cv::Size(640, 480),
 292                                        cv::Size(128, 128)),
 293                                 Values(CV_8UC1),
 294                                 Values(CORE_CPU)));
 295
 296 INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test,
 297                         Combine(Values(CV_8UC4),
 298                                 Values(cv::Size(1280, 720),
 299                                        cv::Size(640, 480),
 300                                        cv::Size(128, 128)),
 301                                 Values(CV_8UC1),
 302                                 Values(CORE_CPU)));
 303
 304 INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest,
 305                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 306                                 Values(cv::Size(1280, 720),
 307                                        cv::Size(640, 480),
 308                                        cv::Size(128, 128)),
 309                                 Values(-1),
 310                                 Values(CORE_CPU),
 311                                 Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
 312                                 Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
 313                                 Values(cv::Size(64,64),
 314                                        cv::Size(30,30))));
 315
 316 INSTANTIATE_TEST_CASE_P(ResizePTestCPU, ResizePTest,
 317                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 318                                 Values(cv::Size(1280, 720),
 319                                        cv::Size(640, 480),
 320                                        cv::Size(128, 128)),
 321                                 Values(-1),
 322                                 Values(CORE_CPU),
 323                                 Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
 324                                 Values(cv::INTER_LINEAR),
 325                                 Values(cv::Size(64,64),
 326                                        cv::Size(30,30))));
 327
 328 INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy,
 329                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 330                                 Values(cv::Size(1280, 720),
 331                                        cv::Size(640, 480),
 332                                        cv::Size(128, 128)),
 333                                 Values(-1),
 334                                 Values(CORE_CPU),
 335                                 Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
 336                                 Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
 337                                 Values(0.5, 0.1),
 338                                 Values(0.5, 0.1)));
 339
 340 INSTANTIATE_TEST_CASE_P(Merge3TestCPU, Merge3Test,
 341                         Combine(Values(CV_8UC1),
 342                                 Values(cv::Size(1280, 720),
 343                                        cv::Size(640, 480),
 344                                        cv::Size(128, 128)),
 345                                 Values(CV_8UC3),
 346                                 Values(CORE_CPU)));
 347
 348 INSTANTIATE_TEST_CASE_P(Merge4TestCPU, Merge4Test,
 349                         Combine(Values(CV_8UC1),
 350                                 Values(cv::Size(1280, 720),
 351                                        cv::Size(640, 480),
 352                                        cv::Size(128, 128)),
 353                                 Values(CV_8UC4),
 354                                 Values(CORE_CPU)));
 355
 356 INSTANTIATE_TEST_CASE_P(RemapTestCPU, RemapTest,
 357                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 358                                 Values(cv::Size(1280, 720),
 359                                        cv::Size(640, 480),
 360                                        cv::Size(128, 128)),
 361                                 Values(-1),
 362                                 Values(CORE_CPU)));
 363
 364 INSTANTIATE_TEST_CASE_P(FlipTestCPU, FlipTest,
 365                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 366                                 Values(cv::Size(1280, 720),
 367                                        cv::Size(640, 480),
 368                                        cv::Size(128, 128)),
 369                                 Values(-1),
 370                                 Values(CORE_CPU),
 371                                 Values(0,1,-1)));
 372
 373 INSTANTIATE_TEST_CASE_P(CropTestCPU, CropTest,
 374                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 375                                 Values(cv::Size(1280, 720),
 376                                        cv::Size(640, 480),
 377                                        cv::Size(128, 128)),
 378                                 Values(-1),
 379                                 Values(CORE_CPU),
 380                                 Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
 381
 382 INSTANTIATE_TEST_CASE_P(CopyTestCPU, CopyTest,
 383                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 384                                 Values(cv::Size(1280, 720),
 385                                        cv::Size(640, 480),
 386                                        cv::Size(128, 128)),
 387                                 Values(-1),
 388                                 Values(CORE_CPU)));
 389
 390 INSTANTIATE_TEST_CASE_P(LUTTestCPU, LUTTest,
 391                         Combine(Values(CV_8UC1, CV_8UC3),
 392                                 Values(cv::Size(1280, 720),
 393                                        cv::Size(640, 480),
 394                                        cv::Size(128, 128)),
 395                                 Values(CV_8UC1),
 396                                 Values(CORE_CPU)));
 397
 398 INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest,
 399                         Combine(Values(CV_8UC3),
 400                                 Values(cv::Size(1280, 720),
 401                                        cv::Size(640, 480),
 402                                        cv::Size(128, 128)),
 403                                 Values(CV_8UC3),
 404                                 Values(CORE_CPU)));
 405
 406 INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest,
 407                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 408                                 Values(cv::Size(1280, 720),
 409                                        cv::Size(640, 480),
 410                                        cv::Size(128, 128)),
 411                                 Values(CV_8U, CV_16U, CV_16S, CV_32F),
 412                                 Values(CORE_CPU),
 413                                 Values(AbsExact().to_compare_obj()),
 414                                 Values(2.5, 1.0, -1.0),
 415                                 Values(250.0, 0.0, -128.0)));
 416
 417 INSTANTIATE_TEST_CASE_P(ConcatHorTestCPU, ConcatHorTest,
 418                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 419                                 Values(cv::Size(1280, 720),
 420                                        cv::Size(640, 480),
 421                                        cv::Size(128, 128)),
 422                                 Values(-1),
 423                                 Values(CORE_CPU)));
 424
 425 INSTANTIATE_TEST_CASE_P(ConcatVertTestCPU, ConcatVertTest,
 426                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 427                                 Values(cv::Size(1280, 720),
 428                                        cv::Size(640, 480),
 429                                        cv::Size(128, 128)),
 430                                 Values(-1),
 431                                 Values(CORE_CPU)));
 432
 433 INSTANTIATE_TEST_CASE_P(ConcatVertVecTestCPU, ConcatVertVecTest,
 434                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 435                                 Values(cv::Size(1280, 720),
 436                                        cv::Size(640, 480),
 437                                        cv::Size(128, 128)),
 438                                 Values(-1),
 439                                 Values(CORE_CPU)));
 440
 441 INSTANTIATE_TEST_CASE_P(ConcatHorVecTestCPU, ConcatHorVecTest,
 442                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 443                                 Values(cv::Size(1280, 720),
 444                                        cv::Size(640, 480),
 445                                        cv::Size(128, 128)),
 446                                 Values(-1),
 447                                 Values(CORE_CPU)));
 448
 449 INSTANTIATE_TEST_CASE_P(WarpPerspectiveTestCPU, WarpPerspectiveTest,
 450                         Combine(Values(CV_8UC1, CV_8UC3),
 451                                 Values(cv::Size(1280, 720),
 452                                        cv::Size(640, 480)),
 453                                 Values(-1),
 454                                 Values(CORE_CPU),
 455                                 Values(AbsExact().to_compare_obj()),
 456                                 Values(-50.0, 90.0),
 457                                 Values(0.6),
 458                                 Values(cv::INTER_LINEAR),
 459                                 Values(cv::BORDER_CONSTANT),
 460                                 Values(cv::Scalar())));
 461
 462 INSTANTIATE_TEST_CASE_P(WarpAffineTestCPU, WarpAffineTest,
 463                         Combine(Values(CV_8UC1, CV_8UC3),
 464                                 Values(cv::Size(1280, 720),
 465                                        cv::Size(640, 480)),
 466                                 Values(-1),
 467                                 Values(CORE_CPU),
 468                                 Values(AbsExact().to_compare_obj()),
 469                                 Values(-50.0, 90.0),
 470                                 Values(0.6),
 471                                 Values(cv::INTER_LINEAR),
 472                                 Values(cv::BORDER_CONSTANT),
 473                                 Values(cv::Scalar())));
 474
 475 INSTANTIATE_TEST_CASE_P(NormalizeTestCPU, NormalizeTest,
 476                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
 477                                 Values(cv::Size(1280, 720),
 478                                        cv::Size(640, 480)),
 479                                 Values(-1),
 480                                 Values(CORE_CPU),
 481                                 Values(AbsExact().to_compare_obj()),
 482                                 Values(0.0, 15.0),
 483                                 Values(1.0, 120.0, 255.0),
 484                                 Values(NORM_MINMAX, NORM_INF, NORM_L1, NORM_L2),
 485                                 Values(-1, CV_8U, CV_16U, CV_16S, CV_32F)));
 486
 487 // PLEASE DO NOT PUT NEW ACCURACY TESTS BELOW THIS POINT! //////////////////////
 488
 489 INSTANTIATE_TEST_CASE_P(BackendOutputAllocationTestCPU, BackendOutputAllocationTest,
 490                         Combine(Values(CV_8UC3, CV_16SC2, CV_32FC1),
 491                                 Values(cv::Size(50, 50)),
 492                                 Values(-1),
 493                                 Values(CORE_CPU)));
 494
 495 INSTANTIATE_TEST_CASE_P(BackendOutputAllocationLargeSizeWithCorrectSubmatrixTestCPU,
 496                         BackendOutputAllocationLargeSizeWithCorrectSubmatrixTest,
 497                         Combine(Values(CV_8UC3, CV_16SC2, CV_32FC1),
 498                                 Values(cv::Size(50, 50)),
 499                                 Values(-1),
 500                                 Values(CORE_CPU)));
 501
 502 INSTANTIATE_TEST_CASE_P(ReInitOutTestCPU, ReInitOutTest,
 503                         Combine(Values(CV_8UC3, CV_16SC4, CV_32FC1),
 504                                 Values(cv::Size(640, 480)),
 505                                 Values(-1),
 506                                 Values(CORE_CPU),
 507                                 Values(cv::Size(640, 400),
 508                                        cv::Size(10, 480))));
 509
 510 INSTANTIATE_TEST_CASE_P(ParseTestCPU, ParseSSDBLTest,
 511                         Combine(Values(CV_8UC1, CV_8UC3, CV_32FC1),
 512                                 Values(cv::Size(1920, 1080)),
 513                                 Values(-1),
 514                                 Values(CORE_CPU),
 515                                 Values(0.3f, 0.5f, 0.7f),
 516                                 Values(-1, 0, 1)));
 517
 518 INSTANTIATE_TEST_CASE_P(ParseTestCPU, ParseSSDTest,
 519                         Combine(Values(CV_8UC1, CV_8UC3, CV_32FC1),
 520                                 Values(cv::Size(1920, 1080)),
 521                                 Values(-1),
 522                                 Values(CORE_CPU),
 523                                 Values(0.3f, 0.5f, 0.7f),
 524                                 testing::Bool(),
 525                                 testing::Bool()));
 526
 527 INSTANTIATE_TEST_CASE_P(ParseTestCPU, ParseYoloTest,
 528                         Combine(Values(CV_8UC1, CV_8UC3, CV_32FC1),
 529                                 Values(cv::Size(1920, 1080)),
 530                                 Values(-1),
 531                                 Values(CORE_CPU),
 532                                 Values(0.3f, 0.5f, 0.7f),
 533                                 Values(0.5f, 1.0f),
 534                                 Values(80, 7)));
 535
 536 INSTANTIATE_TEST_CASE_P(SizeTestCPU, SizeTest,
 537                         Combine(Values(CV_8UC1, CV_8UC3, CV_32FC1),
 538                                 Values(cv::Size(32, 32),
 539                                        cv::Size(640, 320)),
 540                                 Values(-1),
 541                                 Values(CORE_CPU)));
 542
 543 INSTANTIATE_TEST_CASE_P(SizeRTestCPU, SizeRTest,
 544                         Combine(Values(CV_8UC1, CV_8UC3, CV_32FC1),
 545                                 Values(cv::Size(32, 32),
 546                                        cv::Size(640, 320)),
 547                                 Values(-1),
 548                                 Values(CORE_CPU)));
 549 }