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!")
运行结果如下：
原图像
高斯双边后图像：
均值迁移后图像：
