[Python图像处理] 三十三.图像各种特效处理及原理万字详解（毛玻璃、浮雕、素描、怀旧、流年、滤镜等）

此文转载自：https://blog.csdn.net/Eastmount/article/details/111568397

该系列文章是讲解Python OpenCV图像处理知识，前期主要讲解图像入门、OpenCV基础用法，中期讲解图像处理的各种算法，包括图像锐化算子、图像增强技术、图像分割等，后期结合深度学习研究图像识别、图像分类应用。希望文章对您有所帮助，如果有不足之处，还请海涵~

这篇万字文章一方面是感谢大家读这个专栏的喜欢，另一方面圣诞节、元旦节、情人节要到了，送给大家拿去表白或美化自己吧！哈哈。前面一篇文章介绍了两个重要的算法——傅里叶变换和霍夫变换。这篇文章将介绍12种常见的图像处理特效，万字长文整理，希望对您有所帮助。同时，该部分知识均为作者查阅资料撰写总结，并且开设成了收费专栏，为小宝赚点奶粉钱，感谢您的抬爱。当然如果您是在读学生或经济拮据，可以私聊我给你每篇文章开白名单，或者转发原文给你，更希望您能进步，一起加油喔~

• https://github.com/eastmountyxz/ImageProcessing-Python

前文参考：
[Python图像处理] 一.图像处理基础知识及OpenCV入门函数
[Python图像处理] 二.OpenCV+Numpy库读取与修改像素
[Python图像处理] 三.获取图像属性、兴趣ROI区域及通道处理
[Python图像处理] 四.图像平滑之均值滤波、方框滤波、高斯滤波及中值滤波
[Python图像处理] 五.图像融合、加法运算及图像类型转换
[Python图像处理] 六.图像缩放、图像旋转、图像翻转与图像平移
[Python图像处理] 七.图像阈值化处理及算法对比
[Python图像处理] 八.图像腐蚀与图像膨胀
[Python图像处理] 九.形态学之图像开运算、闭运算、梯度运算
[Python图像处理] 十.形态学之图像顶帽运算和黑帽运算
[Python图像处理] 十一.灰度直方图概念及OpenCV绘制直方图
[Python图像处理] 十二.图像几何变换之图像仿射变换、图像透视变换和图像校正
[Python图像处理] 十三.基于灰度三维图的图像顶帽运算和黑帽运算
[Python图像处理] 十四.基于OpenCV和像素处理的图像灰度化处理
[Python图像处理] 十五.图像的灰度线性变换
[Python图像处理] 十六.图像的灰度非线性变换之对数变换、伽马变换
[Python图像处理] 十七.图像锐化与边缘检测之Roberts算子、Prewitt算子、Sobel算子和Laplacian算子
[Python图像处理] 十八.图像锐化与边缘检测之Scharr算子、Canny算子和LOG算子
[Python图像处理] 十九.图像分割之基于K-Means聚类的区域分割
[Python图像处理] 二十.图像量化处理和采样处理及局部马赛克特效
[Python图像处理] 二十一.图像金字塔之图像向下取样和向上取样
[Python图像处理] 二十二.Python图像傅里叶变换原理及实现
[Python图像处理] 二十三.傅里叶变换之高通滤波和低通滤波
[Python图像处理] 二十四.图像特效处理之毛玻璃、浮雕和油漆特效
[Python图像处理] 二十五.图像特效处理之素描、怀旧、光照、流年以及滤镜特效
[Python图像处理] 二十六.图像分类原理及基于KNN、朴素贝叶斯算法的图像分类案例
[Python图像处理] 二十七.OpenGL入门及绘制基本图形（一）
[Python图像处理] 二十八.OpenCV快速实现人脸检测及视频中的人脸
[Python图像处理] 二十九.MoviePy视频编辑库实现抖音短视频剪切合并操作
[Python图像处理] 三十.图像量化及采样处理万字详细总结（推荐）
[Python图像处理] 三十一.图像点运算处理两万字详细总结（灰度化处理、阈值化处理）
[Python图像处理] 三十二.傅里叶变换（图像去噪）与霍夫变换（特征识别）万字详细总结
[Python图像处理] 三十三.图像各种特效处理及原理万字详解（毛玻璃、浮雕、素描、怀旧、流年、滤镜等）

