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 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 #define IMGPROC_CPU cv::gapi::imgproc::cpu::kernels()
  14
  15 namespace opencv_test
  16 {
  17
  18
  19 INSTANTIATE_TEST_CASE_P(Filter2DTestCPU, Filter2DTest,
  20                         Combine(Values(AbsExact().to_compare_f()),
  21                                 Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
  22                                 Values(3, 4, 5, 7),
  23                                 Values(cv::Size(1280, 720),
  24                                        cv::Size(640, 480),
  25                                        cv::Size(128, 128)),
  26                                 Values(cv::BORDER_DEFAULT),
  27                                 Values(-1, CV_32F),
  28 /*init output matrices or not*/ testing::Bool(),
  29                                 Values(cv::compile_args(IMGPROC_CPU))));
  30
  31 INSTANTIATE_TEST_CASE_P(BoxFilterTestCPU, BoxFilterTest,
  32                         Combine(Values(AbsTolerance(0).to_compare_f()),
  33                                 Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
  34                                 Values(3,5),
  35                                 Values(cv::Size(1280, 720),
  36                                        cv::Size(640, 480)),
  37                                 Values(cv::BORDER_DEFAULT),
  38                                 Values(-1, CV_32F),
  39 /*init output matrices or not*/ testing::Bool(),
  40                                 Values(cv::compile_args(IMGPROC_CPU))));
  41
  42 INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_8U, SepFilterTest,
  43                         Combine(Values(AbsExact().to_compare_f()),
  44                                 Values(CV_8UC1, CV_8UC3),
  45                                 Values(3),
  46                                 Values(cv::Size(1280, 720),
  47                                        cv::Size(640, 480)),
  48                                 Values(-1, CV_16S, CV_32F),
  49 /*init output matrices or not*/ testing::Bool(),
  50                                 Values(cv::compile_args(IMGPROC_CPU))));
  51
  52 INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_other, SepFilterTest,
  53                         Combine(Values(AbsExact().to_compare_f()),
  54                                 Values(CV_16UC1, CV_16SC1, CV_32FC1),
  55                                 Values(3),
  56                                 Values(cv::Size(1280, 720),
  57                                        cv::Size(640, 480)),
  58                                 Values(-1, CV_32F),
  59 /*init output matrices or not*/ testing::Bool(),
  60                                 Values(cv::compile_args(IMGPROC_CPU))));
  61
  62 INSTANTIATE_TEST_CASE_P(BlurTestCPU, BlurTest,
  63                         Combine(Values(AbsTolerance(0.0).to_compare_f()),
  64                                 Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
  65                                 Values(3,5),
  66                                 Values(cv::Size(1280, 720),
  67                                        cv::Size(640, 480)),
  68                                 Values(cv::BORDER_DEFAULT),
  69 /*init output matrices or not*/ testing::Bool(),
  70                                 Values(cv::compile_args(IMGPROC_CPU))));
  71
  72 INSTANTIATE_TEST_CASE_P(gaussBlurTestCPU, GaussianBlurTest,
  73                         Combine(Values(AbsExact().to_compare_f()),
  74                                 Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
  75                                 Values(3, 5),
  76                                 Values(cv::Size(1280, 720),
  77                                        cv::Size(640, 480)),
  78 /*init output matrices or not*/ testing::Bool(),
  79                                 Values(cv::compile_args(IMGPROC_CPU))));
  80
  81 INSTANTIATE_TEST_CASE_P(MedianBlurTestCPU, MedianBlurTest,
  82                         Combine(Values(AbsExact().to_compare_f()),
  83                                 Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
  84                                 Values(3, 5),
  85                                 Values(cv::Size(1280, 720),
  86                                        cv::Size(640, 480)),
  87 /*init output matrices or not*/ testing::Bool(),
  88                                 Values(cv::compile_args(IMGPROC_CPU))));
  89
  90 INSTANTIATE_TEST_CASE_P(ErodeTestCPU, ErodeTest,
  91                         Combine(Values(AbsExact().to_compare_f()),
  92                                 Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
  93                                 Values(3, 5),
  94                                 Values(cv::Size(1280, 720),
  95                                        cv::Size(640, 480)),
  96                                 Values(cv::MorphShapes::MORPH_RECT,
  97                                        cv::MorphShapes::MORPH_CROSS,
  98                                        cv::MorphShapes::MORPH_ELLIPSE),
  99 /*init output matrices or not*/ testing::Bool(),
 100                                 Values(cv::compile_args(IMGPROC_CPU))));
 101
 102 INSTANTIATE_TEST_CASE_P(Erode3x3TestCPU, Erode3x3Test,
 103                         Combine(Values(AbsExact().to_compare_f()),
 104                                 Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
 105                                 Values(cv::Size(1280, 720),
 106                                        cv::Size(640, 480)),
 107 /*init output matrices or not*/ testing::Bool(),
 108                                 Values(1,2,4),
 109                                 Values(cv::compile_args(IMGPROC_CPU))));
 110
 111 INSTANTIATE_TEST_CASE_P(DilateTestCPU, DilateTest,
 112                         Combine(Values(AbsExact().to_compare_f()),
 113                                 Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
 114                                 Values(3, 5),
 115                                 Values(cv::Size(1280, 720),
 116                                        cv::Size(640, 480)),
 117                                 Values(cv::MorphShapes::MORPH_RECT,
 118                                        cv::MorphShapes::MORPH_CROSS,
 119                                        cv::MorphShapes::MORPH_ELLIPSE),
 120 /*init output matrices or not*/ testing::Bool(),
 121                                 Values(cv::compile_args(IMGPROC_CPU))));
 122
 123 INSTANTIATE_TEST_CASE_P(Dilate3x3TestCPU, Dilate3x3Test,
 124                         Combine(Values(AbsExact().to_compare_f()),
 125                                 Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
 126                                 Values(cv::Size(1280, 720),
 127                                        cv::Size(640, 480)),
 128 /*init output matrices or not*/ testing::Bool(),
 129                                 Values(1,2,4),
 130                                 Values(cv::compile_args(IMGPROC_CPU))));
 131
 132 INSTANTIATE_TEST_CASE_P(SobelTestCPU, SobelTest,
 133                         Combine(Values(AbsExact().to_compare_f()),
 134                                 Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
 135                                 Values(3, 5),
 136                                 Values(cv::Size(1280, 720),
 137                                        cv::Size(640, 480)),
 138                                 Values(-1, CV_16S, CV_32F),
 139                                 Values(0, 1),
 140                                 Values(1, 2),
 141 /*init output matrices or not*/ testing::Bool(),
 142                                 Values(cv::compile_args(IMGPROC_CPU))));
 143
 144 INSTANTIATE_TEST_CASE_P(SobelTestCPU32F, SobelTest,
 145                         Combine(Values(AbsExact().to_compare_f()),
 146                                 Values(CV_32FC1),
 147                                 Values(3, 5),
 148                                 Values(cv::Size(1280, 720),
 149                                        cv::Size(640, 480)),
 150                                 Values(CV_32F),
 151                                 Values(0, 1),
 152                                 Values(1, 2),
 153 /*init output matrices or not*/ testing::Bool(),
 154                                 Values(cv::compile_args(IMGPROC_CPU))));
 155
 156 INSTANTIATE_TEST_CASE_P(SobelXYTestCPU, SobelXYTest,
 157                         Combine(Values(AbsExact().to_compare_f()),
 158                                 Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
 159                                 Values(3, 5),
 160                                 Values(cv::Size(1280, 720),
 161                                        cv::Size(640, 480)),
 162                                 Values(-1, CV_16S, CV_32F),
 163                                 Values(1, 2),
 164                                 Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT),
 165                                 Values(0, 1, 255),
 166                                 Values(cv::compile_args(IMGPROC_CPU))));
 167
 168 INSTANTIATE_TEST_CASE_P(SobelXYTestCPU32F, SobelXYTest,
 169                         Combine(Values(AbsExact().to_compare_f()),
 170                                 Values(CV_32FC1),
 171                                 Values(3, 5),
 172                                 Values(cv::Size(1280, 720),
 173                                        cv::Size(640, 480)),
 174                                 Values(CV_32F),
 175                                 Values(1, 2),
 176                                 Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT),
 177                                 Values(0, 1, 255),
 178                                 Values(cv::compile_args(IMGPROC_CPU))));
 179
 180 INSTANTIATE_TEST_CASE_P(EqHistTestCPU, EqHistTest,
 181                         Combine(Values(AbsExact().to_compare_f()),
 182                                 Values(cv::Size(1280, 720),
 183                                 cv::Size(640, 480)),
 184 /*init output matrices or not*/ testing::Bool(),
 185                                 Values(cv::compile_args(IMGPROC_CPU))));
 186
 187 INSTANTIATE_TEST_CASE_P(CannyTestCPU, CannyTest,
 188                         Combine(Values(AbsSimilarPoints(0, 0.05).to_compare_f()),
 189                                 Values(CV_8UC1, CV_8UC3),
 190                                 Values(cv::Size(1280, 720),
 191                                        cv::Size(640, 480)),
 192                                 Values(3.0, 120.0),
 193                                 Values(125.0, 240.0),
 194                                 Values(3, 5),
 195                                 testing::Bool(),
 196 /*init output matrices or not*/ testing::Bool(),
 197                                 Values(cv::compile_args(IMGPROC_CPU))));
 198
 199 INSTANTIATE_TEST_CASE_P(RGB2GrayTestCPU, RGB2GrayTest,
 200                         Combine(Values(AbsExact().to_compare_f()),
 201                                 Values(cv::Size(1280, 720),
 202                                 cv::Size(640, 480)),
 203 /*init output matrices or not*/ testing::Bool(),
 204                                 Values(cv::compile_args(IMGPROC_CPU))));
 205
 206 INSTANTIATE_TEST_CASE_P(BGR2GrayTestCPU, BGR2GrayTest,
 207                         Combine(Values(AbsExact().to_compare_f()),
 208                                 Values(cv::Size(1280, 720),
 209                                        cv::Size(640, 480)),
 210 /*init output matrices or not*/ testing::Bool(),
 211                                 Values(cv::compile_args(IMGPROC_CPU))));
 212
 213 INSTANTIATE_TEST_CASE_P(RGB2YUVTestCPU, RGB2YUVTest,
 214                         Combine(Values(AbsExact().to_compare_f()),
 215                                 Values(cv::Size(1280, 720),
 216                                        cv::Size(640, 480)),
 217 /*init output matrices or not*/ testing::Bool(),
 218                                 Values(cv::compile_args(IMGPROC_CPU))));
 219
 220 INSTANTIATE_TEST_CASE_P(YUV2RGBTestCPU, YUV2RGBTest,
 221                         Combine(Values(AbsExact().to_compare_f()),
 222                                 Values(cv::Size(1280, 720),
 223                                        cv::Size(640, 480)),
 224                             /*init output matrices or not*/ testing::Bool(),
 225                                 Values(cv::compile_args(IMGPROC_CPU))));
 226
 227 INSTANTIATE_TEST_CASE_P(NV12toRGBTestCPU, NV12toRGBTest,
 228                         Combine(Values(AbsExact().to_compare_f()),
 229                                 Values(cv::Size(1280, 720),
 230                                        cv::Size(640, 480)),
 231                                 Values(cv::compile_args(IMGPROC_CPU))));
 232
 233 INSTANTIATE_TEST_CASE_P(NV12toBGRTestCPU, NV12toBGRTest,
 234                         Combine(Values(AbsExact().to_compare_f()),
 235                                 Values(cv::Size(1280, 720),
 236                                        cv::Size(640, 480)),
 237                                 Values(cv::compile_args(IMGPROC_CPU))));
 238
 239 INSTANTIATE_TEST_CASE_P(RGB2LabTestCPU, RGB2LabTest,
 240                         Combine(Values(AbsExact().to_compare_f()),
 241                                 Values(cv::Size(1280, 720),
 242                                        cv::Size(640, 480)),
 243 /*init output matrices or not*/ testing::Bool(),
 244                                 Values(cv::compile_args(IMGPROC_CPU))));
 245
 246 INSTANTIATE_TEST_CASE_P(BGR2LUVTestCPU, BGR2LUVTest,
 247                         Combine(Values(AbsExact().to_compare_f()),
 248                                 Values(cv::Size(1280, 720),
 249                                        cv::Size(640, 480)),
 250 /*init output matrices or not*/ testing::Bool(),
 251                                 Values(cv::compile_args(IMGPROC_CPU))));
 252
 253 INSTANTIATE_TEST_CASE_P(LUV2BGRTestCPU, LUV2BGRTest,
 254                         Combine(Values(AbsExact().to_compare_f()),
 255                                 Values(cv::Size(1280, 720),
 256                                        cv::Size(640, 480)),
 257 /*init output matrices or not*/ testing::Bool(),
 258                                 Values(cv::compile_args(IMGPROC_CPU))));
 259
 260 INSTANTIATE_TEST_CASE_P(BGR2YUVTestCPU, BGR2YUVTest,
 261                         Combine(Values(AbsExact().to_compare_f()),
 262                                 Values(cv::Size(1280, 720),
 263                                        cv::Size(640, 480)),
 264 /*init output matrices or not*/ testing::Bool(),
 265                                 Values(cv::compile_args(IMGPROC_CPU))));
 266
 267 INSTANTIATE_TEST_CASE_P(YUV2BGRTestCPU, YUV2BGRTest,
 268                         Combine(Values(AbsExact().to_compare_f()),
 269                                 Values(cv::Size(1280, 720),
 270                                        cv::Size(640, 480)),
 271 /*init output matrices or not*/ testing::Bool(),
 272                                 Values(cv::compile_args(IMGPROC_CPU))));
 273
 274 } // opencv_test