modules/ocl/test/test_filters.cpp

   1 /*M///////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
   4 //
   5 //  By downloading, copying, installing or using the software you agree to this license.
   6 //  If you do not agree to this license, do not download, install,
   7 //  copy or use the software.
   8 //
   9 //
  10 //                           License Agreement
  11 //                For Open Source Computer Vision Library
  12 //
  13 // Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
  14 // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
  15 // Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
  16 // Third party copyrights are property of their respective owners.
  17 //
  18 // @Authors
  19 //    Niko Li, newlife20080214@gmail.com
  20 //    Jia Haipeng, jiahaipeng95@gmail.com
  21 //    Zero Lin, Zero.Lin@amd.com
  22 //    Zhang Ying, zhangying913@gmail.com
  23 //    Yao Wang, bitwangyaoyao@gmail.com
  24 //
  25 // Redistribution and use in source and binary forms, with or without modification,
  26 // are permitted provided that the following conditions are met:
  27 //
  28 //   * Redistribution's of source code must retain the above copyright notice,
  29 //     this list of conditions and the following disclaimer.
  30 //
  31 //   * Redistribution's in binary form must reproduce the above copyright notice,
  32 //     this list of conditions and the following disclaimer in the documentation
  33 //     and/or other oclMaterials provided with the distribution.
  34 //
  35 //   * The name of the copyright holders may not be used to endorse or promote products
  36 //     derived from this software without specific prior written permission.
  37 //
  38 // This software is provided by the copyright holders and contributors "as is" and
  39 // any express or implied warranties, including, but not limited to, the implied
  40 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  41 // In no event shall the Intel Corporation or contributors be liable for any direct,
  42 // indirect, incidental, special, exemplary, or consequential damages
  43 // (including, but not limited to, procurement of substitute goods or services;
  44 // loss of use, data, or profits; or business interruption) however caused
  45 // and on any theory of liability, whether in contract, strict liability,
  46 // or tort (including negligence or otherwise) arising in any way out of
  47 // the use of this software, even if advised of the possibility of such damage.
  48 //
  49 //M*/
  50
  51 #include "test_precomp.hpp"
  52
  53 #ifdef HAVE_OPENCL
  54
  55 using namespace cvtest;
  56 using namespace testing;
  57 using namespace std;
  58
  59
  60 PARAM_TEST_CASE(FilterTestBase,
  61                 MatType,
  62                 cv::Size, // kernel size
  63                 cv::Size, // dx,dy
  64                 int       // border type, or iteration
  65                 )
  66 {
  67     //src mat
  68     cv::Mat mat1;
  69     cv::Mat dst;
  70
  71     // set up roi
  72     int roicols;
  73     int roirows;
  74     int src1x;
  75     int src1y;
  76     int dstx;
  77     int dsty;
  78
  79     //src mat with roi
  80     cv::Mat mat1_roi;
  81     cv::Mat dst_roi;
  82
  83     //ocl dst mat for testing
  84     cv::ocl::oclMat gdst_whole;
  85
  86     //ocl mat with roi
  87     cv::ocl::oclMat gmat1;
  88     cv::ocl::oclMat gdst;
  89
  90     void random_roi()
  91     {
  92 #ifdef RANDOMROI
  93         //randomize ROI
  94         cv::RNG &rng = TS::ptr()->get_rng();
  95         roicols = rng.uniform(2, mat1.cols);
  96         roirows = rng.uniform(2, mat1.rows);
  97         src1x   = rng.uniform(0, mat1.cols - roicols);
  98         src1y   = rng.uniform(0, mat1.rows - roirows);
  99         dstx    = rng.uniform(0, dst.cols  - roicols);
 100         dsty    = rng.uniform(0, dst.rows  - roirows);
 101 #else
 102         roicols = mat1.cols;
 103         roirows = mat1.rows;
 104         src1x = 0;
 105         src1y = 0;
 106         dstx = 0;
 107         dsty = 0;
 108 #endif
 109
 110         mat1_roi = mat1(Rect(src1x, src1y, roicols, roirows));
 111         dst_roi  = dst(Rect(dstx, dsty, roicols, roirows));
 112
 113         gdst_whole = dst;
 114         gdst = gdst_whole(Rect(dstx, dsty, roicols, roirows));
 115
 116         gmat1 = mat1_roi;
 117     }
 118
 119     void Init(int mat_type)
 120     {
 121         cv::Size size(MWIDTH, MHEIGHT);
 122         mat1 = randomMat(size, mat_type, 5, 16);
 123         dst  = randomMat(size, mat_type, 5, 16);
 124     }
 125
 126     void Near(double threshold)
 127     {
 128         EXPECT_MAT_NEAR(dst, Mat(gdst_whole), threshold);
 129     }
 130 };
 131
 132 /////////////////////////////////////////////////////////////////////////////////////////////////
 133 // blur
 134 struct Blur : FilterTestBase
 135 {
 136     int type;
 137     cv::Size ksize;
 138     int bordertype;
 139
 140     virtual void SetUp()
 141     {
 142         type = GET_PARAM(0);
 143         ksize = GET_PARAM(1);
 144         bordertype = GET_PARAM(3);
 145         Init(type);
 146     }
 147 };
 148
 149 TEST_P(Blur, Mat)
 150 {
 151     for(int j = 0; j < LOOP_TIMES; j++)
 152     {
 153         random_roi();
 154         cv::blur(mat1_roi, dst_roi, ksize, Point(-1, -1), bordertype);
 155         cv::ocl::blur(gmat1, gdst, ksize, Point(-1, -1), bordertype);
 156         Near(1.0);
 157     }
 158 }
 159
 160
 161 /////////////////////////////////////////////////////////////////////////////////////////////////
 162 //Laplacian
 163 struct Laplacian : FilterTestBase
 164 {
 165     int type;
 166     cv::Size ksize;
 167
 168     virtual void SetUp()
 169     {
 170         type = GET_PARAM(0);
 171         ksize = GET_PARAM(1);
 172         Init(type);
 173     }
 174 };
 175
 176 TEST_P(Laplacian, Accuracy)
 177 {
 178     for(int j = 0; j < LOOP_TIMES; j++)
 179     {
 180         random_roi();
 181         cv::Laplacian(mat1_roi, dst_roi, -1, ksize.width, 1);
 182         cv::ocl::Laplacian(gmat1, gdst, -1, ksize.width, 1);
 183         Near(1e-5);
 184     }
 185 }
 186
 187
 188
 189 /////////////////////////////////////////////////////////////////////////////////////////////////
 190 // erode & dilate
 191 struct ErodeDilate : FilterTestBase
 192 {
 193     int type;
 194     int iterations;
 195
 196     //erode or dilate kernel
 197     cv::Mat kernel;
 198
 199     virtual void SetUp()
 200     {
 201         type = GET_PARAM(0);
 202         iterations = GET_PARAM(3);
 203         Init(type);
 204         //              rng.fill(kernel, cv::RNG::UNIFORM, cv::Scalar::all(0), cv::Scalar::all(3));
 205         kernel = randomMat(Size(3, 3), CV_8UC1, 0, 3);
 206     }
 207
 208 };
 209
 210 TEST_P(ErodeDilate, Mat)
 211 {
 212     for(int j = 0; j < LOOP_TIMES; j++)
 213     {
 214         random_roi();
 215         cv::erode(mat1_roi, dst_roi, kernel, Point(-1, -1), iterations);
 216         cv::ocl::erode(gmat1, gdst, kernel, Point(-1, -1), iterations);
 217         Near(1e-5);
 218     }
 219     for(int j = 0; j < LOOP_TIMES; j++)
 220     {
 221         random_roi();
 222         cv::dilate(mat1_roi, dst_roi, kernel, Point(-1, -1), iterations);
 223         cv::ocl::dilate(gmat1, gdst, kernel, Point(-1, -1), iterations);
 224         Near(1e-5);
 225     }
 226 }
 227
 228
 229 /////////////////////////////////////////////////////////////////////////////////////////////////
 230 // Sobel
 231 struct Sobel : FilterTestBase
 232 {
 233     int type;
 234     int dx, dy, ksize, bordertype;
 235
 236     virtual void SetUp()
 237     {
 238         type = GET_PARAM(0);
 239         Size s = GET_PARAM(1);
 240         ksize = s.width;
 241         s = GET_PARAM(2);
 242         dx = s.width;
 243         dy = s.height;
 244         bordertype = GET_PARAM(3);
 245         Init(type);
 246     }
 247 };
 248
 249 TEST_P(Sobel, Mat)
 250 {
 251     for(int j = 0; j < LOOP_TIMES; j++)
 252     {
 253         random_roi();
 254         cv::Sobel(mat1_roi, dst_roi, -1, dx, dy, ksize, /*scale*/0.00001,/*delta*/0, bordertype);
 255         cv::ocl::Sobel(gmat1, gdst, -1, dx, dy, ksize,/*scale*/0.00001,/*delta*/0, bordertype);
 256         Near(1);
 257     }
 258 }
 259
 260
 261 /////////////////////////////////////////////////////////////////////////////////////////////////
 262 // Scharr
 263 struct Scharr : FilterTestBase
 264 {
 265     int type;
 266     int dx, dy, bordertype;
 267
 268     virtual void SetUp()
 269     {
 270         type = GET_PARAM(0);
 271         Size s = GET_PARAM(2);
 272         dx = s.width;
 273         dy = s.height;
 274         bordertype = GET_PARAM(3);
 275         Init(type);
 276     }
 277 };
 278
 279 TEST_P(Scharr, Mat)
 280 {
 281     for(int j = 0; j < LOOP_TIMES; j++)
 282     {
 283         random_roi();
 284         cv::Scharr(mat1_roi, dst_roi, -1, dx, dy, /*scale*/1,/*delta*/0, bordertype);
 285         cv::ocl::Scharr(gmat1, gdst, -1, dx, dy,/*scale*/1,/*delta*/0, bordertype);
 286         Near(1);
 287     }
 288
 289 }
 290
 291
 292 /////////////////////////////////////////////////////////////////////////////////////////////////
 293 // GaussianBlur
 294 struct GaussianBlur : FilterTestBase
 295 {
 296     int type;
 297     cv::Size ksize;
 298     int bordertype;
 299     double sigma1, sigma2;
 300
 301     virtual void SetUp()
 302     {
 303         type = GET_PARAM(0);
 304         ksize = GET_PARAM(1);
 305         bordertype = GET_PARAM(3);
 306         Init(type);
 307         cv::RNG &rng = TS::ptr()->get_rng();
 308         sigma1 = rng.uniform(0.1, 1.0);
 309         sigma2 = rng.uniform(0.1, 1.0);
 310     }
 311 };
 312
 313 TEST_P(GaussianBlur, Mat)
 314 {
 315     for(int j = 0; j < LOOP_TIMES; j++)
 316     {
 317         random_roi();
 318         cv::GaussianBlur(mat1_roi, dst_roi, ksize, sigma1, sigma2, bordertype);
 319         cv::ocl::GaussianBlur(gmat1, gdst, ksize, sigma1, sigma2, bordertype);
 320         Near(1);
 321     }
 322
 323 }
 324
 325
 326
 327 INSTANTIATE_TEST_CASE_P(Filter, Blur, Combine(
 328                         Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4),
 329                         Values(cv::Size(3, 3), cv::Size(5, 5), cv::Size(7, 7)),
 330                         Values(Size(0, 0)), //not use
 331                         Values((MatType)cv::BORDER_CONSTANT, (MatType)cv::BORDER_REPLICATE, (MatType)cv::BORDER_REFLECT, (MatType)cv::BORDER_REFLECT_101)));
 332
 333
 334 INSTANTIATE_TEST_CASE_P(Filters, Laplacian, Combine(
 335                         Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
 336                         Values(Size(3, 3)),
 337                         Values(Size(0, 0)), //not use
 338                         Values(0)));        //not use
 339
 340 INSTANTIATE_TEST_CASE_P(Filter, ErodeDilate, Combine(
 341                         Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4),
 342                         Values(Size(0, 0)), //not use
 343                         Values(Size(0, 0)), //not use
 344                         Values(1)));
 345
 346
 347 INSTANTIATE_TEST_CASE_P(Filter, Sobel, Combine(
 348                         Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
 349                         Values(Size(3, 3), Size(5, 5)),
 350                         Values(Size(1, 0), Size(1, 1), Size(2, 0), Size(2, 1)),
 351                         Values((MatType)cv::BORDER_CONSTANT, (MatType)cv::BORDER_REPLICATE)));
 352
 353
 354 INSTANTIATE_TEST_CASE_P(Filter, Scharr, Combine(
 355                         Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4),
 356                         Values(Size(0, 0)), //not use
 357                         Values(Size(0, 1), Size(1, 0)),
 358                         Values((MatType)cv::BORDER_CONSTANT, (MatType)cv::BORDER_REPLICATE)));
 359
 360 INSTANTIATE_TEST_CASE_P(Filter, GaussianBlur, Combine(
 361                         Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4),
 362                         Values(Size(3, 3), Size(5, 5)),
 363                         Values(Size(0, 0)), //not use
 364                         Values((MatType)cv::BORDER_CONSTANT, (MatType)cv::BORDER_REPLICATE)));
 365
 366
 367
 368 #endif // HAVE_OPENCL