opencv4.2.0.34+python3.8.2+（获取图片视频并打开、numpy、色彩空间、数值与逻辑计算、图像的切割合并填充、floodFill、卷积模糊处理、高斯噪声处理高斯模糊、ERF）

（有的运行结果没弄上去，但文中代码本人亲测均通过；至于有人因版本问题出现个别错误，我相信对于大家应该没什么问题，文档就是很好的辅助学习资料）

文章目录

一、openCV和openGL的区别二、opencv的安装和测试（win10环境下）三、opencv的模块四、读取显示图片及其信息五、获取摄像头并打开六、numpy操作数组输出图片（1）读取一张图片，修改颜色通道后输出（2）多通道函数：zeros和ones（3）单通道函数：zeros和ones（4）像素取反（5）矩阵填充和重塑矩阵七、色彩空间（1）通过inRange函数进行色彩捕捉（2）通道合并八、图片色素的数值运算(加减乘除)和逻辑运算(与或非异或)（1）数值运算（2）逻辑运算（按位与或非异或运算+粗略提高图像对比度和亮度）九、图像的切割，合并和填充十、floodFill填充函数(泛洪填充)十一、利用卷积对图像模糊处理十二、添加高斯噪声并使用高斯模糊处理十三、边缘保留滤波（EPF）

一、openCV和openGL的区别

OpenCV是 Open Source Computer Vision Library OpenGL是 Open Graphics Library OpenCV主要是提供图像处理和视频处理的基础算法库，还涉及一些机器学习的算法。比如你想实现视频的降噪、运动物体的跟踪、目标（比如人脸）的识别这些都是CV的领域 OpenGL则专注在Graphics，3D绘图。 其实两者的区别就是Computer Vision和Computer Graphics这两个学科之间的区别，前者专注于从采集到的视觉图像中获取信息，是用机器来理解图像；后者是用机器绘制合适的视觉图像给人看。

二、opencv的安装和测试（win10环境下）

一般opencv有四个模块： opencv-python: 只包含opencv库的主要模块. 一般不推荐安装. opencv-contrib-python: 包含主要模块和contrib模块, 功能基本完整, 推荐安装. opencv-python-headless: 和opencv-python一样, 但是没有GUI功能, 无外设系统可用. opencv-contrib-python-headless: 和opencv-contrib-python一样但是没有GUI功能. 无外设系统可用. 因此一般来说都会选择安装opencv-contrib-python window环境下安装命令：pip install opencv-contrib-python -i https://pypi.tuna.tsinghua.edu.cn/simple （当然pip命令有可能也需要安装更新之类的，网上查找更新命令即可，如果可以运行当我没说；如果直接使用安装命令pip install opencv-contrib-python会比较慢，所以我使用了国内资源） 不要同时安装opencv-python和opencv-contrib-python 1.可以在window终端下进行简单的测试（当然我写的时候按python代码块处理了，所以出现下面情况）

>>>import cv2 >>>cv2.__version__ '4.2.0'

2.在pycharm中的测试（pycharm的安装和破解网上很多，我这里不进行解释；还有在pycharm中进行测试的时候，虽然cv2模块已经下载好，但是pycharm中并没有导入，可参考下面网址，将下载好的模块导入到pycharm中【https://blog.csdn.net/ShadowFox_/article/details/82871575】） 如果可以输出图片，并且在关闭后输出Hi，Python！那么表示安装成功（第三行代码处图片路径最好是英文；代码中注意W是大写,如果不是同样会输出图片，但关闭图片之后不会输出Hi，Python！）

三、opencv的模块

下面的五个横框表示基础模块。右边是扩展的模块，也就是opencv-contrib-python中的contrib，下载该模块之后才可以使用。上面的11个模块是基于下面五个基础模块的。

四、读取显示图片及其信息

