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 #define IMGPROC_FLUID cv::gapi::imgproc::fluid::kernels()
  12
  13 namespace opencv_test
  14 {
  15
  16 INSTANTIATE_TEST_CASE_P(RGB2GrayTestFluid, RGB2GrayTest,
  17                         Combine(Values(ToleranceColor(1e-3).to_compare_f()),
  18                                 Values(cv::Size(1280, 720),
  19                                 cv::Size(640, 480)),
  20                                 Values(true, false),
  21                                 Values(cv::compile_args(IMGPROC_FLUID))));
  22
  23 INSTANTIATE_TEST_CASE_P(BGR2GrayTestFluid, BGR2GrayTest,
  24                         Combine(Values(ToleranceColor(1e-3).to_compare_f()),
  25                                 Values(cv::Size(1280, 720),
  26                                        cv::Size(640, 480)),
  27                                 Values(true, false),
  28                                 Values(cv::compile_args(IMGPROC_FLUID))));
  29
  30 INSTANTIATE_TEST_CASE_P(RGB2YUVTestFluid, RGB2YUVTest,
  31                         Combine(Values(ToleranceColor(1e-3).to_compare_f()),
  32                                 Values(cv::Size(1280, 720),
  33                                        cv::Size(640, 480)),
  34                                 Values(true, false),
  35                                 Values(cv::compile_args(IMGPROC_FLUID))));
  36
  37 INSTANTIATE_TEST_CASE_P(YUV2RGBTestFluid, YUV2RGBTest,
  38                         Combine(Values(ToleranceColor(1e-3).to_compare_f()),
  39                                 Values(cv::Size(1280, 720),
  40                                        cv::Size(640, 480)),
  41                                 Values(true, false),
  42                                 Values(cv::compile_args(IMGPROC_FLUID))));
  43
  44 INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest,
  45                         Combine(Values(AbsSimilarPoints(1, 0.05).to_compare_f()),
  46                                 Values(cv::Size(1280, 720),
  47                                        cv::Size(640, 480)),
  48                                 Values(true, false),
  49                                 Values(cv::compile_args(IMGPROC_FLUID))));
  50
  51 // FIXME: Not supported by Fluid yet (no kernel implemented)
  52 INSTANTIATE_TEST_CASE_P(BGR2LUVTestFluid, BGR2LUVTest,
  53                         Combine(Values(ToleranceColor(5e-3, 6).to_compare_f()),
  54                                 Values(cv::Size(1280, 720),
  55                                        cv::Size(640, 480)),
  56                                 Values(true, false),
  57                                 Values(cv::compile_args(IMGPROC_FLUID))));
  58
  59 INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
  60                         Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
  61                                 Values(CV_8UC1, CV_16UC1, CV_16SC1),
  62                                 Values(3), // add kernel size=5 when implementation is ready
  63                                 Values(cv::Size(1280, 720),
  64                                        cv::Size(640, 480)),
  65                                 Values(cv::BORDER_DEFAULT),
  66                                 Values(true, false),
  67                                 Values(cv::compile_args(IMGPROC_FLUID))));
  68
  69 INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest,
  70                         Combine(Values(ToleranceFilter(1e-3f, 0.01).to_compare_f()),
  71                                 Values(CV_8UC1, CV_16UC1, CV_16SC1),
  72                                 Values(3), // add kernel size=5 when implementation is ready
  73                                 Values(cv::Size(1280, 720),
  74                                        cv::Size(640, 480)),
  75                                 Values(true, false),
  76                                 Values(cv::compile_args(IMGPROC_FLUID))));
  77
  78 INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest,
  79                         Combine(Values(AbsExact().to_compare_f()),
  80                                 Values(CV_8UC1, CV_16UC1, CV_16SC1),
  81                                 Values(3), // add kernel size=5 when implementation is ready
  82                                 Values(cv::Size(1280, 720),
  83                                        cv::Size(640, 480)),
  84                                 Values(true, false),
  85                                 Values(cv::compile_args(IMGPROC_FLUID))));
  86
  87 INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest,
  88                         Combine(Values(AbsExact().to_compare_f()),
  89                                 Values(CV_8UC1, CV_16UC1, CV_16SC1),
  90                                 Values(3), // add kernel size=5 when implementation is ready
  91                                 Values(cv::Size(1280, 720),
  92                                        cv::Size(640, 480)),
  93                                 Values(cv::MorphShapes::MORPH_RECT,
  94                                        cv::MorphShapes::MORPH_CROSS,
  95                                        cv::MorphShapes::MORPH_ELLIPSE),
  96                                 Values(true, false),
  97                                 Values(cv::compile_args(IMGPROC_FLUID))));
  98
  99 INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest,
 100                         Combine(Values(AbsExact().to_compare_f()),
 101                                 Values(CV_8UC1, CV_16UC1, CV_16SC1),
 102                                 Values(3), // add kernel size=5 when implementation is ready
 103                                 Values(cv::Size(1280, 720),
 104                                        cv::Size(640, 480)),
 105                                 Values(cv::MorphShapes::MORPH_RECT,
 106                                        cv::MorphShapes::MORPH_CROSS,
 107                                        cv::MorphShapes::MORPH_ELLIPSE),
 108                                 Values(true, false),
 109                                 Values(cv::compile_args(IMGPROC_FLUID))));
 110
 111 INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest,
 112                         Combine(Values(AbsExact().to_compare_f()),
 113                                 Values(CV_8UC1, CV_16UC1, CV_16SC1),
 114                                 Values(3), // add kernel size=5 when implementation is ready
 115                                 Values(cv::Size(1280, 720),
 116                                        cv::Size(640, 480)),
 117                                 Values(-1, CV_16S, CV_32F),
 118                                 Values(0, 1),
 119                                 Values(1, 2),
 120                                 Values(true, false),
 121                                 Values(cv::compile_args(IMGPROC_FLUID))));
 122
 123 INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest,
 124                         Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
 125                                 Values(CV_32FC1),
 126                                 Values(3), // add kernel size=5 when implementation is ready
 127                                 Values(cv::Size(1280, 720),
 128                                        cv::Size(640, 480)),
 129                                 Values(CV_32F),
 130                                 Values(0, 1),
 131                                 Values(1, 2),
 132                                 Values(true, false),
 133                                 Values(cv::compile_args(IMGPROC_FLUID))));
 134
 135 INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
 136                         Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
 137                                 Values(CV_8UC1, CV_16UC1, CV_16SC1),
 138                                 Values(3), // add kernel size=5 when implementation is ready
 139                                 Values(cv::Size(1280, 720),
 140                                        cv::Size(640, 480)),
 141                                 Values(cv::BORDER_DEFAULT),
 142                                 Values(-1, CV_32F),
 143                                 Values(true, false),
 144                                 Values(cv::compile_args(IMGPROC_FLUID))));
 145
 146 INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
 147                         Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
 148                                 Values(CV_32FC1),
 149                                 Values(3), // add kernel size=5 when implementation is ready
 150                                 Values(cv::Size(1280, 720),
 151                                        cv::Size(640, 480)),
 152                                 Values(-1, CV_32F),
 153                                 Values(true, false),
 154                                 Values(cv::compile_args(IMGPROC_FLUID))));
 155
 156 INSTANTIATE_TEST_CASE_P(filter2DTestFluid, Filter2DTest,
 157                         Combine(Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()),
 158                                 Values(CV_8UC1, CV_16UC1, CV_16SC1),
 159                                 Values(3), // add kernel size=4,5,7 when implementation ready
 160                                 Values(cv::Size(1280, 720),
 161                                        cv::Size(640, 480),
 162                                        cv::Size(128, 128)),
 163                                 Values(cv::BORDER_DEFAULT),
 164                                 Values(-1, CV_32F),
 165                                 Values(true, false),
 166                                 Values(cv::compile_args(IMGPROC_FLUID))));
 167
 168 } // opencv_test