modules/imgproc/perf/perf_histogram.cpp

   1 #include "perf_precomp.hpp"
   2
   3 using namespace std;
   4 using namespace cv;
   5 using namespace perf;
   6 using namespace testing;
   7 using std::tr1::make_tuple;
   8 using std::tr1::get;
   9
  10 typedef tr1::tuple<Size, MatType> Size_Source_t;
  11 typedef TestBaseWithParam<Size_Source_t> Size_Source;
  12 typedef TestBaseWithParam<Size> MatSize;
  13
  14 static const float rangeHight = 256.0f;
  15 static const float rangeLow = 0.0f;
  16
  17 PERF_TEST_P(Size_Source, calcHist1d,
  18             testing::Combine(testing::Values(sz3MP, sz5MP),
  19                              testing::Values(CV_8U, CV_16U, CV_32F) )
  20             )
  21 {
  22     Size size = get<0>(GetParam());
  23     MatType type = get<1>(GetParam());
  24     Mat source(size.height, size.width, type);
  25     Mat hist;
  26     int channels [] = {0};
  27     int histSize [] = {256};
  28     int dims = 1;
  29     int numberOfImages = 1;
  30
  31     const float range[] = {rangeLow, rangeHight};
  32     const float* ranges[] = {range};
  33
  34     randu(source, rangeLow, rangeHight);
  35
  36     declare.in(source);
  37
  38     TEST_CYCLE_MULTIRUN(3)
  39     {
  40         calcHist(&source, numberOfImages, channels, Mat(), hist, dims, histSize, ranges);
  41     }
  42
  43     SANITY_CHECK(hist);
  44 }
  45
  46 PERF_TEST_P(Size_Source, calcHist2d,
  47             testing::Combine(testing::Values(sz3MP, sz5MP),
  48                              testing::Values(CV_8UC2, CV_16UC2, CV_32FC2) )
  49             )
  50 {
  51     Size size = get<0>(GetParam());
  52     MatType type = get<1>(GetParam());
  53     Mat source(size.height, size.width, type);
  54     Mat hist;
  55     int channels [] = {0, 1};
  56     int histSize [] = {256, 256};
  57     int dims = 2;
  58     int numberOfImages = 1;
  59
  60     const float r[] = {rangeLow, rangeHight};
  61     const float* ranges[] = {r, r};
  62
  63     randu(source, rangeLow, rangeHight);
  64
  65     declare.in(source);
  66     TEST_CYCLE()
  67     {
  68         calcHist(&source, numberOfImages, channels, Mat(), hist, dims, histSize, ranges);
  69     }
  70
  71     SANITY_CHECK(hist);
  72 }
  73
  74 PERF_TEST_P(Size_Source, calcHist3d,
  75             testing::Combine(testing::Values(sz3MP, sz5MP),
  76                              testing::Values(CV_8UC3, CV_16UC3, CV_32FC3) )
  77             )
  78 {
  79     Size size = get<0>(GetParam());
  80     MatType type = get<1>(GetParam());
  81     Mat hist;
  82     int channels [] = {0, 1, 2};
  83     int histSize [] = {32, 32, 32};
  84     int dims = 3;
  85     int numberOfImages = 1;
  86     Mat source(size.height, size.width, type);
  87
  88     const float r[] = {rangeLow, rangeHight};
  89     const float* ranges[] = {r, r, r};
  90
  91     randu(source, rangeLow, rangeHight);
  92
  93     declare.in(source);
  94     TEST_CYCLE()
  95     {
  96         calcHist(&source, numberOfImages, channels, Mat(), hist, dims, histSize, ranges);
  97     }
  98
  99     SANITY_CHECK(hist);
 100 }
 101
 102 PERF_TEST_P(MatSize, equalizeHist,
 103             testing::Values(TYPICAL_MAT_SIZES)
 104             )
 105 {
 106     Size size = GetParam();
 107     Mat source(size.height, size.width, CV_8U);
 108     Mat destination;
 109     declare.in(source, WARMUP_RNG);
 110
 111     TEST_CYCLE()
 112     {
 113         equalizeHist(source, destination);
 114     }
 115
 116     SANITY_CHECK(destination);
 117 }
 118
 119 typedef tr1::tuple<Size, double> Sz_ClipLimit_t;
 120 typedef TestBaseWithParam<Sz_ClipLimit_t> Sz_ClipLimit;
 121
 122 PERF_TEST_P(Sz_ClipLimit, CLAHE,
 123             testing::Combine(testing::Values(::perf::szVGA, ::perf::sz720p, ::perf::sz1080p),
 124                              testing::Values(0.0, 40.0))
 125             )
 126 {
 127     const Size size = get<0>(GetParam());
 128     const double clipLimit = get<1>(GetParam());
 129
 130     Mat src(size, CV_8UC1);
 131     declare.in(src, WARMUP_RNG);
 132
 133     Ptr<CLAHE> clahe = createCLAHE(clipLimit);
 134     Mat dst;
 135
 136     TEST_CYCLE() clahe->apply(src, dst);
 137
 138     SANITY_CHECK(dst);
 139 }