Opencv-python学习笔记

一、图像读入、显示与保存

1、读入图片

frame=cv2.imread("路径",显示格式)  #读入图像，显示格式可不用

路径：C:\Users\Lin Ren Jun\Desktop 两个反斜杠
显示格式：
cv.IMREAD_UNCHANGED 保持原来格式
cv.IMREAD_GRAYSCALE 读入成灰度图
cv.IMREADCOLOR 读入成彩色图

2、显示图片

cv2.imshow("窗口名",图像名)  #窗口显示图像

cv2.waitKey(a)  #等待函数

a>0,等待a毫秒
a<0,等待直到键盘点击
a=0,无限等待
什么都没有：无限等待

cv2.destroyAllWindows() #删除所有窗口

3、保存图片

cv2.imwrite("D:\\test.jpg",img)  #将img图片保存到D盘下，保存的文件名为test.jpg

二、像素处理

1、读取像素
返回值=图像（位置参数）
灰度图像：返回值为灰度值
BGR图像：返回值分别为B、G、R三个值

#img为灰度图
p=img[12,34]  #得到img图像在第12行第34列的像素值

#frame为BGR图像
#法一：分别得到三个通道的像素值
blue=frame[12,34,0]  #得到frame图像在第12行第34列的蓝色通道的像素值
green=frame[12,34,1] #得到frame图像在第12行第34列的绿色通道的像素值
red =frame[12,34,2]  #得到frame图像在第12行第34列的红色通道的像素值

#法二：不指定通道
w=frame[12,34]  #w得到的是B、G、R三个值

2、修改像素值

#img为灰度图
img[12,34]=255  #将img图像在第12行第34列的像素值改为255

#frame为BGR图像
#法一
frame[12,34,0]=100  #蓝色通道
frame[12,34,1]=110  #绿色通道
frame[12,34,2]=120  #红色通道
#法二
frame[12,34]=[100,110,120]

三、使用numpy进行像素处理

1、读取像素
返回值=图像.item(位置参数)

#img是灰度图
p=img.item(12,34)
#frame是BGR图像
blue=frame.item(12,34,0)
green=frame.item(12,34,1)
red=frame.item(12,34,2)

2、修改像素
图像.itemset(位置，新值)

#img为灰度图
img.itemset((12,34),255)
#frame为BGR图像
frame.itemset((12,34,0),100)  #蓝色通道
frame.itemset((12,34,1),110)  #绿色通道
frame.itemset((12,34,2),120)  #红色通道

四、获取图像属性

1、形状：行、列、通道数
使用shape
灰度图：返回行数、列数
BGR图：返回行数、列数、通道数

#img为灰度图
print(img.shape)
#比如说结果为：（100，200）
#表示该灰度图有100行，200列

#frame为BGR图
print(frame.shape)
#比如说结果为：（100，200，3）
#表示该BGR图有100行，200列，3个通道数

2、像素数目
灰度图：返回行数x列数的值
BGR图：返回行数x列数x通道数的值
使用size

print(img.size)

3、图像数据类型
使用dtype

print(img.dtype)  #比如说打印结果为uint8

五、感兴趣区域ROI

face=img[100:200,300:400]  #face为ROI,img是原始图像，
                           #表示第100行到第200行，和第300列到400列的区域

#简单使用：
face=img[100:200,300:400]
img[200:300,100,200]=face
#即把img的[200:300,100,200]区域的图像也变成了[100:200,300:400]区域
#的图像一样的了

六、通道的拆分与合并

1、拆分
使用split

#img为彩色图像
#法一：一次性拆分
b,g,r=cv2.split(img)  #其中b,g,r为图像，可以理解为把img彩色图像
                      #拆分为b,g,r这3个灰度图像
#法二：分别拆分
b=cv2.split(img)[0]
g=cv2.split(img)[1]
r=cv2.split(img)[2]

2、合并
使用merge

#img为彩色图像
img=cv2.merge([b,g,r])  #b,g,r可以看作是3个灰度图像，注意顺序

##记住一个写法：
import numpy as np
b=np.zeros((rows,cols),dtype=img.dtype)  #表示b图像里面像素都是0，
                                         #img表示彩色图

七、图像加分

1、numpy加法
numpy加法用的是取模加法

结果=图像1（像素）+图像2（像素）
如果结果>255，则结果对255取模（比如说：255+58=（255+58）%255=58）
如果结果<=255,则结果不做处理（比如说：10+20=30）

