文章目录

1.安装
2.画图
3.几何变换
- 3.1 位计算
- 3.2 遮挡
- 3.3 通道切分合并
- 3.4 金字塔
- 3.5 缩放
- 3.6 平移
- 3.7 旋转
- 3.8 仿射变换
- 3.9 透视变换
4.形态学
5.模糊(平滑)
6.色彩空间转换
7.二值化
8.图像梯度
9.canny边缘检测
10.视频操作
- 10.1 读取摄像头视频
- 10.2 读取视频文件
- 10.3 视频写入
- 10.4 视频提取指定颜色
11.直方图
12.模板匹配
13.直线/圆/轮廓检测
14.人脸检测
15.数字验证码识别
16.图像拼接/保存器

1.安装

pip install opencv-python，下面第一行是扩展模块，第二行是OCR。

附：如果cv.不提醒代码提示功能，ctrl+左键就可以查看源码，先pip上图前两行：
‪xxx\Anaconda3\Lib\site-packages\cv2\__init__.py中删除原来程序，写入下段程序：

import sys
import os
import importlib
os.environ["PATH"] += os.pathsep + os.path.dirname(os.path.realpath(__file__))
from .cv2 import *
globals().update(importlib.import_module('cv2.cv2').__dict__)

2.画图

import numpy as np
import cv2
import matplotlib.pyplot as plt
def show(image):plt.imshow(image)plt.axis('off')plt.show()
image = np.zeros((300,300,3),dtype='uint8')
show(image)

green = (0,255,0)  # opencv:RGB
cv2.line(image,(0,0),(300,300),green) # 左上角（0，0），右下角（300，300）
show(image)

blue = (0,0,255)
cv2.line (image,(300,0),(150,150),blue,5)  # 这里5为粗细，默认为1
show(image)

red = (255,0,0)
cv2.rectangle(image,(10,10),(60,60),red,2) # 2改则为-1则为红色实心填充矩形
show(image)

(cx,cy)=image.shape[1]//2,image.shape[0]//2  # 宽/2，高/2，则为圆心
white = (255,255,255)
for r in range(0,151,15): #0到150，151取不到，步长15cv2.circle(image,(cx,cy),r,white,2)
show(image)

image = np.zeros((300,300,3),dtype='uint8')
for i in range(10):radius=np.random.randint(5,20) # 半径取值color=np.random.randint(0,255,size=(3,)).tolist() # tolist()变列表[]，颜色取值pt=np.random.randint(0,300,size=(2,)) # 圆心取值cv2.circle(image,tuple(pt),radius,color,-1) # 画图
show(image)

image = cv2.imread('C:/Users/yuta/Desktop/img3/20190720072950_000256_cc8cdaa6430.JPG')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
show(image)

3.几何变换

# -*- encoding: utf-8 -*-
# -*- coding=GBK -*-
import cv2
import os
import numpy as np
import matplotlib as plt
import matplotlib.pyplot as plt
for imgname in os.listdir("C:/Users/yuta/Desktop/img3"):imgpath = "C:/Users/yuta/Desktop/img3/"+imgnameprint(imgpath)src = cv2.imread(imgpath)a = cv2.flip(src,1) # 水平翻转b = cv2.flip(src, 0) # 垂直翻转c = cv2.flip(src, -1) # 水平+垂直d = src[200:,150:-150]  # 剪裁，x方向：200到最后，y方向：150到 下往上150cv2.imshow('input image', b)cv2.waitKey(0)

     M = np.ones(src.shape,dtype='uint8')*100 # 生成和图片形状相同并且全为100的数据e = cv2.add(src,M)  # 所有像素加100，往255白发展，调亮度f = cv2.subtract(src, M)cv2.imshow('input image', e)cv2.waitKey(0)

# 图像加法
print(cv2.add(np.unit8([200]),np.uint8([100]))) #输出[[255]]，图像范围0-255，300也转为255
# 普通加法
print(np.unit8([200])+np.uint8([100]))  #[44]，unit8也0-255，加到255重新记为1

# 图像减法
print(cv2.subtract(np.uint8([50]),np.uint8([100]))) #输出[[0]]，图像范围0-255，-50转为0
# 普通减法
print(np.uint8([50])-np.unit8([100])) #输出[206]

