python opencv 开发说明书

1.基本语法
 src = cv.imread(“E:\1.jpg”) //获取图片位置cv.namedWindow(“Image”，cv.WINDOW_AUTOSIZE) //命名显示窗口并设置属性
cv.imshow(“Image”,img) //显示窗口并将图片显示
cv.waitKey(0) //等待输入响应
cv.destroyAllWindows() //销毁窗口
2.图像加载与保存
 图片属性
 1.通道数目2.高宽
3.像素数据
4.图像类型
图片属性获取
 print(type(image)) //显示image类型print(image.shape) //显示图片宽高和通道数
print(image.size) //显示总像素数据大小
print(image.dtype) //通道所占位数
摄像头获取
 capture=cv.VideoCapture(0) //获取视频while(True):
ret, frame=capture.read() //调用摄像头
frame=cv.flip(frame,1) //镜像调整
cv.imshow(“video”,frame) //显示窗口
c=cv.waitKey(50)
if c==27:
break
保存图片
 cv.imwrite(“E:/result.png”,img) //将img保存在路径下并命名与格式3.Numpy数组操作
 包介绍详细 www.numpy.org
 作用：
 遍历数组中的每个像素点修改数组中像素点的值
data\dtype\size\shape\len
遍历图像像素
 def access_pixels(image):print(image.shape)
height=image.shape[0]
width=image.shape[1]
channel=image.shape[2]
print(“width:%s,height:%s,channels:%s”%(width,height,channel))
for rowin range(height):
for colin range(width):
for cin range(channel):
pv = image[row, col, c]
image[row,col,c]=255-pv
cv.imshow(“pixels_demo”,image)
注：对于上述操作可以用像素取反函数完成
def inverse(image):
dst=cv.bitwise_not(image) //像素取反
cv.imshow(“show”,dst)
初始化图片
 np.zeros([400,400,3],np.uint8) //初始化0np.ones([400,400])*255 //初始化1
fill(122) //填充数组
reshape([1,9]) //改变数组形状
4.色彩空间
 相关概念
 RGB，HSV, HIS,YCrCb, YUV代码检测：
gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
cv.imshow(“gray”,gray)
hsv=cv.cvtColor(image,cv.COLOR_BGR2HSV)
cv.imshow(“hsv”,hsv)
yuv = cv.cvtColor(image, cv.COLOR_BGR2YUV)
cv.imshow(“yuv”, yuv)
Ycrcb = cv.cvtColor(image, cv.COLOR_BGR2YCrCb)
cv.imshow(“Ycrcb”, Ycrcb)
色彩空间转换API
用inRange处理
 获取视频中的蓝色：capture = cv.VideoCapture(“E:\test.mp4”)
while(True):
ret, frame = capture.read()
if ret ==False:
break
hsv=cv.cvtColor(frame, cv.COLOR_BGR2HSV)lower=np.array([100,43,46])
upper=np.array([124,255,255])#蓝色区域范围
mask=cv.inRange(hsv,lowerb=lower,upperb=upper)cv.imshow(“mask”,mask)
cv.imshow(“video”, frame)
c = cv.waitKey(40)
if c ==27:
break
分离与合并通道
 r,g,b= cv.split(src) #分离cv.imshow(“blue”,b)
cv.imshow(“green”,g)
cv.imshow(“red”,r)
cv.merge([r,g,b]) #合并
5.像素运算
 算术运算
 加减乘除——调节亮度，对比度def add_demo(m1,m2):
dst = cv.add(m1, m2) #加
cv.imshow(“add”, dst)
def subtract_demo(m1,m2):
dst = cv.subtract(m1, m2) #减
cv.imshow(“substract”, dst)
def divide_demo(m1,m2):
dst = cv.divide(m1, m2) #除
cv.imshow(“divide”, dst)
def multiply_demo(m1,m2):
dst = cv.multiply(m1, m2) #乘
cv.imshow(“multiply”, dst)
注：mean（src） #求均值
M,dev = meanStdDev(src) #返回均值和方差(对比度）
逻辑运算
 与或非——遮罩层控制dst = cv.bitwise_and(m1, m2) #与