import cv2 as cv import numpy as np # 输出图片属性 def get_image_info(image): """ 查看图片的属性 :param image: 要输出的图片 """ # 显示图片类型 numpy类型的数组 print(type(image)) # 图像矩阵的shape属性表示图像的大小，shape会返回tuple元组，第一个元素表示矩阵行数，第二个元组表示矩阵列数，第三个元素是3，表示像素值由光的三原色组成 print(image.shape) # 图像大小 print(image.size) # 图像类型 print(image.dtype) # 将图片作为矩阵进行输出 pixel_data = np.array(image) print(type(pixel_data)) print(pixel_data) # 读取图片 src = cv.imread("D:/image/dingxia.jpg") # 创建窗口，不写也可show出来，第一个参数是窗口名字，第二个参数为窗口显示方式 # 为0或cv.WINDOW_NORMAL：可以改变窗口大小 # 不写或cv.WINDOW_AUTOSIZE则不可改变大小 cv.namedWindow("Hello opencv!",cv.WINDOW_AUTOSIZE) # 显示图片窗口，第一个参数是窗口名称，第二个参数是要显示的图片 cv.imshow("Hello opencv!",src) # 调用函数 get_image_info(src) # 对图片另存，不要存C盘，要用权限 cv.imwrite("D:/image/1.png",src) # 窗口显示时间waitKey(k)，k<=0，窗口一直显示，按下数字键消失，k>0，表示显示多少毫秒 cv.waitKey(0) # 删除建立的全部窗口，释放资源 cv.destroyAllWindows() print("Hi,Python!")

五、获取摄像头并打开

import cv2 as cv def video_demo(): """ 打开摄像头或视频文件 """ # 打开摄像头，0代表的是设备id，如果有多个摄像头，可以设置其他数值 # 第二个参数是因为采用默认的API控制出错，所以加上cv.CAP_DSHOW capture = cv.VideoCapture(0, cv.CAP_DSHOW) while True: # 读取摄像头,它能返回两个参数，第一个参数是bool型的ret，其值为True或False，代表有没有读到图片；第二个参数是frame，是当前截取一帧的图片 ret, frame = capture.read() # 翻转 0:上下颠倒 大于0:水平颠倒 小于0:180旋转 frame = cv.flip(frame, 1) cv.imshow("video", frame) # esc对应的ascii值为27，使用esc关闭窗口 c = cv.waitKey(50) if c == 27: break video_demo() cv.destroyAllWindows()

特别注意第10行代码处，参数cv.CAP_DSHOW一开始我没有写，在关闭摄像头时出现下列报错，所以我加上该参数，这是由于采用默认的API控制出错 [ WARN:0] global C:\projects\opencv-python\opencv\modules\videoio\src\cap_msmf.cpp (674) SourceReaderCB::~SourceReaderCB terminating async callback

六、numpy操作数组输出图片

（1）读取一张图片，修改颜色通道后输出

# -*- coding=GBK -*- import cv2 as cv import numpy as np # numpy数组操作 def access_pixels(image): print(image.shape) height = image.shape[0] width = image.shape[1] channel = image.shape[2] print("width : %s, height : %s, channel : %s" % (width, height, channel)) for row in range(height): for col in range(width): for c in range(channel): # 得到行数,列数,通道数的矩阵 pv = image[row, col, c] # 对矩阵进行操作可改变图像像素，为什么255减去原因暂时不知，后续知道会进行更改 image[row, col, c] = 255 - pv cv.imshow("later", image) src = cv.imread("D:/image/dingxia.jpg") # cv.namedWindow("原来", cv.WINDOW_NORMAL) 可以不写 cv.imshow("start", src) t1 = cv.getTickCount() # 毫秒级别的计时函数,记录了系统启动以来的时间毫秒 access_pixels(src) t2 = cv.getTickCount() time = (t2 - t1) * 1000 / cv.getTickFrequency() # getTickFrequency用于返回CPU的频率,就是每秒的计时周期数 print("time: %s" % time) # 输出运行的时间 cv.waitKey(0) cv.destroyAllWindows()

（2）多通道函数：zeros和ones

