OpenCV--python 学习笔记

安装opencv :  pip install opencv-python

导入图片：

img = cv.imread('close.jpg')
cv.imshow('image', img)

• cv.imshow()显示窗口，窗口名字是image,窗口显示close.jpg 

上面可能显示不出来，加上cv.waitkey(毫秒)延长窗口显示时间

cv.waitkey(1000)
cv.destroyallwindows()#让窗口消失

图像是由像素点构成的，每个像素点可以分为r、g、b三种（三原色）

b,g,r=cv.split(img)
print(f'蓝色{b}')
print(f'绿色{g}')
print(f'红色{r}')

 显示像素点

灰度转换：

方法一：

b,g,r=cv.split(img)
plt.imshow(b,cmap=plt.cm.gray)

方法二：

gray=cv.cvtcolor(img,cv.color_bgr2gray)
plt.imshow(gray,cmap=plt.cm.gray)

灰度转为彩色：

将上述方法一形成的bgr合并

img2=cv.merge((b,g,r))
plt.imshow(img2[:,:,::-1])

bgr图片转为hsv：

hsv=cv.cvtcolor(img,cv.color_bgr2hsv)
plt.imshow(hsv,cmap=plt.cm.hsv)

---

一些简单操作合辑：

 图片叠加

加载两个图片：

img1=cv.imread("image/huaban.jpg")
img1=cv.imread("image/download1.jpg")

注：图片网络随机寻找的

查看图片长宽

img1=cv.imread("image/huaban.jpg")
height, width, channels = img1.shape
print(f'高：{height}，宽：{width}')

两个图片大小不一致时让图片一致：

1、手动修改其中一张

# 指定新的宽度和高度
new_width = 1200
new_height = 800
# 缩放图片
flo = cv.resize(img1, (new_width, new_height))
plt.imshow(flo[:,:,::-1])

2、代码调整

img1=cv.imread("image/huaban.jpg")
img2=cv.imread("image/download1.jpg")
if img1 is none or img2 is none:
    print("出错！加载不出图片.")
else:
    # 检查图像尺寸是否相同
    if img1.shape != img2.shape:
        # 如果尺寸不同，调整第二张图像的尺寸以匹配第一张
        img2 = cv.resize(img2, (img1.shape[1], img1.shape[0]))

显示图片：

fig,axes=plt.subplots(nrows=1,ncols=2,figsize=(10,8),dpi=100)
axes[0].imshow(img1[:,:,::-1])
axes[1].imshow(img2[:,:,::-1])
plt.show()

两张图片：

叠加方法一：cv.add()

image1=cv.add(img2,img1)
plt.imshow(image1[:,:,::-1])

不知道是因为图片还是因为什么原因和理想的不一样

叠加方法二：直接相加

image2=img1+img2
plt.imshow(image2[:,:,::-1])

emm...两张都能出现了，但是这个颜色有点奇怪 

方法三：分权重  cv.addweighted()

image3=cv.addweighted(img1,0.3,img2,0.7,0)
plt.imshow(image3[:,:,::-1])

 这样子方法一的问题就解决了（应该是花瓣图片有底）

将长宽都增加一倍：

rows,cols=img2.shape[:2]
img2_1=cv.resize(img2,(2*cols,2*rows))
plt.imshow(img2_1[:,:,::-1])

图像平移：

m=np.float32([[1,0,100],[0,1,50]])
img2_2=cv.warpaffine(img2,m,(2*cols,2*rows))
plt.imshow(img2_2[:,:,::-1])

图像旋转：

调用cv.getrotationmatrix2d获取旋转矩阵，然后调用cv.warpaffine()进行旋转

m=cv.getrotationmatrix2d((cols/2,rows/2),120,0.5)
img2_3=cv.warpaffine(img2,m,(cols,rows))
plt.imshow(img2_3[:,:,::-1])

 仿射变换:

将图片原来三个点变到新位置，图片原来平行的边变换后依旧平行

调用cv.getaffinetransform将创建变换矩阵，最后该矩阵将传递给cv.warpaffine()进行变换

m=np.float32([[50,50],[250,50],[50,200]])
n=np.float32([[100,100],[250,100],[50,200]])
m=cv.getaffinetransform(m,n)
img2_4=cv.warpaffine(img2,m,(cols,rows))

投射变化：

通过函数cv.getperspectivetransform()找到变换矩阵，将cv.warpperspective()进行投射变换

m=np.float32([[50,50],[250,50],[50,200],[23,32]])
n=np.float32([[60,60],[250,50],[50,200],[23,32]])
m=cv.getperspectivetransform(m,n)
img2_5=cv.warpperspective(img2,m,(cols,rows))