3.1 位计算

     rectangle = np.zeros((300,300,3),dtype='uint8')white = (255,255,255)cv2.rectangle(rectangle,(25,25),(275,275),white,-1) # (25,25)初始，(275,275)终止，-1填充cv2.imshow('input image', rectangle)cv2.waitKey(0)

与：有0为0，或：有1为1，异或：同0

     circle = np.zeros((300,300,3),dtype='uint8')white = (255, 255, 255)cv2.circle(circle,(150,150),150,white,-1) # (150,150)圆心，150半径cv2.imshow('input image', circle)cv2.waitKey(0)

     g = cv2.bitwise_and(rectangle,circle) # AND与，有0变0即有黑变黑h = cv2.bitwise_or(rectangle,circle)  # OR或，有白变白i = cv2.bitwise_xor(rectangle,circle) # XOR异或，黑白变白，黑黑和白白变黑cv2.imshow('input image', g)cv2.waitKey(0)

3.2 遮挡

     mask = np.zeros(src.shape,dtype='uint8') white = (255,255,255)cv2.rectangle(mask,(50,50),(250,350),white,-1)  # 创建黑色遮挡cv2.imshow('input image', mask)cv2.waitKey(0)

  masked = cv2.bitwise_and(src, mask)cv2.imshow('input image', masked)cv2.waitKey(0)

3.3 通道切分合并

     (R,G,B) = cv2.split(src)   #cv2.imshow('input image',G)，分开就是三张单通道黑白，print(R.shape)merged = cv2.merge([R,G,B]) cv2.imshow('input image', merged) #产生彩色原图cv2.waitKey(0)

3.4 金字塔

imgpath = "C:/Users/yuta/Desktop/img3/20190720072950_000256_cc8cdaa64390.JPG"
src1 = cv2.imread(imgpath)
for i in range(3):src1=cv2.pyrDown(src1)  #不能j=print(src1.shape)cv2.imshow('input image',src1) # 生成3张大小不同图cv2.waitKey(0)

down_image1 = cv2.pyrDown(src1)
down_image2 = cv2.pyrDown(down_image1)
up_image = cv2.pyrUp(down_image2)
laplacian = down_image1-up_imagecv2.imshow('input image',laplacian)
cv2.waitKey(0)

3.5 缩放

3.6 平移

3.7 旋转

3.8 仿射变换

3.9 透视变换

4.形态学

腐，膨。开，闭，开闭。白帽，黑帽

kernel1=cv2.getStructuringElement(cv2.MORPH_RECT,(5,5))
kernel2=cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
kernel3=cv2.getStructuringElement(cv2.MORPH_CROSS,(5,5))
erosion = cv2.erode(src1,kernel1) # 腐蚀cv2.imshow('input image',erosion)
cv2.waitKey(0)

for i in range(3):erosion = cv2.erode(src1, kernel1,iterations=i+1)cv2.imshow('input image', erosion) #三次腐蚀颜色越来越深cv2.waitKey(0)

for i in range(3):dilation= cv2.dilate(src1, kernel1,iterations=i+1) #膨胀dilate，取得是局部最大值cv2.imshow('input image', dilation) #三次膨胀颜色越来越白cv2.waitKey(0)

kernel1=cv2.getStructuringElement(cv2.MORPH_RECT,(5,5))
opening = cv2.morphologyEx(src1,cv2.MORPH_OPEN,kernel1) # 开运算：先腐蚀后膨胀
closing = cv2.morphologyEx(src1,cv2.MORPH_CLOSE,kernel1) # 闭运算：先膨胀后腐蚀cv2.imshow('input image', opening)
cv2.waitKey(0)

opening = cv2.morphologyEx(src1,cv2.MORPH_OPEN,kernel1) # 开闭运算
closing = cv2.morphologyEx(opening,cv2.MORPH_CLOSE,kernel1)
cv2.imshow('input image', closing)
cv2.waitKey(0)

gradient = cv2.morphologyEx(src1,cv2.MORPH_GRADIENT,kernel1)cv2.imshow('input image', gradient)
cv2.waitKey(0)

blackhat = cv2.morphologyEx(src1,cv2.MORPH_BLACKHAT,kernel1)cv2.imshow('input image', blackhat)
cv2.waitKey(0)

5.模糊(平滑)

