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 namespace
  13 {
  14 #define CORE_CPU [] () { return cv::compile_args(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
 160 INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
 161                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
 162                                 Values(cv::Size(1280, 720),
 163                                        cv::Size(640, 480),
 164                                        cv::Size(128, 128)),
 165                                 Values(-1),
 166                                 Values(CORE_CPU),
 167                                 Values(AND, OR, XOR)));
 168
 169 INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest,
 170                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 171                                 Values(cv::Size(1280, 720),
 172                                        cv::Size(640, 480),
 173                                        cv::Size(128, 128)),
 174                                 Values(-1),
 175                                 Values(CORE_CPU)));
 176
 177 INSTANTIATE_TEST_CASE_P(MinTestCPU, MinTest,
 178                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 179                                 Values(cv::Size(1280, 720),
 180                                        cv::Size(640, 480),
 181                                        cv::Size(128, 128)),
 182                                 Values(-1),
 183                                 Values(CORE_CPU)));
 184
 185 INSTANTIATE_TEST_CASE_P(MaxTestCPU, MaxTest,
 186                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 187                                 Values(cv::Size(1280, 720),
 188                                        cv::Size(640, 480),
 189                                        cv::Size(128, 128)),
 190                                 Values(-1),
 191                                 Values(CORE_CPU)));
 192
 193 INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
 194                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 195                                 Values(cv::Size(1280, 720),
 196                                        cv::Size(640, 480),
 197                                        cv::Size(128, 128)),
 198                                 Values(-1),
 199                                 //Values(1e-5),
 200                                 Values(CORE_CPU),
 201                                 Values(AbsToleranceScalar(1e-5).to_compare_obj())));
 202
 203 INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest,
 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                                 Values(-1),
 209                                 Values(CORE_CPU)));
 210
 211 INSTANTIATE_TEST_CASE_P(AbsDiffCTestCPU, AbsDiffCTest,
 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),
 217                                 Values(CORE_CPU)));
 218
 219 INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest,
 220                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 221                                 Values(cv::Size(1280, 720),
 222                                        cv::Size(640, 480),
 223                                        cv::Size(128, 128)),
 224                                 Values( -1, CV_8U, CV_16U, CV_32F ),
 225                                 Values(CORE_CPU),
 226                                 Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_obj())));
 227
 228 INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
 229                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 230                                 Values(cv::Size(1280, 720),
 231                                        cv::Size(640, 480),
 232                                        cv::Size(128, 128)),
 233                                 Values(-1),
 234                                 Values(CORE_CPU),
 235                                 Values(AbsToleranceScalar(1e-5).to_compare_obj()),
 236                                 Values(NORM_INF, NORM_L1, NORM_L2)));
 237
 238 INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest,
 239                         Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
 240                                 Values(cv::Size(1280, 720),
 241                                        cv::Size(640, 480),
 242                                        cv::Size(128, 128)),
 243                                 Values(-1),
 244                                 Values(CORE_CPU)));
 245
 246 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest,
 247                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 248                                 Values(cv::Size(1280, 720),
 249                                        cv::Size(640, 480),
 250                                        cv::Size(128, 128)),
 251                                 Values(-1),
 252                                 Values(CORE_CPU),
 253                                 Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC,
 254                                     cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)));
 255
 256 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdOTTest,
 257                         Combine(Values(CV_8UC1),
 258                                 Values(cv::Size(1280, 720),
 259                                        cv::Size(640, 480),
 260                                        cv::Size(128, 128)),
 261                                 Values(-1),
 262                                 Values(CORE_CPU),
 263                                 Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
 264
 265
 266 INSTANTIATE_TEST_CASE_P(InRangeTestCPU, InRangeTest,
 267                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
 268                                 Values(cv::Size(1280, 720),
 269                                        cv::Size(640, 480),
 270                                        cv::Size(128, 128)),
 271                                 Values(-1),
 272                                 Values(CORE_CPU)));
 273
 274 INSTANTIATE_TEST_CASE_P(Split3TestCPU, Split3Test,
 275                         Combine(Values(CV_8UC3),
 276                                 Values(cv::Size(1280, 720),
 277                                        cv::Size(640, 480),
 278                                        cv::Size(128, 128)),
 279                                 Values(CV_8UC1),
 280                                 Values(CORE_CPU)));
 281
 282 INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test,
 283                         Combine(Values(CV_8UC4),
 284                                 Values(cv::Size(1280, 720),
 285                                        cv::Size(640, 480),
 286                                        cv::Size(128, 128)),
 287                                 Values(CV_8UC1),
 288                                 Values(CORE_CPU)));
 289
 290 INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest,
 291                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 292                                 Values(cv::Size(1280, 720),
 293                                        cv::Size(640, 480),
 294                                        cv::Size(128, 128)),
 295                                 Values(-1),
 296                                 Values(CORE_CPU),
 297                                 Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
 298                                 Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
 299                                 Values(cv::Size(64,64),
 300                                        cv::Size(30,30))));
 301
 302 INSTANTIATE_TEST_CASE_P(ResizePTestCPU, ResizePTest,
 303                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 304                                 Values(cv::Size(1280, 720),
 305                                        cv::Size(640, 480),
 306                                        cv::Size(128, 128)),
 307                                 Values(-1),
 308                                 Values(CORE_CPU),
 309                                 Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
 310                                 Values(cv::INTER_LINEAR),
 311                                 Values(cv::Size(64,64),
 312                                        cv::Size(30,30))));
 313
 314 INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy,
 315                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 316                                 Values(cv::Size(1280, 720),
 317                                        cv::Size(640, 480),
 318                                        cv::Size(128, 128)),
 319                                 Values(-1),
 320                                 Values(CORE_CPU),
 321                                 Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
 322                                 Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
 323                                 Values(0.5, 0.1),
 324                                 Values(0.5, 0.1)));
 325
 326 INSTANTIATE_TEST_CASE_P(Merge3TestCPU, Merge3Test,
 327                         Combine(Values(CV_8UC1),
 328                                 Values(cv::Size(1280, 720),
 329                                        cv::Size(640, 480),
 330                                        cv::Size(128, 128)),
 331                                 Values(CV_8UC3),
 332                                 Values(CORE_CPU)));
 333
 334 INSTANTIATE_TEST_CASE_P(Merge4TestCPU, Merge4Test,
 335                         Combine(Values(CV_8UC1),
 336                                 Values(cv::Size(1280, 720),
 337                                        cv::Size(640, 480),
 338                                        cv::Size(128, 128)),
 339                                 Values(CV_8UC4),
 340                                 Values(CORE_CPU)));
 341
 342 INSTANTIATE_TEST_CASE_P(RemapTestCPU, RemapTest,
 343                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 344                                 Values(cv::Size(1280, 720),
 345                                        cv::Size(640, 480),
 346                                        cv::Size(128, 128)),
 347                                 Values(-1),
 348                                 Values(CORE_CPU)));
 349
 350 INSTANTIATE_TEST_CASE_P(FlipTestCPU, FlipTest,
 351                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 352                                 Values(cv::Size(1280, 720),
 353                                        cv::Size(640, 480),
 354                                        cv::Size(128, 128)),
 355                                 Values(-1),
 356                                 Values(CORE_CPU),
 357                                 Values(0,1,-1)));
 358
 359 INSTANTIATE_TEST_CASE_P(CropTestCPU, CropTest,
 360                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 361                                 Values(cv::Size(1280, 720),
 362                                        cv::Size(640, 480),
 363                                        cv::Size(128, 128)),
 364                                 Values(-1),
 365                                 Values(CORE_CPU),
 366                                 Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
 367
 368 INSTANTIATE_TEST_CASE_P(LUTTestCPU, LUTTest,
 369                         Combine(Values(CV_8UC1, CV_8UC3),
 370                                 Values(cv::Size(1280, 720),
 371                                        cv::Size(640, 480),
 372                                        cv::Size(128, 128)),
 373                                 Values(CV_8UC1),
 374                                 Values(CORE_CPU)));
 375
 376 INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest,
 377                         Combine(Values(CV_8UC3),
 378                                 Values(cv::Size(1280, 720),
 379                                        cv::Size(640, 480),
 380                                        cv::Size(128, 128)),
 381                                 Values(CV_8UC3),
 382                                 Values(CORE_CPU)));
 383
 384 INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest,
 385                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 386                                 Values(cv::Size(1280, 720),
 387                                        cv::Size(640, 480),
 388                                        cv::Size(128, 128)),
 389                                 Values(CV_8U, CV_16U, CV_16S, CV_32F),
 390                                 Values(CORE_CPU),
 391                                 Values(AbsExact().to_compare_obj()),
 392                                 Values(2.5, 1.0, -1.0),
 393                                 Values(250.0, 0.0, -128.0)));
 394
 395 INSTANTIATE_TEST_CASE_P(ConcatHorTestCPU, ConcatHorTest,
 396                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 397                                 Values(cv::Size(1280, 720),
 398                                        cv::Size(640, 480),
 399                                        cv::Size(128, 128)),
 400                                 Values(-1),
 401                                 Values(CORE_CPU)));
 402
 403 INSTANTIATE_TEST_CASE_P(ConcatVertTestCPU, ConcatVertTest,
 404                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 405                                 Values(cv::Size(1280, 720),
 406                                        cv::Size(640, 480),
 407                                        cv::Size(128, 128)),
 408                                 Values(-1),
 409                                 Values(CORE_CPU)));
 410
 411 INSTANTIATE_TEST_CASE_P(ConcatVertVecTestCPU, ConcatVertVecTest,
 412                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 413                                 Values(cv::Size(1280, 720),
 414                                        cv::Size(640, 480),
 415                                        cv::Size(128, 128)),
 416                                 Values(-1),
 417                                 Values(CORE_CPU)));
 418
 419 INSTANTIATE_TEST_CASE_P(ConcatHorVecTestCPU, ConcatHorVecTest,
 420                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
 421                                 Values(cv::Size(1280, 720),
 422                                        cv::Size(640, 480),
 423                                        cv::Size(128, 128)),
 424                                 Values(-1),
 425                                 Values(CORE_CPU)));
 426
 427 INSTANTIATE_TEST_CASE_P(NormalizeTestCPU, NormalizeTest,
 428                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
 429                                 Values(cv::Size(1280, 720),
 430                                        cv::Size(640, 480)),
 431                                 Values(-1),
 432                                 Values(CORE_CPU),
 433                                 Values(AbsExact().to_compare_obj()),
 434                                 Values(0.0, 15.0),
 435                                 Values(1.0, 120.0, 255.0),
 436                                 Values(NORM_MINMAX, NORM_INF, NORM_L1, NORM_L2),
 437                                 Values(-1, CV_8U, CV_16U, CV_16S, CV_32F)));
 438
 439 INSTANTIATE_TEST_CASE_P(BackendOutputAllocationTestCPU, BackendOutputAllocationTest,
 440                         Combine(Values(CV_8UC3, CV_16SC2, CV_32FC1),
 441                                 Values(cv::Size(50, 50)),
 442                                 Values(-1),
 443                                 Values(CORE_CPU)));
 444
 445 INSTANTIATE_TEST_CASE_P(BackendOutputAllocationLargeSizeWithCorrectSubmatrixTestCPU,
 446                         BackendOutputAllocationLargeSizeWithCorrectSubmatrixTest,
 447                         Combine(Values(CV_8UC3, CV_16SC2, CV_32FC1),
 448                                 Values(cv::Size(50, 50)),
 449                                 Values(-1),
 450                                 Values(CORE_CPU)));
 451
 452 INSTANTIATE_TEST_CASE_P(ReInitOutTestCPU, ReInitOutTest,
 453                         Combine(Values(CV_8UC3, CV_16SC4, CV_32FC1),
 454                                 Values(cv::Size(640, 480)),
 455                                 Values(-1),
 456                                 Values(CORE_CPU),
 457                                 Values(cv::Size(640, 400),
 458                                        cv::Size(10, 480))));
 459 }