图像金字塔：

imgup=cv.pyrup(img2)#向上采样
imgup2=cv.pyrup(imgup)#向上采样
imgdown=cv.pyrdown(img2)#向下采样

cv.imshow('enlarge', imgup)
cv.imshow('original', img2)
cv.imshow('shrink', imgdown)
cv.waitkey(0)
cv.destroyallwindows()

 图像框变化

腐蚀&膨胀/erode()&dilate()：

img = cv.imread("image/zai.png")
kenel=np.ones((5,5),np.uint8)
img2=cv.erode(img,kenel)
img3=cv.dilate(img,kenel)

开运算：cv.morph_open

先腐蚀后膨胀

img = cv.imread("image/zhou.jpg")
kernel = np.ones((10, 10), np.uint8)
cvopen = cv.morphologyex(img,cv.morph_open,kernel)

闭运算：cv.morph_close

先膨胀后腐蚀

img = cv.imread("image/xue.jpg")
kernel = np.ones((10, 10), np.uint8)
cvopen = cv.morphologyex(img,cv.morph_close,kernel)

礼帽和黑帽

个人对礼帽和黑帽的理解是得到干扰图像的白点

礼帽：cv.morph_tophat

礼帽是原图像与开运算之差

img = cv.imread("image/zhou.jpg")
kernel = np.ones((10, 10), np.uint8)
cvopen = cv.morphologyex(img,cv.morph_tophat,kernel)

黑帽：cv.morph_blackhat

黑帽是闭运算与原图像之差

img = cv.imread("image/xue.jpg")
kernel = np.ones((10, 10), np.uint8)
cvopen = cv.morphologyex(img,cv.morph_blackhat,kernel)

图像噪声

椒盐噪声：

# 加入椒盐噪声
def sp_noise(image, amount):
    output = image.copy()
    threshold = 1 - amount
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            rdm = random.random()
            if rdm < amount:
                output[i][j] = 0
            elif rdm > threshold:
                output[i][j] = 255
    return output

高斯噪声：

# 加入高斯噪声
def gaussian_noise(image, mean, var):
    image = np.array(image / 255, dtype=float)
    noise = np.random.normal(mean, var ** 0.5, image.shape)
    out = image + noise
    if out.min() < 0:
        low_clip = -1.
    else:
        low_clip = 0.
    out = np.clip(out, low_clip, 1.0)
    out = np.uint8(out * 255)
    return out

image = cv.imread("image/mao.jpg")
img_jy= sp_noise(image, amount=0.05)
img_gs = gaussian_noise(image,mean=0,var=0.05)

均值滤波：

对椒盐噪声有效果

blur = cv.blur(img_jy,(5,5))

高斯滤波：

对高斯噪声有效果

blur = cv.gaussianblur(img_gs,(5,5),3)

中值滤波：

对椒盐噪声有奇效

blur = cv.medianblur(img_jy,5)

直方图

掩膜&灰度图

# 创建蒙版
mask = np.zeros(img.shape[:2], np.uint8)
mask[500:1300, 1500:2200] = 255#蒙版的位置
# 掩模
masked_img = cv.bitwise_and(img,img,mask = mask)
# 统计掩膜后图像的灰度图
mask_histr = cv.calchist([img],[0],mask,[256],[1,256])

均衡化：

# 创建一个自适应均衡化的对象，并应用于图像
clahe = cv.createclahe(cliplimit=2.0, tilegridsize=(8,8))
img_jhh = clahe.apply(img)

边缘检测

sobel滤波

# 计算sobel卷积结果
x = cv.sobel(img, cv.cv_16s, 1, 0)
y = cv.sobel(img, cv.cv_16s, 0, 1)
# 将数据进行转换
scale_absx = cv.convertscaleabs(x) 
scale_absy = cv.convertscaleabs(y)
# 4 结果合成
sobel= cv.addweighted(scale_absx, 0.5, scale_absy, 0.5, 0)

 scharr算子：x = cv.sobel(img, cv.cv_16s, 1, 0)——>加入ksize=-1(y同理)

canny检测

# canny边缘检测
lowthreshold = 40#较小的阈值将间断的边缘连接起来
max_lowthreshold = 50#较大的阈值检测图像中明显的边缘
canny = cv.canny(img, lowthreshold, max_lowthreshold) 

laplacian算子 

#laplacian转换
result = cv.laplacian(img,cv.cv_16s)
scale_abs = cv.convertscaleabs(result)

模板匹配

