OpenCV笔记：滤波器

1.方框滤波

函数名：boxFilter

接口定义：

void boxFilter( InputArray src, OutputArray dst, int ddepth,
                Size ksize, Point anchor=Point(-1,-1),
                bool normalize=true,
                int borderType=BORDER_DEFAULT );

测试代码：

static void on_box_filter(int, void *) {
    if (box_filter_size < 3)
        box_filter_size = 3;
    boxFilter(lena_bmp, box_filter_bmp, -1, Size(box_filter_size, box_filter_size));
    imshow("Box Filter", box_filter_bmp);
}

int main() {    
    lena_bmp = imread("../lena.bmp");

    namedWindow("Box Filter", 1);
    createTrackbar("Size", "Box Filter", &box_filter_size, 40, on_box_filter);
    imshow("Box Filter", lena_bmp);
    waitKey(0);
}

2.均值滤波

函数名：blur

接口定义：

void blur( InputArray src, OutputArray dst,
           Size ksize, Point anchor=Point(-1,-1),
           int borderType=BORDER_DEFAULT );

测试代码：

static void on_blur_filter(int, void *) {   
    blur(lena+bmp, blur_test_bmp, Size(blur_size, blur_size));
    imshow("Blur Filter", blur_test_bmp);
}

int main() {
    lena_bmp = imread("../lena.bmp");
    namedWindow("Blur Filter", 1);
    createTrackbar("Size", "Blur Filter", &blur_size, on_blur_filter);
    imshow("Blur Filter", lena_bmp);
    waitKey(0);
}

3.高斯滤波

函数名：GaussianBlur

接口定义：

void GaussianBlur( InputArray src,
                   OutputArray dst, Size ksize,
                   double sigmaX, double sigmaY=0,
                   int borderType=BORDER_DEFAULT );

测试代码：

static void on_gaussian_blur(int, void *) {
    if (gaussian_blur_size < 1) 
        gaussian_blur_size = 1;
    GaussianBlur(lena_bmp, gaussian_blur_bmp, Size(gaussian_blur_size * 2 + 1, 
        gaussian_blur_size * 2 + 1), gaussian_sigma_x / 10.0, gaussian_sigma_y / 10.0);
    imshow("Gaussian Blur", gaussian_blur_bmp);
}

int main() {
    lena_bmp = imread("../lena.bmp");
    namedWindow("Gaussian Blur", 1);
    createTrackbar("Size", "Gaussian Blur", &gaussian_blur_size, 40, on_gaussian_blur);
    createTrackbar("SigmaX", "Gaussian Blur", &gaussian_sigma_x, 100, on_gaussian_blur);
    createTrackbar("SigmaY", "Gaussian Blur", &gaussian_sigma_y, 100, on_gaussian_blur);
    imshow("Gaussian Blur", lena_bmp);
    waitKey(0);
}

4.中值滤波

函数名：medianBlur

接口定义：

void medianBlur( InputArray src, OutputArray dst, int ksize );

测试代码：

static void on_median_blur(int, void *) {
    if (median_size < 3) 
        median_size = 3;
    medianBlur(lena_bmp, median_blur_bmp, median_size * 2 + 1);
    imshow("Median Blur", median_blur_bmp);
}

int main() {
    lena_bmp = imread("../lena.bmp");
    namedWindow("Median Blur", 1);
    createTrackbar("Median Size:", "Median Blur", &median_size, 40, on_median_blur);
    imshow("Median Blur", lena_bmp);
    waitKey(0);
}

5.卷积运算

函数名：filter2D

接口定义：

void sepFilter2D( InputArray src, OutputArray dst, int ddepth,
                  InputArray kernelX, InputArray kernelY,
                  Point anchor=Point(-1,-1),
                  double delta=0, int borderType=BORDER_DEFAULT );

测试代码：

void test_filter2d() {
    /* 注意类型 */
    Mat kernel3 = (Mat_<char>(3, 3) << 1, 2, 1,
                                    0, 0, 0, 
                                    -1, -2, -1);
    Mat filter2d_bmp;
    filter2D(lena_bmp, filter2d_bmp, lena_bmp.depth(), kernel3);
    namedWindow("Filter2D", 1);
    imshow("Filter2D", filter2d_bmp);
}

int main() {
    lena_bmp = imread("../lena.bmp");
    test_filter2d();
    waitKey(0);
}

6.双边滤波

函数名：bilateralFilter

接口定义：

void bilateralFilter( InputArray src, OutputArray dst, int d,
                      double sigmaColor, double sigmaSpace,
                      int borderType=BORDER_DEFAULT );

测试代码：

double generate_gaussian_noise(double mu, double sigma) {
    const double epsilon = std::numeric_limits<double>::min();
    static double z0, z1;
    static bool flag = false;
    flag = !flag;
    if (!flag)
        return z1*sigma + mu;
    double u1, u2;
    do {
        u1 = rand()*(1.0 / RAND_MAX);
        u2 = rand()*(1.0 / RAND_MAX);
    } while (u1 <= epsilon);
    z0 = sqrt(-2.0*log(u1))*cos(2.0*CV_PI*u2);
    z1 = sqrt(-2.0*log(u1))*sin(2.0*CV_PI*u2);
    return z0*sigma + mu;
}

void add_gaussian_noise(const Mat& src, Mat& dst, double mu, double sigma) {
    dst = src.clone();
    int channels = dst.channels();
    int nrows = dst.rows;
    int ncols = dst.cols*channels;
    if (dst.isContinuous()) {
        ncols *= nrows;
        nrows = 1;
    }
    for (int i = 0; i < nrows; i++)
        for (int j = 0; j < ncols; j++) {
            dst.ptr<uchar>(i)[j] = saturate_cast<uchar>(dst.ptr<uchar>(i)[j] + 
                generate_gaussian_noise(mu, sigma) * 32);
        }
}

static void on_bilateral_filter(int, void *) {
    bilateralFilter(gaussian_noise_bmp, bilateral_bmp, d - 5, sigma_color*1.0, sigma_space*1.0);
    imshow("Bilateral Filter", bilateral_bmp);
}

int main() {
    namedWindow("Bilateral Filter", 1);
    add_gaussian_noise(lena_bmp, gaussian_noise_bmp, -2, 4.5);
    createTrackbar("d", "Bilateral Filter", &d, 20, on_bilateral_filter);
    createTrackbar("Color", "Bilateral Filter", &sigma_color, 500, on_bilateral_filter);
    createTrackbar("Space", "Bilateral Filter", &sigma_space, 500, on_bilateral_filter);
    waitKey(0);
}