kernelsizes = [(3,3),(9,9),(15,15)] # 越大越模糊
plt.figure(figsize = (15,15))
src1 = cv2.cvtColor(src1, cv2.COLOR_BGR2RGB)
for i,kernel in enumerate (kernelsizes):plt.subplot(1,3,i+1)blur = cv2.blur(src1,kernel) # 平均平滑plt.axis('off')plt.title('Blurred'+str(kernel)) # 设置标题plt.imshow(blur)
plt.show()

kernelsizes = [(3,3),(9,9),(15,15)]
plt.figure(figsize = (15,15))
src1 = cv2.cvtColor(src1, cv2.COLOR_BGR2RGB)
for i,kernel in enumerate (kernelsizes):plt.subplot(1,3,i+1)blur = cv2.GaussianBlur(src1,kernel,0) # 0为标准差plt.axis('off')plt.title('Blurred'+str(kernel))plt.imshow(blur)
plt.show()

plt.figure(figsize = (15,15))
src1 = cv2.cvtColor(src1, cv2.COLOR_BGR2RGB)
for i,kernel in enumerate ((3,9,15)):plt.subplot(1,3,i+1)blur = cv2.medianBlur(src1,kernel)plt.axis('off')plt.title('Blurred'+str(kernel))plt.imshow(blur)
plt.show()

params = [(11,21,7),(11,41,21),(15,75,75)]
plt.figure(figsize = (15,15))
src1 = cv2.cvtColor(src1, cv2.COLOR_BGR2RGB)
for i,(diameter,sigmaColor,sigmaSpace) in enumerate (params): # 邻域直径，灰度值相似性高斯滤波函数标准差，空间高斯函数标准差plt.subplot(1,3,i+1)blur = cv2.bilateralFilter(src1,diameter,sigmaColor,sigmaSpace) #平均平滑plt.axis('off')plt.title('Blurred'+str((diameter,sigmaColor,sigmaSpace)))plt.imshow(blur)
plt.show()

6.色彩空间转换

(B,G,R) = cv2.split(src1)
zeros = np.zeros(src1.shape[:2],dtype='uint8') #src1.shape[:2]和src1宽高一样cv2.imshow('input image', cv2.merge([zeros,G,zeros]))
cv2.waitKey(0)

hsv = cv2.cvtColor(src1,cv2.COLOR_BGR2HSV)
zeros = np.zeros(src1.shape[:2],dtype='uint8')
for(name,chan) in zip(('H','S','V'),cv2.split(hsv)):cv2.imshow(name,chan)cv2.waitKey(0)
cv2.destroyAllWindows()

lab = cv2.cvtColor(src1,cv2.COLOR_BGR2LAB)
zeros = np.zeros(src1.shape[:2],dtype='uint8')
for (name,chan) in zip(('L','A','B'),cv2.split(lab)):cv2.imshow(name,chan) #缩进
cv2.waitKey(0)

gray = cv2.cvtColor(src1,cv2.COLOR_BGR2GRAY)cv2.imshow('original',src1)
cv2.imshow('gray',gray)
cv2.waitKey(0)

7.二值化

gray =cv2.cvtColor(src1,cv2.COLOR_BGR2GRAY)
plt.imshow(gray,'gray') # plt显示要加‘gray’
plt.axis('off')
plt.show()

ret1,thresh1 = cv2.threshold(gray,127,255,cv2.THRESH_BINARY) #127阈值
ret2,thresh2 = cv2.threshold(gray,127,255,cv2.THRESH_BINARY_INV)
ret3,thresh3 = cv2.threshold(gray,127,255,cv2.THRESH_TRUNC)
ret4,thresh4 = cv2.threshold(gray,127,255,cv2.THRESH_TOZERO)
ret5,thresh5 = cv2.threshold(gray,127,125,cv2.THRESH_TOZERO_INV)
titles = ['original','BINARY','BINARY_INV','TRUNC','TOZERO','TOZERO_INV']
src1 = [gray,thresh1,thresh2,thresh3,thresh4,thresh5]
plt.figure(figsize=(15,5))
for i in range(6):plt.subplot(2,3,i+1)plt.imshow(src1[i],'gray')plt.title(titles[i])plt.axis('off')
plt.show()

#下面为遮挡，白色部分显示原图即提取。将阈值调小显示更好，但太小黑色背景会有白色噪声点
cv2.imshow('mask',cv2.bitwise_and(src1,src1,mask=thresh1))
cv2.waitKey(0)