import cv2 as cv import numpy as np # 自定义多通道图片1 def create_image_zeros(): # zeros:double类零矩阵 创建400*400 3个通道的矩阵图像 参数时classname为uint8 img = np.zeros([400, 400, 3], np.uint8) # ones([400, 400])是创建一个400*400的全1矩阵，*255即是全255矩阵 *后面数字可以自由变换 并将这个矩阵的值赋给img的第一维 img[:, :, 0] = np.ones([400, 400]) * 0 img[:, :, 1] = np.ones([400, 400]) * 0 img[:, :, 2] = np.ones([400, 400]) * 0 # 输出一张400*400的白色图片(255 255 255):蓝(B)、绿(G)、红(R)，bgr顺序不能乱，和常说的rgb反过来了 cv.imshow("自制图片1", img) # 自定义多通道图片2 def create_image_ones(): img = np.ones([400, 400, 3], np.uint8) img[:, :, 0] = img[:, :, 0] * 255 img[:, :, 1] = img[:, :, 1] * 255 img[:, :, 2] = img[:, :, 2] * 255 cv.imshow("自制图片2", img) create_image_zeros() create_image_ones() cv.waitKey(0) cv.destroyAllWindows()

区别： zeros：生成全0的矩阵 ones：生成全1的矩阵

（3）单通道函数：zeros和ones

# -*- coding=GBK -*- import cv2 as cv import numpy as np def create_image_zeros(): img = np.zeros([400, 400, 1], np.uint8) # img[:, :, 0] = 127, 下面代码也可以这样写，直接赋值127，效果相同 img[:, :, 0] = np.ones([400, 400]) * 127 cv.imshow("自制图片1", img) def create_image_ones(): img = np.zeros([400, 400, 1], np.uint8) # zeros是全0矩阵，所以需要用到ones全1矩阵乘像素值；img[:, :, 0] = 127,下面代码也可以这样写，直接赋值127，效果相同 img[:, :, 0] = np.ones([400, 400]) * 127 # 下面代码直接使用ones全1矩阵，所以可以直接使用该行代码 img = img * 127 # img = np.ones([400, 400, 1], np.uint8) # img = img * 127 cv.imshow("自制图片2", img) create_image_zeros() create_image_ones() cv.waitKey(0) cv.destroyAllWindows()

对于单通道，像素在0-255之间变化，图像在黑与白之间变化；而对于多通道，三种通道bgr的出现，使图像出现彩色。 对于zeros和ones来说都可以处理多通道和单通道，唯一区别就是一个全0，一个全1，所以zeros还是需要用到ones函数进行像素的设置，全0进行乘法*的运算永远是全0，这样是达不到效果的

（4）像素取反

# -*- coding=GBK -*- import cv2 as cv import numpy as np # 像素取反 def inverse(image): dst = cv.bitwise_not(image) cv.imshow("inverse", dst) src = cv.imread("D:/image/dingxia.jpg") cv.namedWindow("start", cv.WINDOW_NORMAL) cv.imshow("start", src) t1 = cv.getTickCount() inverse(src) t2 = cv.getTickCount() time = (t2 - t1) * 1000 / cv.getTickFrequency() print("time: %s" % time) cv.waitKey(0) cv.destroyAllWindows()

（5）矩阵填充和重塑矩阵

# -*- coding=GBK -*- import cv2 as cv import numpy as np def create_image(): # 生成一个3*3维的单通道矩阵 m1 = np.ones([3, 3], np.uint8) # 向矩阵中填充值，可以是int，float，complex，有时候注意np.uint8是整型，如果fill填充的是float型可能涉及到溢出，12222.388就是特殊案例，注意上下对应即可 m1.fill(12222.388) print(m1) # 对矩阵进行重塑，改变矩阵样式 m2 = m1.reshape([1, 9]) print(m2) # array需要将数组内容一一列出，而ones只需给出大小进行填充即可 m3 = np.array([[2, 3, 4], [4, 5, 6], [6, 7, 8]], np.uint32) # m3.fill(9) print(m3) create_image() cv.waitKey(0) cv.destroyAllWindows()

七、色彩空间

（1）通过inRange函数进行色彩捕捉

这个模型中颜色的参数分别是：色调Hue（H），饱和度Saturation（S），明度Value（V）。

