inference-engine/thirdparty/fluid/modules/gapi/test/gpu/gapi_core_tests_gpu.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 #define CORE_GPU cv::gapi::core::gpu::kernels()
  12
  13 namespace opencv_test
  14 {
  15
  16 // FIXME: Wut? See MulTestGPU/MathOpTest below (duplicate?)
  17 INSTANTIATE_TEST_CASE_P(AddTestGPU, MathOpTest,
  18                         Combine(Values(ADD, MUL),
  19                                 testing::Bool(),
  20                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  21                                 Values(1.0),
  22                                 Values(cv::Size(1280, 720),
  23                                        cv::Size(640, 480),
  24                                        cv::Size(128, 128)),
  25                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  26     /*init output matrices or not*/ testing::Bool(),
  27                                 Values(false),
  28                                 Values(cv::compile_args(CORE_GPU))),
  29                         opencv_test::PrintMathOpCoreParams());
  30
  31 INSTANTIATE_TEST_CASE_P(MulTestGPU, MathOpTest,
  32                         Combine(Values(MUL),
  33                                 testing::Bool(),
  34                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  35                                 Values(1.0, 0.5, 2.0),
  36                                 Values(cv::Size(1280, 720),
  37                                        cv::Size(640, 480),
  38                                        cv::Size(128, 128)),
  39                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  40     /*init output matrices or not*/ testing::Bool(),
  41                                 Values(false),
  42                                 Values(cv::compile_args(CORE_GPU))),
  43                         opencv_test::PrintMathOpCoreParams());
  44
  45 INSTANTIATE_TEST_CASE_P(SubTestGPU, MathOpTest,
  46                         Combine(Values(SUB),
  47                                 testing::Bool(),
  48                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  49                                 Values (1.0),
  50                                 Values(cv::Size(1280, 720),
  51                                        cv::Size(640, 480),
  52                                        cv::Size(128, 128)),
  53                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  54     /*init output matrices or not*/ testing::Bool(),
  55                                 testing::Bool(),
  56                                 Values(cv::compile_args(CORE_GPU))),
  57                         opencv_test::PrintMathOpCoreParams());
  58
  59 INSTANTIATE_TEST_CASE_P(DivTestGPU, MathOpTest,
  60                         Combine(Values(DIV),
  61                                 testing::Bool(),
  62                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  63                                 Values (1.0, 0.5, 2.0),
  64                                 Values(cv::Size(1280, 720),
  65                                        cv::Size(640, 480),
  66                                        cv::Size(128, 128)),
  67                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  68     /*init output matrices or not*/ testing::Bool(),
  69                                 testing::Bool(),
  70                                 Values(cv::compile_args(CORE_GPU))),
  71                         opencv_test::PrintMathOpCoreParams());
  72
  73 INSTANTIATE_TEST_CASE_P(MulTestGPU, MulDoubleTest,
  74                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  75                                 Values(cv::Size(1280, 720),
  76                                        cv::Size(640, 480),
  77                                        cv::Size(128, 128)),
  78                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  79     /*init output matrices or not*/ testing::Bool(),
  80                                 Values(cv::compile_args(CORE_GPU))));
  81
  82 INSTANTIATE_TEST_CASE_P(DivTestGPU, DivTest,
  83                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  84                                 Values(cv::Size(1280, 720),
  85                                        cv::Size(640, 480),
  86                                        cv::Size(128, 128)),
  87                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  88     /*init output matrices or not*/ testing::Bool(),
  89                                 Values(cv::compile_args(CORE_GPU))));
  90
  91 INSTANTIATE_TEST_CASE_P(DivCTestGPU, DivCTest,
  92                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  93                                 Values(cv::Size(1280, 720),
  94                                        cv::Size(640, 480),
  95                                        cv::Size(128, 128)),
  96                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  97     /*init output matrices or not*/ testing::Bool(),
  98                                 Values(cv::compile_args(CORE_GPU))));
  99
 100 INSTANTIATE_TEST_CASE_P(MeanTestGPU, MeanTest,
 101                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 102                                 Values(cv::Size(1280, 720),
 103                                        cv::Size(640, 480),
 104                                        cv::Size(128, 128)),
 105     /*init output matrices or not*/ testing::Bool(),
 106                                 Values(cv::compile_args(CORE_GPU))));
 107
 108 //TODO: mask test doesn't work
 109 #if 0
 110 INSTANTIATE_TEST_CASE_P(MaskTestGPU, MaskTest,
 111                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 112                                 Values(cv::Size(1280, 720),
 113                                        cv::Size(640, 480),
 114                                        cv::Size(128, 128)),
 115 /*init output matrices or not*/ testing::Bool(),
 116                                 Values(cv::compile_args(CORE_GPU))));
 117 #endif
 118
 119 INSTANTIATE_TEST_CASE_P(SelectTestGPU, SelectTest,
 120                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 121                                 Values(cv::Size(1280, 720),
 122                                        cv::Size(640, 480),
 123                                        cv::Size(128, 128)),
 124 /*init output matrices or not*/ testing::Bool(),
 125                                 Values(cv::compile_args(CORE_GPU))));
 126
 127 INSTANTIATE_TEST_CASE_P(Polar2CartGPU, Polar2CartTest,
 128                         Combine(Values(cv::Size(1280, 720),
 129                                        cv::Size(640, 480),
 130                                        cv::Size(128, 128)),
 131 /*init output matrices or not*/ testing::Bool(),
 132                                 Values(cv::compile_args(CORE_GPU))));
 133
 134 INSTANTIATE_TEST_CASE_P(Cart2PolarGPU, Cart2PolarTest,
 135                         Combine(Values(cv::Size(1280, 720),
 136                                        cv::Size(640, 480),
 137                                        cv::Size(128, 128)),
 138 /*init output matrices or not*/ testing::Bool(),
 139                                 Values(cv::compile_args(CORE_GPU))));
 140
 141 INSTANTIATE_TEST_CASE_P(CompareTestGPU, CmpTest,
 142                         Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
 143                                 testing::Bool(),
 144                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 145                                 Values(cv::Size(1280, 720),
 146                                        cv::Size(640, 480),
 147                                        cv::Size(128, 128)),
 148 /*init output matrices or not*/ testing::Bool(),
 149                                 Values(cv::compile_args(CORE_GPU))),
 150                         opencv_test::PrintCmpCoreParams());
 151
 152 INSTANTIATE_TEST_CASE_P(BitwiseTestGPU, BitwiseTest,
 153                         Combine(Values(AND, OR, XOR),
 154                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
 155                                 Values(cv::Size(1280, 720),
 156                                        cv::Size(640, 480),
 157                                        cv::Size(128, 128)),
 158 /*init output matrices or not*/ testing::Bool(),
 159                                 Values(cv::compile_args(CORE_GPU))),
 160                         opencv_test::PrintBWCoreParams());
 161
 162 INSTANTIATE_TEST_CASE_P(BitwiseNotTestGPU, NotTest,
 163                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 164                                 Values(cv::Size(1280, 720),
 165                                        cv::Size(640, 480),
 166                                        cv::Size(128, 128)),
 167  /*init output matrices or not*/ testing::Bool(),
 168                                 Values(cv::compile_args(CORE_GPU))));
 169
 170 INSTANTIATE_TEST_CASE_P(MinTestGPU, MinTest,
 171                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 172                                 Values(cv::Size(1280, 720),
 173                                        cv::Size(640, 480),
 174                                        cv::Size(128, 128)),
 175 /*init output matrices or not*/ testing::Bool(),
 176                                 Values(cv::compile_args(CORE_GPU))));
 177
 178 INSTANTIATE_TEST_CASE_P(MaxTestGPU, MaxTest,
 179                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 180                                 Values(cv::Size(1280, 720),
 181                                        cv::Size(640, 480),
 182                                        cv::Size(128, 128)),
 183 /*init output matrices or not*/ testing::Bool(),
 184                                 Values(cv::compile_args(CORE_GPU))));
 185
 186 INSTANTIATE_TEST_CASE_P(SumTestGPU, SumTest,
 187                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 188                                 Values(cv::Size(1280, 720),
 189                                        cv::Size(640, 480),
 190                                        cv::Size(128, 128)),
 191 /*init output matrices or not*/ testing::Bool(),
 192                                 Values(AbsToleranceScalar(1e-3).to_compare_f()),//TODO: too relaxed?
 193                                 Values(cv::compile_args(CORE_GPU))));
 194
 195 INSTANTIATE_TEST_CASE_P(AbsDiffTestGPU, AbsDiffTest,
 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 /*init output matrices or not*/ testing::Bool(),
 201                                 Values(cv::compile_args(CORE_GPU))));
 202
 203 INSTANTIATE_TEST_CASE_P(AbsDiffCTestGPU, AbsDiffCTest,
 204                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 205                                 Values(cv::Size(1280, 720),
 206                                        cv::Size(640, 480),
 207                                        cv::Size(128, 128)),
 208 /*init output matrices or not*/ testing::Bool(),
 209                                 Values(cv::compile_args(CORE_GPU))));
 210
 211 INSTANTIATE_TEST_CASE_P(AddWeightedTestGPU, AddWeightedTest,
 212                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 213                                 Values(cv::Size(1280, 720),
 214                                        cv::Size(640, 480),
 215                                        cv::Size(128, 128)),
 216                                 Values( -1, CV_8U, CV_16U, CV_32F ),
 217 /*init output matrices or not*/ testing::Bool(),
 218                                 Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()),
 219                                 Values(cv::compile_args(CORE_GPU))));
 220
 221 INSTANTIATE_TEST_CASE_P(NormTestGPU, NormTest,
 222                         Combine(Values(NORM_INF, NORM_L1, NORM_L2),
 223                                 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(AbsToleranceScalar(1e-3).to_compare_f()), //TODO: too relaxed?
 228                                 Values(cv::compile_args(CORE_GPU))),
 229                         opencv_test::PrintNormCoreParams());
 230
 231 INSTANTIATE_TEST_CASE_P(IntegralTestGPU, IntegralTest,
 232                         Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
 233                                 Values(cv::Size(1280, 720),
 234                                        cv::Size(640, 480),
 235                                        cv::Size(128, 128)),
 236                                 Values(cv::compile_args(CORE_GPU))));
 237
 238 INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdTest,
 239                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 240                                 Values(cv::Size(1280, 720),
 241                                        cv::Size(640, 480),
 242                                        cv::Size(128, 128)),
 243                                 Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV),
 244 /*init output matrices or not*/ testing::Bool(),
 245                                 Values(cv::compile_args(CORE_GPU))));
 246
 247 INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdOTTest,
 248                         Combine(Values(CV_8UC1),
 249                                 Values(cv::Size(1280, 720),
 250                                        cv::Size(640, 480),
 251                                        cv::Size(128, 128)),
 252                                 Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE),
 253 /*init output matrices or not*/ testing::Bool(),
 254                                 Values(cv::compile_args(CORE_GPU))));
 255
 256
 257 INSTANTIATE_TEST_CASE_P(InRangeTestGPU, InRangeTest,
 258                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 259                                 Values(cv::Size(1280, 720),
 260                                        cv::Size(640, 480),
 261                                        cv::Size(128, 128)),
 262 /*init output matrices or not*/ testing::Bool(),
 263                                 Values(cv::compile_args(CORE_GPU))));
 264
 265 INSTANTIATE_TEST_CASE_P(Split3TestGPU, Split3Test,
 266                         Combine(Values(cv::Size(1280, 720),
 267                                        cv::Size(640, 480),
 268                                        cv::Size(128, 128)),
 269                                 Values(cv::compile_args(CORE_GPU))));
 270
 271 INSTANTIATE_TEST_CASE_P(Split4TestGPU, Split4Test,
 272                         Combine(Values(cv::Size(1280, 720),
 273                                        cv::Size(640, 480),
 274                                        cv::Size(128, 128)),
 275                                 Values(cv::compile_args(CORE_GPU))));
 276
 277 INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTest,
 278                         Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
 279                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 280                                 Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
 281                                 Values(cv::Size(1280, 720),
 282                                        cv::Size(640, 480),
 283                                        cv::Size(128, 128)),
 284                                 Values(cv::Size(64,64),
 285                                        cv::Size(30,30)),
 286                                 Values(cv::compile_args(CORE_GPU))));
 287
 288 INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTestFxFy,
 289                         Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
 290                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 291                                 Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
 292                                 Values(cv::Size(1280, 720),
 293                                        cv::Size(640, 480),
 294                                        cv::Size(128, 128)),
 295                                 Values(0.5, 0.1),
 296                                 Values(0.5, 0.1),
 297                                 Values(cv::compile_args(CORE_GPU))));
 298
 299 INSTANTIATE_TEST_CASE_P(Merge3TestGPU, Merge3Test,
 300                         Combine(Values(cv::Size(1280, 720),
 301                                        cv::Size(640, 480),
 302                                        cv::Size(128, 128)),
 303                                 Values(cv::compile_args(CORE_GPU))));
 304
 305 INSTANTIATE_TEST_CASE_P(Merge4TestGPU, Merge4Test,
 306                         Combine(Values(cv::Size(1280, 720),
 307                                        cv::Size(640, 480),
 308                                        cv::Size(128, 128)),
 309                                 Values(cv::compile_args(CORE_GPU))));
 310
 311 INSTANTIATE_TEST_CASE_P(RemapTestGPU, RemapTest,
 312                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 313                                 Values(cv::Size(1280, 720),
 314                                        cv::Size(640, 480),
 315                                        cv::Size(128, 128)),
 316 /*init output matrices or not*/ testing::Bool(),
 317                                 Values(cv::compile_args(CORE_GPU))));
 318
 319 INSTANTIATE_TEST_CASE_P(FlipTestGPU, FlipTest,
 320                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 321                                 Values(0,1,-1),
 322                                 Values(cv::Size(1280, 720),
 323                                        cv::Size(640, 480),
 324                                        cv::Size(128, 128)),
 325 /*init output matrices or not*/ testing::Bool(),
 326                                 Values(cv::compile_args(CORE_GPU))));
 327
 328 INSTANTIATE_TEST_CASE_P(CropTestGPU, CropTest,
 329                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 330                                 Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)),
 331                                 Values(cv::Size(1280, 720),
 332                                        cv::Size(640, 480),
 333                                        cv::Size(128, 128)),
 334 /*init output matrices or not*/ testing::Bool(),
 335                                 Values(cv::compile_args(CORE_GPU))));
 336
 337 INSTANTIATE_TEST_CASE_P(LUTTestGPU, LUTTest,
 338                         Combine(Values(CV_8UC1, CV_8UC3),
 339                                 Values(CV_8UC1),
 340                                 Values(cv::Size(1280, 720),
 341                                        cv::Size(640, 480),
 342                                        cv::Size(128, 128)),
 343 /*init output matrices or not*/ testing::Bool(),
 344                                 Values(cv::compile_args(CORE_GPU))));
 345
 346 INSTANTIATE_TEST_CASE_P(LUTTestCustomGPU, LUTTest,
 347                         Combine(Values(CV_8UC3),
 348                                 Values(CV_8UC3),
 349                                 Values(cv::Size(1280, 720),
 350                                        cv::Size(640, 480),
 351                                        cv::Size(128, 128)),
 352 /*init output matrices or not*/ testing::Bool(),
 353                                 Values(cv::compile_args(CORE_GPU))));
 354
 355 INSTANTIATE_TEST_CASE_P(ConvertToGPU, ConvertToTest,
 356                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 357                                 Values(CV_8U, CV_16U, CV_16S, CV_32F),
 358                                 Values(cv::Size(1280, 720),
 359                                        cv::Size(640, 480),
 360                                        cv::Size(128, 128)),
 361                                 Values(cv::compile_args(CORE_GPU))));
 362
 363 INSTANTIATE_TEST_CASE_P(ConcatHorTestGPU, ConcatHorTest,
 364                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 365                                 Values(cv::Size(1280, 720),
 366                                        cv::Size(640, 480),
 367                                        cv::Size(128, 128)),
 368                                 Values(cv::compile_args(CORE_GPU))));
 369
 370 INSTANTIATE_TEST_CASE_P(ConcatVertTestGPU, ConcatVertTest,
 371                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 372                                 Values(cv::Size(1280, 720),
 373                                        cv::Size(640, 480),
 374                                        cv::Size(128, 128)),
 375                                 Values(cv::compile_args(CORE_GPU))));
 376
 377 //TODO: fix this backend to allow ConcatVertVec ConcatHorVec
 378 #if 0
 379 INSTANTIATE_TEST_CASE_P(ConcatVertVecTestGPU, ConcatVertVecTest,
 380                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 381                                 Values(cv::Size(1280, 720),
 382                                        cv::Size(640, 480),
 383                                        cv::Size(128, 128)),
 384                                 Values(cv::compile_args(CORE_GPU))));
 385
 386 INSTANTIATE_TEST_CASE_P(ConcatHorVecTestGPU, ConcatHorVecTest,
 387                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 388                                 Values(cv::Size(1280, 720),
 389                                        cv::Size(640, 480),
 390                                        cv::Size(128, 128)),
 391                                 Values(cv::compile_args(CORE_GPU))));
 392 #endif
 393 }