基础

读取一个图片，并把它存入一个变量中
变量 = cv2.imread(“图片”)

显示图片
cv2.imshow(“窗口名”,图片变量名)

暂停窗口并等待键盘输入
cv2.waitKey()

#存入照片
img = cv2.imread("opencv_logo.jpg")

#显示图片
cv2.imshow("image",img)

#暂停窗口并等待键盘输入
cv2.waitKey()

‍

灰度图

显示蓝绿红的灰度图
cv2.imshow(“窗口名” 变量[ :, :, 0]) 1 2

明暗分布平均灰度(加权平均)
变量 = cv2.cvColor(变量, cv2.COLOR_BGR2GRAY)

cv2.imshow("blue", image[:, :, 0])
cv2.imshow("green", image[:, :, 1])
cv2.imshow("red", image[:, :, 2])

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow("gray", gray)

‍

照片裁剪

照片裁剪（左上角开始）
新变量 =照片变量[竖开始:结束, 横开始:结束]

#照片裁剪（左上角开始）
im = img[10:170, 40:200]

‍

画图 import numpy as np

创建图片(画布)
变量 = np.zeros([竖, 横, 3], dtype=np.uint8)

画横线
cv2.line(照片, (开始坐标 , ), (结束坐标 , ), (BGR颜色 , , ), 线的粗细)

画矩形
cv2.rectangle(图片, (顶点坐标 , ), (对角坐标 , ), (BGR颜色 , , ), 线的粗细)

画圆形
cv2.circle(图片, (圆心 , ), 半径, (BGR颜色 , , ), 线的粗细)

画字符
cv2.putText(图片, “字符”, (位置 , ), 字体序号, 缩放系数, (BGR颜色 , , ), 线的粗细, 线条类型1为实线)

import cv2
import numpy as np

print(cv2.getVersionString())

#创建画布
img = np.zeros([300, 500, 3], dtype=np.uint8)

#画线
cv2.line(img, (100 , 200), (200 , 275), (255, 0, 0), 3)

#画矩形
cv2.rectangle(img, (200, 100), (300 , 200),  (0, 0, 255), 4)

#画圆形
cv2.circle(img, (150, 150), 90, (0, 255, 0), 5)

#显示字符
cv2.putText(img, "hello", (20,100 ), 1, 1, (255, 255, 255), 1, 1)

#显示图片
cv2.imshow("image",img)

#暂停窗口并等待键盘输入
cv2.waitKey()

‍

滤波

高斯滤波器（去噪点）
变量 = cv2.GaussianBlur(图片, (5, 5), 0)
奇书（内核）标准差

中值滤波器（相对于高斯滤波器可以进一步减少噪点）
变量 = cv2.medianBlur(图片, 5)

#高斯滤波器（去噪点）
im = cv2.GaussianBlur(img, (5, 5), 1)
#中值滤波器（相对于高斯滤波器可以进一步减少噪点）
i = cv2.medianBlur(img, 5)

‍

图像特征提取

转角特征提取

import cv2
#打开图片
image = cv2.imread("opencv_logo.jpg")
#转换为灰度图
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#获取图像中的特征点          最多返回500点  点质量优于0.1  特征点之间距离大于10像素
corners = cv2.goodFeaturesToTrack(gray, 500, 0.1, 10)

corners为二维数组，所以下面的corner为里面每一个一维数组

#找到特征点后，把每个特征点标记出来
for corner in corners:
    #把数组值一次赋给x y
    x, y = corner.ravel()
    cv2.circle(image, (int(x), int(y)), 3, (255, 0, 255), -1)

cv2.imshow("corners", image)
cv2.waitKey()

‍

模板匹配(先改为灰度图)

变量 = cv2.matchTemplate(待检测图像, 模板, cv2.TM_CCOEFF_NORMED)
标准相关匹配代码（各自标准化再匹配，可以不受关照强度影响）（对图像大小敏感，不能匹配大小不同的，要匹配的话需要放大缩小多次依次匹配）

找出匹配系数大于0.9的点
数组变量 = np.where(match >= 0.9)
输出结果是两个 NumPy 数组的元组，而且是先匹配y在匹配x，所以用的时候需要倒过来，需要执行zip(*数组变量[::-1])
zip的命令不能直接打印，会输出内存地址，前面加上list（数组变量）再打印就可以看到了，实际使用的时候不用加list（）

import cv2
import numpy as np

image = cv2.imread("poker.jpg")
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

#图片上的其中一个菱形作为模板
template = gray[75:105, 235:265]
#匹配
match = cv2.matchTemplate(gray, template, cv2.TM_CCOEFF_NORMED)
#找出匹配系数大于0.9的点
locations = np.where(match >= 0.9)

w, h = template.shape[0:2]
for p in zip(*locations[::-1]):
    x1, y1 = p[0], p[1]
    x2, y2 = x1 + w, y1 + h
    cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)

cv2.imshow("image", image)
cv2.waitKey()

‍

图像梯度算法检测边缘

将图像读入成灰度图
变量名 = cv2.imread(“图像”， cv2.IMREAD_GRAYSCALE)

