【4】python-opencv3教程：图像平滑1（高斯平滑，快速均值平滑，中值平滑，双边滤波平滑）

╰半夏微凉° 2022-03-16 04:24 433阅读 0赞

# 第四节：图像平滑1 #

### **一：高斯平滑** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 1][]

通过以上步骤我们写一个构建高斯卷积算子的代码

def getGaussKernel(sigma, H, W):    
    
        # 第一步:构建高斯矩阵
        gaussMatrix = np.zeros([H, W], np.float32)
        # 得到中心点的位置
        cH = (H - 1)/2
        cW = (W - 1)/2
        # 计算guass(sigma, r, c)
        for r in range(H):
            for c in range(W):
                norm2 = math.pow(r-cH, 2) + math.pow(c-cW, 2)
                gaussMatrix[r][c] = math.exp(-norm2/(2*math.pow(sigma, 2)))
        # 第二步:计算高斯矩阵的和
        sumGM = np.sum(gaussMatrix)
        # 第三步:归一化
        gaussKernel = gaussMatrix/sumGM
        return gaussKernel

其实在真正的实践中，这个高斯卷积算子不用我们去实现，opencv给我们提供了函数cv2.getGaussianKernel()。。还有一点我想说一下，高斯算子是一个可分的算子，也就是分为一个子算子乘另一个子算子。。我们在做卷积的时候，图像可以先与水平高斯卷积核卷积，卷积出来的结果再与垂直方向的高斯卷积核卷积。。 我们做一个高斯卷积平滑的例子。。

import numpy as np
    from scipy import signal
    import cv2
    
    def gaussBlur(image, sigma, H, W, _boundary = 'fill', _fillvalue=0):
        # 构建水平方向上的高斯卷积核
        gaussKernel_x = cv2.getGaussianKernel(sigma, W, cv2.CV_64F)
        # 转置
        gaussKernel_x = np.transpose(gaussKernel_x)
        # 图像矩阵与水平高斯卷积核卷积
        gaussBlur_x = signal.convolve2d(image, gaussKernel_x, mode='same', boundary=_boundary, fillvalue=_fillvalue)
    
        gaussKernel_y = cv2.getGaussianKernel(sigma, H, cv2.CV_64F)
        # 与垂直方向上的高斯卷积核卷积
        gaussBlur_xy = signal.convolve2d(gaussBlur_x, gaussKernel_y, mode='same', boundary=_boundary, fillvalue=_fillvalue)
        return gaussBlur_xy
    
    if __name__ == '__main__':
        image = cv2.imread('p1.jpg', cv2.IMREAD_GRAYSCALE)
        # 显示原图
        cv2.imshow('origin', image)
        # 高斯平滑
        blurImage = gaussBlur(image, 5, 51, 51, 'symm')
    
        # 对blurImage进行灰度级显示
        blurImage = np.round(blurImage)
        blurImage = blurImage.astype(np.uint8)
        cv2.imshow('smooth', blurImage)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

输出结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 2][]

### **二：均值平滑+快速均值平滑** ###

均值平滑

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 4][]

快速均值平滑

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 6][]

然后，图像积分完成后，计算某个位置的像素值，用下面的公式。。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 9][]

下面是代码实现：