ret1,thresh1 = cv2.threshold(gray,0,255,cv2.THRESH_BINARY | cv2.THRESH_OTSU) # 0阈值自动
ret2,thresh2 = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)
print('ret1',ret1)
print('ret2',ret2)plt.imshow(thresh1,'gray')
plt.axis('off')
plt.show()
plt.imshow(thresh2,'gray')
plt.axis('off')
plt.show()

image = cv2.cvtColor(src1,cv2.COLOR_BGR2GRAY) # 变灰度图
image = cv2.medianBlur(image,5) # 中值滤波
ret,th1 = cv2.threshold(image,127,255,cv2.THRESH_BINARY) # 普通二值化
th2 = cv2.adaptiveThreshold(image,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,11,3) # 平均值阈值
th3 = cv2.adaptiveThreshold(image,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,3) # 高斯阈值titles = ['original','Global','Thresholding','adaptive Mean Thresholding','Adaptive Gaussian Thresholding']
images = [image,th1,th2,th3]
plt.figure(figsize=(10,5))
for i in range(4):plt.subplot(2,2,i+1)plt.imshow(images[i],'gray')plt.axis('off')plt.title(titles[i])
plt.show()

8.图像梯度

def gradient(image):image = cv2.cvtColor(image,cv2.COLOR_RGB2GRAY)laplacian = cv2.Laplacian(image,cv2.CV_64F) #cv2.CV_64F输出图像的深度（数据类型），64位float类型，因为梯度可能是正或负sobelx = cv2.Sobel(image,cv2.CV_64F,1,0,ksize=3) #1，0表示在X方向求一阶导数，最大可以求2阶导数sobely = cv2.Sobel(image,cv2.CV_64F,0,1,ksize=3) #0，1表示在y方向求一阶导数，最大可以求2阶导数titles = ['Original','Laplacian','SobelX','SobelY']images = [image,laplacian,sobelx,sobely]plt.figure(figsize=(10,5))for i in range(4):plt.subplot(2,2,i+1)plt.imshow(images[i],'gray')plt.title(titles[i])plt.axis('off')plt.show()
gradient(src1)

9.canny边缘检测

def edge_detection(image,minVal=100,maxVal=200):image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)edges = cv2.Canny(image,minVal,maxVal)plt.imshow(edges,'gray')plt.axis('off')plt.show()
edge_detection(src1)

image = cv2.cvtColor(src1,cv2.COLOR_BGR2GRAY)
image = cv2.GaussianBlur(image,(3,3),0)
Value = [(10,150),(100,200),(180,230)]
plt.figure(figsize=(20,5))
for i,(minVal,maxVal) in enumerate(Value):plt.subplot(1,3,i+1)edges = cv2.Canny(image,minVal,maxVal)edges= cv2.GaussianBlur(edges,(3,3),0)plt.imshow(edges,'gray')plt.title(str((minVal,maxVal)))plt.axis('off')
plt.show()

def auto_canny(image,sigma=0.33):v=np.median(image)lower = int(max(0,(1.0-sigma)*v))upper = int(min(255,(1.0+sigma)*v))edged = cv2.Canny(image,lower,upper)print(lower,upper)return edged
edges = auto_canny(src1)
edges = cv2.GaussianBlur(edges,(3,3),0)
plt.imshow(edges,'gray')
plt.axis('off')
plt.show()

10.视频操作

10.1 读取摄像头视频

cap = cv2.VideoCapture(0)
while(True):ret,frame = cap.read()  #ret读取成功True或失败False,frame读取到的图像内容，读取一帧数据gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)cv2.imshow('frame',gray) #或('frame',frame)if cv2.waitKey(1) & 0xff == ord('q'): #waitKey功能是不断刷新图像，单位ms，返回值是当前键盘按键值。ord返回对应的ASCII数值break
cap.release()
cv2.destroyAllWindows()

10.2 读取视频文件

cap = cv2.VideoCapture('D:/KK_Movies/kk 2019-09-21 11-29-04.mp4')
fps = cap.get(cv2.CAP_PROP_FPS) # 视频每秒传输帧数
frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) # 视频图像宽度
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))  # 视频图像长度
print(fps)
print(frame_width)
print(frame_height)while(True):ret,frame = cap.read() if ret != True:breakcv2.imshow('frame',frame)if cv2.waitKey(25)&0xff == ord('q'): # 25变大视频播放变慢break
cap.release()
cv2.destroyAllWindows()