文章目录

• 一.图像毛玻璃特效
• 二.图像浮雕特效
• 三.图像油漆特效
• 四.图像素描特效
• 五.图像怀旧特效
• 六.图像光照特效
• 七.图像流年特效
• 八.图像水波特效
• 九.图像卡通特效
• 十.图像滤镜特效
• 十一.图像直方图均衡化特效
• 十二.图像模糊特效
• 十三.本章小结

---

前面文章围绕Python图像处理，从图像基础操作、几何变换、点运算、直方图、图像增强、图像平滑、图像锐化等方面进行了详细讲解。本篇文章将继续补充常见的图像特效处理，从而让读者实现各种各样的图像特殊效果。

一.图像毛玻璃特效

图像毛玻璃特效如下图所示，左边为原始图像，右边为毛玻璃特效图像。它是用图像邻域内随机一个像素点的颜色来替代当前像素点颜色的过程，从而为图像增加一个毛玻璃模糊的特效。

Python实现代码主要是通过双层循环遍历图像的各像素点，再用定义的随机数去替换各邻域像素点的颜色，具体代码如下所示。

#coding:utf-8
#By:Eastmount CSDN 2020-12-22
import cv2
import numpy as np
import matplotlib.pyplot as plt

#读取原始图像
src = cv2.imread('scenery.png')

#新建目标图像
dst = np.zeros_like(src)

#获取图像行和列
rows, cols = src.shape[:2]

#定义偏移量和随机数
offsets = 5
random_num = 0

#毛玻璃效果: 像素点邻域内随机像素点的颜色替代当前像素点的颜色
for y in range(rows - offsets):
    for x in range(cols - offsets):
        random_num = np.random.randint(0,offsets)
        dst[y,x] = src[y + random_num,x + random_num]

#显示图像
cv2.imshow('src',src)
cv2.imshow('dst',dst)

cv2.waitKey()
cv2.destroyAllWindows()

---

二.图像浮雕特效

图像浮雕特效是仿造浮雕艺术而衍生的处理，它将要呈现的图像突起于石头表面，根据凹凸程度不同形成三维的立体效果。Python绘制浮雕图像是通过勾画图像的轮廓，并降低周围的像素值，从而产生一张具有立体感的浮雕效果图。传统的方法是设置卷积核，再调用OpenCV的filter2D()函数实现浮雕特效。该函数主要是利用内核实现对图像的卷积运算，其函数原型如下所示：

• dst = filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]])
  – src表示输入图像
  – dst表示输出的边缘图，其大小和通道数与输入图像相同
  – ddepth表示目标图像所需的深度
  – kernel表示卷积核，一个单通道浮点型矩阵
  – anchor表示内核的基准点，其默认值为（-1，-1），位于中心位置
  – delta表示在储存目标图像前可选的添加到像素的值，默认值为0
  – borderType表示边框模式

核心代码如下：

kernel = np.array([[-1,0,0],[0,1,0],[0,0,0]])
output = cv2.filter2D(src, -1, kernel)

该部分将直接对各像素点进行处理，采用相邻像素相减的方法来得到图像轮廓与平面的差，类似边缘的特征，从而获得这种立体感的效果。为了增强图片的主观感受，还可以给这个差加上一个固定值，如150。实现效果如下图所示。

Python通过双层循环遍历图像的各像素点，使用相邻像素值之差来表示当前像素值，从而得到图像的边缘特征，最后加上固定数值150得到浮雕效果，具体代码如下所示。

# -*- coding: utf-8 -*-
#By:Eastmount CSDN 2020-12-22
import cv2
import numpy as np

#读取原始图像
img = cv2.imread('scenery.png', 1)