dst = cv.bitwise_or(m1, m2) #或
dst = cv.bitwise_not(m1) #非
调整亮度对比度
#调整对比度与亮度 c：对比度，b：亮度
def contract_brightness_demo(image,c,b):
h,w,ch=image.shape
blank=np.zeros([h,w,ch],image.dtype) #调整亮度对比度
dst=cv.addWeighted(image,c,blank,1-c,b)
cv.imshow(“con_bri_demo”, dst)
6.ROI与泛洪填充
 注：ROI：所选处理区域#改变图片某区域颜色
face= src[50:250,100:300]
gray=cv.cvtColor(face,cv.COLOR_BGR2GRAY)
backface=cv.cvtColor(gray,cv.COLOR_GRAY2BGR)
face= src[50:250,100:300]=backface
cv.imshow(“face”,src)
泛洪填充
 def fill_color_demo(image):copyImg=image.copy()
h,w=image.shape[:2]
mask= np.zeros([h+2,w+2],np.uint8)
cv.floodFill(copyImg,mask,(30,30),(0,255,255),(100,100,100),(50,50,50), cv.FLOODFILL_FIXED_RANGE) #改变图像 泛洪填充
cv.imshow(“fill_color”,copyImg)
def fill_binary():
image=np.zeros([400,400,3],np.uint8)
image[100:300 , 100:300 , :] =255
cv.imshow("fill_binary",image)mask=np.ones([402,402,1],np.uint8)
mask[101:301,101:301] =0
cv.floodFill(image,mask,(200,200),(0,0,255),cv.FLOODFILL_MASK_ONLY)#不改变图像 只填充遮罩层
cv.imshow(“filled binary”,image)
floodFill（）
 floodFill(Mat image,Mat mask,Point seedPoint,Scalar newVal)floodFill(image, mask, seedpoint ,newVal,rect,loDiff,upDiff,flags)
src(seed.x,seed.y)-loDiff<=src(x,y)<=src(seed.x,seed.y)+upDiff合并图像
作用：合并图像
7.模糊操作
 均值模糊，中值模糊，自定义模糊模糊是卷积的一种表象
dst=cv.blur(image,(15,1)) #x方向15像素卷积，y方向1像素卷积，不模糊
dst=cv.medianBlur(image,5) #中值模糊 常用于去燥点
kernel=np.ones([5,5],np.float32)/25
dst=cv.filter2D(image,-1,kernel=kernel) #自定义模糊
高斯模糊
 def clamp(pv):if pv>255:
return 255
if pv<0:return 0
else:return pv
高斯模糊原理代码
def gaosi_noise(image):
h,w,c = image.shape
for rowin range(h):
for colin 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)
API内置函数
dst=cv.GaussianBlur(src,(0,0),15) #0*0高斯模糊
8.边缘保留滤波（EPF）
 高斯双边，均值迁移，操作双边模糊：
dst=cv.bilateralFilter(image,0,100,15)
均值迁移：
dst=cv.pyrMeanShiftFiltering(image,10,50)
作用：美颜，磨皮美白
9.图像直方图（待学）
 10.模块匹配
 在整个图像区域发现与给定子图像匹配的小块区域模板匹配算法
算法种类
算法公式
 通过三种算法匹配def template_demo():
tpl=cv.imread(“E:\3.png”) #要匹配的图片
target=cv.imread(“E:\2.png”) #总的大图片
cv.imshow(“tpl”,tpl)
cv.imshow(“target”,target)
method=[cv.TM_SQDIFF_NORMED,cv.TM_CCORR_NORMED,cv.TM_CCOEFF_NORMED]
th,tw=tpl.shape[:2]
for mdin method:
print(md)
result=cv.matchTemplate(target,tpl,md)
min_val,max_val,min_loc,max_loc=cv.minMaxLoc(result)
if md==cv.TM_SQDIFF_NORMED:
tl=min_loc
else:
tl=max_loc
br =(tl[0]+tw,tl[1]+th)
cv.rectangle(target,tl,br,(0,0,255),2)
cv.imshow(“match-”+np.str(md),target)
11.图像二值化
 二值图像（Binary Image）， 二值化方法二值化方法：
