opencv——图像滤波_高斯滤波

1、高斯模糊_练习

#!/usr/bin/env python3
# -*- coding: utf-8 -*-


"""
低通滤波有模糊图像，消除噪声的作用
        高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，
        用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。 

    使用函数cv2.GaussianBlur()进行高斯模糊
    函数原型：GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType]]]) -> dst
        返回值
            dst：高斯模糊后的图像
        参数解析：
                ksize: 高斯内核大小
                    ksize.width和ksize.height可以不相同但是这两个值必须为正奇数
                    如果这两个值为0，他们的值将由sigma计算。

                sigmaX: 高斯核函数在X方向上的标准偏差

                sigmaY: 高斯核函数在Y方向上的标准偏差，如果sigmaY是0，
                        会自动将sigmaY的值设置为与sigmaX相同的值，
                        如果sigmaX和sigmaY都是0，这两个值将由ksize.width和ksize.height计算而来
                borderType:边框模式用于图像外部的像素，默认边缘像素拷贝

"""

import cv2 as cv
import numpy as np

# img_path = './images/Fig4.11(a).jpg'
# img_path = './images/Fig5.08(a).jpg'
# img_path = './images/Fig5.08(b).jpg'

# img_path = './images/fig_nasa.tif'
# img_path = './images/Fig5.26a.jpg'

img_path = './images/noisy2.png'

img = cv.imread(img_path, 0)

# 中值滤波
g_blur_3 = cv.GaussianBlur(img, (3, 3), 3, 3)
g_blur_5 = cv.GaussianBlur(img, (5, 5), 3, 3)
g_blur_9 = cv.GaussianBlur(img, (9, 9), 3, 3)
g_blur_15 = cv.GaussianBlur(img, (15, 15), 3, 3)
g_blur_35 = cv.GaussianBlur(img, (35, 35), 3, 3)

_, g_blur_src_thr = cv.threshold(img, 127, 255, cv.THRESH_BINARY)
_, g_blur_3_thr = cv.threshold(g_blur_3, 127, 255, cv.THRESH_BINARY)
_, g_blur_5_thr = cv.threshold(g_blur_5, 127, 255, cv.THRESH_BINARY)
_, g_blur_9_thr = cv.threshold(g_blur_9, 127, 255, cv.THRESH_BINARY)
_, g_blur_15_thr = cv.threshold(g_blur_15, 127, 255, cv.THRESH_BINARY)
_, g_blur_35_thr = cv.threshold(g_blur_35, 127, 255, cv.THRESH_BINARY)

cv.imwrite('./outputs/g_blur_src.jpg', img)
cv.imwrite('./outputs/g_blur_3.jpg', g_blur_3)
cv.imwrite('./outputs/g_blur_5.jpg', g_blur_5)
cv.imwrite('./outputs/g_blur_9.jpg', g_blur_9)
cv.imwrite('./outputs/g_blur_15.jpg', g_blur_15)
cv.imwrite('./outputs/g_blur_35.jpg', g_blur_35)

cv.imwrite('./outputs/g_blur_src_thr.jpg', g_blur_src_thr)
cv.imwrite('./outputs/g_blur_3_thr.jpg', g_blur_3_thr)
cv.imwrite('./outputs/g_blur_5_thr.jpg', g_blur_5_thr)
cv.imwrite('./outputs/g_blur_9_thr.jpg', g_blur_9_thr)
cv.imwrite('./outputs/g_blur_15_thr.jpg', g_blur_15_thr)
cv.imwrite('./outputs/g_blur_35_thr.jpg', g_blur_35_thr)

h1 = np.hstack((img, g_blur_3, g_blur_5))
h2 = np.hstack((g_blur_9, g_blur_15, g_blur_35))
cv.imshow('g_blur_test', np.vstack((h1, h2)))

cv.waitKey(0)
cv.destroyAllWindows()

2、高斯模糊

#!/usr/bin/env python3
# -*- coding: utf-8 -*-


"""
低通滤波有模糊图像，消除噪声的作用
        高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，
        用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。 

    使用函数cv2.GaussianBlur()进行高斯模糊
    函数原型：GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType]]]) -> dst
        返回值
            dst：高斯模糊后的图像
        参数解析：
                ksize: 高斯内核大小
                    ksize.width和ksize.height可以不相同但是这两个值必须为正奇数
                    如果这两个值为0，他们的值将由sigma计算。

                sigmaX: 高斯核函数在X方向上的标准偏差

                sigmaY: 高斯核函数在Y方向上的标准偏差，如果sigmaY是0，
                        会自动将sigmaY的值设置为与sigmaX相同的值，
                        如果sigmaX和sigmaY都是0，这两个值将由ksize.width和ksize.height计算而来
                borderType:边框模式用于图像外部的像素，默认边缘像素拷贝

"""