import cv2 as cv import numpy as np def extract_object_demo(): """ inRange函数色彩捕捉 """ video = cv.VideoCapture("D:/image/white.mp4") while True: ret, frame = video.read() if not ret: break # 通过inrange函数进行色彩捕捉，对白色进行捕捉，这个看自己视频中要捕捉颜色，然后根据下方表确定范围 hsv = cv.cvtColor(frame, cv.COLOR_RGB2HSV) lower_hsv = np.array([0, 0, 221]) upper_hsv = np.array([180, 30, 255]) mask = cv.inRange(hsv, lowerb=lower_hsv, upperb=upper_hsv) cv.imshow("mask", mask) # 逻辑与运算，后面几节出现，对与运算加上mask也可以出现图像，mask是可选参数，具体参数含义可查看opencv官方文档 dst = cv.bitwise_and(frame, frame, mask=mask) cv.imshow("dst", dst) cv.imshow("video", frame) c = cv.waitKey(40) if c == 27: break def color_space_demo(image): # 色彩空间转换API，当然还有很多，rgb，gray，hsv，yuv，ycrcb比较常见，尤其rgb到hsv和yuv的转换记牢 gray = cv.cvtColor(image, cv.COLOR_RGB2GRAY) cv.imshow("gray", gray) hsv = cv.cvtColor(image, cv.COLOR_RGB2HSV) cv.imshow("hsv", hsv) yuv = cv.cvtColor(image, cv.COLOR_RGB2YUV) cv.imshow("yuv", yuv) ycrcb = cv.cvtColor(image, cv.COLOR_RGB2YCrCb) cv.imshow("ycrcb", ycrcb) src = cv.imread("D:/image/dingxia.jpg") # cv.namedWindow("start", cv.WINDOW_AUTOSIZE) # cv.imshow("start", src) extract_object_demo() # color_space_demo(src) cv.waitKey(0) cv.destroyAllWindows()

（2）通道合并

# -*- coding=GBK -*- import cv2 as cv import numpy as np def merge_channel(image): # 使用split将图片切分为三个通道 b, g, r = cv.split(image) cv.imshow("blue", b) cv.imshow("green", g) cv.imshow("red", r) # 使用merge进行通道的合并 img = cv.merge([b, g, r]) cv.imshow("merge", img) # 修改某个单通道的值 img[:, :, 2] = 100 cv.imshow("单通道", img) src = cv.imread("D:/image/dingxia.jpg") cv.namedWindow("start", cv.WINDOW_AUTOSIZE) cv.imshow("start", src) merge_channel(src) cv.waitKey(0) cv.destroyAllWindows()

八、图片色素的数值运算(加减乘除)和逻辑运算(与或非异或)

（1）数值运算

opencv自带图片色素的处理函数：

相加：add()

相减：subtract()

相乘：multiply()

相除：divide()

原理就是：通过获取两张（一次只能是两张）个图片的同一个位置的色素值来实现运算。

运算的要求：两张图片的shape要一样。

例图：（自己保存为图片格式即可）

import cv2 as cv import numpy as np def add_pixels(m1, m2): dst = cv.add(m1, m2) cv.imshow("add", dst) def subtract_pixels(m1, m2): dst = cv.subtract(m1, m2) cv.imshow("subtract", dst) # cv.imwrite("D:/image/linux_window.jpg", dst) linux-window还是比较好看就保存了 def multiply_pixels(m1, m2): dst = cv.multiply(m1, m2) cv.imshow("multiply", dst) def divide_pixels(m1, m2): dst = cv.divide(m1, m2) cv.imshow("divide", dst) # 均值和方差 mean表示均值，meanStdDev可返回均值和方差 def others(m1, m2): M1, dev1 = cv.meanStdDev(m1) M2, dev2 = cv.meanStdDev(m2) # 取和图像m1相同的高宽，【:2】涉及切片，左实右虚，取shape前两个 h, w = m1.shape[:2] print(M1) print(M2) print(dev1) print(dev2) # 对于像素相同的矩阵，方差均为0，这里使用了全0矩阵，所以输出的均值和方差均为0 # 若使用ones全1矩阵，那么输出均值为1，方差为0 img = np.zeros([h, w], np.uint8) m, dev = cv.meanStdDev(img) print(m) print(dev) src1 = cv.imread("D:/image/linux.jpg") src2 = cv.imread("D:/image/window.jpg") # cv.namedWindow("Hello opencv!", cv.WINDOW_AUTOSIZE)有没有影响不大，除非对图片有大小变化需求 cv.imshow("Hello linux!", src1) cv.imshow("Hello window!", src2) # add add_pixels(src1, src2) # subtract subtract_pixels(src1, src2) # multiply multiply_pixels(src1, src2) # divide divide_pixels(src1, src2) others(src1, src2) cv.waitKey(0) cv.destroyAllWindows() print("Hi,Python!")