平方差匹配：cv_tm_sqdiff()
相关匹配：cv_tm_ccorr()
利用相关系数匹配：cv_tm_ccoeff()

原图与匹配图：

在我的示例里面，相关系数匹配成功

h,w,l = cat.shape
res = cv.matchtemplate(img, cat, cv.tm_ccoeff)
min_val, max_val, min_loc, max_loc = cv.minmaxloc(res)#绘制匹配位置
#使用平方差时最大值为最佳匹配位置
top_left = max_loc
bottom_right = (top_left[0] + w, top_left[1] + h)

霍夫变换

gray = cv.cvtcolor(img, cv.color_bgr2gray)#将图像转换为灰度图像
edges = cv.canny(gray, 50, 150)#边缘检测
lines = cv.houghlines(edges, 0.8, np.pi / 180, 150)#霍夫变换
# 将检测的线绘制在图像上
for line in lines:
    rho, theta = line[0]
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a * rho
    y0 = b * rho
    x1 = int(x0 + 1000 * (-b))
    y1 = int(y0 + 1000 * (a))
    x2 = int(x0 - 1000 * (-b))
    y2 = int(y0 - 1000 * (a))
    cv.line(img, (x1, y1), (x2, y2), (0, 255, 0))

检测圆：

gay_img = cv.cvtcolor(planets, cv.color_bgra2gray)
img = cv.medianblur(gay_img, 7)  #中值模糊，去噪点
circles = cv.houghcircles(img, cv.hough_gradient, 1, 200, param1=100, param2=30, minradius=0, maxradius=100)#霍夫变换
# 将检测结果绘制在图像上
for i in circles[0, :]:  # 遍历矩阵每一行的数据
    # 绘制圆形
    cv.circle(planets, (int(i[0]), int(i[1])),int(i[2]), (0, 255, 0), 2)#圆心，半径，颜色，宽
    # 绘制圆心
    cv.circle(planets, (int(i[0]), int(i[1])), 1, (0, 0, 255), 3)#圆心，半径

调参后能够识别六个圆

图像特征提取与描述

harris角点检测

gray = cv.cvtcolor(img, cv.color_bgr2gray)
gray = np.float32(gray)
dst = cv.cornerharris(gray,2,3,0.04)
#设置阈值，将角点绘制出来，阈值根据图像进行选择
img[dst>0.001*dst.max()] = [0,0,255]

 因为图片选的不好，把文字的角点都检测出来了

shi-tomas角点检测

gray = cv.cvtcolor(img,cv.color_bgr2gray)
corners = cv.goodfeaturestotrack(gray,1000,0.01,10)  # 角点检测
for i in corners:
    x,y = i.ravel()
    cv.circle(img,(int(x),int(y)),2,(0,0,255),1)#绘制

sift/surf检测

gray= cv.cvtcolor(img,cv.color_bgr2gray)
sift = cv.sift_create()
kp,des=sift.detectandcompute(gray,none)
cv.drawkeypoints(img,kp,img,flags=cv.draw_matches_flags_draw_rich_keypoints)

fast检测

fast = cv.fastfeaturedetector_create(threshold=30)#创建一个fast对象，传入阈值，注意：可以处理彩色空间图像
kp = fast.detect(img,none)#检测图像上的关键点
img2 = cv.drawkeypoints(img, kp, none, color=(0,0,255))#在图像上绘制关键点
fast.setnonmaxsuppression(0)#关闭非极大值抑制
kp = fast.detect(img,none)
img3 = cv.drawkeypoints(img, kp, none, color=(0,0,255))#在图像上绘制关键点

orb检测

orb = cv.orb_create(nfeatures=500)
kp,des = orb.detectandcompute(img,none)
img2 = cv.drawkeypoints(img, kp, none, color=(0,0,255), flags=0)

lbp算法

face = cv.cvtcolor(img,cv.color_bgr2gray)
lbp = local_binary_pattern(face, 8, 1)# 原始lbp特征
clbp = local_binary_pattern(face,8,1.0,method="ror")# 圆形lbp特征
varlbp = local_binary_pattern(face,8,1.0,method="var")#旋转不变lbp特征
uniformlbp = local_binary_pattern(face,8,1.0,method="nri_uniform")#等价特征
uniformlbp = local_binary_pattern(face, 8, 1.0, method='nri_uniform')#图像，邻域像素点数，半径，

hog算法

fd, hog = feature.hog(img, orientations=9, pixels_per_cell=(16, 16),cells_per_block=(2, 2), visualize=true, channel_axis=2)
img_hog= exposure.rescale_intensity(hog, in_range=(0, 10))