import numpy as np
    import cv2
    
    def integral(image):
        '''
        图像积分
        :param image:
        :return:
        '''
        rows, cols = image.shape
    
        # 行积分运算
        inteImageC = np.zeros((rows, cols), np.float32)
        for r in range(rows):
            for c in range(cols):
                if c == 0:
                    inteImageC[r][c] = image[r][c]
                else:
                    inteImageC[r][c] = inteImageC[r][c-1] + image[r][c]
    
        # 列积分
        interImage = np.zeros((rows, cols), np.float32)
        for c in range(cols):
            for r in range(rows):
                if r == 0:
                    interImage[r][c] = inteImageC[r][c]
                else:
                    interImage[r][c] = interImage[r-1][c] + inteImageC[r][c]
        # 先行再列  或者 先列再行  积分的结果是一致的
    
        # 上边和左边补零
        interImage_0 = np.zeros((rows+1, cols+1), np.float32)
        interImage_0[1:rows+1, 1:cols+1] = interImage
        return interImage_0
    
    # 快速均值滤波
    def fastMeanBlur(image, winSize, borderType=cv2.BORDER_DEFAULT):
    
        halfH = int((winSize[0] - 1) / 2)
        halfW = int((winSize[1] - 1) / 2)
        ratio = 1.0 / (winSize[0] * winSize[1])
        # 边界扩充
        paddImage = cv2.copyMakeBorder(image, halfH, halfH, halfW, halfW, borderType)
        # 图像积分
        paddIntegral = integral(paddImage)
    
        # 获取图像的高宽
        rows, cols = image.shape
    
        # 均值滤波后的结果
        meanBlurImage = np.zeros((rows, cols), np.float32)
    
        r, c = 0, 0
        for h in range(halfH, halfH+rows, 1):   # 这里要想到边界扩充
            for w in range(halfW, halfW+cols, 1):
                meanBlurImage[r][c] = (paddIntegral[h+halfH+1][w+halfW+1] + paddIntegral[h-halfH][w-halfW]
                                       -paddIntegral[h+halfH+1][w-halfW]-paddIntegral[h-halfH][w+halfW+1])*ratio
                c += 1
            r += 1
            c = 0
        return meanBlurImage
    
    if __name__ == '__main__':
    
        image = cv2.imread('p1.jpg', cv2.IMREAD_GRAYSCALE)
    
        meanBlurImage = fastMeanBlur(image, (5, 5), borderType=cv2.BORDER_DEFAULT)
        meanBlurImage = meanBlurImage.astype(np.uint8)
        cv2.imshow('origin', image)
        cv2.imshow('meanBlurImage', meanBlurImage)
    
        # common_mean = common_mean_blur(image, (3, 3))
        # common_mean = np.round(common_mean)
        # common_mean = common_mean.astype(np.uint8)
        # cv2.imshow('common_image', common_mean)
    
        cv2.waitKey(0)
        cv2.destroyAllWindows()

输出结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 10][]

### ** 三：中值平滑** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 11][]

中值平滑对有椒盐噪声的图片效果非常好。。所以我们下面将实验一下效果：先对图像加椒盐噪声，再对图像做中值平滑

代码实现：

import numpy as np
    import random
    import cv2
    
    # 先加一点椒盐噪声   1000个白点，1000个黑点
    def salt(image, number):
        # 图像的宽，高
        rows, cols = image.shape
        # 加入椒盐噪声后的图像
        saltImage = np.copy(image)
        for i in range(number):
            randR = random.randint(0, rows - 1)
            randC = random.randint(0, cols - 1)
            saltImage[randR][randC] = 255
        for i in range(number):
            randR = random.randint(0, rows - 1)
            randC = random.randint(0, cols - 1)
            saltImage[randR][randC] = 0
    
        return saltImage
    
    def medianBlur(image, winSize):
        # 图像的高，宽
        rows, cols = image.shape
        # 窗口的宽高均为奇数
        winH, winW = winSize
        halfWinH = int((winH - 1) / 2)
        halfWinW = int((winW - 1) / 2)
    
        # 中值滤波后的输出图像
        medianBlurImage = np.zeros(image.shape, image.dtype)
        for r in range(rows):
            for c in range(cols):
                # 判断边界
                rTop = 0 if r-halfWinH < 0 else r-halfWinH
                rBottom = rows-1 if r+halfWinH > rows-1 else r+halfWinH
                cLeft = 0 if c-halfWinW < 0 else c-halfWinW
                cRight = cols if c+halfWinW > cols-1 else c+halfWinW
    
                # 取邻域
                region = image[rTop:rBottom+1, cLeft:cRight+1]
                # 求中值
                medianBlurImage[r][c] = np.median(region)
        return medianBlurImage
    
    if __name__ == '__main__':
    
        image = cv2.imread('p1.jpg', cv2.IMREAD_GRAYSCALE)
        saltImage = salt(image, 1000)
    
        # 用中值滤波平滑加了椒盐噪声的图片
        medianBlurImage = medianBlur(saltImage, (5, 5))
        
        cv2.imshow('saltImage', saltImage)
        cv2.imshow('meanImage', medianBlurImage)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