10.3 视频写入

cap = cv2.VideoCapture('D:/KK_Movies/kk 2019-09-21 11-29-04.mp4')
fps = cap.get(cv2.CAP_PROP_FPS)
frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
print(fps)
print(frame_width)
print(frame_height)fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('C:/Users/yuta/Desktop/333/1.avi',fourcc,fps,(frame_width,frame_height))
while(True):ret,frame = cap.read()if ret == True:#frame = cv2.flip(frame,1)out.write(frame)cv2.imshow('frame',frame)if cv2.waitKey(25)&0xff == ord('q'):breakelse:break
out.release()
cap.release()
cv2.destroyAllWindows()

10.4 视频提取指定颜色

# 色彩空间转为hsv和inrange函数从视频中提取指定颜色
# 并将其置为白，其余置为黑，实现跟踪某一颜色
import cv2 as cv
import numpy as np
def nextrace_object_demo():capture = cv.VideoCapture("E:/1.mp4")#导入视频while True:ret, frame = capture.read()if ret == False:breakhsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)#上一行将frame视频一帧图转为hsv色彩空间
#如下设置绿色的范围，跟踪视频中的绿色，调节图像颜色信息（H）、饱和度（S）、亮度（V）区间lower_hsv = np.array([35, 43, 46])#设置过滤的绿色的低值，可查看下表upper_hsv = np.array([77, 255, 255])#设置过滤的绿色的高值mask = cv.inRange(hsv, lowerb=lower_hsv, upperb=upper_hsv)#用inRange函数提取指定颜色范围，这里对hsv来处理，得到二值图#dst = cv.bitwise_and(frame,frame,mask=mask)#cv.imshow("mask",dst)cv.imshow("video", frame)cv.imshow("mask", mask)if cv.waitKey(50) & 0xFF == ord('q'):breaknextrace_object_demo()
cv.waitKey(0)
cv.destroyAllWindows()

下图为#两行用bitwise_and输出

可以通过下表对应颜色的数值过滤其他颜色，HSV颜色对应RGB的分量范围：

import cv2 as cv
import numpy as np
src = cv.imread("E:/images/demo.JPG")
cv.namedWindow("input image", cv.WINDOW_NORMAL)
cv.imshow('input image',src)
# 通道分离，输出三个单通道图片
b, g, r = cv.split(src)  # 将彩色图像分割成3个通道
cv.imshow("blue", b)
cv.imshow("green", g)
cv.imshow("red", r)# 通道合并
src = cv.merge([b, g, r])
cv.imshow("merge image", src)# 修改某个通道的值，[:, :, 0]为第一个通道，[:, :, 1]为第二个通道
src[:, :, 2] = 100
cv.imshow("changed image", src)cv.waitKey(0)
cv.destroyAllWindows()

11.直方图

# -*- coding: utf-8 -*-
import cv2 as cv
import matplotlib.pyplot as plt
def plot_demo(image):  #x轴为像素点取值，y轴为像素点个数plt.figure(figsize = (5,3))plt.hist(image.ravel(), 256, [0, 256])#image.ravel()将图像展开，256为bins数量，[0, 256]为范围plt.ylim([0, 20000])plt.title('123')plt.show()
def image_hist(image):color = ('blue', 'green', 'red')for i, color in enumerate(color):# 计算出直方图，calcHist(images, channels, mask, histSize(有多少个bin), ranges）hist = cv.calcHist(image, [i], None, [256], [0, 256])print(hist.shape)plt.plot(hist, color=color)plt.xlim([0, 256])plt.show()#上面为绘制图片直方图，下面是直方图应用
def equalHist_demo(image):gray = cv.cvtColor(image,cv.COLOR_BGR2GRAY)
#下行 `全局`直方图均衡化，提升对比度（默认提升），只能是灰度图像用于增强图像对比度，即黑的更黑，白的更白dst = cv.equalizeHist(gray)cv.imshow("equalHist_demo", dst)
#下行`局部`直方图均衡化，自定义，clipLimit是对比度的大小，tileGridSize是每次处理块的大小clahe = cv.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))clahe_dst = clahe.apply(gray)cv.imshow("clahe", clahe_dst)src = cv.imread("E:\images/demo.jpg")
cv.imshow("yuantu", src)plot_demo(src)
image_hist(src)
equalHist_demo(src)cv.waitKey(0)
cv.destroyAllWindows()