#获取图像的高度和宽度
height, width = img.shape[:2]

#图像灰度处理
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

#创建目标图像
dstImg = np.zeros((height,width,1),np.uint8)

#浮雕特效算法：newPixel = grayCurrentPixel - grayNextPixel + 150
for i in range(0,height):
    for j in range(0,width-1):
        grayCurrentPixel = int(gray[i,j])
        grayNextPixel = int(gray[i,j+1])
        newPixel = grayCurrentPixel - grayNextPixel + 150
        if newPixel > 255:
            newPixel = 255
        if newPixel < 0:
            newPixel = 0
        dstImg[i,j] = newPixel
        
#显示图像
cv2.imshow('src', img)
cv2.imshow('dst',dstImg)

#等待显示
cv2.waitKey()
cv2.destroyAllWindows()

---

三.图像油漆特效

图像油漆特效类似于油漆染色后的轮廓图形，它主要采用自定义卷积核和cv2.filter2D()函数实现，其运行结果如下图所示。

Python实现代码主要通过Numpy定义卷积核，再进行特效处理，卷积核如公式（1）所示，其中心权重为10，其余值均为-1。

# -*- coding: utf-8 -*-
#By:Eastmount CSDN 2020-12-22
import cv2
import numpy as np

#读取原始图像
src = cv2.imread('scenery.png')

#图像灰度处理
gray = cv2.cvtColor(src,cv2.COLOR_BGR2GRAY)

#自定义卷积核
kernel = np.array([[-1,-1,-1],[-1,10,-1],[-1,-1,-1]])
#kernel = np.array([[0,-1,0],[-1,5,-1],[0,-1,0]])

#图像浮雕效果
output = cv2.filter2D(gray, -1, kernel)

#显示图像
cv2.imshow('Original Image', src)
cv2.imshow('Emboss_1',output)

#等待显示
cv2.waitKey()
cv2.destroyAllWindows()

---

四.图像素描特效

图像素描特效会将图像的边界都凸显出来，通过边缘检测及阈值化处理能实现该功能。一幅图像的内部都具有相似性，而在图像边界处具有明显的差异，边缘检测利用数学中的求导来扩大这种变化。但是求导过程中会增大图像的噪声，所以边缘检测之前引入了高斯滤波降噪处理。本小节的图像素描特效主要经过以下几个步骤：

• (1) 调用cv2.cvtColor()函数将彩色图像灰度化处理；
• (2) 通过cv2.GaussianBlur()函数实现高斯滤波降噪；
• (3) 边缘检测采用Canny算子实现；
• (4) 最后通过cv2.threshold()反二进制阈值化处理实现素描特效。

其运行代码如下所示。

#coding:utf-8
#By:Eastmount CSDN 2020-12-22
import cv2
import numpy as np

#读取原始图像
img = cv2.imread('scenery.png')

#图像灰度处理
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

#高斯滤波降噪
gaussian = cv2.GaussianBlur(gray, (5,5), 0)
 
#Canny算子
canny = cv2.Canny(gaussian, 50, 150)

#阈值化处理
ret, result = cv2.threshold(canny, 100, 255, cv2.THRESH_BINARY_INV)

#显示图像
cv2.imshow('src', img)
cv2.imshow('result', result)

cv2.waitKey()
cv2.destroyAllWindows()

最终输出结果如下图所示，它将彩色图像素描处理。

图像的素描特效有很多种方法，本小节仅提供了一种方法，主要提取的是图像的边缘轮廓，还有很多更精细的素描特效方法，提取的轮廓更为清晰，如下图所示。希望读者能自行扩展相关算法知识，并实现对应的效果。参考何老师翻译的文章，推荐大家学习。

• 使用python和opencv将图片转化为素描图-python代码解析

完整代码如下：

#coding:utf-8
import cv2
import numpy as np
 