全局阈值，局部阈值
全局阈值：
OTSU方法阈值
 def threshold_demo(image):gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
ret, binary=cv.threshold(gray,0,255,cv.THRESH_BINARY | cv.THRESH_OTSU)
#0,255表示偏向的两极
print(“threshold value %s”%ret)
cv.imshow(“binary”,binary)
cv.THRESH_TRIANGLE方法
 局部阈值：def local_threshold_demo(image):
gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
binary=cv.adaptiveThreshold(gray,255,cv.ADAPTIVE_THRESH_MEAN_C,cv.THRESH_BINARY,25,10)
#ADAPTIVE_THRESH_MEAN_C方法
#还有ADAPTIVE_THRESH_GAUSSIAN_C方法
cv.imshow(“binary”,binary)
自定义：
def custom_threshold_demo(image):
gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
h,w=gray.shape[:2]
m=np.reshape(gray,[1,w*h])
mean=m.sum()/(w*h)
print(“mean:”,mean)
ret,binary=cv.threshold(gray,mean,255,cv.THRESH_BINARY)
cv.imshow(“binary”,binary)
超大图片二值化
 def image_big_binary(image):print(image.shape)
cw =256
ch =256

h,w=image.shape[:2]gray =cv.cvtColor(image,cv.COLOR_BGR2GRAY)
for rowin range(0,h,ch):
for colin range(0,w,cw):
roi = gray[row:row+ch,col:cw+col]
ret,dst = cv.threshold(roi, 0, 255, cv.THRESH_BINARY| cv.THRESH_OTSU)
gray[row:row+ch,col:cw+col] =dst
print(np.std(dst),np.mean(dst))
cv.imshow(“gray”,gray)
12.图像金字塔
 高斯金字塔 与拉普拉斯金字塔，图像金字塔原理图像金字塔原理 reduce=高斯模糊+降采样
expand=扩大+卷积PyrDown：降采样
PyrUp：还原
13.图像梯度
 一阶导数与Sobel算子，二阶导数和拉普拉斯算子Sobel算子
def soble_demo(image):
grad_x = cv.Sobel(image,cv.CV_32F,1,0) //Sobel算子提取边缘
grad_y = cv.Scharr(image,cv.CV_32F,0,1) //Scharr是Sobel算子加强版
gradx=cv.convertScaleAbs(grad_x)
grady=cv.convertScaleAbs(grad_y)
cv.imshow(“grad_x”,gradx)
cv.imshow(“grad_y”,grady)
gradxy = cv.addWeighted(gradx,0.5,grady,0.5,0)
cv.imshow(“grad”,gradxy)
拉普拉斯算子
def lapilian_demo(image):
#dst = cv.Laplacian(image,cv.CV_32F) #拉普拉斯算子
#lpls = cv.convertScaleAbs(dst)
kernel= np.array([[1,1,1],[1,-8,1],[1,1,1]])dst=cv.filter2D(image,cv.CV_32F,kernel=kernel)
lpls=cv.convertScaleAbs(dst)
cv.imshow(“lapl”,lpls)
边缘提取
 canny算法边缘检测算法高斯模糊，灰度转换，计算梯度，非最大信号抑制，高低阈值链接
def canny_demo(image):
blur=cv.GaussianBlur(image,(3,3),0)
gray=cv.cvtColor(blur,cv.COLOR_BGR2GRAY)
xgrad=cv.Sobel(gray,cv.CV_16SC1,1,0)
ygrad=cv.Sobel(gray,cv.CV_16SC1,0,1)
edge_output=cv.Canny(xgrad,ygrad,50,150)
#50为低阈值，150为高阈值，高一版是低的三倍或两倍
cv.imshow(“Edge”,edge_output)
dst=cv.bitwise_and(image,image,mask=edge_output)
cv.imshow(“Color_edge”,dst)
14.直线检测
 霍夫直线变换检测def line_detection(image):
gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
edges=cv.Canny(gray,50,150,apertureSize=3)
lines=cv.HoughLines(edges,1,np.pi/180,200)
for linein lines:
print(type(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(image,(x1,y1),(x2,y2),(0,0,255),2)
cv.imshow(“lines”,image)
def line_possible(image):
gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
edges = cv.Canny(gray, 50, 150, apertureSize=3)
lines = cv.HoughLinesP(edges, 1, np.pi /180, 100,minLineLength=50,maxLineGap=10)
for linein lines:
x1,y1,x2,y2=line[0]
cv.line(image, (x1, y1), (x2, y2), (0, 0, 255), 2)
cv.imshow(“lines_possible”, image)
15.圆检测
 霍夫圆检测首先对图像进行中值滤波
1.检测边缘，发现可能圆心 2.基于第一步开始计算最佳半径大小
def circle_demo(image):
dst=cv.pyrMeanShiftFiltering(image,10,100)
gary=cv.cvtColor(dst,cv.COLOR_BGR2GRAY)
circle=cv.HoughCircles(gary,cv.HOUGH_GRADIENT,1,50,param1=50,param2=30,minRadius=0,maxRadius=0)
#调整50这个参数根据具体情况调整
circle=np.uint16(np.around(circle))
for iin circle[0,:]:
cv.circle(image,(i[0],i[1]),i[2],(0,0,255),2)
cv.circle(image,(i[0],i[1]),2,(0,0,255),2)
cv.imshow(“circle”,image)
16.轮廓检测
 findContours发现轮廓drawContours绘制轮廓
用梯度避免阈值烦恼
def contours_demo(image):
dst=cv.GaussianBlur(image,(3,3),0)
gray=cv.cvtColor(dst,cv.COLOR_BGR2GRAY)
ret,binary=cv.threshold(gray,0,255,cv.THRESH_BINARY|cv.THRESH_OTSU)
cv.imshow(“binary”,binary)
cloneImg,contours,heriachy=cv.findContours(binary,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)
for i,contourin enumerate(contours):
cv.drawContours(image,contours,i,(0,0,255),2)
#填充轮廓最后的2改成-1
print(i)
cv.imshow(“contours”,image)
17.对象检测
 弧长面积，多边形拟合，几何矩计算def measure_object(image):
dst = cv.GaussianBlur(image, (3, 3), 0)
gray = cv.cvtColor(dst, cv.COLOR_BGR2GRAY)
ret,binary=cv.threshold(gray,0,255,cv.THRESH_BINARY_INV | cv.THRESH_OTSU)
print(“threshold value %s”%ret)
cv.imshow(“binary”,binary)
dstt = cv.cvtColor(binary, cv.COLOR_GRAY2BGR)
outImg,contours,hireachy=cv.findContours(binary,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)
for i,contourin enumerate(contours):
#cv.drawContours(image, contours, i, (0, 0, 255), 2)
area = cv.contourArea(contour)print(“area”,area)
x, y, w, h = cv.boundingRect(contour)
mm = cv.moments(contour)
print(type(mm))
cx = mm[‘m10’]/mm[‘m00’]
cy = mm[‘m01’]/mm[‘m00’]#找到重心
cv.circle(image,(np.int(cx),np.int(cy)),3,(0,255,255),-1)#cv.rectangle(image, (x, y), (x+w), (x+h), (0, 0, 255), 2)
approxCurve = cv.approxPolyDP(contour, 10, True)           #逼近边数if approxCurve.shape[0] ==3:
cv.drawContours(dstt, contours, i, (0, 255, 0), 2)
if approxCurve.shape[0]==4:
cv.drawContours(dstt, contours, i, (0, 0, 255), 2)
if approxCurve.shape[0] >4:
cv.drawContours(dstt, contours, i, (255, 0, 0), 2)
print(approxCurve.shape)
cv.imshow(“measure”, dstt)