12.模板匹配

# -*- coding: utf-8 -*-
import cv2 as cv
import numpy as np
# 模板匹配，就是在整个图像区域发现与给定子图像匹配的小块区域，
# 需要模板图像T和待检测图像-源图像S
# 工作方法：在待检测的图像上，从左到右，从上倒下计算模板图像与重叠子图像匹配度，
# 匹配度越大，两者相同的可能性越大。
def template_demo():tpl = cv.imread("E:\images/4.jpg")target = cv.imread("E:\images/3.jpg")cv.imshow("template", tpl)cv.imshow("target", target)methods = [cv.TM_SQDIFF_NORMED, cv.TM_CCORR_NORMED, cv.TM_CCOEFF_NORMED]  #上行参数三种模板匹配方法th, tw = tpl.shape[:2] #模板的高宽for md in methods: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: #cv.TM_SQDIFF_NORMED最小时最相似，其他最大时最相似tl = min_locelse:tl = max_locbr = (tl[0] + tw, tl[1] + th)  # br为右下角坐标=tl为左上角坐标+宽高cv.rectangle(target, tl, br, (0, 0, 255), 2) # (0, 0, 255)为红色，2为线宽，绘到target上。cv.imshow("match-"+np.str(md), target)template_demo()cv.waitKey(0)
cv.destroyAllWindows()

13.直线/圆/轮廓检测

霍夫变换：目的是通过投票程序在特定类型的形状内找到对象的不完美实例。这个投票程序是在一个参数空间中进行的，在这个参数空间中，候选对象被当作所谓的累加器空间中的局部最大值来获得。Hough变换主要优点是能容忍特征边界描述中的间隙，并且相对不受图像噪声的影响。

霍夫直线变换：1.Hough Line Transform用来做直线检测
2.前提条件：边缘检测已完成
3.平面空间到极坐标空间转换

# -*- coding: utf-8 -*-
import cv2 as cv
import numpy as np
def line_detection(image):gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)edges = cv.Canny(gray, 50, 150, apertureSize=3)#Canny做梯度窗口大小apertureSize=3#cv2.HoughLines()返回值就是（ρ,θ）。ρ 的单位是像素，θ 的单位是弧度。#这个函数的第一个参数是一个二值化图像，所以在进行霍夫变换之前要首先进行二值化，或者进行 Canny边缘检测。#第二和第三个值分别代表 ρ 和 θ 的精确度。第四个参数是阈值，只有累加其中的值高于阈值时才被认为是一条直线，#也可以把它看成能检测到的直线的最短长度（以像素点为单位）。lines = cv.HoughLines(edges, 1, np.pi/180, 80)#'NoneType' object is not iterable：没有检测到直线，lines为空，进入for循环发生错误：调整上面第四个参数。for line in lines:print(type(lines))rho, theta = line[0]a = np.cos(theta)b = np.sin(theta)x0 = a * rhoy0 = b * rhox1 = 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) # 2为像素宽cv.imshow("line_detection", image)def line_detection_possible_demo(image):gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)edges = cv.Canny(gray, 50, 150, apertureSize=3)lines = cv.HoughLinesP(edges, 1, np.pi / 180, 80, minLineLength=50, maxLineGap=10)for x1, y1, x2, y2 in lines[0]:cv.line(image, (x1, y1), (x2, y2), (255, 0, 0), 2)cv.imshow('line_detection_possible_demo', image)def detection_circles_demo(image):dst = cv.pyrMeanShiftFiltering(image, 10, 100)#均值迁移，sp，sr为空间域核与像素范围域核半径gray = cv.cvtColor(dst, cv.COLOR_BGR2GRAY)circles = cv.HoughCircles(gray, cv.HOUGH_GRADIENT, 1, 20, param1=40, param2=30, minRadius=0, maxRadius=0)#上面1为dp步长，20为最小距离，圆心小于20为一个圆。circles = np.uint16(np.around(circles))print(circles.shape)for i in circles[0,:]:  # draw the outer circlecv.circle(image, (i[0], i[1]), i[2], (0, 255, 0), 2) # draw the center of the circlecv.circle(image, (i[0], i[1]), 2, (255, 0, 0), 3)  # 画圆心cv.imshow('detected circles', image)def main():src = cv.imread("E:\images/dave.png")cv.imshow("demo",src)line_detection(src)line_detection_possible_demo(src)img = cv.imread("E:\images/circle.png")detection_circles_demo(img)cv.waitKey(0)cv.destroyAllWindows()if __name__ == '__main__':main()

