Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Tetragramm
GitHub Repository: Tetragramm/opencv
 Path: blob/master/modules/imgproc/test/test_smooth_bitexact.cpp
16344 views
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
#include "test_precomp.hpp"

6


7
namespace opencv_test { namespace {

8


9
    static const int fixedShiftU8 = 8;

10
    static const int64_t fixedOne = (1L << fixedShiftU8);

11


12
    int64_t v[][9] = {

13
        { fixedOne }, // size 1, sigma 0

14
        { fixedOne >> 2, fixedOne >> 1, fixedOne >> 2 }, // size 3, sigma 0

15
        { fixedOne >> 4, fixedOne >> 2, 6 * (fixedOne >> 4), fixedOne >> 2, fixedOne >> 4 }, // size 5, sigma 0

16
        { fixedOne >> 5, 7 * (fixedOne >> 6), 7 * (fixedOne >> 5), 9 * (fixedOne >> 5), 7 * (fixedOne >> 5), 7 * (fixedOne >> 6), fixedOne >> 5 }, // size 7, sigma 0

17
        { 4, 13, 30, 51, 61, 51, 30, 13, 4 }, // size 9, sigma 0

18
        { 81, 95, 81 }, // size 3, sigma 1.75

19
        { 65, 125, 65 }, // size 3, sigma 0.875

20
        { 0, 7, 242, 7, 0 }, // size 5, sigma 0.375

21
        { 4, 56, 136, 56, 4 } // size 5, sigma 0.75

22
    };

23


24
    template <typename T, int fixedShift>

25
    T eval(Mat src, vector<int64_t> kernelx, vector<int64_t> kernely)

26
    {

27
        static const int64_t fixedRound = ((1LL << (fixedShift * 2)) >> 1);

28
        int64_t val = 0;

29
        for (size_t j = 0; j < kernely.size(); j++)

30
        {

31
            int64_t lineval = 0;

32
            for (size_t i = 0; i < kernelx.size(); i++)

33
                lineval += src.at<T>((int)j, (int)i) * kernelx[i];

34
            val += lineval * kernely[j];

35
        }

36
        return saturate_cast<T>((val + fixedRound) >> (fixedShift * 2));

37
    }

38


39
TEST(GaussianBlur_Bitexact, Linear8U)

40
{

41
    struct testmode

42
    {

43
        int type;

44
        Size sz;

45
        Size kernel;

46
        double sigma_x;

47
        double sigma_y;

48
        vector<int64_t> kernel_x;

49
        vector<int64_t> kernel_y;

50
    } modes[] = {

51
        { CV_8UC1, Size(   1,   1), Size(3, 3), 0, 0, vector<int64_t>(v[1], v[1]+3), vector<int64_t>(v[1], v[1]+3) },

52
        { CV_8UC1, Size(   2,   2), Size(3, 3), 0, 0, vector<int64_t>(v[1], v[1]+3), vector<int64_t>(v[1], v[1]+3) },

53
        { CV_8UC1, Size(   3,   1), Size(3, 3), 0, 0, vector<int64_t>(v[1], v[1]+3), vector<int64_t>(v[1], v[1]+3) },

54
        { CV_8UC1, Size(   1,   3), Size(3, 3), 0, 0, vector<int64_t>(v[1], v[1]+3), vector<int64_t>(v[1], v[1]+3) },

55
        { CV_8UC1, Size(   3,   3), Size(3, 3), 0, 0, vector<int64_t>(v[1], v[1]+3), vector<int64_t>(v[1], v[1]+3) },

56
        { CV_8UC1, Size(   3,   3), Size(5, 5), 0, 0, vector<int64_t>(v[2], v[2]+5), vector<int64_t>(v[2], v[2]+5) },

57
        { CV_8UC1, Size(   3,   3), Size(7, 7), 0, 0, vector<int64_t>(v[3], v[3]+7), vector<int64_t>(v[3], v[3]+7) },

58
        { CV_8UC1, Size(   5,   5), Size(3, 3), 0, 0, vector<int64_t>(v[1], v[1]+3), vector<int64_t>(v[1], v[1]+3) },

59
        { CV_8UC1, Size(   5,   5), Size(5, 5), 0, 0, vector<int64_t>(v[2], v[2]+5), vector<int64_t>(v[2], v[2]+5) },

60
        { CV_8UC1, Size(   3,   5), Size(5, 5), 0, 0, vector<int64_t>(v[2], v[2]+5), vector<int64_t>(v[2], v[2]+5) },

61
        { CV_8UC1, Size(   5,   5), Size(5, 5), 0, 0, vector<int64_t>(v[2], v[2]+5), vector<int64_t>(v[2], v[2]+5) },

62
        { CV_8UC1, Size(   5,   5), Size(7, 7), 0, 0, vector<int64_t>(v[3], v[3]+7), vector<int64_t>(v[3], v[3]+7) },

63
        { CV_8UC1, Size(   7,   7), Size(7, 7), 0, 0, vector<int64_t>(v[3], v[3]+7), vector<int64_t>(v[3], v[3]+7) },

64
        { CV_8UC1, Size( 256, 128), Size(3, 3), 0, 0, vector<int64_t>(v[1], v[1]+3), vector<int64_t>(v[1], v[1]+3) },

65
        { CV_8UC2, Size( 256, 128), Size(3, 3), 0, 0, vector<int64_t>(v[1], v[1]+3), vector<int64_t>(v[1], v[1]+3) },

66
        { CV_8UC3, Size( 256, 128), Size(3, 3), 0, 0, vector<int64_t>(v[1], v[1]+3), vector<int64_t>(v[1], v[1]+3) },

67
        { CV_8UC4, Size( 256, 128), Size(3, 3), 0, 0, vector<int64_t>(v[1], v[1]+3), vector<int64_t>(v[1], v[1]+3) },

68
        { CV_8UC1, Size( 256, 128), Size(5, 5), 0, 0, vector<int64_t>(v[2], v[2]+5), vector<int64_t>(v[2], v[2]+5) },

69
        { CV_8UC1, Size( 256, 128), Size(7, 7), 0, 0, vector<int64_t>(v[3], v[3]+7), vector<int64_t>(v[3], v[3]+7) },

70
        { CV_8UC1, Size( 256, 128), Size(9, 9), 0, 0, vector<int64_t>(v[4], v[4]+9), vector<int64_t>(v[4], v[4]+9) },

71
        { CV_8UC1, Size( 256, 128), Size(3, 3), 1.75, 0.875, vector<int64_t>(v[5], v[5]+3), vector<int64_t>(v[6], v[6]+3) },

72
        { CV_8UC2, Size( 256, 128), Size(3, 3), 1.75, 0.875, vector<int64_t>(v[5], v[5]+3), vector<int64_t>(v[6], v[6]+3) },

73
        { CV_8UC3, Size( 256, 128), Size(3, 3), 1.75, 0.875, vector<int64_t>(v[5], v[5]+3), vector<int64_t>(v[6], v[6]+3) },

74
        { CV_8UC4, Size( 256, 128), Size(3, 3), 1.75, 0.875, vector<int64_t>(v[5], v[5]+3), vector<int64_t>(v[6], v[6]+3) },

75
        { CV_8UC1, Size( 256, 128), Size(5, 5), 0.375, 0.75, vector<int64_t>(v[7], v[7]+5), vector<int64_t>(v[8], v[8]+5) }

76
    };

77


78
    int bordermodes[] = {

79
        BORDER_CONSTANT | BORDER_ISOLATED,

80
        BORDER_REPLICATE | BORDER_ISOLATED,

81
        BORDER_REFLECT | BORDER_ISOLATED,

82
        BORDER_WRAP | BORDER_ISOLATED,

83
        BORDER_REFLECT_101 | BORDER_ISOLATED

84
//        BORDER_CONSTANT,

85
//        BORDER_REPLICATE,

86
//        BORDER_REFLECT,

87
//        BORDER_WRAP,

88
//        BORDER_REFLECT_101

89
    };

90


91
    for (int modeind = 0, _modecnt = sizeof(modes) / sizeof(modes[0]); modeind < _modecnt; ++modeind)

92
    {

93
        int type = modes[modeind].type, depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);

94
        int dcols = modes[modeind].sz.width, drows = modes[modeind].sz.height;

95
        Size kernel = modes[modeind].kernel;

96


97
        int rows = drows + 20, cols = dcols + 20;

98
        Mat src(rows, cols, type), refdst(drows, dcols, type), dst;

99
        for (int j = 0; j < rows; j++)

100
        {

101
            uint8_t* line = src.ptr(j);

102
            for (int i = 0; i < cols; i++)

103
                for (int c = 0; c < cn; c++)

104
                {

105
                    RNG rnd(0x123456789abcdefULL);

106
                    double val = j < rows / 2 ? (i < cols / 2 ? ((sin((i + 1)*CV_PI / 256.)*sin((j + 1)*CV_PI / 256.)*sin((cn + 4)*CV_PI / 8.) + 1.)*128.) :

107
                        (((i / 128 + j / 128) % 2) * 250 + (j / 128) % 2)) :

108
                        (i < cols / 2 ? ((i / 128) * (85 - j / 256 * 40) * ((j / 128) % 2) + (7 - i / 128) * (85 - j / 256 * 40) * ((j / 128 + 1) % 2)) :

109
                        ((uchar)rnd));

110
                    if (depth == CV_8U)

111
                        line[i*cn + c] = (uint8_t)val;

112
                    else if (depth == CV_16U)

113
                        ((uint16_t*)line)[i*cn + c] = (uint16_t)val;

114
                    else if (depth == CV_16S)

115
                        ((int16_t*)line)[i*cn + c] = (int16_t)val;

116
                    else if (depth == CV_32S)

117
                        ((int32_t*)line)[i*cn + c] = (int32_t)val;

118
                    else

119
                        CV_Assert(0);

120
                }

121
        }

122
        Mat src_roi = src(Rect(10, 10, dcols, drows));

123


124


125
        for (int borderind = 0, _bordercnt = sizeof(bordermodes) / sizeof(bordermodes[0]); borderind < _bordercnt; ++borderind)

126
        {

127
            Mat src_border;

128
            cv::copyMakeBorder(src_roi, src_border, kernel.height / 2, kernel.height / 2, kernel.width / 2, kernel.width / 2, bordermodes[borderind]);

129
            for (int c = 0; c < src_border.channels(); c++)

130
            {

131
                int fromTo[2] = { c, 0 };

132
                int toFrom[2] = { 0, c };

133
                Mat src_chan(src_border.size(), CV_MAKETYPE(src_border.depth(),1));

134
                Mat dst_chan(refdst.size(), CV_MAKETYPE(refdst.depth(), 1));

135
                mixChannels(src_border, src_chan, fromTo, 1);

136
                for (int j = 0; j < drows; j++)

137
                    for (int i = 0; i < dcols; i++)

138
                    {

139
                        if (depth == CV_8U)

140
                            dst_chan.at<uint8_t>(j, i) = eval<uint8_t, fixedShiftU8>(src_chan(Rect(i,j,kernel.width,kernel.height)), modes[modeind].kernel_x, modes[modeind].kernel_y);

141
                        else if (depth == CV_16U)

142
                            dst_chan.at<uint16_t>(j, i) = eval<uint16_t, fixedShiftU8>(src_chan(Rect(i, j, kernel.width, kernel.height)), modes[modeind].kernel_x, modes[modeind].kernel_y);

143
                        else if (depth == CV_16S)

144
                            dst_chan.at<int16_t>(j, i) = eval<int16_t, fixedShiftU8>(src_chan(Rect(i, j, kernel.width, kernel.height)), modes[modeind].kernel_x, modes[modeind].kernel_y);

145
                        else if (depth == CV_32S)

146
                            dst_chan.at<int32_t>(j, i) = eval<int32_t, fixedShiftU8>(src_chan(Rect(i, j, kernel.width, kernel.height)), modes[modeind].kernel_x, modes[modeind].kernel_y);

147
                        else

148
                            CV_Assert(0);

149
                    }

150
                mixChannels(dst_chan, refdst, toFrom, 1);

151
            }

152


153
            cv::GaussianBlur(src_roi, dst, kernel, modes[modeind].sigma_x, modes[modeind].sigma_y, bordermodes[borderind]);

154


155
            EXPECT_GE(0, cvtest::norm(refdst, dst, cv::NORM_L1))

156
                << "GaussianBlur " << cn << "-chan mat " << drows << "x" << dcols << " by kernel " << kernel << " sigma(" << modes[modeind].sigma_x << ";" << modes[modeind].sigma_y << ") failed with max diff " << cvtest::norm(refdst, dst, cv::NORM_INF);

157
        }

158
    }

159
}

160


161
}} // namespace

162


163