输出结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 12][]

### **四：双边滤波平滑** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 13][]

![2019022616175918.png][]

代码实现：

import cv2
    import numpy as np
    import math
    
    def getClosenessWeight(sigma_g, H, W):
    
        # 计算空间距离权重模板
        r, c = np.mgrid[0:H:1, 0:W:1]  # 构造三维表
        r -= int((H-1) / 2)
        c -= int((W-1) / 2)
        closeWeight = np.exp(-0.5*(np.power(r, 2)+np.power(c, 2))/math.pow(sigma_g, 2))
        return closeWeight
    
    def bfltGray(I, H, W, sigma_g, sigma_d):
    
        # 构建空间距离权重模板
        closenessWeight = getClosenessWeight(sigma_g, H, W)
    
        # 模板的中心点位置
        cH = int((H - 1) / 2)
        cW = int((W - 1) / 2)
    
        # 图像矩阵的行数和列数
        rows, cols = I.shape
    
        # 双边滤波后的结果
        bfltGrayImage = np.zeros(I.shape, np.float32)
        for r in range(rows):
            for c in range(cols):
                pixel = I[r][c]
                # 判断边界
                rTop = 0 if r-cH < 0 else r-cH
                rBottom = rows-1 if r+cH > rows-1 else r+cH
                cLeft = 0 if c-cW < 0 else c-cW
                cRight = cols-1 if c+cW > cols-1 else c+cW
    
                # 权重模板的作用区域
                region = I[rTop:rBottom+1, cLeft:cRight+1]
    
                # 构建灰度值相似性的权重因子
                similarityWeightTemp = np.exp(-0.5*np.power(region-pixel, 2.0)/math.pow(sigma_d, 2))
                closenessWeightTemp = closenessWeight[rTop-r+cH:rBottom-r+cH+1, cLeft-c+cW:cRight-c+cW+1]
    
                # 两个权重模板相乘
                weightTemp = similarityWeightTemp * closenessWeightTemp
    
                # 归一化权重模板
                weightTemp = weightTemp / np.sum(weightTemp)
    
                # 权重模板和对应邻域值相乘求和
                bfltGrayImage[r][c] = np.sum(region * weightTemp)
        return bfltGrayImage
    
    if __name__ == '__main__':
    
        image = cv2.imread('p1.jpg', cv2.IMREAD_GRAYSCALE)
        # 显示原图
        cv2.imshow('origin', image)
    
        # 将灰度值进行归一化
        image = image / 255.0
    
        # 双边滤波
        bfltImage = bfltGray(image, 33, 33, 19, 0.2)
        cv2.imshow('bfltImage', bfltImage)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

双边滤波的代码运行不出来，不知道代码有问题还是电脑有问题？  大家复制过去自己跑一下。。。。

###      未完待续。。。。。。图像平滑还有第二部分。。。 ###

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70]: /images/20220316/d772106e71b14c4fa7f661990cd1ac1c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 1]: /images/20220316/c9f7aae12b564903b3eb050c3230694b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 2]: /images/20220316/cfe953513f504a70aa652cd251a72c82.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 3]: /images/20220316/816ab8d5905541c7a339c3f42bf4eccf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 4]: /images/20220316/13a3eebe093944b88c7104cefcd682e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 5]: /images/20220316/f7b513b3f4274bc3b006dd4fe8ff4eca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 6]: /images/20220316/b2c407ec4ad5479a912c3273d97c44ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 7]: /images/20220316/942df575be50460faa99fb2a871ae15a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 8]: /images/20220316/c2d0040a07354afda7e3b0cb99922376.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 9]: /images/20220316/253ceb91f552495bb606c6e6ba5d4c9d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 10]: /images/20220316/67a7f4a665384413b2945ffdd7fdbe8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 11]: /images/20220316/daf54b0bf16045b2b2fcf7588f85896f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 12]: /images/20220316/3fedc722a8564289a0c434214d5d1b75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 13]: /images/20220316/dece04846c954f249547a05b90007a06.png
[2019022616175918.png]: /images/20220316/5fdf461e4c8d47fc99099f57e0b5fbda.png