inference-engine/thirdparty/fluid/modules/gapi/test/cpu/gapi_imgproc_tests_fluid.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_imgproc_tests.hpp"
  10
  11 namespace
  12 {
  13 #define IMGPROC_FLUID [] () { return cv::compile_args(cv::gapi::imgproc::fluid::kernels()); }
  14 }  // anonymous namespace
  15
  16 namespace opencv_test
  17 {
  18
  19 INSTANTIATE_TEST_CASE_P(RGB2GrayTestFluid, RGB2GrayTest,
  20                         Combine(Values(CV_8UC3),
  21                                 Values(cv::Size(1280, 720),
  22                                        cv::Size(640, 480)),
  23                                 Values(CV_8UC1),
  24                                 Values(IMGPROC_FLUID),
  25                                 Values(ToleranceColor(1e-3).to_compare_obj())));
  26
  27 INSTANTIATE_TEST_CASE_P(BGR2GrayTestFluid, BGR2GrayTest,
  28                         Combine(Values(CV_8UC3),
  29                                 Values(cv::Size(1280, 720),
  30                                        cv::Size(640, 480)),
  31                                 Values(CV_8UC1),
  32                                 Values(IMGPROC_FLUID),
  33                                 Values(ToleranceColor(1e-3).to_compare_obj())));
  34
  35 INSTANTIATE_TEST_CASE_P(RGB2YUVTestFluid, RGB2YUVTest,
  36                         Combine(Values(CV_8UC3),
  37                                 Values(cv::Size(1280, 720),
  38                                        cv::Size(640, 480)),
  39                                 Values(CV_8UC3),
  40                                 Values(IMGPROC_FLUID),
  41                                 Values(ToleranceColor(1e-3).to_compare_obj())));
  42
  43 INSTANTIATE_TEST_CASE_P(YUV2RGBTestFluid, YUV2RGBTest,
  44                         Combine(Values(CV_8UC3),
  45                                 Values(cv::Size(1280, 720),
  46                                        cv::Size(640, 480)),
  47                                 Values(CV_8UC3),
  48                                 Values(IMGPROC_FLUID),
  49                                 Values(ToleranceColor(1e-3).to_compare_obj())));
  50
  51 INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest,
  52                         Combine(Values(CV_8UC3),
  53                                 Values(cv::Size(1280, 720),
  54                                        cv::Size(640, 480)),
  55                                 Values(CV_8UC3),
  56                                 Values(IMGPROC_FLUID),
  57                                 Values(AbsSimilarPoints(1, 0.05).to_compare_obj())));
  58
  59 // FIXME: Not supported by Fluid yet (no kernel implemented)
  60 INSTANTIATE_TEST_CASE_P(BGR2LUVTestFluid, BGR2LUVTest,
  61                         Combine(Values(CV_8UC3),
  62                                 Values(cv::Size(1280, 720),
  63                                        cv::Size(640, 480)),
  64                                 Values(CV_8UC3),
  65                                 Values(IMGPROC_FLUID),
  66                                 Values(ToleranceColor(5e-3, 6).to_compare_obj())));
  67
  68 INSTANTIATE_TEST_CASE_P(RGB2HSVTestFluid, RGB2HSVTest,
  69                         Combine(Values(CV_8UC3),
  70                                 Values(cv::Size(1280, 720),
  71                                        cv::Size(640, 480)),
  72                                 Values(CV_8UC3),
  73                                 Values(IMGPROC_FLUID),
  74                                 Values(ToleranceColor(1e-3).to_compare_obj())));
  75
  76 INSTANTIATE_TEST_CASE_P(BayerGR2RGBTestFluid, BayerGR2RGBTest,
  77                         Combine(Values(CV_8UC1),
  78                                 Values(cv::Size(1280, 720),
  79                                        cv::Size(640, 480)),
  80                                 Values(CV_8UC3),
  81                                 Values(IMGPROC_FLUID),
  82                                 Values(ToleranceColor(1e-3).to_compare_obj())));
  83
  84 INSTANTIATE_TEST_CASE_P(RGB2YUV422TestFluid, RGB2YUV422Test,
  85                         Combine(Values(CV_8UC3),
  86                                 Values(cv::Size(1280, 720),
  87                                        cv::Size(640, 480)),
  88                                 Values(CV_8UC2),
  89                                 Values(IMGPROC_FLUID),
  90                                 Values(AbsTolerance(1).to_compare_obj())));
  91
  92 INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
  93                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
  94                                 Values(cv::Size(1280, 720),
  95                                        cv::Size(640, 480)),
  96                                 Values(-1),
  97                                 Values(IMGPROC_FLUID),
  98                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
  99                                 Values(3), // add kernel size=5 when implementation is ready
 100                                 Values(cv::BORDER_DEFAULT)));
 101
 102 INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest,
 103                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 104                                 Values(cv::Size(1280, 720),
 105                                        cv::Size(640, 480)),
 106                                 Values(-1),
 107                                 Values(IMGPROC_FLUID),
 108                                 Values(ToleranceFilter(1e-3f, 0.01).to_compare_obj()),
 109                                 Values(3))); // add kernel size=5 when implementation is ready
 110
 111 INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest,
 112                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 113                                 Values(cv::Size(1280, 720),
 114                                        cv::Size(640, 480)),
 115                                 Values(-1),
 116                                 Values(IMGPROC_FLUID),
 117                                 Values(AbsExact().to_compare_obj()),
 118                                 Values(3))); // add kernel size=5 when implementation is ready
 119
 120 INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest,
 121                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 122                                 Values(cv::Size(1280, 720),
 123                                        cv::Size(640, 480)),
 124                                 Values(-1),
 125                                 Values(IMGPROC_FLUID),
 126                                 Values(AbsExact().to_compare_obj()),
 127                                 Values(3), // add kernel size=5 when implementation is ready
 128                                 Values(cv::MorphShapes::MORPH_RECT,
 129                                        cv::MorphShapes::MORPH_CROSS,
 130                                        cv::MorphShapes::MORPH_ELLIPSE)));
 131
 132 INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest,
 133                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 134                                 Values(cv::Size(1280, 720),
 135                                        cv::Size(640, 480)),
 136                                 Values(-1),
 137                                 Values(IMGPROC_FLUID),
 138                                 Values(AbsExact().to_compare_obj()),
 139                                 Values(3), // add kernel size=5 when implementation is ready
 140                                 Values(cv::MorphShapes::MORPH_RECT,
 141                                        cv::MorphShapes::MORPH_CROSS,
 142                                        cv::MorphShapes::MORPH_ELLIPSE)));
 143
 144 INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest,
 145                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 146                                 Values(cv::Size(1280, 720),
 147                                        cv::Size(640, 480)),
 148                                 Values(-1, CV_16S, CV_32F),
 149                                 Values(IMGPROC_FLUID),
 150                                 Values(AbsExact().to_compare_obj()),
 151                                 Values(3), // add kernel size=5 when implementation is ready
 152                                 Values(0, 1),
 153                                 Values(1, 2)));
 154
 155 INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest,
 156                         Combine(Values(CV_32FC1),
 157                                 Values(cv::Size(1280, 720),
 158                                        cv::Size(640, 480)),
 159                                 Values(CV_32F),
 160                                 Values(IMGPROC_FLUID),
 161                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
 162                                 Values(3), // add kernel size=5 when implementation is ready
 163                                 Values(0, 1),
 164                                 Values(1, 2)));
 165
 166 INSTANTIATE_TEST_CASE_P(SobelXYTestFluid, SobelXYTest,
 167                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
 168                                 Values(cv::Size(1280, 720),
 169                                        cv::Size(640, 480)),
 170                                 Values(-1, CV_16S, CV_32F),
 171                                 Values(IMGPROC_FLUID),
 172                                 Values(AbsExact().to_compare_obj()),
 173                                 Values(3),
 174                                 Values(1, 2),
 175                                 Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT_101),
 176                                 Values(0, 1, 255)));
 177
 178 INSTANTIATE_TEST_CASE_P(SobelXYTestFluid32F, SobelXYTest,
 179                         Combine(Values(CV_32FC1),
 180                                 Values(cv::Size(1280, 720),
 181                                        cv::Size(640, 480)),
 182                                 Values(CV_32F),
 183                                 Values(IMGPROC_FLUID),
 184                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
 185                                 Values(3),
 186                                 Values(1, 2),
 187                                 Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT_101),
 188                                 Values(0, 1, 255)));
 189
 190 INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
 191                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 192                                 Values(cv::Size(1280, 720),
 193                                        cv::Size(640, 480)),
 194                                 Values(-1, CV_32F),
 195                                 Values(IMGPROC_FLUID),
 196                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
 197                                 Values(3), // add kernel size=5 when implementation is ready
 198                                 Values(cv::BORDER_DEFAULT)));
 199
 200 INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
 201                         Combine(Values(CV_32FC1),
 202                                 Values(cv::Size(1280, 720),
 203                                        cv::Size(640, 480)),
 204                                 Values(-1, CV_32F),
 205                                 Values(IMGPROC_FLUID),
 206                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
 207                                 Values(3))); // add kernel size=5 when implementation is ready
 208
 209 INSTANTIATE_TEST_CASE_P(filter2DTestFluid, Filter2DTest,
 210                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
 211                                 Values(cv::Size(1280, 720),
 212                                        cv::Size(640, 480),
 213                                        cv::Size(128, 128)),
 214                                 Values(-1, CV_32F),
 215                                 Values(IMGPROC_FLUID),
 216                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
 217                                 Values(3), // add kernel size=4,5,7 when implementation ready
 218                                 Values(cv::BORDER_DEFAULT)));
 219
 220 } // opencv_test