OpenCV-Python图像处理基础知识

最新推荐文章于 2023-05-12 16:20:41 发布

Qiuyu2550317721

最新推荐文章于 2023-05-12 16:20:41 发布

阅读量356

点赞数 1

文章标签： opencv 图像处理 python

本文链接：https://blog.csdn.net/qq_50081337/article/details/128352456

版权

代码0：

OpenCV-python图像处理处理图像问题的一般流程：
A、读入彩色图像；
B、滤波去噪，比如高斯滤波和均值滤波；
C、将三通道彩色图像进行灰度化，如果有必要再进行滤波操作；
D、将灰度化的图像进行二值化；
D、将二值化的图像进行形态学操作（比如腐蚀、膨胀、开运算和闭运算）对目标区域与非目标区进行进一步划分；
E、对目标区域进行边缘检测（例如Canny）；
F、对目标区域进行轮廓提取；
G、对目标区域进行绘制矩形框标定和计算距离或者其它测量；
H、对检测的区域进行文字标定；

代码1：

import cv2 as cv

img = cv.imread('C:/Users/Lenovo/Desktop/1.jpg') #读图像
cv.namedWindow('new',cv.WINDOW_NORMAL) # 重命名窗口
cv.resizeWindow('new',640,640) #设置显示窗口的大小
cv.imshow('new',img)# 显示窗口
key =cv.waitKey(0)
if key == ord('q'):
exit()

代码2：
import cv2 as cv

img = cv.imread('C:/Users/Lenovo/Desktop/1.jpg') #读图像
cv.namedWindow('new',cv.WINDOW_NORMAL)
cv.resizeWindow('new',640,640)
cv.imshow('new',img)
key =cv.waitKey(0)
if key == ord('q'):
cv.destroyAllWindows()

代码3：
import cv2 as cv
def cv_show(name,img): #显示函数封装
cv.namedWindow('new', cv.WINDOW_NORMAL)
cv.resizeWindow('new', 640, 640)
cv.imshow('new', img)
key = cv.waitKey(0)
if key == ord('q'):
cv.destroyAllWindows()

img = cv.imread('C:/Users/Lenovo/Desktop/1.jpg') #读图像
cv_show('image',img)

代码4：

# 打开摄像头
import cv2
cv2.namedWindow('Video',cv2.WINDOW_NORMAL)
cv2.resizeWindow('Video',640,480)

cap =cv2.VideoCapture(0) #打开摄像头
# 循环读取摄像头每一帧
while True:
ret, frame =cap.read()
if not ret: #如果没有正确打开摄像头，则退出
break

cv2.imshow('Video',frame)
key =cv2.waitKey(10)#这里是每帧图像延时10ms
if key == ord('q'):
break
cap.release() #别忘释放摄像头资源
cv2.destAllWindows()

代码5：

# 从摄像头中视频录制
import cv2
cap =cv2.VideoCapture(0) #开启摄像头
fourcc =cv2.VideoWriter_fourcc(*'mp4v')

# 创建videowriter
vw =cv2.VideoWriter('output.mp4',fourcc,30,(640,480))

while cap.isOpened():
ret, frame = cap.read()
if not ret:
break

# 写每帧数据
vw.write(frame)
cv2.imshow('frame', frame)

if cv2.waitKey(1) == ord('q'):
break

cap.release()
vw.release()
cv2.destroyAllWindows()

代码6：

# trackbar的使用--调色板的使用
import cv2
import numpy as np

# 创建显示窗口及大小
cv2.namedWindow('trackbar',cv2.WINDOW_NORMAL)
cv2.resizeWindow('trackbar',640,480)

# 定义回调函数
def callback(value):
# print(value)
pass

# 创建三个trackbar
cv2.createTrackbar('R','trackbar',0, 255, callback)
cv2.createTrackbar('G','trackbar',0, 255, callback)
cv2.createTrackbar('B','trackbar',0, 255, callback)

#创建背景图片
img =np.zeros((480,640,3),np.uint8)
while True:
r =cv2.getTrackbarPos('R','trackbar')
g = cv2.getTrackbarPos('G', 'trackbar')
b = cv2.getTrackbarPos('B', 'trackbar')

# 用获取到的三个值修改背景图片颜色
img[:] = [b, g, r]
cv2.imshow('trackbar',img)
key = cv2.waitKey(1)
if key == ord('q'):
break

cv2.destroyAllWindows()

代码7：
# OpenCV颜色空间转换
import cv2

def callback(value):
pass

cv2.namedWindow('color',cv2.WINDOW_NORMAL)
cv2.resizeWindow('color',640,480)

img = cv2.imread('C:/Users/Lenovo/Desktop/1.jpg')
# 定义颜色空间转化列表
color_spaces =[
cv2.COLOR_BGR2RGBA, cv2.COLOR_BGR2BGRA,
cv2.COLOR_BGR2GRAY, cv2.COLOR_BGR2HSV,
cv2.COLOR_BGR2YUV
]

# 设置trackbar
cv2.createTrackbar('trackbar', 'color', 0, 4, callback)

while True:
# 获取trackbar的值
index = cv2.getTrackbarPos('trackbar', 'color')
# 进行颜色空间转换
cvt_img =cv2.cvtColor(img, color_spaces[index])
cv2.imshow('color', cvt_img)
key = cv2.waitKey(10)
if key == ord('q'):
break
cv2.destroyAllWindows()

代码8：

# OpenCV复制
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/1.jpg')

#浅拷贝
img2 =img.view()

#深拷贝
img3 =img.copy()

img[10:100, 10:100] =[0, 0, 255] #BGR,red
# cv2.imshow('res', np.hstack((img,img2,img3))) #横向堆叠显示结果
cv2.imshow('res', np.vstack((img,img2,img3))) #竖向堆叠显示结果
cv2.waitKey(0)
cv2.destroyAllWindows()

代码9：

# 图像的分割与融合
import cv2
import numpy as np