拉普拉斯算子
新图像 = cv2.Laplacian(图像变量， cv2.CV_64F)

canny边缘检测
新图像 = cv2.Canny(图像变量，梯度区间 , )
使用梯度区间来检测

import cv2
#将图像读入成灰度图
gray = cv2.imread("opencv_logo.jpg", cv2.IMREAD_GRAYSCALE)

#拉普拉斯算子
laplacian = cv2.Laplacian(gray, cv2.CV_64F)

#canny边缘检测
canny = cv2.Canny(gray, 100, 200)

cv2.imshow("gray", gray)
cv2.imshow("laplacian", laplacian)
cv2.imshow("canny", canny)

cv2.waitKey()

‍

阈值算法

固定阈值

ret, 新图像= cv2.threshold(阈值化的输入灰度图像, 阈值值, 像素值, cv2.THRESH_BINARY)
ret：这是用于阈值化的阈值值。它可能与你在 阈值值 参数中提供的值相同，也可能不同。OpenCV 的阈值化函数会自动使用各种技术计算一个最优的阈值值，并将其保存在 ret 中。
像素值，输入图像中像素的灰度值大于此阈值值时，将被设为像素值
cv2.THRESH_BINARY_INV 反向阈值

自适应阈值

新图像 = cv2.adaptiveThreshold(输入的灰度图, maxValue, adaptiveMethod, thresholdType, blockSize, C)

maxValue：这是像素值，用于设置灰度值大于阈值的像素。在这里，它被设置为255，表示灰度值大于阈值的像素将被设为白色（255）。
adaptiveMethod：这是自适应阈值化的方法。有两个可选值：cv2.ADAPTIVE_THRESH_MEAN_C 和 cv2.ADAPTIVE_THRESH_GAUSSIAN_C。这里选择了 cv2.ADAPTIVE_THRESH_GAUSSIAN_C，它使用局部像素的高斯加权平均值作为阈值，可以产生更平滑的效果。
thresholdType：这是阈值化类型。对于自适应阈值化，只能选择 cv2.THRESH_BINARY 或 cv2.THRESH_BINARY_INV。在这里，选择了 cv2.THRESH_BINARY，表示灰度值大于阈值的像素被设为 maxValue，灰度值小于阈值的像素被设为0。
blockSize：这是一个整数值，指定用于计算每个像素阈值的邻域区域的大小。它必须是奇数。在这里，使用了 115。
C：这是从均值或加权平均值中减去的常数。它用于微调阈值的计算。在这里，使用了1。

大金算法（自适应阈值）-聚类分析算法

ret, binary_otsu = cv2.threshold(输入的灰度图, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

import cv2

gray = cv2.imread("bookpage.jpg", cv2.IMREAD_GRAYSCALE)
# 固定阈值
ret, binary = cv2.threshold(gray, 10, 255, cv2.THRESH_BINARY)
# 自适应阈值
binary_adaptive = cv2.adaptiveThreshold(
    gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 115, 1)
# 大金算法
ret1, binary_otsu = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

cv2.imshow("gray", gray)
cv2.imshow("binary", binary)
cv2.imshow("adaptive", binary_adaptive)
cv2.imshow("otsu", binary_otsu)

cv2.waitKey()

‍

图像形态学算法

腐蚀

新图像 = cv2.erode(传入的图像, kernel二维数组)
kernel: 腐蚀操作所使用的卷积核（也称为结构元素）。卷积核是一个二维数组，它决定了腐蚀的形状和大小。
当卷积核的大小相对较小时，腐蚀操作会更加强烈。这意味着腐蚀后的结果图像中物体的边界会进一步收缩，物体的尺寸会缩小，且可能会消除一些小的噪点。
当卷积核的大小相对较大时，腐蚀操作会相对较弱。这意味着腐蚀后的结果图像中物体的边界可能会保持更多的原始形状和尺寸。
可由np.ones((5, 5), np.uint8)生成

膨胀

图像 = cv2.dilate(传入的图像, kernel二维数组)

import cv2
import numpy as np

gray = cv2.imread("opencv_logo.jpg", cv2.IMREAD_GRAYSCALE)

# cv2.THRESH_BINARY_INV  反向阈值
_, binary = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY_INV)

kernel = np.ones((5, 5), np.uint8)
# 腐蚀
erosion = cv2.erode(binary, kernel)
# 膨胀
dilation = cv2.dilate(binary, kernel)


cv2.imshow("binary", binary)
cv2.imshow("腐蚀", erosion)
cv2.imshow("膨胀", dilation)
cv2.waitKey()

‍

调用摄像头

获取摄像头指针
变量 = cv2.VideoCapture(摄像头序号，只有一个就是0)

读取摄像图片
_, 存储图像的变量= capture.read()

import cv2
# 获取摄像头指针
capture = cv2.VideoCapture(0)

while True:
    # 读取摄像图片
    _, frame = capture.read()

    cv2.imshow("camera", frame)
    # 等待键盘输入1秒
    key = cv2.waitKey(1)
    # 如果我们输入任意键，返回值就不是-1
    if key != -1:
        break
# 释放指针
capture.release()

‍

基础

灰度图