import cv2 as cv

img = cv.imread('./test.png')


def nothing(x):
    pass


cv.namedWindow('image')
# 创建滑动条
cv.createTrackbar('ksize.width', 'image', 1, 13, nothing)
cv.createTrackbar('ksize.height', 'image', 1, 13, nothing)
cv.createTrackbar('sigmaX', 'image', 0, 10, nothing)
cv.createTrackbar('sigmaY', 'image', 0, 10, nothing)

cv.imshow('img', img)
while True:

    kw = cv.getTrackbarPos('ksize.width', 'image')
    kh = cv.getTrackbarPos('ksize.height', 'image')
    sx = cv.getTrackbarPos('sigmaX', 'image')
    sy = cv.getTrackbarPos('sigmaY', 'image')
    kw = kw if kw % 2 == 1 else kw + 1
    kh = kh if kh % 2 == 1 else kh + 1

    g_blur = cv.GaussianBlur(img, (kw, kh), sx, sy)

    cv.imshow('image', g_blur)

    k = cv.waitKey(25) & 0XFF
    if chr(k) == 'q':
        break

cv.destroyAllWindows()

3、正态分布

import numpy as np

sampleNo = 1000
# 一维正态分布
# 下面三种方式是等效的
mu = 3
sigma = 0.1
np.random.seed(0)
s = np.random.normal(.5, .1, size=9)
dst = s / sum(s)
dst_3x3 = dst.reshape(3, 3)

img = np.array([80, 73, 69, 77, 83, 74, 74, 79, 74], np.uint8).reshape(3, 3)
img_1 = np.array([80, 80, 73, 80, 80, 73, 77, 77, 76], np.uint8).reshape(3, 3)
resize = img * dst_3x3
resize_1 = img_1 * dst_3x3
print(img)
print('*' * 60)
print(dst_3x3)
print('*' * 60)
print(resize)
print(int(sum(resize.reshape(-1, ))))
print(int(sum(resize_1.reshape(-1, ))))
print(sum(dst))

4、综合对比

#!/usr/bin/env python3
# -*- coding: utf-8 -*-


"""
对摄像头的每一帧，分别进行多种滤波操作，放在一起显示，以直观的查看滤波函数的差异性
"""

import cv2 as cv
import numpy as np


def nothing(x):
    pass


# 打开系统默认摄像头
cap = cv.VideoCapture(0)

cv.namedWindow('windows')
cv.createTrackbar('ks', 'windows', 3, 31, nothing)
font = cv.FONT_HERSHEY_SIMPLEX

while cap.isOpened():
    ret, frame = cap.read()
    frame = cv.resize(frame, None, fx=.5, fy=.5, interpolation=cv.INTER_CUBIC)
    if not ret:
        break
    ks = cv.getTrackbarPos('ks', 'windows')
    # 保证kernel为正奇数
    ks = ks if ks % 2 == 1 else ks + 1

    # 2D 卷积
    kernel = np.ones((ks, ks), np.float32) / (ks * ks)
    filter2D = cv.filter2D(frame, -1, kernel)
    filter2D = cv.putText(filter2D, "filter2D", (20, 20), font, .65, (255, 255, 255), 2)

    # 平均模糊
    blur = cv.blur(frame, (ks, ks))
    blur = cv.putText(blur, "blur", (20, 20), font, .65, (255, 255, 255), 2)

    # 高斯滤波
    g_blur = cv.GaussianBlur(frame, (ks, ks), 0)
    g_blur = cv.putText(g_blur, "g_blur", (20, 20), font, .65, (255, 255, 255), 2)

    # 中值滤波
    medianBlur = cv.medianBlur(frame, ks)
    medianBlur = cv.putText(medianBlur, "medianBlur", (20, 20), font, .65, (255, 255, 255), 2)

    # 双边滤波
    b_filter = cv.bilateralFilter(frame, -1, 2 * ks, int(.7 * ks))
    b_filter = cv.putText(b_filter, "b_filter", (20, 20), font, .65, (255, 255, 255), 2)

    hs1 = np.hstack((frame, filter2D, blur))
    hs2 = np.hstack((g_blur, medianBlur, b_filter))
    vs = np.vstack((hs1, hs2))

    cv.imshow('windows', vs)
    k = cv.waitKey(24) & 0xFF
    if chr(k) == 'q':
        break