（2）逻辑运算（按位与或非异或运算+粗略提高图像对比度和亮度）

opencv自带图片色素的处理函数：

与：bitwise_add() 全1则1，其他为0

或：bitwise_or() 有1为1，其他为0

非：bitwise_not() 1为0，0为1

异或：bitwise_xor() 相同为0，不同为1

对于0 1 的来说，这四种操作比较好理解，对于像素值来说要采用下表方式进行按位与或非、异或操作：

import cv2 as cv import numpy as np def logic_demo(m1, m2): """ 逻辑运算 与或非异或 :param m1: 第一张图片 :param m2: 第二张图片 """ dst = cv.bitwise_and(m1, m2) cv.imshow("and", dst) dst = cv.bitwise_or(m1, m2) cv.imshow("or",dst) dst = cv.bitwise_not(m1) cv.imshow("not1", dst) dst = cv.bitwise_not(m2) cv.imshow("not2", dst) dst = cv.bitwise_xor(m1, m2) cv.imshow("xor", dst) def contrast_brightness_demo(image, c, b): """ 调整图像对比度和亮度 :param image: 要调整的图片 :param c: 对比度 :param b: 亮度 """ h, w, ch = image.shape # blank是一个全0的矩阵，是黑色的 blank = np.zeros([h, w, ch], image.dtype) dst = cv.addWeighted(image, c, blank, 1-c, b) cv.imshow("demo", dst) src1 = cv.imread("D:/image/linux.jpg") src2 = cv.imread("D:/image/window.jpg") # cv.namedWindow("Hello opencv!", cv.WINDOW_AUTOSIZE) cv.imshow("Hello linux!", src1) cv.imshow("Hello window!", src2) # 逻辑运算 与或非异或 # logic_demo(src1, src2) # 调整图像对比度和亮度 contrast_brightness_demo(src2, 1.5, 0) cv.waitKey(0) cv.destroyAllWindows() print("Hi,Python!")

addWeighted(InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1);

一共有七个参数：前4个是两张要合成的图片及它们所占比例，第5个double gamma起微调作用，第6个OutputArray dst是合成后的图片，第七个输出的图片的类型（可选参数，默认-1）

有公式得出两个图片加成输出的图片为：dst=src1alpha+src2beta+gamma

九、图像的切割，合并和填充

从被处理的图像以方框、圆、椭圆、不规则多边形等方式勾勒出需要处理的区域，称为感兴趣区域ROI（region of interest）

import cv2 as cv import numpy as np src = cv.imread("D:/image/dingxia.jpg") cv.namedWindow("Hello opencv!", cv.WINDOW_AUTOSIZE) cv.imshow("Hello opencv!", src) # 切割图像，范围的查找要自己慢慢试 img = src[50:200, 230:350] # 将切割出的图像填充变成灰色 gray = cv.cvtColor(img, cv.COLOR_RGB2GRAY) # 下面这行代码是为了增加通道，因为gray为灰度图像，是单通道，而src是三通道，所以需要cvtColor一下，将其转换为三通道 # 而且由于灰度图像无法再恢复成彩色图像，所以cvtColor之后，只会增加通道数，图像表现还是灰色 backface = cv.cvtColor(gray, cv.COLOR_RGB2BGR) # 合并图像 src[50:200, 230:350] = backface cv.imshow("gray", src) cv.waitKey(0) cv.destroyAllWindows() print("Hi,Python!")