def dodgeNaive(image, mask):
    # determine the shape of the input image
    width, height = image.shape[:2]
 
    # prepare output argument with same size as image
    blend = np.zeros((width, height), np.uint8)
 
    for col in range(width):
        for row in range(height):
            # do for every pixel
            if mask[col, row] == 255:
                # avoid division by zero
                blend[col, row] = 255
            else:
                # shift image pixel value by 8 bits
                # divide by the inverse of the mask
                tmp = (image[col, row] << 8) / (255 - mask)
                # print('tmp={}'.format(tmp.shape))
                # make sure resulting value stays within bounds
                if tmp.any() > 255:
                    tmp = 255
                    blend[col, row] = tmp
    return blend
 
def dodgeV2(image, mask):
    return cv2.divide(image, 255 - mask, scale=256)
 
def burnV2(image, mask):
    return 255 - cv2.divide(255 - image, 255 - mask, scale=256)
 
def rgb_to_sketch(src_image_name, dst_image_name):
    img_rgb = cv2.imread(src_image_name)
    img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)
    # 读取图片时直接转换操作
    # img_gray = cv2.imread('example.jpg', cv2.IMREAD_GRAYSCALE)
 
    img_gray_inv = 255 - img_gray
    img_blur = cv2.GaussianBlur(img_gray_inv, ksize=(21, 21),
                                sigmaX=0, sigmaY=0)
    img_blend = dodgeV2(img_gray, img_blur)
 
    cv2.imshow('original', img_rgb)
    cv2.imshow('gray', img_gray)
    cv2.imshow('gray_inv', img_gray_inv)
    cv2.imshow('gray_blur', img_blur)
    cv2.imshow("pencil sketch", img_blend)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    cv2.imwrite(dst_image_name, img_blend)
 
if __name__ == '__main__':
    src_image_name = 'scenery.png'
    dst_image_name = 'sketch_example.jpg'
    rgb_to_sketch(src_image_name, dst_image_name)

---

五.图像怀旧特效

图像怀旧特效是指图像经历岁月的昏暗效果，如图13-6所示，左边“src”为原始图像，右边“dst”为怀旧特效图像。

怀旧特效是将图像的RGB三个分量分别按照一定比例进行处理的结果，其怀旧公式如（2）所示。

Python实现代码主要通过双层循环遍历图像的各像素点，再结合该公式计算各颜色通道的像素值，最终生成如图所示的效果，其完整代码如下。

#coding:utf-8
#By:Eastmount CSDN 2020-12-22
import cv2
import numpy as np

#读取原始图像
img = cv2.imread('nv.png')

#获取图像行和列
rows, cols = img.shape[:2]

#新建目标图像
dst = np.zeros((rows, cols, 3), dtype="uint8")

#图像怀旧特效
for i in range(rows):
    for j in range(cols):
        B = 0.272*img[i,j][2] + 0.534*img[i,j][1] + 0.131*img[i,j][0]
        G = 0.349*img[i,j][2] + 0.686*img[i,j][1] + 0.168*img[i,j][0]
        R = 0.393*img[i,j][2] + 0.769*img[i,j][1] + 0.189*img[i,j][0]
        if B>255:
            B = 255
        if G>255:
            G = 255
        if R>255:
            R = 255
        dst[i,j] = np.uint8((B, G, R))
        
#显示图像
cv2.imshow('src', img)
cv2.imshow('dst', dst)

cv2.waitKey()
cv2.destroyAllWindows()

---

六.图像光照特效

图像光照特效是指图像存在一个类似于灯光的光晕特效，图像像素值围绕光照中心点呈圆形范围内的增强。如下图所示，该图像的中心点为（192，192），光照特效之后中心圆范围内的像素增强了200。该处理效果最早是作者2013年Android图像处理做的应用，现在改成了Python，哈哈！

• [Android] 通过Menu实现图片怀旧、浮雕、模糊、光照和素描效果