14.人脸检测

haar和lap数据：https://github.com/opencv/opencv/tree/master/data
win10下载子目录见文章：https://blog.csdn.net/weixin_43435675/article/details/88201615

import cv2 as cvdef face_detection(image):gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)face_detector = cv.CascadeClassifier(r"E:\images/1/haarcascade_frontalface_alt_tree.xml")# 在Python中\是转义符，\u表示其后是UNICODE编码，因此\User在这里会报错，在字符串前面加个r表示就可以了faces = face_detector.detectMultiScale(gray, 1.02, 2)# 多个尺度检测,向上或者向下是原来1.02倍，# 第二个参数是移动距离，第三个参数是识别度，越大识别读越高# faces就是几个候选矩形框for x, y, w, h in faces: # 取出这四个值cv.rectangle(image, (x, y), (x+w, y+h), (0, 0, 255), 2) # 绘制在图上cv.imshow("result", image)def main():src = cv.imread("E:\images/lena.jpg")cv.imshow("input image", src)face_detection(src)# # 视频检测# capture = cv.VideoCapture(0)# while True:#     ret, frame = capture.read()#     frame = cv.flip(frame, 1)#     face_detection(frame)#     c = cv.waitKey(10)#     if c == 27:   #c == 27 时是用esc关闭的#         breakcv.waitKey(0)cv.destroyAllWindows()  # 关闭所有窗口if __name__ == '__main__':main()

15.数字验证码识别

pip install pytesseract
错误：pytesseract.pytesseract.TesseractNotFoundError: tesseract is not installed or it’s not in your path
解决：C:\Users\yuta\Anaconda3\Lib\site-packages\pytesseract中pytesseract.py改路径保存：下载tesseract.exe地址：https://github.com/tesseract-ocr/tesseract/wiki 选择系统对应版本下载安装，默认安装在C:\Program Files

import cv2 as cv
import numpy as np
from PIL import Image
import pytesseract as tess
"""
预处理-去除干扰线和点
不同的结构元素中选择
Image和numpy array相互转换
识别和输出
"""
def recognition_demo(image):gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV | cv.THRESH_OTSU)cv.imshow("binary", binary)kernel = cv.getStructuringElement(cv.MORPH_RECT, (4, 4))bin1 = cv.morphologyEx(binary,cv.MORPH_OPEN, kernel=kernel)cv.imshow("bin1", bin1)textImage = Image.fromarray(bin1)text = tess.image_to_string(textImage)print("The result:", text)def main():src = cv.imread("E:\images\yzm.jpg")cv.imshow("demo",src)recognition_demo(src)cv.waitKey(0)cv.destroyAllWindows()if __name__ == '__main__':main()

16.图像拼接/保存器

# -*- coding: utf8 -*-
import cv2
img_head = cv2.imread('C:/Users/yuta/Desktop/6/20190924153611.jpg')  #读取头像和国旗图案
img_flag = cv2.imread('C:/Users/yuta/Desktop/6/timg (2).jpg')
w_head, h_head = img_head.shape[:2]  #获取头像和国旗图案宽度
w_flag, h_flag = img_flag.shape[:2]
print(w_head)
print(h_head)
print(w_flag)
print(h_flag)
scale = w_head / w_flag / 4  #计算图案缩放比例
print(scale)img_flag = cv2.resize(img_flag, (0, 0), fx=scale, fy=scale) #缩放图案
w_flag, h_flag = img_flag.shape[:2] #获取缩放后新宽度for c in range(0, 3): #按3个通道合并图片img_head[w_head - w_flag:, h_head - h_flag:, c] = img_flag[:, :, c]
cv2.imwrite('new_head.jpg', img_head)