十、floodFill填充函数(泛洪填充)

floodFill函数：漫水填充算法

基本思想： 所谓漫水填充，简单来说，就是自动选中了和种子点相连的区域，接着将该区域替换成指定的颜色，这是个非常有用的功能,经常用来标记或者分离图像的一部分进行处理或分析.漫水填充也可以用来从输入图像获取掩码区域,掩码会加速处理过程,或者只处理掩码指定的像素点.

以此填充算法为基础，类似photoshop的魔术棒选择工具就很容易实现了。漫水填充（FloodFill）是查找和种子点联通的颜色相同的点，魔术棒选择工具则是查找和种子点联通的颜色相近的点，将和初始种子像素颜色相近的点压进栈作为新种子

在OpenCV中，漫水填充是填充算法中最通用的方法。且在OpenCV 2.X中，使用C++重写过的FloodFill函数有两个版本。一个不带掩膜mask的版本，和一个带mask的版本。这个掩膜mask，就是用于进一步控制哪些区域将被填充颜色（比如说当对同一图像进行多次填充时）。这两个版本的FloodFill，都必须在图像中选择一个种子点，然后把临近区域所有相似点填充上同样的颜色，不同的是，不一定将所有的邻近像素点都染上同一颜色，漫水填充操作的结果总是某个连续的区域。当邻近像素点位于给定的范围（从loDiff到upDiff）内或在原始seedPoint像素值范围内时，FloodFill函数就会为这个点涂上颜色。

官方定义为： 第一个版本的floodfill(该版本没有mask参数)

int floodFill(InputOutputArray image, Point seedPoint, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 )

第二个版本的floodfill

int floodFill(InputOutputArray image, InputOutputArray mask, Point seedPoint,Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 )

以第二个版本进行介绍，但不知道为什么，python中调用这个函数，Rect* rect=0这个参数没有，剩下7个参数 ，至于Rect*类型的rect，有默认值0，一个可选的参数，用于设置floodFill函数将要重绘区域的最小边界矩形区域。在pycharm中没有暂时不考虑

通俗解释：floodFill( 1.操作的图像, 2.掩模, 3.起始像素点，4.填充的颜色, 6.填充颜色的低值， 7.填充颜色的高值 ,8.填充的方法)第五个rect忽略

参数6.填充颜色的低值就是：参数3位置的像素 减去 参数6

参数7.填充颜色的高值就是：参数3位置的像素 加上 参数7

即是这两个数值之间的色素替换为参数4的颜色

彩色图像一般是FLOODFILL_FIXED_RANGE 指定颜色填充

还有一种是FLOODFILL_MASK_ONLY，mask的指定的位置为零时才填充，不为零不填充

最后一个参数的比较： FLOODFILL_FIXED_RANGE - 如果设置为这个标识符的话，就会考虑当前像素与种子像素之间的差，否则就考虑当前像素与其相邻像素的差。也就是说，这个范围是浮动的。 FLOODFILL_MASK_ONLY - 如果设置为这个标识符的话，函数不会去填充改变原始图像 (也就是忽略第四个参数newVal),而是去填充掩模图像（mask）。这个标识符只对第二个版本的floodFill有用，因第一个版本里面压根就没有mask参数。

至于指定颜色填充的过程，就和FLOODFILL_FIXED_RANGE解释的一样，会和相邻的像素作比较，采用泛洪的方法填充（个人理解，没有找到可信度高的介绍，很遗憾）

该链接是我参考的一篇博客，专门讲解floodfill函数，有兴趣可以看一看 【https://blog.csdn.net/qq_27901569/article/details/49934763】