Python实现代码主要是通过双层循环遍历图像的各像素点，寻找图像的中心点，再通过计算当前点到光照中心的距离（平面坐标系中两点之间的距离），判断该距离与图像中心圆半径的大小关系，中心圆范围内的图像灰度值增强，范围外的图像灰度值保留，并结合边界范围判断生成最终的光照效果。

#coding:utf-8
#By:Eastmount CSDN 2020-12-22
import cv2
import math
import numpy as np

#读取原始图像
img = cv2.imread('nv.png')

#获取图像行和列
rows, cols = img.shape[:2]

#设置中心点
centerX = rows / 2
centerY = cols / 2
print(centerX, centerY)
radius = min(centerX, centerY)
print(radius)

#设置光照强度
strength = 200

#新建目标图像
dst = np.zeros((rows, cols, 3), dtype="uint8")

#图像光照特效
for i in range(rows):
    for j in range(cols):
        #计算当前点到光照中心的距离(平面坐标系中两点之间的距离)
        distance = math.pow((centerY-j), 2) + math.pow((centerX-i), 2)
        #获取原始图像
        B =  img[i,j][0]
        G =  img[i,j][1]
        R = img[i,j][2]
        if (distance < radius * radius):
            #按照距离大小计算增强的光照值
            result = (int)(strength*( 1.0 - math.sqrt(distance) / radius ))
            B = img[i,j][0] + result
            G = img[i,j][1] + result
            R = img[i,j][2] + result
            #判断边界 防止越界
            B = min(255, max(0, B))
            G = min(255, max(0, G))
            R = min(255, max(0, R))
            dst[i,j] = np.uint8((B, G, R))
        else:
            dst[i,j] = np.uint8((B, G, R))
        
#显示图像
cv2.imshow('src', img)
cv2.imshow('dst', dst)

cv2.waitKey()
cv2.destroyAllWindows()

---

七.图像流年特效

流年是用来形容如水般流逝的光阴或年华，图像处理中特指将原图像转换为具有时代感或岁月沉淀的特效，其效果如下图所示。

Python实现代码详见如下，它将原始图像的蓝色（B）通道的像素值开根号，再乘以一个权重参数，产生最终的流年效果。

#coding:utf-8
#By:Eastmount CSDN 2020-12-22
import cv2
import math
import numpy as np

#读取原始图像
img = cv2.imread('nv.png')

#获取图像行和列
rows, cols = img.shape[:2]

#新建目标图像
dst = np.zeros((rows, cols, 3), dtype="uint8")

#图像流年特效
for i in range(rows):
    for j in range(cols):
        #B通道的数值开平方乘以参数12
        B = math.sqrt(img[i,j][0]) * 12
        G =  img[i,j][1]
        R =  img[i,j][2]
        if B>255:
            B = 255
        dst[i,j] = np.uint8((B, G, R))
        
#显示图像
cv2.imshow('src', img)
cv2.imshow('dst', dst)

cv2.waitKey()
cv2.destroyAllWindows()

---

八.图像水波特效

图像水波特效是将图像转换为波浪的效果，围绕水波中心点进行波纹涟漪传递，如图所示。该效果有点丑，读者可以设置透明度进一步优化，可能效果会好看些。

Python实现代码如下所示，它通过计算水波中心位置，然后调用np.sin()函数计算水波传递函数，最终形成水波特效。该小节的代码是依次计算图像所有像素点并进行相关运算，具有一定难度，希望读者能实现对应的效果。

#coding:utf-8
#By:Eastmount CSDN 2020-12-22
import cv2
import math
import numpy as np

#读取原始图像
img = cv2.imread('scenery.png')

#获取图像行和列
rows, cols = img.shape[:2]

#新建目标图像
dst = np.zeros((rows, cols, 3), dtype="uint8")

#定义水波特效参数
wavelength = 20
amplitude = 30
phase = math.pi / 4

#获取中心点
centreX = 0.5
centreY = 0.5
radius = min(rows, cols) / 2

#设置水波覆盖面积
icentreX = cols*centreX
icentreY = rows*centreY
    