img =np.zeros((200,200,3),np.uint8)

# 分割通道
b, g, r =cv2.split(img)
# 修改一些颜色
b[10:100, 10:100] =255
g[10:100, 10:100] =255

#合并通道
img2 =cv2.merge((b,g,r))
cv2.imshow('b,g',np.hstack((b,g)))
cv2.imshow('res', np.hstack((img,img2)))
cv2.waitKey(0)
cv2.destroyAllWindows()

代码10：

# 绘制线
import cv2
import numpy as np

# 创建纯黑的背景图用来画图形
img =np.zeros((480,640,3),np.uint8)

# line(img,pt1,pt2,color,thickness,lineType,shift)
cv2.line(img,(10,20),(300,400),(0,0,255),5,4)
cv2.line(img,(80,100),(380,480),(0,255,255),5,16)

cv2.imshow('draw',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码11：

# 绘制矩形
import cv2
import numpy as np

# 创建纯黑的背景图用来画图形
img =np.zeros((480,640,3),np.uint8)

cv2.rectangle(img,(80,100),(380,380),(0,0,255),5,4) #矩形的左上角点坐标和右下角点坐标，即两个对角点坐标

cv2.imshow('draw',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码12：
# 绘制圆
import cv2
import numpy as np

# 创建纯黑的背景图用来画图形
img =np.zeros((480,640,3),np.uint8)

cv2.circle(img,(320,240),50,(0,0,255),5,4) #圆心及半径

cv2.imshow('draw',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码13：

# 绘制椭圆
import cv2
import numpy as np

# 创建纯黑的背景图用来画图形
img =np.zeros((480,640,3),np.uint8)

# ellipse(img,中心点，长宽的一半，角度，从哪个角度开始，从哪个角度结束，。。。。。。)
cv2.ellipse(img,(320,240),(100,50), 0, 0, 360, (0,0,255),5,4) #画椭圆

cv2.imshow('draw',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码14：

# 绘制显示的文本
import cv2
import numpy as np

# 创建纯黑的背景图用来画图形
img =np.zeros((480,640,3),np.uint8)

# putText(img,text,org,fontFace,fontScale,color[,lineType[,bottomLeftOrigin]])
cv2.putText(img,'Hello Opencv',(50,400),cv2.FONT_HERSHEY_COMPLEX,2,[0,0,255])

cv2.imshow('draw',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码15：

# 图像的基本运算：加减乘除
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
dog =cv2.imread('C:/Users/Lenovo/Desktop/3.jfif')

print(cat.shape)#显示猫图像的高度、宽度、通道数
print(dog.shape)#显示狗图像的高度、宽度、通道数

# 加法操作要求两张图片的高、宽及通道数相同,add的规则就是两个图对应位置的元素相加，如果超过255时，全部变为255.
# 减法操作为对应位置相减，减完小于0，则统一为0.
# 乘 multiply
# 除 divide
new_img_add = cv2.add(cat,dog)
new_img_subtract =cv2.subtract(cat,dog)
new_img_multiply =cv2.multiply(cat,dog)
new_img_divide =cv2.divide(cat,dog)

# cv2.imshow('res',np.hstack((cat,dog,new_img_add)))
# cv2.imshow('res',np.hstack((cat,dog,new_img_subtract)))
# cv2.imshow('res',np.hstack((cat,dog,new_img_multiply)))
cv2.imshow('res',np.hstack((cat,dog,new_img_divide)))

cv2.waitKey(0)
cv2.destroyAllWindows()

代码16：

# 图像的融合：是指两张图像按照不同权重相加
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
dog =cv2.imread('C:/Users/Lenovo/Desktop/3.jfif')

print(cat.shape)#显示猫图像的高度、宽度、通道数
print(dog.shape)#显示狗图像的高度、宽度、通道数

new_img =cv2.addWeighted(cat, 0.7, dog, 0.3, -20)

cv2.imshow('res',np.hstack((dog,new_img)))

cv2.waitKey(0)
cv2.destroyAllWindows()

代码17：

# 图像的位运算
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
dog =cv2.imread('C:/Users/Lenovo/Desktop/3.jfif')

# 一张图片的元素按位非操作
cat_not = cv2.bitwise_not(cat)
print('cat:',cat[:2, :2])
print('dog:',dog[:2, :2])
print(cat_not[:2, :2])

# 两张图像在对应位置的元素进行按位与操作
cat_and_dog = cv2.bitwise_and(cat,dog)

# 两张图像的对应元素按照位或操作
cat_or_dog =cv2.bitwise_or(cat,dog)

# cv2.imshow('res',np.hstack((cat,cat_not)))
# cv2.imshow('res',np.hstack((cat,cat_and_dog)))
# cv2.imshow('res',np.hstack((cat_not,cat_and_dog)))
cv2.imshow('res',np.hstack((cat_and_dog,cat_or_dog)))

cv2.waitKey(0)
cv2.destroyAllWindows()

代码18：

# 图像的基本变换：放大缩小、平移旋转
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
dog =cv2.imread('C:/Users/Lenovo/Desktop/3.jfif')

# 把猫缩放成和狗一样大
new_cat = cv2.resize(cat,(499,360))# 宽度、高度,其作用可以代替切片，但是整体变化
cv2.imshow('cat',cat)
cv2.imshow('new_cat',new_cat)

new_dog =cv2.resize(dog,(800,800),interpolation=cv2.INTER_NEAREST)
cv2.imshow('dog',dog)
cv2.imshow('new_dog',new_dog)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码19：

# 图像的基本变换：放大缩小、平移旋转
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
dog =cv2.imread('C:/Users/Lenovo/Desktop/3.jfif')

# 把猫缩放成和狗一样大
new_cat = cv2.resize(cat,(499,360))# 宽度、高度,其作用可以代替切片，但是整体变化
cv2.imshow('cat',cat)
cv2.imshow('new_cat',new_cat)

new_dog_1 =cv2.resize(dog,(800,800),interpolation=cv2.INTER_NEAREST)
new_dog_2 =cv2.resize(dog,(800,800),interpolation=cv2.INTER_LINEAR)
new_dog_3 =cv2.resize(dog,(800,800),interpolation=cv2.INTER_CUBIC)
new_dog_4 =cv2.resize(dog,(800,800),interpolation=cv2.INTER_AREA)

cv2.imshow('dog',dog)
cv2.imshow('new_dog_1',new_dog_1)
cv2.imshow('new_dog_2',new_dog_2)
cv2.imshow('new_dog_3',new_dog_3)
cv2.imshow('new_dog_4',new_dog_4)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码20：

# 图像的基本变换：放大缩小、平移旋转
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
dog =cv2.imread('C:/Users/Lenovo/Desktop/3.jfif')

# 按照在x和y方向的比例进行缩放
new_cat = cv2.resize(cat,dsize=None, fx =0.5, fy =0.5)

cv2.imshow('cat',cat)
cv2.imshow('new_cat',new_cat)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码21：

# 图像的基本变换：图像翻转
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
dog =cv2.imread('C:/Users/Lenovo/Desktop/3.jfif')

# 翻转 filpCode=0,表示上下翻转；filpCode>0,表示左右翻转；filpCode<0,表示上下左右翻转。
new_cat = cv2.flip(cat,1)

cv2.imshow('new_cat',np.hstack((cat,new_cat)))

cv2.waitKey(0)
cv2.destroyAllWindows()

代码22：

# 图像的基本变换：旋转
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
dog =cv2.imread('C:/Users/Lenovo/Desktop/3.jfif')

# 图像旋转，ROTATE_90_CLOCKWISE，表示90度顺时针旋转图片；ROTATE_180,180度；ROTATE_90_COUNTERCLOCKWISE，表示90度逆时针旋转
# new_cat = cv2.rotate(cat,rotateCode=cv2.ROTATE_90_CLOCKWISE)
# new_cat = cv2.rotate(cat,rotateCode=cv2.ROTATE_180)
new_cat = cv2.rotate(cat,rotateCode=cv2.ROTATE_90_COUNTERCLOCKWISE)

cv2.imshow('cat',cat)
cv2.imshow('new_cat',new_cat)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码23：

# 图像的仿射变换之平移
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')

h,w,ch = cat.shape
M = np.float32([[1,0,200],[0,1,200]])#变换矩阵M
new_cat = cv2.warpAffine(cat,M, dsize=(w,h))

cv2.imshow('cat',cat)
cv2.imshow('new_cat',new_cat)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码24：

# 图像的仿射变换之获取变换矩阵，因为在进行旋转时人工不方便计算变化矩阵
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')

h,w,ch = cat.shape

#先获取变换矩阵:(100,100)旋转中心，15逆时针旋转角度，1表示不进行缩放
# M = cv2.getRotationMatrix2D((100,100),15,1)
M = cv2.getRotationMatrix2D((w/2,h/2),15,1)

new_cat = cv2.warpAffine(cat,M,(w,h))#再进行仿射变换

cv2.imshow('cat',cat)
cv2.imshow('new_cat',new_cat)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码25：

# 图像的仿射变换之获取变换矩阵：通过三个点，即原始图片上的三个点坐标和变换之后三个对应的三个坐标。
import cv2
import numpy as np
cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
h,w,ch = cat.shape
# 定义原始图像的坐标点src和变换之后的对应三个点坐标dst,建立三个方程
src =np.float32([[50,100],[80,100],[200,300]])
dst = np.float32([[100,150],[360,200],[280,120]])
M = cv2.getAffineTransform(src,dst) #获取变化矩阵M
new_cat = cv2.warpAffine(cat,M,(w,h))#通过M，进行仿射变换
cv2.imshow('cat',cat)
cv2.imshow('new_cat',new_cat)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码26：

# 图像的透视变换：解决视角矫正问题，比如银行卡放倾斜：需要4个点相互对应
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')

# 定义原始图像的坐标点src和变换之后的对应四个点坐标dst,建立四个方程
src =np.float32([[10,110],[210,110],[0,400],[250,390]])
dst = np.float32([[0,0],[230,0],[0,300],[230,300]])

M = cv2.getPerspectiveTransform(src,dst) #获取变化矩阵M
new_cat = cv2.warpPerspective(cat,M,(230,300))#通过M，进行透视变换

cv2.namedWindow('cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('cat',640,480)
cv2.imshow('cat',cat)

cv2.namedWindow('new_cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('new_cat',640,480)
cv2.imshow('new_cat',new_cat)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码27：

# 卷积操作过滤器
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')

# kernel必须是float型
kernel =np.ones((5,5),np.float32)/25 #相当于平均滤波
dst= cv2.filter2D(cat,-1,kernel)

cv2.namedWindow('cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('cat',640,480)
cv2.imshow('cat',cat)

cv2.namedWindow('new_cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('new_cat',640,480)
cv2.imshow('new_cat',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码28：

# 卷积操作过滤器
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')

# kernel必须是float型
# kernel =np.ones((5,5),np.float32)/25 #相当于平均滤波

# kernel =np.array([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]])
kernel =np.array([[-2,1,0],[-1,1,1],[0,1,2]])
dst= cv2.filter2D(cat,-1,kernel)

cv2.namedWindow('cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('cat',640,480)
cv2.imshow('cat',cat)

cv2.namedWindow('new_cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('new_cat',640,480)
cv2.imshow('new_cat',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码29：

# 卷积操作过滤器
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
cat = cv2.cvtColor(cat,cv2.COLOR_BGR2GRAY)
# kernel必须是float型
# kernel =np.ones((5,5),np.float32)/25 #相当于平均滤波

# kernel =np.array([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]]) #边缘卷积核
# kernel =np.array([[-2,1,0],[-1,1,1],[0,1,2]]) # 浮雕卷积核
kernel =np.array([[0,-1,0],[-1,5,-1],[0,-1,0]]) # 锐化卷积核,需要将彩色改成灰度图
dst= cv2.filter2D(cat,-1,kernel)

cv2.namedWindow('cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('cat',640,480)
cv2.imshow('cat',cat)

cv2.namedWindow('new_cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('new_cat',640,480)
cv2.imshow('new_cat',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码30：

# 方盒滤波和均值滤波
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')

#不需要手动创建卷积核，只需要方盒滤波的卷积核大小
# dst = cv2.boxFilter(cat,-1,(5,5),normalize=True) #方盒跟kernel一样的结果

# 均值滤波:没有位深ddpeth这个参数
dst =cv2.blur(cat,(5,5))

cv2.namedWindow('cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('cat',640,480)
cv2.imshow('cat',cat)

cv2.namedWindow('new_cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('new_cat',640,480)
cv2.imshow('new_cat',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码31：

# 高斯滤波：专门去除东一堆西一堆的高斯噪声
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')

dst =cv2.GaussianBlur(cat,(5,5),sigmaX=3) #高斯是元组（5,5）类型，不是数值5

cv2.namedWindow('cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('cat',640,480)
cv2.imshow('cat',cat)

cv2.namedWindow('new_cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('new_cat',640,480)
cv2.imshow('new_cat',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码32：

# 中值滤波：专门去除分布均匀的椒盐噪声
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')

dst =cv2.medianBlur(cat,9) #中值滤波是卷积核是数字5，而高斯滤波是元组类型。

cv2.namedWindow('cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('cat',640,480)
cv2.imshow('cat',cat)

cv2.namedWindow('new_cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('new_cat',640,480)
cv2.imshow('new_cat',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码33：

# 双边滤波：在高斯滤波的基础上考虑了边缘灰度值（空间距离+灰度距离），其作用是能够局部降噪并且很好地保留边缘信息。
import cv2
import numpy as np

cat =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')

dst =cv2.bilateralFilter(cat,7,20,50) # 数值7表示高斯卷积核大小，20为灰度距离的标准差，50为空间距离（高斯）的标准差

cv2.namedWindow('cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('cat',640,480)
cv2.imshow('cat',cat)

cv2.namedWindow('new_cat',cv2.WINDOW_NORMAL)
cv2.resizeWindow('new_cat',640,480)
cv2.imshow('new_cat',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码34：

# Sobel算子
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')

# 计算X方向的梯度,X方向没有了，只有Y方向的格子
dx =cv2.Sobel(img, cv2.CV_64F,dx =1, dy =0, ksize =3)
# 计算Y方向的梯度,Y方向没有了，只有X方向的格子
dy =cv2.Sobel(img, cv2.CV_64F,dx =0, dy =1, ksize =3)

# dst =cv2.add(dx,dy)
dst =cv2.addWeighted(dx, 0.5, dy, 0.5,gamma =0)
cv2.imshow('dx',dx)
cv2.imshow('dy',dy)
cv2.imshow('dst',dst)

cv2.waitKey(0)
cv2.destroyAllWondows()

代码35：

# Scharr算子
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')

# 计算X方向的梯度,X方向没有了，只有Y方向的格子
dx =cv2.Scharr(img, cv2.CV_64F,dx =1, dy =0)
# 计算Y方向的梯度,Y方向没有了，只有X方向的格子
dy =cv2.Scharr(img, cv2.CV_64F,dx =0, dy =1)

# dst =cv2.add(dx,dy)
dst =cv2.addWeighted(dx, 0.5, dy, 0.5,gamma =0)

cv2.imshow('dx',dx)
cv2.imshow('dy',dy)
cv2.imshow('dst',dst)

cv2.waitKey(0)
cv2.destroyAllWondows()

代码36：
# 拉普拉斯算子:是一种基于二阶导数边缘检测的算子，很容易受噪声的影响，先高斯去噪，然后在拉普拉斯检测边缘
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
dst =cv2.Laplacian(img,-1,ksize =3)

cv2.imshow('dst',dst)
cv2.waitKey(0)
cv2.destroyAllWondows()

代码37：

# Canny算子边缘检测算子:（相对最好的边缘检测算子）
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif')
dst =cv2.Canny(img,80,150) # 阈值越小，细节越丰富

cv2.imshow('dst',dst)
cv2.waitKey(0)
cv2.destroyAllWondows()

代码38：

# 图像全局二值化-阈值二值化（一般用这个二值化）
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 二值化,用的最多，会返回阈值和二值化处理后的图片

cv2.imshow('gray',gray)
cv2.imshow('dst',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码39：

# 自适应阈值二值化（这个阈值二值化比较智能，当全局阈值化不行时可以尝试这个阈值化）
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
dst =cv2.adaptiveThreshold(gray,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,9,0) # 自适应阈值二值化,只会返回二值化处理后的图片

cv2.imshow('gray',gray)
cv2.imshow('dst',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码40：
# 腐蚀形态学操作，只有卷积核内卷积时的图像全为白色才为白色，否则为黑色。
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
# 定义卷积核
kernel = np.ones((3,3),np.uint8)
dst =cv2.erode(gray,kernel,iterations=2) # 腐蚀操作,可以直接处理彩色图或者灰度图也可以

cv2.imshow('gray',gray)
cv2.imshow('dst',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码41：

# 腐蚀形态学操作，只有卷积核内卷积时的图像全为白色才为白色，否则为黑色。
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 二值化,用的最多，会返回阈值和二值化处理后的图片

# 定义卷积核
kernel = np.ones((3,3),np.uint8)
dst =cv2.erode(dst1,kernel,iterations=2) # 腐蚀操作,可以直接处理彩色图、灰度图、二值化图

cv2.imshow('gray',gray)
cv2.imshow('thresh',dst1)
cv2.imshow('erode',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码42：

# 获取形态学卷积核
import cv2
import numpy as np

kernel_rect =cv2.getStructuringElement(cv2.MORPH_RECT,(15,15))#矩形形状5x5全为1的卷积核
kernel_ellipse =cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(15,15)) #椭圆形状5x5全为1的卷积核
kernel_cross =cv2.getStructuringElement(cv2.MORPH_CROSS,(15,15)) #十字架形状5x5全为1的卷积核
print(kernel_rect)
print(kernel_ellipse)
print(kernel_rect)

代码43：

# 腐蚀形态学操作，只有卷积核内卷积时的图像全为白色才为白色，否则为黑色。（目的是让噪声区域减小）
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 定义卷积核
# kernel = np.ones((3,3),np.uint8)
kernel =cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))#矩形形状3x3全为1的卷积核
dst =cv2.erode(dst1,kernel,iterations=2) # 腐蚀操作,可以直接处理彩色图、灰度图、二值化图

# cv2.imshow('gray',gray)
cv2.imshow('thresh',dst1)
cv2.imshow('erode',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码44：

# 膨胀形态学操作，只有卷积核内卷积时的图像全为黑色才为黑色，否则为白色。（让目标区域变大和连贯）
# 膨胀是腐蚀的相反操作,基本原理是只要保证卷积核的锚点是非0值,周边无论是0还是非0值,都变成非0值.
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 定义卷积核
# kernel = np.ones((3,3),np.uint8)
kernel =cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))#矩形形状3x3全为1的卷积核
dst =cv2.dilate(dst1,kernel,iterations=2) # 膨胀操作,可以直接处理彩色图、灰度图、二值化图

# cv2.imshow('gray',gray)
cv2.imshow('thresh',dst1)
cv2.imshow('dilate',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码45：

# 腐蚀和膨胀的结合.
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 定义卷积核
kernel =cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))#矩形形状3x3全为1的卷积核
dst2 =cv2.erode(dst1,kernel,iterations=2) # 腐蚀操作,可以直接处理彩色图、灰度图、二值化图
dst3 =cv2.dilate(dst2,kernel,iterations=2) # 膨胀操作,可以直接处理彩色图、灰度图、二值化图

# cv2.imshow('gray',gray)
cv2.imshow('thresh',dst1)
cv2.imshow('erode',dst2)
cv2.imshow('erode+dilate',dst3)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码46：

# 形态学开运算：先腐蚀erode再膨胀dilate，（用于去除目标区域外部的噪声）
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 定义卷积核
kernel =cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))#矩形形状3x3全为1的卷积核
dst2 =cv2.morphologyEx(dst1, cv2.MORPH_OPEN,kernel,iterations =2) # 开运算

# cv2.imshow('gray',gray)
cv2.imshow('thresh',dst1)
cv2.imshow('erode',dst2)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码47：

# 形态学闭运算：先膨胀dilate再腐蚀erode，（用于去除目标区域内部的噪声）
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 定义卷积核
kernel =cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))#矩形形状3x3全为1的卷积核
dst2 =cv2.morphologyEx(dst1, cv2.MORPH_CLOSE,kernel,iterations =2) # 闭运算

# cv2.imshow('gray',gray)
cv2.imshow('thresh',dst1)
cv2.imshow('close',dst2)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码48：

# 形态学梯度：原图减去腐蚀后的图，腐蚀之后原图边缘变小了，原图-腐蚀就可以得到腐蚀掉的部分，即边缘。
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 定义卷积核
kernel =cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))#矩形形状3x3全为1的卷积核
dst2 =cv2.morphologyEx(dst1, cv2.MORPH_GRADIENT,kernel,iterations =2) # 形态学梯度

# cv2.imshow('gray',gray)
cv2.imshow('thresh',dst1)
cv2.imshow('close',dst2)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码49：

# 顶帽运算：顶帽 =原图-开运算
# 开运算的效果是去除图形外的噪声。原图-开运算就得到了去掉的噪声。
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 定义卷积核
kernel =cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))#矩形形状3x3全为1的卷积核
dst2 =cv2.morphologyEx(dst1, cv2.MORPH_TOPHAT,kernel,iterations =2) # 顶帽

# cv2.imshow('gray',gray)
cv2.imshow('thresh',dst1)
cv2.imshow('tophat',dst2)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码50：

# 黑帽运算：黑帽 =原图-闭运算
# 开运算的效果是去除图形内部的噪声。原图-闭运算就得到了去掉内部的噪声。
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 定义卷积核
kernel =cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))#矩形形状3x3全为1的卷积核
dst2 =cv2.morphologyEx(dst1, cv2.MORPH_BLACKHAT,kernel,iterations =2) # 顶帽

# cv2.imshow('gray',gray)
cv2.imshow('thresh',dst1)
cv2.imshow('tophat',dst2)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码51：

# 查找轮廓 contours, hierarchy =cv2.findContours(dst1,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 查找轮廓
contours, hierarchy =cv2.findContours(dst1,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

print(type(contours)) #contours是列表，而不是ndarray,里面放的是ndarray，每个ndarray放着coutours
print(contours)
print(hierarchy)

cv2.imshow('thresh',dst1)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码52：

# 查找轮廓 + 绘制轮廓
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 查找轮廓
contours, hierarchy =cv2.findContours(dst1,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
#绘制轮廓会直接修改原图，如果想保持原图不变，建议copy一份。
img_copy =img.copy()
#绘制查找到的轮廓,这里直接绘制在img_copy图片上了，而没有在img原图
cv2.drawContours(img_copy,contours,-1,(0,0,255),2)

cv2.imshow('img',img)#显示原图
cv2.imshow('img_copy',img_copy) #显示在img_copy绘制的轮廓

cv2.waitKey(0)
cv2.destroyAllWindows()

代码53：

# 计算轮廓面积和轮廓周长，单位是像素点
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/2.jfif') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

#计算轮廓面积
area = cv2.contourArea(contours[20])
print('area',area)
#计算轮廓周长
perimeter = cv2.arcLength(contours[20],closed=True)
print('perimeter',perimeter)

cv2.imshow('img',img)#显示原图
cv2.imshow('img_copy',img_copy) #显示在img_copy绘制的轮廓

cv2.waitKey(0)
cv2.destroyAllWindows()

代码54：

# 多边形逼近和凸包
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/hand.png') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 使用多边形逼近，近似模拟手的轮廓
approx =cv2.approxPolyDP(contours[0],20,closed=True) #这个数值20就是多项式阈值
# approx本质上就是一个轮廓数据
# 绘制近似逼近approx的轮廓
cv2.drawContours(img_copy,[approx],0,(0,255,0),2)

cv2.imshow('img',img)#显示原图
cv2.imshow('img_copy',img_copy) #显示在img_copy绘制的轮廓
cv2.waitKey(0)
cv2.destroyAllWindows()

代码55：

# 多边形逼近和凸包
import cv2
import numpy as np

# 查找轮廓方法一
contours, hierarchy =cv2.findContours(dst1,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
#绘制轮廓会直接修改原图，如果想保持原图不变，建议copy一份。
img_copy =img.copy()
#绘制查找到的轮廓,这里直接绘制在img_copy图片上了，而没有在img原图
cv2.drawContours(img_copy,contours,0,(0,0,255),2) #绘制的查找到的轮廓

# 使用多边形逼近，近似模拟手的轮廓方法二
approx =cv2.approxPolyDP(contours[0],20,closed=True) #这个数值20就是多项式阈值
# approx本质上就是一个轮廓数据
cv2.drawContours(img_copy,[approx],0,(0,255,0),2)# 绘制近似逼近approx的轮廓

# 使用凸包近似逼近，模拟手的轮廓方法三
hull = cv2.convexHull(contours[0]) #计算凸包
cv2.drawContours(img_copy,[hull],0,(255,0,0),2) #绘制凸包方法的轮廓

cv2.imshow('img',img)#显示原图
cv2.imshow('img_copy',img_copy) #显示在img_copy绘制的轮廓
cv2.waitKey(0)
cv2.destroyAllWindows()

代码56：

# 最小外接矩形
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/rect.png') #读入彩色图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #灰度化
thresh, dst1 =cv2.threshold(gray,127,255,cv2.THRESH_BINARY) # 阈值二值化,用的最多，会返回阈值和二值化处理后的图片数据

# 查找轮廓
contours, hierarchy =cv2.findContours(dst1,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
#绘制轮廓会直接修改原图，如果想保持原图不变，建议copy一份。
img_copy =img.copy()
rect = cv2.minAreaRect(contours[1]) #查找及挖掘轮廓contours[1]中的最小外接矩形，而不是绘制最小外接矩形，rect是一个旋转的矩形，是由矩形的起始坐标x,y，矩形的长宽，以及矩形的旋转角度(rad)组成
print(rect) #打印最小外接矩形rect内容
# 注意的是坐标点必须是整数
box = cv2.boxPoints(rect) # 这里是帮助我们将rect中旋转矩形的4个坐标点计算出来
print(box) #打印box内容
# 为了避免较大偏差，四舍五入
box =np.round(box).astype('int64')
box =np.int0(box) #然后再转化成整数
cv2.drawContours(img_copy,[box],0,(255,0,0),2) #绘制由box四个坐标点围成的矩形

cv2.imshow('img',img)#显示原图
cv2.imshow('img_copy',img_copy) #显示在img_copy绘制的轮廓
cv2.waitKey(0)
cv2.destroyAllWindows()

代码57：

# 最小外接矩形和最大外接矩形
import cv2
import numpy as np

# 最大外接矩形,就是方方正正的矩形，返回起始点的坐标x,y 和(w，h)
x,y,w,h = cv2.boundingRect(contours[1])
cv2.rectangle(img_copy,(x,y),(x + w, y + h),(0,255,0),2) #绘制最大外接矩形

cv2.imshow('img',img)#显示原图
cv2.imshow('img_copy',img_copy) #显示在img_copy绘制的轮廓
cv2.waitKey(0)
cv2.destroyAllWindows()

代码58：

# 图像金字塔之高斯金字塔：向下采样是指粗暴地去除偶数行和列的方法
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/lena.png') #读入彩色图像

print(img.shape)
dst = cv2.pyrDown(img) #分辨率减小的操作，下采样(朝着金字塔的顶尖的方向)---高斯下采样
print(dst.shape)
dst2 = cv2.pyrDown(dst) #再进行一次下采样
print(dst2.shape)

cv2.imshow('img',img)
cv2.imshow('dst',dst)
cv2.imshow('dst2',dst2)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码59：

# 图像金字塔之高斯金字塔：向上采样是指粗暴地添加偶数行和列的方法
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/lena.png') #读入彩色图像

print(img.shape)
dst = cv2.pyrUp(img) #分辨率增大的操作，上采样(朝着金字塔的底部的方向)---高斯上采样
print(dst.shape)
dst2 = cv2.pyrUp(dst) #再进行一次上采样
print(dst2.shape)

cv2.imshow('img',img)
cv2.imshow('dst',dst)
cv2.imshow('dst2',dst2)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码60：

# 拉普拉斯金字塔：原始图像减去先下采样再上采样的图像
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/lena.png') #读入彩色图像

# 先下采样缩小照片
dst1 = cv2.pyrDown(img) #分辨率增大的操作，上采样(朝着金字塔的底部的方向)---高斯上采样
# 再上采样放大照片
dst2 = cv2.pyrUp(dst1) #再进行一次上采样
# 原图-dst2
lap0 = img - dst2 # 第一层的拉普拉斯结果

# 第二层拉普拉斯
# 先下采样缩小照片
dst3 = cv2.pyrDown(dst2) #分辨率增大的操作，上采样(朝着金字塔的底部的方向)---高斯上采样
# 再上采样放大照片
dst4 = cv2.pyrUp(dst3) #再进行一次上采样
# 原图-dst2
lap1 = dst2 - dst4 # 第一层的拉普拉斯结果

cv2.imshow('img',img)
cv2.imshow('lap0',lap0)
cv2.imshow('lap1',lap1)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码61：

# Opencv 统计直方图
import cv2
import numpy as np
import matplotlib.pyplot as plt

img =cv2.imread('C:/Users/Lenovo/Desktop/lena.png') #读入彩色图像
hist_B = cv2.calcHist([img],[0],None,[256],[0,255]) #直方图统计, B
hist_G= cv2.calcHist([img],[1],None,[256],[0,255]) #直方图统计, G
hist_R= cv2.calcHist([img],[2],None,[256],[0,255]) #直方图统计, R
plt.plot(hist_B,color='b',label ='blue')
plt.plot(hist_G,color='g',label ='green')
plt.plot(hist_R,color='r',label = 'red')
plt.legend()
plt.show()

cv2.waitKey(0)
cv2.destroyAllWindows()

代码62：

# 直方图均衡化
import cv2
import numpy as np
import matplotlib.pyplot as plt

img =cv2.imread('C:/Users/Lenovo/Desktop/lena.png') #读入彩色图像
gray =cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) #灰度化

# lena变黑
gray_back =gray - 40
#lena 变亮
gray_bright =gray + 40

cv2.imshow('lenna',np.hstack((gray,gray_back,gray_bright)))

# 查看各自的直方图
hist_gray = cv2.calcHist([gray],[0],None,[256],[0,255])
hist_back = cv2.calcHist([gray_back],[0],None,[256],[0,255])
hist_bright = cv2.calcHist([gray_bright],[0],None,[256],[0,255])

#绘制直方图
plt.plot(hist_gray,label ='gray')
plt.plot(hist_back,label ='dark')
plt.plot(hist_back,label ='bright')
plt.legend()
plt.show()

# 直方图均衡化处理
dark_equ = cv2.equalizeHist(gray_back)
bright_equ = cv2.equalizeHist(gray_bright)
cv2.imshow('gray_dark and dark_equ',np.hstack((gray_back,dark_equ)))
cv2.imshow('gray_bright and bright_equ',np.hstack((gray_bright,bright_equ)))

cv2.waitKey(0)
cv2.destroyAllWindows()

代码63：

# 直方图均衡化
import cv2
import numpy as np
import matplotlib.pyplot as plt

img =cv2.imread('C:/Users/Lenovo/Desktop/lena.png') #读入彩色图像
gray =cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) #灰度化

# lena变黑
gray_back =gray - 40
#lena 变亮
gray_bright =gray + 40

cv2.imshow('lenna',np.hstack((gray,gray_back,gray_bright)))

#绘制直方图
plt.plot(hist_gray,label ='gray')
plt.plot(hist_back,label ='dark')
plt.plot(hist_back,label ='bright')
plt.legend()
plt.show()

# 进行均衡化处理
dark_equ = cv2.equalizeHist(gray_back)
bright_equ = cv2.equalizeHist(gray_bright)
cv2.imshow('gray_dark and dark_equ',np.hstack((gray_back,dark_equ)))
cv2.imshow('gray_bright and bright_equ',np.hstack((gray_bright,bright_equ)))
# 查看均衡化的直方图
dark_equ = cv2.calcHist([dark_equ],[0],None,[256],[0,255])
bright_equ = cv2.calcHist([bright_equ],[0],None,[256],[0,255])
plt.plot(dark_equ,label ='dark_equ')
plt.plot(bright_equ,label ='bright_equ')
plt.legend()
plt.show()

cv2.waitKey(0)
cv2.destroyAllWindows()

代码64：

# 掩膜方法的直方图，就是指感兴趣的目标区域的直方图
import cv2
import numpy as np
import matplotlib.pyplot as plt

img =cv2.imread('C:/Users/Lenovo/Desktop/lena.png') #读入彩色图像
gray =cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) #灰度化

# 生成掩膜图像
mask = np.zeros(gray.shape,np.uint8)

# 设置想要统计直方图的区域
mask[50:150, 100:200] = 255
# 掩膜后的目标区域
mask_region = cv2.bitwise_and(gray,gray,mask =mask)

cv2.imshow('gray',gray)
cv2.imshow('mask',mask)
cv2.imshow('mask_region',mask_region)

cv2.waitKey(0)
cv2.destroyAllWindows()

代码65：***车辆统计项目： https://www.bilibili.com/video/BV12Z4y1z7jb?p=67&vd_source=9896432c8d2da3eee75b86d9ef464d8b
65-1加载视频：
# 加载视频
import cv2
import numpy as np
cap =cv2.VideoCapture('C:/Users/Lenovo/Desktop/car.mp4') #加载视频
# cap =cv2.VideoCapture(0) #打开摄像头

#循环读取视频帧
while True:
ret,frame =cap.read()
if ret ==True:
cv2.namedWindow('video', cv2.WINDOW_NORMAL)
cv2.resizeWindow('video', 1280, 640)
cv2.imshow('video',frame)

key =cv2.waitKey(10)
#用户按esc退出
if key ==27:
break

#最后释放资源
cap.release()
cv2.destroyAllWindows()

65-2：去除背景示例
# 去除背景
import cv2
import numpy as np
cap =cv2.VideoCapture(0) #打开摄像头
# 创建mog对象
mog =cv2.createBackgroundSubtractorMOG2()#静置的为背景

#循环读取视频帧
while True:
ret,frame =cap.read()
if ret ==True:
fgmask =mog.apply(frame)#在每帧图像中施加去背景算法

cv2.namedWindow('fgmask', cv2.WINDOW_NORMAL)
cv2.resizeWindow('fgmask', 1280, 640)
cv2.imshow('fgmask',fgmask)

key =cv2.waitKey(1)
#用户按esc退出
if key ==27:
break

#最后释放资源
cap.release()
cv2.destroyAllWindows()

65-3：车辆识别并计数代码

# 形态学识别车辆（真正达到高精度还需要深度学习检测，然后加上本节的计数方法才可以）
import cv2
import numpy as np

cap =cv2.VideoCapture('C:/Users/Lenovo/Desktop/car.mp4') #加载视频
# 创建mog对象
mog =cv2.createBackgroundSubtractorMOG2()#静置的为背景
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(5,5))
min_w =100
min_h =90
line_high =600
offset =7
cars = []
carnum = 0

# 计算外接矩形中线点函数
def center(x,y,w,h):
x1 = int(w/2)
y1 = int(h/2)
cx = int(x) + x1
cy = int(y) + y1
return cx, cy

#循环读取视频帧
while True:
ret,frame =cap.read()
if ret ==True:
# 先灰度化处理，然后高斯去噪
gray =cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY) #灰度化
blur =cv2.GaussianBlur(gray,(3,3),5) #高斯去噪
fgmask =mog.apply(blur)#去背景
erode =cv2.erode(fgmask,kernel,iterations=1) #腐蚀，让噪声点减小
dialte = cv2.dilate(erode,kernel,iterations=2) #膨胀，让目标区域加深
close =cv2.morphologyEx(dialte,cv2.MORPH_CLOSE,kernel)#闭运算去除内部噪声
contours, _ =cv2.findContours(close,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) #寻找轮廓
# 划线，即表示车辆通过这个线时开始计数。
cv2.line(frame,(10,line_high),(1280,line_high),(255,255,0),3)

# 画出所有检测出来的轮廓
for contour in contours:
# 最大外接矩形
(x,y,w,h) = cv2.boundingRect(contour)#根据轮廓获取矩形框的坐标信息
# 通过外接矩形的宽高来过滤掉小矩形框
is_valid =(w>=min_w) and (h>=min_h)
if not is_valid:
continue
# 通过这个is_valid判断语句，表明是正常车辆
cv2.rectangle(frame,(x,y),(x+w,y+h),(0,0,255),2)#绘制矩形框
# 把车抽象为一点，即外接矩形的中心点
cpoint = center(x,y,w,h)
cars.append(cpoint)
cv2.circle(frame,(cpoint),5,(0,0,255),-1) #绘制把车抽象为一点

#判断汽车是否过检测线
for (x,y) in cars:
if y > (line_high - offset) and y < (line_high +offset):
#落入了有效区间，计数加1
carnum += 1
cars.remove((x,y))
# print(carnum)

cv2.putText(frame,'Cars Counts:'+str(carnum),(500,60),cv2.FONT_HERSHEY_SIMPLEX,2,(255,0,255),5) #将计数写入每帧图像中
cv2.namedWindow('fgmask', cv2.WINDOW_NORMAL)
cv2.resizeWindow('fgmask', 1280, 720)
cv2.imshow('fgmask',frame)

key =cv2.waitKey(50)
#用户按esc退出
if key ==27:
break

#最后释放资源
cap.release()
cv2.destroyAllWindows()

代码66：

# Harris角点检测
import cv2
import numpy as np
dst_thresd =0.01
img =cv2.imread('C:/Users/Lenovo/Desktop/jiaodian.png') #加载视频
# 变成灰度图片
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
#Harris角点检测,blochSize类似于卷积核，可以是偶数，返回角点反应
dst = cv2.cornerHarris(gray,blockSize =2,ksize =3, k =0.04)
# print(gray.shape)
# print(dst)
# print(dst.shape)
# print(type(dst))
# 设置阈值，然后显示角点
img[dst > (dst_thresd * dst.max())] = [0,0,255]
cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码67：SIFT关键点检测

# SIFT关键点检测算法：包含中心点和角点
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/jiaodian.png') #加载视频
# 变成灰度图片
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

#创建SIFT对象
sift =cv2.SIFT_create()
#进行检测
kp =sift.detect(gray)
# print(kp) #kp是一个列表，里面存放的是封装的KeyPoint对象
#绘制关键点,对gray开始绘制，使用kp关键点，显示在img
cv2.drawKeypoints(gray,kp,img)

cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码68：SIFT关键点描述子

# SIFT关键点描述子（128维，16x16维），作用可以做图像与图像之间的特征匹配。
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/jiaodian.png') #加载视频
# 变成灰度图片
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

#创建SIFT对象
sift =cv2.SIFT_create()
#进行检测
kp =sift.detect(gray)
# print(kp) #kp是一个列表，里面存放的是封装的KeyPoint对象

#计算描述子
kp,descript = sift.compute(gray,kp)
print(len(kp))
print(type(descript))
print(descript.shape)
print(descript[0])

# 一步到位计算
kp,descript = sift.detectAndCompute(gray,None)

#绘制关键点,对gray开始绘制，使用kp关键点，显示在img
cv2.drawKeypoints(gray,kp,img)

cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

代码69：Shi-Tomasi角点检测（是Harris角点检测的改进算法）

# Shi-Tomasi角点检测
import cv2
import numpy as np

img =cv2.imread('C:/Users/Lenovo/Desktop/jiaodian.png') #加载视频
# 变成灰度图片
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

# Shi-Tomasi角点检测
corners =cv2.goodFeaturesToTrack(gray,maxCorners=0, qualityLevel=0.01, minDistance=10)
# print(corners)
# print(type(corners))
corners =np.int0(corners) #转换为int型

#画出角点
for i in corners:
#i相当于corners中的每一行数据，ravel()把二维变一维了。即角点的坐标点
x,y = i.ravel()
cv2.circle(img,(x,y),3,(0,0,255),-1)

cv2.imshow('Shi-Tomasi',img)
cv2.waitKey(0)
cv2.destroyAllWindows()