import cv2 as cv import numpy as np # 指定颜色填充 def fill_color_demo(image): copyImg = image.copy() h, w = image.shape[:2] # zeros和ones不写通道数默认单通道 # mask它应该为单通道、8位、长和宽上都比输入图像 image 大两个像素点的图像 +2是官方函数要求 # 需要注意的是，漫水填充不会填充掩膜mask的非零像素区域。也就是只填充掩膜mask的0的区域 mask = np.zeros([h+2, w+2], np.uint8) cv.floodFill(copyImg, mask, (100, 100), (0, 255, 255), (100, 100, 100), (50, 50, 50), cv.FLOODFILL_FIXED_RANGE) cv.imshow("fill_color_demo", copyImg) # 指定位置填充 def fill_binary(): image = np.ones([400, 400, 3], np.uint8) image[100:300, 100:300, :] = 255 cv.imshow("fill_binary", image) # zeros和ones不写通道数默认单通道 mask = np.ones([402, 402], np.uint8) # 将要填充位置的像素设为0 mask[101:301, 101:301] = 0 cv.floodFill(image, mask, (100, 100), (0, 0, 255), cv.FLOODFILL_MASK_ONLY) cv.imshow("filled binary", image) src = cv.imread("D:/image/dingxia.jpg") cv.namedWindow("Hello opencv!", cv.WINDOW_AUTOSIZE) cv.imshow("Hello opencv!", src) # 第一个使用图片填充，第二个自己在函数内随便建了一个图像进行填充的 fill_color_demo(src) fill_binary() cv.waitKey(0) cv.destroyAllWindows() print("Hi,Python!")

十一、利用卷积对图像模糊处理

1.均值模糊函数blur()：定义：blur(src,ksize,dst=None, anchor=None, borderType=None)

定义是有5个参数，但最后三个均为none,所以也就2个参数

src：要处理的原图像

ksize: 周围关联的像素的范围：代码中（5，5）就是5*5的大小，就是计算这些范围内的均值来确定中心位置的大小

2.中值模糊函数medianBlur(): 定义：medianBlur(src, ksize, dst=None)

ksize与blur()函数不同，不是矩阵，而是一个数字，例如为5，就表示了5*5的方阵

3.高斯平滑函数GaussianBlur():定义：GaussianBlur(src, ksize, sigmaX, dst=None, sigmaY=None, borderType=None)

sigmaX：标准差

4.双边滤波函数bilateralFilter():定义：bilateralFilter(src, d, sigmaColor, sigmaSpace, dst=None, borderType=None) d：邻域直径 sigmaColor：颜色标准差 sigmaSpace：空间标准差

5.自定义模糊 使用的函数为：filter2D()：定义为filter2D(src,ddepth,kernel)

ddepth：深度，输入值为-1时，目标图像和原图像深度保持一致

kernel: 卷积核（或者是相关核）,一个单通道浮点型矩阵

修改kernel矩阵即可实现不同的模糊

原图： lena的加入椒盐噪声的彩色图片没找到，只有找到灰色图像，可以用这个加入椒盐噪声的lena图片对均值和中值进行比较，中值会取得比较好的效果

import cv2 as cv import numpy as np # 均值模糊 def blur_demo(image): # （5，5）分别表示横向和竖向，（5，5）比较常用 dst = cv.blur(image, (5, 5)) cv.imshow("blue_demo", dst) # 中值模糊，用于处理椒盐噪声，比均值处理效果好 def median_blur_demo(image): dst = cv.medianBlur(image, 5) cv.imshow("median_blur_demo", dst) # 高斯模糊 def gaussian_blur_demo(image): dst = cv.GaussianBlur(image, (5, 5), 2) cv.imshow("gaussian_blur_demo", dst) # 双边滤波 def bilateralFilter_demo(image): dst = cv.bilateralFilter(image, 5, 5, 2) cv.imshow("bilateralFilter_demo", dst) # 自定义模糊、锐化处理； # 总和为0，做边缘梯度；奇数或者总和为1，做增强，锐化处理 def custom_blur_demo(image): # 自定义矩阵，并防止数值溢出(第一种表示方法) # kernel = np.ones([5, 5], np.float32)/25 # (第二种表示方法) # kernel = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]], np.float32)/9 # 下方数据为标准的锐化算子（一般数据要求奇数或总和为1） kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], np.float32) dst = cv.filter2D(image, -1, kernel=kernel) cv.imshow("median_blur_demo", dst) src = cv.imread("D:/image/lena.jpg") cv.namedWindow("Hello opencv!", cv.WINDOW_AUTOSIZE) cv.imshow("Hello opencv!", src) # 均值模糊 # blur_demo(src) # 中值模糊 # median_blur_demo(src) # 高斯模糊 # gaussian_blur_demo(src) # 双边滤波 # bilateralFilter_demo(src) # 自定义模糊 custom_blur_demo(src) cv.waitKey(0) cv.destroyAllWindows() print("Hi,Python!")