#图像水波特效
for i in range(rows):
    for j in range(cols):
        dx = j - icentreX
        dy = i - icentreY
        distance = dx*dx + dy*dy
        
        if distance>radius*radius:
            x = j
            y = i
        else:
            #计算水波区域
            distance = math.sqrt(distance)
            amount = amplitude * math.sin(distance / wavelength * 2*math.pi - phase)
            amount = amount *  (radius-distance) / radius
            amount = amount * wavelength / (distance+0.0001)
            x = j + dx * amount
            y = i + dy * amount

        #边界判断
        if x<0:
            x = 0
        if x>=cols-1:
            x = cols - 2
        if y<0:
            y = 0
        if y>=rows-1:
            y = rows - 2

        p = x - int(x)
        q = y - int(y)
        
        #图像水波赋值
        dst[i, j, :] = (1-p)*(1-q)*img[int(y),int(x),:] + p*(1-q)*img[int(y),int(x),:]
        + (1-p)*q*img[int(y),int(x),:] + p*q*img[int(y),int(x),:]
        
#显示图像
cv2.imshow('src', img)
cv2.imshow('dst', dst)
cv2.waitKey()
cv2.destroyAllWindows()

---

九.图像卡通特效

图像卡通特效是将原始图像转换为具有卡通特色的效果图，本小节的算法主要包括以下几个步骤：

• 调用cv2.bilateralFilter()函数对原始图像进行双边滤波处理。该滤波器可以在保证边界清晰的情况下有效的去掉噪声，将像素值缩短为每7个灰度级为一个值。它同时使用了空间高斯权重和灰度相似性高斯权重，确保边界不会被模糊掉。
• 调用cv2.cvtColor()函数将原始图像转换为灰度图像，并进行中值滤波处理，接着调用cv2.adaptiveThreshold()函数进行自适应阈值化处理，并提取图像的边缘轮廓，将图像转换回彩色图像。此时显示的效果如图所示。

• 最后调用cv2.bitwise_and()函数将第1步和第2步产生的图像进行与运算，产生最终的卡通图像，如图所示。

Python实现代码如下所示。

#coding:utf-8
#By:Eastmount CSDN 2020-12-22
import cv2
import numpy as np

#读取原始图像
img = cv2.imread('nv.png')

#定义双边滤波的数目
num_bilateral = 7

#用高斯金字塔降低取样
img_color = img

#双边滤波处理
for i in range(num_bilateral):
    img_color = cv2.bilateralFilter(img_color, d=9, sigmaColor=9, sigmaSpace=7)

#灰度图像转换
img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

#中值滤波处理
img_blur = cv2.medianBlur(img_gray, 7)

#边缘检测及自适应阈值化处理
img_edge = cv2.adaptiveThreshold(img_blur, 255,
                                 cv2.ADAPTIVE_THRESH_MEAN_C,
                                 cv2.THRESH_BINARY,
                                 blockSize=9,
                                 C=2)

#转换回彩色图像
img_edge = cv2.cvtColor(img_edge, cv2.COLOR_GRAY2RGB)

#与运算
img_cartoon = cv2.bitwise_and(img_color, img_edge)

#显示图像
cv2.imshow('src', img)
cv2.imshow('dst', img_cartoon)
cv2.waitKey()
cv2.destroyAllWindows()

感觉这些算法都实现了，是一个不错的表白神奇啊！

---

十.图像滤镜特效

滤镜主要是用来实现图像的各种特殊效果，它在Photoshop中具有非常神奇的作用。滤镜通常需要同通道、图层等联合使用，才能取得最佳艺术效果。本小节将讲述一种基于颜色查找表（Look up Table）的滤镜处理方法，它通过将每一个原始颜色进行转换之后得到新的颜色。比如，原始图像的某像素点为红色（R-255, G-0, B-0），进行转换之后变为绿色（R-0, G-255, B-0），之后所有是红色的地方都会被自动转换为绿色，而颜色查找表就是将所有的颜色进行一次（矩阵）转换，很多的滤镜功能就是提供了这么一个转换的矩阵，在原始色彩的基础上进行颜色的转换。