result=img1+img2  ##img1,img2分别为图像1，图像2

2、OpenCV加法
OpenCV加法用的是饱和运算

结果=图像1（像素）+图像2（像素）
如果结果>255，则结果为255
如果结果<=255，则结果不做处理（比如说：10+20=30）

result=cv2.add(img1,img2)  #img1,img2分别为图像1，图像2

八、图像的类型转换

1、BGR图转成灰度

img2=cv2.cvtColor(img1,COLOR_BGR2GRAY)  #img1为原图像，img2为
                                        #转换后的灰度图像

2、BGR图转成RGB图

img2=cv2.cvtColor(img1,COLOR_BGR2RGB)  #img1为原图像，img2为
                                       #转换后的RGB图像

3、灰度图转成BGR图

img2=cv2.cvtColor(img1,COLOR_GRAY2BGR)  #img1为原图像，img2为
                                        #转换后的BGR图像

九、图像的缩放

使用resize
语法格式：dst=cv2.resize(src,dsize,fx,fy)
dst:输出的图像
src:原始图像
fx:水平方向缩放，大于1表示放大，小于1表示缩小，等于1表示不变
fy:垂直方向缩放，大于1表示放大，小于1表示缩小，等于1表示不变
注意：有dsize参数就不用写fx和fy参数，有fx和fy参数，dsize参数就写None