十二、添加高斯噪声并使用高斯模糊处理

import cv2 as cv import numpy as np def clamp(pv): if pv > 255: return 255 elif pv < 0: return 0 else: return pv # 增加高斯噪声 def gaussian_noise(image): h, w, c = image.shape for row in range(h): for col in range(w): s = np.random.normal(0, 20, 3) b = image[row, col, 0] # blue g = image[row, col, 1] # green r = image[row, col, 2] # red image[row, col, 0] = clamp(b + s[0]) image[row, col, 1] = clamp(g + s[1]) image[row, col, 2] = clamp(r + s[2]) cv.imshow("noise image", image) src = cv.imread("D:/image/lena.jpg") cv.namedWindow("Hello opencv!", cv.WINDOW_AUTOSIZE) cv.imshow("Hello opencv!", src) t1 = cv.getTickCount() # 增加高斯噪声 gaussian_noise(src) t2 = cv.getTickCount() time = (t2 - t1) / cv.getTickFrequency() print("time consume : %s" % (time*1000)) # 高斯模糊处理，结果说明高斯模糊对高斯噪声有抑制作用 dst = cv.GaussianBlur(src, (5, 5), 0) cv.imshow("Gaussian Blur", dst) cv.waitKey(0) cv.destroyAllWindows() print("Hi,Python!")

结果说明高斯模糊对高斯噪声有抑制作用

十三、边缘保留滤波（EPF）

这个堪比磨皮，非常好玩!

高斯双边 dst = cv.bilateralFilter（ src，d，sigmaColor，sigmaSpace [，dst [，borderType]] ） dst也就是输出，和borderType都是可选参数 src 源8位或浮点，1通道或3通道图像。 dst 与src大小和类型相同的目标映像。 d 滤波期间使用的每个像素邻域的直径。如果它不是正值，则从sigmaSpace计算得出。 sigmaColor 在色彩空间中过滤sigma。参数的较大值表示像素邻域内的其他颜色（请参见sigmaSpace）将混合在一起，从而导致较大区域的半均等颜色。 sigmaSpace 在坐标空间中过滤sigma。该参数的值越大，表示越远的像素就会相互影响，只要它们的颜色足够接近即可（请参见sigmaColor）。当d> 0时，它指定邻域大小，而不考虑sigmaSpace。否则，d与sigmaSpace成比例。 borderType 用于推断图像外部像素的边框模式

均值迁移 dst = cv.pyrMeanShiftFiltering（ src，sp，sr [，dst [，maxLevel [，termcrit]]] ） dst也就是输出，和maxLevel、termcrit都是可选参数 src 源8位3通道图像。 dst 与源格式和大小相同的目标图像。 SP 空间窗口半径。 SR 彩色窗口半径。 maxLevel 用于分割的金字塔的最高级别。 termcrit 终止标准：何时停止均值漂移迭代。

import cv2 as cv import numpy as np # 高斯双边 def bi_demo(image): dst = cv.bilateralFilter(image, 0, 100, 15) cv.imshow("bi_demo", dst) # 均值迁移 def shift_demo(image): dst = cv.pyrMeanShiftFiltering(image, 10, 50) cv.imshow("shift_demo", dst) src = cv.imread("D:/image/dingxia.jpg") cv.namedWindow("Hello opencv!", cv.WINDOW_AUTOSIZE) cv.imshow("Hello opencv!", src) bi_demo(src) shift_demo(src) cv.waitKey(0) cv.destroyAllWindows() print("Hi,Python!")

运行结果如下： 原图像 高斯双边后图像： 均值迁移后图像：