inference-engine/thirdparty/fluid/modules/gapi/test/cpu/gapi_imgproc_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
  10 #include "../common/gapi_imgproc_tests.hpp"
  11 #include <opencv2/gapi/cpu/imgproc.hpp>
  12
  13 namespace
  14 {
  15 #define IMGPROC_CPU [] () { return cv::compile_args(cv::gapi::imgproc::cpu::kernels()); }
  16 }  // anonymous namespace
  17
  18 namespace opencv_test
  19 {
  20
  21 INSTANTIATE_TEST_CASE_P(Filter2DTestCPU, Filter2DTest,
  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_32F),
  27                                 Values(IMGPROC_CPU),
  28                                 Values(AbsExact().to_compare_obj()),
  29                                 Values(3, 4, 5, 7),
  30                                 Values(cv::BORDER_DEFAULT)));
  31
  32 INSTANTIATE_TEST_CASE_P(BoxFilterTestCPU, BoxFilterTest,
  33                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
  34                                 Values(cv::Size(1280, 720),
  35                                        cv::Size(640, 480)),
  36                                 Values(-1, CV_32F),
  37                                 Values(IMGPROC_CPU),
  38                                 Values(AbsTolerance(0).to_compare_obj()),
  39                                 Values(3,5),
  40                                 Values(cv::BORDER_DEFAULT)));
  41
  42 INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_8U, SepFilterTest,
  43                         Combine(Values(CV_8UC1, CV_8UC3),
  44                                 Values(cv::Size(1280, 720),
  45                                         cv::Size(640, 480)),
  46                                 Values(-1, CV_16S, CV_32F),
  47                                 Values(IMGPROC_CPU),
  48                                 Values(AbsExact().to_compare_obj()),
  49                                 Values(3)));
  50
  51 INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_other, SepFilterTest,
  52                         Combine(Values(CV_16UC1, CV_16SC1, CV_32FC1),
  53                                 Values(cv::Size(1280, 720),
  54                                        cv::Size(640, 480)),
  55                                 Values(-1, CV_32F),
  56                                 Values(IMGPROC_CPU),
  57                                 Values(AbsExact().to_compare_obj()),
  58                                 Values(3)));
  59
  60 INSTANTIATE_TEST_CASE_P(BlurTestCPU, BlurTest,
  61                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
  62                                 Values(cv::Size(1280, 720),
  63                                        cv::Size(640, 480)),
  64                                 Values(-1),
  65                                 Values(IMGPROC_CPU),
  66                                 Values(AbsTolerance(0.0).to_compare_obj()),
  67                                 Values(3,5),
  68                                 Values(cv::BORDER_DEFAULT)));
  69
  70 INSTANTIATE_TEST_CASE_P(gaussBlurTestCPU, GaussianBlurTest,
  71                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
  72                                 Values(cv::Size(1280, 720),
  73                                        cv::Size(640, 480)),
  74                                 Values(-1),
  75                                 Values(IMGPROC_CPU),
  76                                 Values(AbsExact().to_compare_obj()),
  77                                 Values(3, 5)));
  78
  79 INSTANTIATE_TEST_CASE_P(MedianBlurTestCPU, MedianBlurTest,
  80                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
  81                                 Values(cv::Size(1280, 720),
  82                                        cv::Size(640, 480)),
  83                                 Values(-1),
  84                                 Values(IMGPROC_CPU),
  85                                 Values(AbsExact().to_compare_obj()),
  86                                 Values(3, 5)));
  87
  88 INSTANTIATE_TEST_CASE_P(ErodeTestCPU, ErodeTest,
  89                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
  90                                 Values(cv::Size(1280, 720),
  91                                        cv::Size(640, 480)),
  92                                 Values(-1),
  93                                 Values(IMGPROC_CPU),
  94                                 Values(AbsExact().to_compare_obj()),
  95                                 Values(3, 5),
  96                                 Values(cv::MorphShapes::MORPH_RECT,
  97                                        cv::MorphShapes::MORPH_CROSS,
  98                                        cv::MorphShapes::MORPH_ELLIPSE)));
  99
 100 INSTANTIATE_TEST_CASE_P(Erode3x3TestCPU, Erode3x3Test,
 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                                 Values(-1),
 105                                 Values(IMGPROC_CPU),
 106                                 Values(AbsExact().to_compare_obj()),
 107                                 Values(1,2,4)));
 108
 109 INSTANTIATE_TEST_CASE_P(DilateTestCPU, DilateTest,
 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                                 Values(-1),
 114                                 Values(IMGPROC_CPU),
 115                                 Values(AbsExact().to_compare_obj()),
 116                                 Values(3, 5),
 117                                 Values(cv::MorphShapes::MORPH_RECT,
 118                                        cv::MorphShapes::MORPH_CROSS,
 119                                        cv::MorphShapes::MORPH_ELLIPSE)));
 120
 121 INSTANTIATE_TEST_CASE_P(Dilate3x3TestCPU, Dilate3x3Test,
 122                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
 123                                 Values(cv::Size(1280, 720),
 124                                        cv::Size(640, 480)),
 125                                 Values(-1),
 126                                 Values(IMGPROC_CPU),
 127                                 Values(AbsExact().to_compare_obj()),
 128                                 Values(1,2,4)));
 129
 130 INSTANTIATE_TEST_CASE_P(SobelTestCPU, SobelTest,
 131                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
 132                                 Values(cv::Size(1280, 720),
 133                                        cv::Size(640, 480)),
 134                                 Values(-1, CV_16S, CV_32F),
 135                                 Values(IMGPROC_CPU),
 136                                 Values(AbsExact().to_compare_obj()),
 137                                 Values(3, 5),
 138                                 Values(0, 1),
 139                                 Values(1, 2)));
 140
 141 INSTANTIATE_TEST_CASE_P(SobelTestCPU32F, SobelTest,
 142                         Combine(Values(CV_32FC1),
 143                                 Values(cv::Size(1280, 720),
 144                                        cv::Size(640, 480)),
 145                                 Values(CV_32F),
 146                                 Values(IMGPROC_CPU),
 147                                 Values(AbsExact().to_compare_obj()),
 148                                 Values(3, 5),
 149                                 Values(0, 1),
 150                                 Values(1, 2)));
 151
 152 INSTANTIATE_TEST_CASE_P(SobelXYTestCPU, SobelXYTest,
 153                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
 154                                 Values(cv::Size(1280, 720),
 155                                        cv::Size(640, 480)),
 156                                 Values(-1, CV_16S, CV_32F),
 157                                 Values(IMGPROC_CPU),
 158                                 Values(AbsExact().to_compare_obj()),
 159                                 Values(3, 5),
 160                                 Values(1, 2),
 161                                 Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT),
 162                                 Values(0, 1, 255)));
 163
 164 INSTANTIATE_TEST_CASE_P(SobelXYTestCPU32F, SobelXYTest,
 165                         Combine(Values(CV_32FC1),
 166                                 Values(cv::Size(1280, 720),
 167                                        cv::Size(640, 480)),
 168                                 Values(CV_32F),
 169                                 Values(IMGPROC_CPU),
 170                                 Values(AbsExact().to_compare_obj()),
 171                                 Values(3, 5),
 172                                 Values(1, 2),
 173                                 Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT),
 174                                 Values(0, 1, 255)));
 175
 176 INSTANTIATE_TEST_CASE_P(EqHistTestCPU, EqHistTest,
 177                         Combine(Values(CV_8UC1),
 178                                 Values(cv::Size(1280, 720),
 179                                        cv::Size(640, 480)),
 180                                 Values(CV_8UC1),
 181                                 Values(IMGPROC_CPU),
 182                                 Values(AbsExact().to_compare_obj())));
 183
 184 INSTANTIATE_TEST_CASE_P(CannyTestCPU, CannyTest,
 185                         Combine(Values(CV_8UC1, CV_8UC3),
 186                                 Values(cv::Size(1280, 720),
 187                                        cv::Size(640, 480)),
 188                                 Values(CV_8UC1),
 189                                 Values(IMGPROC_CPU),
 190                                 Values(AbsSimilarPoints(0, 0.05).to_compare_obj()),
 191                                 Values(3.0, 120.0),
 192                                 Values(125.0, 240.0),
 193                                 Values(3, 5),
 194                                 testing::Bool()));
 195
 196 INSTANTIATE_TEST_CASE_P(RGB2GrayTestCPU, RGB2GrayTest,
 197                         Combine(Values(CV_8UC3),
 198                                 Values(cv::Size(1280, 720),
 199                                        cv::Size(640, 480)),
 200                                 Values(CV_8UC1),
 201                                 Values(IMGPROC_CPU),
 202                                 Values(AbsExact().to_compare_obj())));
 203
 204 INSTANTIATE_TEST_CASE_P(BGR2GrayTestCPU, BGR2GrayTest,
 205                         Combine(Values(CV_8UC3),
 206                                 Values(cv::Size(1280, 720),
 207                                        cv::Size(640, 480)),
 208                                 Values(CV_8UC1),
 209                                 Values(IMGPROC_CPU),
 210                                 Values(AbsExact().to_compare_obj())));
 211
 212 INSTANTIATE_TEST_CASE_P(RGB2YUVTestCPU, RGB2YUVTest,
 213                         Combine(Values(CV_8UC3),
 214                                 Values(cv::Size(1280, 720),
 215                                        cv::Size(640, 480)),
 216                                 Values(CV_8UC3),
 217                                 Values(IMGPROC_CPU),
 218                                 Values(AbsExact().to_compare_obj())));
 219
 220 INSTANTIATE_TEST_CASE_P(YUV2RGBTestCPU, YUV2RGBTest,
 221                         Combine(Values(CV_8UC3),
 222                                 Values(cv::Size(1280, 720),
 223                                        cv::Size(640, 480)),
 224                                 Values(CV_8UC3),
 225                                 Values(IMGPROC_CPU),
 226                                 Values(AbsExact().to_compare_obj())));
 227
 228 INSTANTIATE_TEST_CASE_P(NV12toRGBTestCPU, NV12toRGBTest,
 229                         Combine(Values(CV_8UC1),
 230                                 Values(cv::Size(1280, 720),
 231                                        cv::Size(640, 480)),
 232                                 Values(CV_8UC3),
 233                                 Values(IMGPROC_CPU),
 234                                 Values(AbsExact().to_compare_obj())));
 235
 236 INSTANTIATE_TEST_CASE_P(NV12toBGRTestCPU, NV12toBGRTest,
 237                         Combine(Values(CV_8UC1),
 238                                 Values(cv::Size(1280, 720),
 239                                        cv::Size(640, 480)),
 240                                 Values(CV_8UC3),
 241                                 Values(IMGPROC_CPU),
 242                                 Values(AbsExact().to_compare_obj())));
 243
 244 INSTANTIATE_TEST_CASE_P(NV12toRGBpTestCPU, NV12toRGBpTest,
 245                         Combine(Values(CV_8UC1),
 246                                 Values(cv::Size(1280, 720),
 247                                        cv::Size(640, 480)),
 248                                 Values(CV_8UC3),
 249                                 Values(IMGPROC_CPU),
 250                                 Values(AbsExact().to_compare_obj())));
 251
 252 INSTANTIATE_TEST_CASE_P(NV12toBGRpTestCPU, NV12toBGRpTest,
 253                         Combine(Values(CV_8UC1),
 254                                 Values(cv::Size(1280, 720),
 255                                        cv::Size(640, 480)),
 256                                 Values(CV_8UC3),
 257                                 Values(IMGPROC_CPU),
 258                                 Values(AbsExact().to_compare_obj())));
 259
 260 INSTANTIATE_TEST_CASE_P(RGB2LabTestCPU, RGB2LabTest,
 261                         Combine(Values(CV_8UC3),
 262                                 Values(cv::Size(1280, 720),
 263                                        cv::Size(640, 480)),
 264                                 Values(CV_8UC3),
 265                                 Values(IMGPROC_CPU),
 266                                 Values(AbsExact().to_compare_obj())));
 267
 268 INSTANTIATE_TEST_CASE_P(BGR2LUVTestCPU, BGR2LUVTest,
 269                         Combine(Values(CV_8UC3),
 270                                 Values(cv::Size(1280, 720),
 271                                        cv::Size(640, 480)),
 272                                 Values(CV_8UC3),
 273                                 Values(IMGPROC_CPU),
 274                                 Values(AbsExact().to_compare_obj())));
 275
 276 INSTANTIATE_TEST_CASE_P(LUV2BGRTestCPU, LUV2BGRTest,
 277                         Combine(Values(CV_8UC3),
 278                                 Values(cv::Size(1280, 720),
 279                                        cv::Size(640, 480)),
 280                                 Values(CV_8UC3),
 281                                 Values(IMGPROC_CPU),
 282                                 Values(AbsExact().to_compare_obj())));
 283
 284 INSTANTIATE_TEST_CASE_P(BGR2YUVTestCPU, BGR2YUVTest,
 285                         Combine(Values(CV_8UC3),
 286                                 Values(cv::Size(1280, 720),
 287                                        cv::Size(640, 480)),
 288                                 Values(CV_8UC3),
 289                                 Values(IMGPROC_CPU),
 290                                 Values(AbsExact().to_compare_obj())));
 291
 292 INSTANTIATE_TEST_CASE_P(YUV2BGRTestCPU, YUV2BGRTest,
 293                         Combine(Values(CV_8UC3),
 294                                 Values(cv::Size(1280, 720),
 295                                        cv::Size(640, 480)),
 296                                 Values(CV_8UC3),
 297                                 Values(IMGPROC_CPU),
 298                                 Values(AbsExact().to_compare_obj())));
 299
 300 INSTANTIATE_TEST_CASE_P(RGB2HSVTestCPU, RGB2HSVTest,
 301                         Combine(Values(CV_8UC3),
 302                                 Values(cv::Size(1280, 720),
 303                                        cv::Size(640, 480)),
 304                                 Values(CV_8UC3),
 305                                 Values(IMGPROC_CPU),
 306                                 Values(AbsExact().to_compare_obj())));
 307
 308 INSTANTIATE_TEST_CASE_P(BayerGR2RGBTestCPU, BayerGR2RGBTest,
 309                         Combine(Values(CV_8UC1),
 310                                 Values(cv::Size(1280, 720),
 311                                        cv::Size(640, 480)),
 312                                 Values(CV_8UC3),
 313                                 Values(IMGPROC_CPU),
 314                                 Values(AbsExact().to_compare_obj())));
 315
 316 INSTANTIATE_TEST_CASE_P(RGB2YUV422TestCPU, RGB2YUV422Test,
 317                         Combine(Values(CV_8UC3),
 318                                 Values(cv::Size(1280, 720),
 319                                        cv::Size(640, 480)),
 320                                 Values(CV_8UC2),
 321                                 Values(IMGPROC_CPU),
 322                                 Values(AbsTolerance(1).to_compare_obj())));
 323 } // opencv_test