#方法一：
dst=cv2.resize(src,（100，200））  #表示将src缩放为100列200行像素的图像
				  #注意：100表示列数（不是行），200表示
				  #行数（表示列）
#方法二：
dst=cv2.resize(src,None,fx=0.5,fy=0.7)  #表示将src图像水平方向变为
                                        #原来的0.5倍，垂直方向变为
                                        #原来的0.7倍

图像的翻转

语法:dst=cv2.flip(src,flipCode)
dst:输出的图像
src:原始图像
flipCode:选择的翻转模式

dst=cv2.flip(src,0)   #flipCode=0，以X轴为对称轴进行翻转
dst=cv2.flip(src,1)   #flipCode>0，以Y轴为对称轴进行翻转
dst=cv2.flip(src,-1)  #flipCode<0，以X轴为对称轴,以Y轴为对称轴同时
                      #进行翻转

十、图像阈值threshold及实现

语法：retval,dst=cv2.threshold(scr,thresh,maxval,type)
retval:阈值，等于下面的thresh
dst：输出图像
scr：原始图像
thresh：阈值
maxval：阈值分割后的最大值
type：阈值分割的类型

retval,dst=cv2.threshold(scr,127,255,cv2.THRESH_BINARY)  #二进制阈值化

retval,dst=cv2.threshold(scr,127,255,cv2.THRESH_BINARY_INV)  #反二进制阈值化

retval,dst=cv2.threshold(scr,127,255,cv2.THRESH_TRUNC)  #截断阈值化

retval,dst=cv2.threshold(scr,127,255,cv2.THRESH_TOZERO_INV)  #反阈值化为0

十一、图像平滑

1、均值滤波
使用blur
语法：处理结果=cv2.blur(原始图像，核大小)
注意：核大小是以（宽度，高度）形式表示的元组

#例如：
dst=cv2.blur(scr,(3,3)) 

2、方框滤波
使用boxfilter
语法：处理结果=cv2.boxfilter(原始图像，目标图像深度，核大小，normalize属性)
目标图像深度：通常设定为-1，表示与原始图像一致
核大小：是以（宽度，高度）形式表示的元组
normalize属性:是否对目标图像进行归一化处理，normalize=1表示对目标图 像进行归一化处理（此时方框滤波与均值滤波处理结果一样），若不对normalize属性进行设置，则默认normalize=1。normalize=0表示不对目标图 像进行归一化处理

dst=cv2.boxfilter(scr,-1,(3,3),normalize=1) #进行归一化处理
dst=cv2.boxfilter(scr,-1,(3,3))	            #进行归一化处理
dst=cv2.boxfilter(scr,-1,(3,3),normalize=0) #不进行归一化处理

3、高斯滤波
使用GaussianBlur函数
语法：dst=cv2.GaussianBlur(scr,ksize,sigmaX)
dst:输出图像
scr：原始图像
ksize：核大小（必须为奇数）
sigmaX：X方向方差（不写Y方向方差,默认与X方向方差一致），一般直接令sigmaX=0，他会自己计算出一个方差

#例如：
dst=cv2.GaussianBlur(scr,(3,3),0)

4、中值滤波
将核大小里面的像素按升序或降序排列，取中间的数作为中值滤波的结果
使用medianBlur函数
语法：dst=cv2.medianBlur(scr,ksize)
dst:输出图像
scr:原始图像
ksize:核大小（必须为大于1的奇数，写一个数即可，不是写成（N,N）的形式）

#例如
dst=cv2.medianBlur(scr,3)

十二、形态学变换

1、图像腐蚀
图像腐蚀就是把图像变小了，边缘腐蚀掉，见下图


使用erode函数
语法：dst=cv2.erode(scr,kernel,iterations)
dst:输出图像
scr:原始图像
kernel:卷积核，一般为正方形，里面都是1，可以这样生成：

kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）

iterations:迭代次数，即要进行多少次腐蚀，默认iterations=1，即进行1次腐蚀，iterations=1时可以不用写iterations参数

#例如：
#进行1次腐蚀
import numpy as np
kernel=np.ones((5,5),np.uint8)
dst=cv2.erode(scr,kernel)

#多次腐蚀
import numpy as np
kernel=np.ones((5,5),np.uint8)
dst=cv2.erode(scr,kernel,iterations=9)  #进行9次腐蚀

2、图像膨胀
就是前面图像腐蚀操作的逆操作
运用思路：对于带有毛刺的图像，我们可以先对原始图像进行腐蚀操作，再对腐蚀的结果图进行膨胀操作。见下图（这也就是开运算）

使用dilate函数
语法：dst=cv2.dilate(scr,kernel,iterations)
dst:输出图像
scr:原始图像
kernel:卷积核，一般为正方形，里面都是1，可以这样生成：

kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）

iterations:迭代次数，即要进行多少次膨胀，默认iterations=1，即进行1次膨胀，iterations=1时可以不用写iterations参数

#例如
#进行一次膨胀
import numpy as np
kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）
dst=cv2.dilate(scr,kernel)

#进行多次膨胀
import numpy as np
kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）
dst=cv2.dilate(scr,kernel，iterations=9)
#

3、图像开运算
开运算：对于带有毛刺的图像，我们可以先对原始图像进行腐蚀操作，再对腐蚀的结果图进行膨胀操作，这样可以去掉毛刺，这就是开运算
使用morphologyEx函数
语法：dst=cv2.morphologyEx(scr,cv2.MORPH_OPEN,kernel)
dst:输出图像
scr:原始图像
cv2.MORPH_OPEN:表示采取开运算的操作
kernel:卷积核，一般为正方形，里面都是1，可以这样生成：

kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）	

#例子
import numpy as np
kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）
dst=cv2.morphologyEx(scr,cv2.MORPH_OPEN,kernel)
#注意：如果发现有一些毛刺还是没消掉，可以采样更大的卷积核，比如：
#kernel=np.ones((10，10),np.uint8)

4、图像闭运算
对于图像里面有小黑点，我们可以先对图像进行膨胀操作，再进行腐蚀操作，这样就可以去除图像里面的小黑点，这就是闭运算，见下图

使用morphologyEx函数
语法：dst=cv2.morphologyEx(scr,cv2.MORPH_CLOSE,kernel)
dst:输出图像
scr:原始图像
cv2.MORPH_CLOSE：表示采取闭运算的操作
kernel:卷积核，一般为正方形，里面都是1，可以这样生成：

kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）

#例子
import numpy as np
kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）
dst=cv2.morphologyEx(scr,cv2.MORPH_CLOSE,kernel)
#注意：如果发现有一些黑点还是没消掉，可以采样更大的卷积核，比如：
#kernel=np.ones((10，10),np.uint8)

5、图像梯度
图像梯度运算：输出=原图像膨胀结果图-原图像腐蚀结果图=图像轮廓，如下图：

使用morphologyEx函数
语法：dst=cv2.morphologyEx(scr,cv2.MORPH_GRADIENT,kernel)
dst:输出图像
scr:原始图像
cv2.MORPH_GRADIENT：表示进行梯度运算操作
kernel：卷积核，一般为正方形，里面都是1，可以这样生成：

kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）

#例子：
import numpy as np
kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）
dst=cv2.morphologyEx(scr,cv2.MORPH_GRADIENT,kernel)

6、图像礼帽
图像礼帽操作就是得到噪声图像，就是：
礼帽操作结果=原始图像-原始图像开运算结果图=噪声图像，见下图

使用morphologyEx函数
语法：dst=cv2.morphologyEx(scr,cv2.MORPH_TOPHAT,kernel)
dst:输出图像
scr:原始图像
cv2.MORPH_TOPHAT：表示进行礼帽操作
kernel：卷积核，一般为正方形，里面都是1，可以这样生成：

kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）

#例子：
import numpy as np
kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）
dst=cv2.morphologyEx(scr,cv2.MORPH_TOPHAT,kernel)

7、图像黑帽
图像黑帽操作就是为了得到图像里面的小孔或者黑点，就是：
图像黑帽结果=原始图像闭操作结果图-原始图像，见下图

使用morphologyEx函数
语法：dst=cv2.morphologyEx(scr,cv2.MORPH_BLACKHAT,kernel)
dst：输出图像
scr:原始图像
cv2.MORPH_BLACKHAT：表示进行图像黑帽操作
kernel：卷积核，一般为正方形，里面都是1，可以这样生成：

kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）

#例子：
import numpy as np
kernel=np.ones((5,5),np.uint8)  #生成一个5行5列的卷积核（里面的值都是1）
dst=cv2.morphologyEx(scr,cv2.MORPH_BLACKHAT,kernel)

十三、图像梯度

1、sobel算子
使用函数Sobel
语法：dst=cv2.Sobel(src,ddepth,dx,dy,[ksize])
dst：计算结果（是一个梯度图像）
src：原始图像
ddepth：处理结果图像深度，通常情况下可令ddepth=-1，此时表示结果与原图像深度一致，但是考虑到处理结果可能为负数的情况下，要令ddepth=cv2.CV_64F(注意：要将原图像转化为256色位图，则可以这样：目标图像=cv2.convertScaleAbs(原始图像))
ksize：卷积核
dx：x轴方向，计算x方向的梯度：dx=1，dy=0
dy：y轴方向，计算y方向的梯度：dx=0，dy=1
要是同时计算x和y方向的梯度有两种表达方式：

#方式1（不严谨）：
dst=cv2.Sobel(src,ddepth,1,1)

#方式2（推荐使用）：
dx=cv2.Sobel(src,ddepth,1,0)
dy=cv2.Sobel(src,ddepth,0,1)
dst=dx+dy
#或者
dst=系数1*dx+系数2*dy  #为了防止dst>256所以加了“系数”，一般系数1=系数2=0.5

注意：这一步（dst=系数1dx+系数2dy）要用这个函数实现：
dst=cv2.addWeighted(dx,系数1，dy,系数2，修正值)
计算公式：dst=系数1dx+系数2dy +修正值

#例子：
dx=cv2.Sobel(src,cv2.CV_64F,1,0)
dy=cv2.Sobel(src,cv2.CV_64F,0,1)
dx=cv2.convertScaleAbs(dx)
dy=cv2.convertScaleAbs(dy)
dst=cv2.addWeighted(dx,0.5,dy,0.5,0)  #修正值为0
cv2.imshow("xy"，dst)

2、scharr算子
因为使用3*3 sobel算子时，可能不太精确，scharr算子效果更好
语法：dst=cv2.Scharr(src,ddepth,dx,dy)
dst：计算结果（是一个梯度图像）
src：原始图像
ddepth：处理结果图像深度，通常情况下可令ddepth=-1，此时表示结果与原图像深度一致，但是考虑到处理结果可能为负数的情况下，要令ddepth=cv2.CV_64F(注意：要将原图像转化为256色位图，则可以这样：目标图像=cv2.convertScaleAbs(原始图像))
dx：x轴方向，计算x方向的梯度：dx=1，dy=0
dy：y轴方向，计算y方向的梯度：dx=0，dy=1
注意dx=1时，必须dy=0；dx=0时，必须dy=1

#同时计算x方向和y方向的梯度
dx=cv2.Scharr(src,cv2.CV_64F,1,0)
dy=cv2.Scharr(src,cv2.CV_64F,0,1)
dx=cv2.convertScaleAbs(dx)
dy=cv2.convertScaleAbs(dy)
dst=cv2.addWeighted(dx,0.5,dy,0.5,0)  #修正值为0
cv2.imshow("xy"，dst)