假设现在存在一张新的滤镜颜色查找表，如下图所示，它是一张512×512大小，包含各像素颜色分布的图像。该图片建议大家去我github下载。

滤镜特效实现的Python代码如下所示，它通过自定义getBRG()函数获取颜色查找表中映射的滤镜颜色，再依次循环替换各颜色。

完整代码如下：

#coding:utf-8
import cv2
import math
import numpy as np

#获取滤镜颜色
def getBGR(img, table, i, j):
    #获取图像颜色
    b, g, r = img[i][j]
    #计算标准颜色表中颜色的位置坐标
    x = int(g/4 + int(b/32) * 64)
    y = int(r/4 + int((b%32) / 4) * 64)
    #返回滤镜颜色表中对应的颜色
    return lj_map[x][y]

#读取原始图像
img = cv2.imread('scenery.png')
lj_map = cv2.imread('table.png')

#获取图像行和列
rows, cols = img.shape[:2]

#新建目标图像
dst = np.zeros((rows, cols, 3), dtype="uint8")

#循环设置滤镜颜色
for i in range(rows):
    for j in range(cols):
        dst[i][j] = getBGR(img, lj_map, i, j)
        
#显示图像
cv2.imshow('src', img)
cv2.imshow('dst', dst)

cv2.waitKey()
cv2.destroyAllWindows()

滤镜特效的运行结果如图所示，其中左边“src”为原始女神图像，右边“dst”为滤镜处理后的图像，其颜色变得更为鲜艳，对比度更强。

---

十一.图像直方图均衡化特效

图像直方图均衡化是图像处理领域中利用图像直方图对对比度进行调整的方法，其目的是使输入图像转换为在每一灰度级上都有相同的像素点（即输出的直方图是平的），它可以产生一幅灰度级分布概率均衡的图像，它是增强图像的有效手段之一。

本部分主要是对彩色图像的直方图均衡化特效处理，它将彩色图像用split()函数拆分成BGR三个通道，然后调用equalizeHist()函数分别进行均衡化处理，最后使用merge()方法将均衡化之后的三个通道进行合并，生成最终的效果图。实现代码如下所示。

#coding:utf-8
#By:Eastmount CSDN 2020-12-22
import cv2
import numpy as np

#读取原始图像
img = cv2.imread('scenery.png')

#获取图像行和列
rows, cols = img.shape[:2]

#新建目标图像
dst = np.zeros((rows, cols, 3), dtype="uint8")

#提取三个颜色通道
(b, g, r) = cv2.split(img)

#彩色图像均衡化
bH = cv2.equalizeHist(b)
gH = cv2.equalizeHist(g)
rH = cv2.equalizeHist(r)

#合并通道
dst = cv2.merge((bH, gH, rH))

#显示图像
cv2.imshow('src', img)
cv2.imshow('dst', dst)
cv2.waitKey()
cv2.destroyAllWindows()

最终生成如图所示的图像。

---

十二.图像模糊特效

图像模糊特效可以通过第10章讲述的图像平滑方法实现，包括均值滤波、方框滤波、高斯滤波、中值滤波和双边滤波等，它能消除图像消除图像的噪声并保留图像的边缘轮廓。本小节主要采用高斯滤波进行模糊操作。

图像高斯滤波为图像不同位置的像素值赋予了不同的权重，距离越近的点权重越大，距离越远的点权重越小。下面是常用的3×3和5×5内核的高斯滤波模板。

Python中OpenCV主要调用GaussianBlur()函数实现高斯平滑处理，下面代码是使用11×11核模板进行高斯滤波处理。

# -*- coding: utf-8 -*-
#By:Eastmount CSDN 2020-12-22
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
 
#读取图片
img = cv2.imread('scenery.png')
source = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
 
#高斯滤波
result = cv2.GaussianBlur(source, (11,11), 0)

#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']

