inference-engine/thirdparty/fluid/modules/gapi/test/gapi_gpu_test.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
  11 #include "logger.hpp"
  12 #include "common/gapi_tests_common.hpp"
  13 #include "opencv2/gapi/gpu/ggpukernel.hpp"
  14 #include "opencl_kernels_test_gapi.hpp"
  15
  16
  17 namespace cv
  18 {
  19
  20 #ifdef HAVE_OPENCL
  21
  22     static void reference_symm7x7_CPU(const cv::Mat& in, const cv::Mat& kernel_coeff, int shift, cv::Mat &out)
  23     {
  24         cv::Point anchor = { -1, -1 };
  25         double delta = 0;
  26
  27         const int* ci = kernel_coeff.ptr<int>();
  28
  29         float c_float[10];
  30         float divisor = (float)(1 << shift);
  31         for (int i = 0; i < 10; i++)
  32         {
  33             c_float[i] = ci[i] / divisor;
  34         }
  35         // J & I & H & G & H & I & J
  36         // I & F & E & D & E & F & I
  37         // H & E & C & B & C & E & H
  38         // G & D & B & A & B & D & G
  39         // H & E & C & B & C & E & H
  40         // I & F & E & D & E & F & I
  41         // J & I & H & G & H & I & J
  42
  43         // A & B & C & D & E & F & G & H & I & J
  44
  45         // 9 & 8 & 7 & 6 & 7 & 8 & 9
  46         // 8 & 5 & 4 & 3 & 4 & 5 & 8
  47         // 7 & 4 & 2 & 1 & 2 & 4 & 7
  48         // 6 & 3 & 1 & 0 & 1 & 3 & 6
  49         // 7 & 4 & 2 & 1 & 2 & 4 & 7
  50         // 8 & 5 & 4 & 3 & 4 & 5 & 8
  51         // 9 & 8 & 7 & 6 & 7 & 8 & 9
  52
  53         float coefficients[49] =
  54         {
  55             c_float[9], c_float[8], c_float[7], c_float[6], c_float[7], c_float[8], c_float[9],
  56             c_float[8], c_float[5], c_float[4], c_float[3], c_float[4], c_float[5], c_float[8],
  57             c_float[7], c_float[4], c_float[2], c_float[1], c_float[2], c_float[4], c_float[7],
  58             c_float[6], c_float[3], c_float[1], c_float[0], c_float[1], c_float[3], c_float[6],
  59             c_float[7], c_float[4], c_float[2], c_float[1], c_float[2], c_float[4], c_float[7],
  60             c_float[8], c_float[5], c_float[4], c_float[3], c_float[4], c_float[5], c_float[8],
  61             c_float[9], c_float[8], c_float[7], c_float[6], c_float[7], c_float[8], c_float[9]
  62         };
  63
  64         cv::Mat kernel = cv::Mat(7, 7, CV_32FC1);
  65         float* cf = kernel.ptr<float>();
  66         for (int i = 0; i < 49; i++)
  67         {
  68             cf[i] = coefficients[i];
  69         }
  70
  71         cv::filter2D(in, out, CV_8UC1, kernel, anchor, delta, cv::BORDER_REPLICATE);
  72     }
  73
  74     namespace gapi_test_kernels
  75     {
  76         G_TYPED_KERNEL(TSymm7x7_test, <GMat(GMat, Mat, int)>, "org.opencv.imgproc.symm7x7_test") {
  77             static GMatDesc outMeta(GMatDesc in, Mat, int) {
  78                 return in.withType(CV_8U, 1);
  79             }
  80         };
  81
  82
  83         GAPI_GPU_KERNEL(GGPUSymm7x7_test, TSymm7x7_test)
  84         {
  85             static void run(const cv::UMat& in, const cv::Mat& kernel_coeff, int shift, cv::UMat &out)
  86             {
  87                 if (cv::ocl::isOpenCLActivated())
  88                 {
  89                     cv::Size size = in.size();
  90                     size_t globalsize[2] = { (size_t)size.width, (size_t)size.height };
  91
  92                     const cv::String moduleName = "gapi";
  93                     cv::ocl::ProgramSource source(moduleName, "symm7x7", opencl_symm7x7_src, "");
  94
  95                     static const char * const borderMap[] = { "BORDER_CONSTANT", "BORDER_REPLICATE", "BORDER_UNDEFINED" };
  96                     std::string build_options = " -D BORDER_CONSTANT_VALUE=" + std::to_string(0) +
  97                         " -D " + borderMap[1] +
  98                         " -D SCALE=1.f/" + std::to_string(1 << shift) + ".f";
  99
 100                     cv::String errmsg;
 101                     cv::ocl::Program program(source, build_options, errmsg);
 102                     if (program.ptr() == NULL)
 103                     {
 104                         CV_Error_(cv::Error::OpenCLInitError, ("symm_7x7_test Can't compile OpenCL program: = %s with build_options = %s\n", errmsg.c_str(), build_options.c_str()));
 105                     }
 106                     if (!errmsg.empty())
 107                     {
 108                         std::cout << "OpenCL program build log:" << std::endl << errmsg << std::endl;
 109                     }
 110
 111                     cv::ocl::Kernel kernel("symm_7x7_test", program);
 112                     if (kernel.empty())
 113                     {
 114                         CV_Error(cv::Error::OpenCLInitError, "symm_7x7_test Can't get OpenCL kernel\n");
 115                     }
 116
 117                     cv::UMat gKer;
 118                     kernel_coeff.copyTo(gKer);
 119
 120                     int tile_y = 0;
 121
 122                     int idxArg = kernel.set(0, cv::ocl::KernelArg::PtrReadOnly(in));
 123                     idxArg = kernel.set(idxArg, (int)in.step);
 124                     idxArg = kernel.set(idxArg, (int)size.width);
 125                     idxArg = kernel.set(idxArg, (int)size.height);
 126                     idxArg = kernel.set(idxArg, cv::ocl::KernelArg::PtrWriteOnly(out));
 127                     idxArg = kernel.set(idxArg, (int)out.step);
 128                     idxArg = kernel.set(idxArg, (int)size.height);
 129                     idxArg = kernel.set(idxArg, (int)size.width);
 130                     idxArg = kernel.set(idxArg, (int)tile_y);
 131                     idxArg = kernel.set(idxArg, cv::ocl::KernelArg::PtrReadOnly(gKer));
 132
 133                     if (!kernel.run(2, globalsize, NULL, false))
 134                     {
 135                         CV_Error(cv::Error::OpenCLApiCallError, "symm_7x7_test OpenCL kernel run failed\n");
 136                     }
 137                 }
 138                 else
 139                 {
 140                     //CPU fallback
 141                     cv::Mat in_Mat, out_Mat;
 142                     in_Mat = in.getMat(ACCESS_READ);
 143                     out_Mat = out.getMat(ACCESS_WRITE);
 144                     reference_symm7x7_CPU(in_Mat, kernel_coeff, shift, out_Mat);
 145                 }
 146             }
 147         };
 148
 149         cv::gapi::GKernelPackage gpuTestPackage = cv::gapi::kernels
 150             <GGPUSymm7x7_test
 151             >();
 152
 153     } // namespace gapi_test_kernels
 154 #endif //HAVE_OPENCL
 155
 156 } // namespace cv
 157
 158
 159 namespace opencv_test
 160 {
 161
 162 #ifdef HAVE_OPENCL
 163
 164 using namespace cv::gapi_test_kernels;
 165
 166 TEST(GPU, Symm7x7_test)
 167 {
 168     const auto sz = cv::Size(1280, 720);
 169     cv::Mat in_mat = cv::Mat::eye(sz, CV_8UC1);
 170     cv::Mat out_mat_gapi(sz, CV_8UC1);
 171     cv::Mat out_mat_ocv(sz, CV_8UC1);
 172     cv::Scalar mean = cv::Scalar(127.0f);
 173     cv::Scalar stddev = cv::Scalar(40.f);
 174     cv::randn(in_mat, mean, stddev);
 175
 176     //Symm7x7 coefficients and shift
 177     int coefficients_symm7x7[10] = { 1140, -118, 526, 290, -236, 64, -128, -5, -87, -7 };
 178     int shift = 10;
 179     cv::Mat kernel_coeff(10, 1, CV_32S);
 180     int* ci = kernel_coeff.ptr<int>();
 181     for (int i = 0; i < 10; i++)
 182     {
 183         ci[i] = coefficients_symm7x7[i];
 184     }
 185
 186     // Run G-API
 187     cv::GMat in;
 188     auto out = TSymm7x7_test::on(in, kernel_coeff, shift);
 189     cv::GComputation comp(cv::GIn(in), cv::GOut(out));
 190
 191     auto cc = comp.compile(cv::descr_of(in_mat), cv::compile_args(gpuTestPackage));
 192     cc(cv::gin(in_mat), cv::gout(out_mat_gapi));
 193
 194     // Run OpenCV
 195     reference_symm7x7_CPU(in_mat, kernel_coeff, shift, out_mat_ocv);
 196
 197     compare_f cmpF = AbsSimilarPoints(1, 0.05).to_compare_f();
 198
 199     // Comparison //////////////////////////////////////////////////////////////
 200     {
 201         EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
 202         EXPECT_EQ(out_mat_gapi.size(), sz);
 203     }
 204 }
 205 #endif
 206
 207 } // namespace opencv_test