import threading
from queue import Queue
import os
import numpy as np
from PIL import Image
import time
import logging# 获取异常消息的字符串
import sys
import traceback
def get_exception_string():exc_type, exc_value, exc_traceback = sys.exc_info()exception_list = traceback.format_exception(exc_type, exc_value, exc_traceback)exception_string = ''.join(exception_list)return exception_stringclass ImageSaver(threading.Thread):""" 多线程的图像文件保存器类"""def __new__(cls):""" 重写new方法，实现单实例的效果"""if not hasattr(cls, '_instance'):father_class = super(ImageSaver, cls)cls._instance = father_class.__new__(cls)self = cls._instancesuper(ImageSaver, self).__init__()self.queue = Queue()self.start()return cls._instancedef save_image(self, argument_1, imageFilePath):"""argument_1可以是Image库的图像对象，或者numpy库的ndarray(rgb通道顺序)imageFilePath必须是字符串"""if isinstance(argument_1, np.ndarray):image = Image.fromarray(argument_1)else:image = argument_1put_tuple = (image, imageFilePath)self.queue.put(put_tuple)def run(self):""" 多线程的主要循环运行内容"""while True:try:if not self.queue.empty():image, imageFilePath = self.queue.get()dirPath, imageFileName = os.path.split(imageFilePath)if not os.path.isdir(dirPath):os.makedirs(dirPath)image.save(imageFilePath)except Exception as e:exception_string = get_exception_string()logging.error(exception_string)logging.error('保存到此路径时出错: %s' %imageFilePath)time.sleep(0.0001)

【Python5】图像操作，数字验证码识别，图像拼接/保存器相关推荐

【python OpenCV3.3 图像处理教程：直线检测、圆检测、对象测量、腐蚀、膨胀等形态学操作、数字验证码识别、人脸检测
1. 直线检测 Hough Line Transform:前提:边缘检测已经完成,基于霍夫变换 1.1 原理可以通过(theta,r)唯一表示一个点. 把过三个点的全部直线以某一角度全部计算出来,如 ...
按键精灵+大漠插件简单数字验证码识别实践笔记
因为资源短缺,公司用了一个很老的系统分配资源,每个项目每天都要经历上演一次像抢火车票一样的经历,而往往又空手而归,搞得大家疲惫不堪.而其中的关键在于几个简单的数字验证码的识别,于是在业余时间看了一些验 ...
【Matlab验证码识别】遗传算法和最大熵优化+大津法（OTSU）+自定义阈值数字验证码识别【含GUI源码 1694期】
一.代码运行视频(哔哩哔哩) [Matlab验证码识别]遗传算法和最大熵优化+大津法(OTSU)+自定义阈值数字验证码识别[含GUI源码 1694期] 二.matlab版本及参考文献 1 matlab ...
bmp 格式图像印刷体数字的识别
一.实验目的初步了解模板匹配算法,理解bmp 图像在内存中的存储形式,实现bmp 格式图像印刷体数字的识别. 二.算法概要由于实验要求是对标准印刷体数字进行识别,本实验采用模板匹配中最简单的像素点 ...
验证码识别 matlab,MATLAB数字验证码识别
文件名大小更新时间 MATLAB数字验证码识别[GUI,详细解析,论wen]02020-08-03 MATLAB数字验证码识别[GUI,详细解析,论wen]\Databse02020-08-01 MA ...
数字验证码识别完成自动化登录
一.人工方式处理数字验证码通过selenium打开浏览器获取验证码,然后进行人工输入,从而实现登录访问的学习通网页链接: xxt_link = r'https://passport2.chaoxi ...
基于CNN的四位数字验证码识别
前言验证码技术作为一种反自动化技术,使得很多程序的自动化工作止步.今天作者采用一些数字图像处理和CNN方法来识别较为简单的数字验证码实验步骤实验步骤主要围绕以下展开图像预处理即滤除噪声和字符分 ...
【验证码识别】基于遗传算法优化OUST结合BP神经网络实现数字验证码识别含Matlab源码
1 简介本项目基于MATLAB完成数字验证码识别的GUI设计,图像处理,验证码生成.识别等功能.采用BP神经网络来实现对验证码图像的识别.验证码的识别,大概分为图片预处理.分割字符.识别字符三个过程 ...
基于Python的KNN数字验证码识别
一.主要内容本项目基于Python爬虫爬取验证码图片,对图片进行去噪.分割,通过KNN算法训练模型,实现验证其准确率. 二.系统流程首先从指定的网页中爬取验证码图片数据,然后对数据进行一个去噪和分 ...

【Python5】图像操作，数字验证码识别，图像拼接/保存器