#显示图形
titles = [u'原始图像', u'高斯滤波']  
images = [source, result]  
for i in range(2):  
   plt.subplot(1,2,i+1), plt.imshow(images[i], 'gray')  
   plt.title(titles[i])  
   plt.xticks([]),plt.yticks([])  
plt.show()  

输出结果如图所示，左边为风景原始图像，右边为高斯滤波处理后的图像，它有效地将图像进行了模糊处理。

---

十三.本章小结

图像特效处理效果还非常多，作者这里简单总结12种算法，一方面是感谢读者对“Python图像处理及识别”专栏的喜欢；另一方面圣诞节和元旦节快到了，这些代码送给大家拿去表白或感恩自己吧！

本文主要讲解了图像常见的特效处理，从处理效果图、算法原理、代码实现三个步骤进行详细讲解，涉及图像毛玻璃特效、浮雕特效、油漆特效、素描特效、怀旧特效、光照特效、流年特效、水波特效、卡通特效、图像滤镜、直方图均衡化、模糊特效等，这些知识点将为读者从事Python图像处理相关项目实践或科学研究提供一定基础。

• 源代码下载地址，记得帮忙点star和关注喔。
  https://github.com/eastmountyxz/ImageProcessing-Python

时光嘀嗒嘀嗒的流失，这是我在CSDN写下的第八篇年终总结，比以往时候来的更早一些。《敏而多思，宁静致远》，仅以此篇纪念这风雨兼程的一年，这感恩的一年。列车上只写了一半，这两天完成，思远，思君O(∩_∩)O

• 2020年总结：敏而多思，宁静致远——纪念这风雨兼程的一年

2020年8月18新开的“娜璋AI安全之家”，主要围绕Python大数据分析、网络空间安全、人工智能、Web渗透及攻防技术进行讲解，同时分享CCF、SCI、南核北核论文的算法实现。娜璋之家会更加系统，并重构作者的所有文章，从零讲解Python和安全，写了近十年文章，真心想把自己所学所感所做分享出来，还请各位多多指教，真诚邀请您的关注！谢谢。

---

参考文献，在此感谢这些大佬，共勉！

• [1]Eastmount. [Android] 通过Menu实现图片怀旧、浮雕、模糊、光照和素描效果[EB/OL]. (2014-11-02). https://blog.csdn.net/Eastmount/article/details/40711317.
• [2]有苦向瓜诉说. 用Python来画浮雕画[EB/OL]. (2018.11.29). https://www.jianshu.com/p/00552d2ad0d4.
• [3]幻艺视界. 纯Python综合图像处理小工具（3）10种滤镜算法[EB/OL]. (2015-05-29). https://www.cnblogs.com/sopic/p/4538052.html.
• [4]Antonio.D. OpenCV实现“素描”图像[EB/OL]. (2019-01-13). https://blog.csdn.net/weixin_43305468/article/details/86440200.
• [5]weixin_39059031. 使用python和opencv将图片转化为素描图-python代码解析[EB/OL]. (2018-09-16). https://blog.csdn.net/weixin_39059031/article/details/82724951.
• [6]Matrix_11. Opencv— — water wave[EB/OL]. (2016-02-24). https://chenjunkai.blog.csdn.net/article/details/47059451.
• [7]TingHW. python opencv 卡通化图片[EB/OL]. (2018-11-29). https://blog.csdn.net/TingHW/article/details/84613003.
• [8]百度百科. 滤镜[EB/OL]. (2018-10-01). https://baike.baidu.com/item/滤镜/354809.
• [9]謝灰灰在找胡蘿蔔. IOS开发－－使用lookup table为图片添加滤镜[EB/OL]. (2015-07-12). https://www.jianshu.com/p/b470a5b5a560.
• [10]Eastmount. [数字图像处理] 五.MFC图像点运算之灰度线性变化、灰度非线性变化、阈值化和均衡化处理详解[EB/OL]. (2016-06-02). https://blog.csdn.net/eastmount/article/details/46312145.