inference-engine/thirdparty/fluid/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-2019 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 #define CORE_CPU cv::gapi::core::cpu::kernels()
  13
  14 namespace opencv_test
  15 {
  16
  17
  18 // FIXME: Wut? See MulTestCPU/MathOpTest below (duplicate?)
  19 INSTANTIATE_TEST_CASE_P(AddTestCPU, MathOpTest,
  20                         Combine(Values(ADD, MUL),
  21                                 testing::Bool(),
  22                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  23                                 Values(1.0),
  24                                 Values(cv::Size(1280, 720),
  25                                        cv::Size(640, 480),
  26                                        cv::Size(128, 128)),
  27                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  28     /*init output matrices or not*/ testing::Bool(),
  29                                 Values(false),
  30                                 Values(cv::compile_args(CORE_CPU))),
  31                         opencv_test::PrintMathOpCoreParams());
  32
  33 INSTANTIATE_TEST_CASE_P(MulTestCPU, MathOpTest,
  34                         Combine(Values(MUL),
  35                                 testing::Bool(),
  36                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  37                                 Values(1.0, 0.5, 2.0),
  38                                 Values(cv::Size(1280, 720),
  39                                        cv::Size(640, 480),
  40                                        cv::Size(128, 128)),
  41                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  42     /*init output matrices or not*/ testing::Bool(),
  43                                 Values(false),
  44                                 Values(cv::compile_args(CORE_CPU))),
  45                         opencv_test::PrintMathOpCoreParams());
  46
  47 INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest,
  48                         Combine(Values(SUB),
  49                                 testing::Bool(),
  50                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  51                                 Values (1.0),
  52                                 Values(cv::Size(1280, 720),
  53                                        cv::Size(640, 480),
  54                                        cv::Size(128, 128)),
  55                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  56     /*init output matrices or not*/ testing::Bool(),
  57                                 testing::Bool(),
  58                                 Values(cv::compile_args(CORE_CPU))),
  59                         opencv_test::PrintMathOpCoreParams());
  60
  61 INSTANTIATE_TEST_CASE_P(DivTestCPU, MathOpTest,
  62                         Combine(Values(DIV),
  63                                 testing::Bool(),
  64                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  65                                 Values (1.0, 0.5, 2.0),
  66                                 Values(cv::Size(1280, 720),
  67                                        cv::Size(640, 480),
  68                                        cv::Size(128, 128)),
  69                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  70     /*init output matrices or not*/ testing::Bool(),
  71                                 testing::Bool(),
  72                                 Values(cv::compile_args(CORE_CPU))),
  73                         opencv_test::PrintMathOpCoreParams());
  74
  75 INSTANTIATE_TEST_CASE_P(MulTestCPU, MulDoubleTest,
  76                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  77                                 Values(cv::Size(1280, 720),
  78                                        cv::Size(640, 480),
  79                                        cv::Size(128, 128)),
  80                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  81     /*init output matrices or not*/ testing::Bool(),
  82                                 Values(cv::compile_args(CORE_CPU))));
  83
  84 INSTANTIATE_TEST_CASE_P(DivTestCPU, DivTest,
  85                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
  86                                 Values(cv::Size(1280, 720),
  87                                        cv::Size(640, 480),
  88                                        cv::Size(128, 128)),
  89                                 Values( -1, CV_8U, CV_16U, CV_32F ),
  90     /*init output matrices or not*/ testing::Bool(),
  91                                 Values(cv::compile_args(CORE_CPU))));
  92
  93 INSTANTIATE_TEST_CASE_P(DivCTestCPU, DivCTest,
  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, CV_8U, CV_16U, CV_32F ),
  99     /*init output matrices or not*/ testing::Bool(),
 100                                 Values(cv::compile_args(CORE_CPU))));
 101
 102 INSTANTIATE_TEST_CASE_P(MeanTestCPU, MeanTest,
 103                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 104                                 Values(cv::Size(1280, 720),
 105                                        cv::Size(640, 480),
 106                                        cv::Size(128, 128)),
 107     /*init output matrices or not*/ testing::Bool(),
 108                                 Values(cv::compile_args(CORE_CPU))));
 109
 110 INSTANTIATE_TEST_CASE_P(MaskTestCPU, 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_CPU))));
 117
 118 INSTANTIATE_TEST_CASE_P(SelectTestCPU, SelectTest,
 119                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 120                                 Values(cv::Size(1280, 720),
 121                                        cv::Size(640, 480),
 122                                        cv::Size(128, 128)),
 123 /*init output matrices or not*/ testing::Bool(),
 124                                 Values(cv::compile_args(CORE_CPU))));
 125
 126 INSTANTIATE_TEST_CASE_P(Polar2CartCPU, Polar2CartTest,
 127                         Combine(Values(cv::Size(1280, 720),
 128                                        cv::Size(640, 480),
 129                                        cv::Size(128, 128)),
 130 /*init output matrices or not*/ testing::Bool(),
 131                                 Values(cv::compile_args(CORE_CPU))));
 132
 133 INSTANTIATE_TEST_CASE_P(Cart2PolarCPU, Cart2PolarTest,
 134                         Combine(Values(cv::Size(1280, 720),
 135                                        cv::Size(640, 480),
 136                                        cv::Size(128, 128)),
 137 /*init output matrices or not*/ testing::Bool(),
 138                                 Values(cv::compile_args(CORE_CPU))));
 139
 140 INSTANTIATE_TEST_CASE_P(PhaseCPU, PhaseTest,
 141                         Combine(Values(CV_32F, CV_32FC3),
 142                                 Values(cv::Size(1280, 720),
 143                                        cv::Size(640, 480),
 144                                        cv::Size(128, 128)),
 145                                 testing::Bool(),
 146                                 Values(cv::compile_args(CORE_CPU))));
 147
 148 INSTANTIATE_TEST_CASE_P(SqrtCPU, SqrtTest,
 149                         Combine(Values(CV_32F, CV_32FC3),
 150                                 Values(cv::Size(1280, 720),
 151                                        cv::Size(640, 480),
 152                                        cv::Size(128, 128)),
 153                                 Values(cv::compile_args(CORE_CPU))));
 154
 155 INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest,
 156                         Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
 157                                 testing::Bool(),
 158                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 159                                 Values(cv::Size(1280, 720),
 160                                        cv::Size(640, 480),
 161                                        cv::Size(128, 128)),
 162 /*init output matrices or not*/ testing::Bool(),
 163                                 Values(cv::compile_args(CORE_CPU))),
 164                         opencv_test::PrintCmpCoreParams());
 165
 166 INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
 167                         Combine(Values(AND, OR, XOR),
 168                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
 169                                 Values(cv::Size(1280, 720),
 170                                        cv::Size(640, 480),
 171                                        cv::Size(128, 128)),
 172 /*init output matrices or not*/ testing::Bool(),
 173                                 Values(cv::compile_args(CORE_CPU))),
 174                         opencv_test::PrintBWCoreParams());
 175
 176 INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest,
 177                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 178                                 Values(cv::Size(1280, 720),
 179                                        cv::Size(640, 480),
 180                                        cv::Size(128, 128)),
 181  /*init output matrices or not*/ testing::Bool(),
 182                                 Values(cv::compile_args(CORE_CPU))));
 183
 184 INSTANTIATE_TEST_CASE_P(MinTestCPU, MinTest,
 185                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 186                                 Values(cv::Size(1280, 720),
 187                                        cv::Size(640, 480),
 188                                        cv::Size(128, 128)),
 189 /*init output matrices or not*/ testing::Bool(),
 190                                 Values(cv::compile_args(CORE_CPU))));
 191
 192 INSTANTIATE_TEST_CASE_P(MaxTestCPU, MaxTest,
 193                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 194                                 Values(cv::Size(1280, 720),
 195                                        cv::Size(640, 480),
 196                                        cv::Size(128, 128)),
 197 /*init output matrices or not*/ testing::Bool(),
 198                                 Values(cv::compile_args(CORE_CPU))));
 199
 200 INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
 201                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 202                                 Values(cv::Size(1280, 720),
 203                                        cv::Size(640, 480),
 204                                        cv::Size(128, 128)),
 205 /*init output matrices or not*/ testing::Bool(),
 206                                 //Values(1e-5),
 207                                 Values(AbsToleranceScalar(1e-5).to_compare_f()),
 208                                 Values(cv::compile_args(CORE_CPU))));
 209
 210 INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest,
 211                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 212                                 Values(cv::Size(1280, 720),
 213                                        cv::Size(640, 480),
 214                                        cv::Size(128, 128)),
 215 /*init output matrices or not*/ testing::Bool(),
 216                                 Values(cv::compile_args(CORE_CPU))));
 217
 218 INSTANTIATE_TEST_CASE_P(AbsDiffCTestCPU, AbsDiffCTest,
 219                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 220                                 Values(cv::Size(1280, 720),
 221                                        cv::Size(640, 480),
 222                                        cv::Size(128, 128)),
 223 /*init output matrices or not*/ testing::Bool(),
 224                                 Values(cv::compile_args(CORE_CPU))));
 225
 226 INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest,
 227                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 228                                 Values(cv::Size(1280, 720),
 229                                        cv::Size(640, 480),
 230                                        cv::Size(128, 128)),
 231                                 Values( -1, CV_8U, CV_16U, CV_32F ),
 232 /*init output matrices or not*/ testing::Bool(),
 233                                 Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()),
 234                                 Values(cv::compile_args(CORE_CPU))));
 235
 236 INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
 237                         Combine(Values(NORM_INF, NORM_L1, NORM_L2),
 238                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 239                                 Values(cv::Size(1280, 720),
 240                                        cv::Size(640, 480),
 241                                        cv::Size(128, 128)),
 242                                 //Values(1e-5),
 243                                 Values(AbsToleranceScalar(1e-5).to_compare_f()),
 244                                 Values(cv::compile_args(CORE_CPU))),
 245                         opencv_test::PrintNormCoreParams());
 246
 247 INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest,
 248                         Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
 249                                 Values(cv::Size(1280, 720),
 250                                        cv::Size(640, 480),
 251                                        cv::Size(128, 128)),
 252                                 Values(cv::compile_args(CORE_CPU))));
 253
 254 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest,
 255                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 256                                 Values(cv::Size(1280, 720),
 257                                        cv::Size(640, 480),
 258                                        cv::Size(128, 128)),
 259                                 Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV),
 260 /*init output matrices or not*/ testing::Bool(),
 261                                 Values(cv::compile_args(CORE_CPU))));
 262
 263 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdOTTest,
 264                         Combine(Values(CV_8UC1),
 265                                 Values(cv::Size(1280, 720),
 266                                        cv::Size(640, 480),
 267                                        cv::Size(128, 128)),
 268                                 Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE),
 269 /*init output matrices or not*/ testing::Bool(),
 270                                 Values(cv::compile_args(CORE_CPU))));
 271
 272
 273 INSTANTIATE_TEST_CASE_P(InRangeTestCPU, InRangeTest,
 274                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
 275                                 Values(cv::Size(1280, 720),
 276                                        cv::Size(640, 480),
 277                                        cv::Size(128, 128)),
 278 /*init output matrices or not*/ testing::Bool(),
 279                                 Values(cv::compile_args(CORE_CPU))));
 280
 281 INSTANTIATE_TEST_CASE_P(Split3TestCPU, Split3Test,
 282                         Combine(Values(cv::Size(1280, 720),
 283                                        cv::Size(640, 480),
 284                                        cv::Size(128, 128)),
 285                                 Values(cv::compile_args(CORE_CPU))));
 286
 287 INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test,
 288                         Combine(Values(cv::Size(1280, 720),
 289                                        cv::Size(640, 480),
 290                                        cv::Size(128, 128)),
 291                                 Values(cv::compile_args(CORE_CPU))));
 292
 293 INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest,
 294                         Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
 295                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 296                                 Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
 297                                 Values(cv::Size(1280, 720),
 298                                        cv::Size(640, 480),
 299                                        cv::Size(128, 128)),
 300                                 Values(cv::Size(64,64),
 301                                        cv::Size(30,30)),
 302                                 Values(cv::compile_args(CORE_CPU))));
 303
 304 INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy,
 305                         Combine(Values(AbsSimilarPoints(2, 0.05).to_compare_f()),
 306                                 Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 307                                 Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
 308                                 Values(cv::Size(1280, 720),
 309                                        cv::Size(640, 480),
 310                                        cv::Size(128, 128)),
 311                                 Values(0.5, 0.1),
 312                                 Values(0.5, 0.1),
 313                                 Values(cv::compile_args(CORE_CPU))));
 314
 315 INSTANTIATE_TEST_CASE_P(Merge3TestCPU, Merge3Test,
 316                         Combine(Values(cv::Size(1280, 720),
 317                                        cv::Size(640, 480),
 318                                        cv::Size(128, 128)),
 319                                 Values(cv::compile_args(CORE_CPU))));
 320
 321 INSTANTIATE_TEST_CASE_P(Merge4TestCPU, Merge4Test,
 322                         Combine(Values(cv::Size(1280, 720),
 323                                        cv::Size(640, 480),
 324                                        cv::Size(128, 128)),
 325                                 Values(cv::compile_args(CORE_CPU))));
 326
 327 INSTANTIATE_TEST_CASE_P(RemapTestCPU, RemapTest,
 328                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 329                                 Values(cv::Size(1280, 720),
 330                                        cv::Size(640, 480),
 331                                        cv::Size(128, 128)),
 332 /*init output matrices or not*/ testing::Bool(),
 333                                 Values(cv::compile_args(CORE_CPU))));
 334
 335 INSTANTIATE_TEST_CASE_P(FlipTestCPU, FlipTest,
 336                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 337                                 Values(0,1,-1),
 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                                 Values(cv::compile_args(CORE_CPU))));
 343
 344 INSTANTIATE_TEST_CASE_P(CropTestCPU, CropTest,
 345                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 346                                 Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)),
 347                                 Values(cv::Size(1280, 720),
 348                                        cv::Size(640, 480),
 349                                        cv::Size(128, 128)),
 350 /*init output matrices or not*/ testing::Bool(),
 351                                 Values(cv::compile_args(CORE_CPU))));
 352
 353 INSTANTIATE_TEST_CASE_P(LUTTestCPU, LUTTest,
 354                         Combine(Values(CV_8UC1, CV_8UC3),
 355                                 Values(CV_8UC1),
 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                                 Values(cv::compile_args(CORE_CPU))));
 361
 362 INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest,
 363                         Combine(Values(CV_8UC3),
 364                                 Values(CV_8UC3),
 365                                 Values(cv::Size(1280, 720),
 366                                        cv::Size(640, 480),
 367                                        cv::Size(128, 128)),
 368 /*init output matrices or not*/ testing::Bool(),
 369                                 Values(cv::compile_args(CORE_CPU))));
 370
 371 INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest,
 372                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 373                                 Values(CV_8U, CV_16U, CV_16S, CV_32F),
 374                                 Values(cv::Size(1280, 720),
 375                                        cv::Size(640, 480),
 376                                        cv::Size(128, 128)),
 377                                 Values(cv::compile_args(CORE_CPU))));
 378
 379 INSTANTIATE_TEST_CASE_P(ConcatHorTestCPU, ConcatHorTest,
 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_CPU))));
 385
 386 INSTANTIATE_TEST_CASE_P(ConcatVertTestCPU, ConcatVertTest,
 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_CPU))));
 392
 393 INSTANTIATE_TEST_CASE_P(ConcatVertVecTestCPU, ConcatVertVecTest,
 394                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 395                                 Values(cv::Size(1280, 720),
 396                                        cv::Size(640, 480),
 397                                        cv::Size(128, 128)),
 398                                 Values(cv::compile_args(CORE_CPU))));
 399
 400 INSTANTIATE_TEST_CASE_P(ConcatHorVecTestCPU, ConcatHorVecTest,
 401                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 402                                 Values(cv::Size(1280, 720),
 403                                        cv::Size(640, 480),
 404                                        cv::Size(128, 128)),
 405                                 Values(cv::compile_args(CORE_CPU))));
 406 }