Opencv基础

大写-凌祁

于 2024-03-19 21:10:13 发布

阅读量647

点赞数 8

文章标签： opencv 人工智能计算机视觉

本文链接：https://blog.csdn.net/qq_73553710/article/details/136855608

版权

Opencv学习

基本操作

察看当前摄像头

import cv2  # 导入OpenCV库
cap = cv2.VideoCapture(0)  # 创建一个VideoCapture对象，参数0表示使用默认的摄像头
while True:  # 循环无限执行，直到用户按下'q'键
    success, img = cap.read()  # 调用VideoCapture对象的read()方法，读取一帧画面。success变量表示读取是否成功，img表示读取到的画面
    cv2.imshow("video", img)  # 使用cv2.imshow()方法显示画面。参数"video"表示窗口名，img表示要显示的画面
    if cv2.waitKey(1) & 0xFF == ord('q'):  # 调用cv2.waitKey()方法，等待用户按下键盘上的键。参数1表示等待1毫秒（1毫秒=1000微秒），0xFF表示取按键的ASCII码值，ord('q')表示按下'q'键
        break  # 当用户按下'q'键时，跳出循环
cap.release()  # 释放摄像头资源
cv2.destroyAllWindows()  # 关闭所有显示窗口

打开图像

图像基本操作

import cv2  # 导入OpenCV库
import sys  # 导入sys库
import numpy as np  # 导入numpy库

# 读取图像文件"2.png"。
img = cv2.imread('F:\\Opencv\\2.png')

# 创建一个指定大小的核，用于图像处理（如模糊和膨胀等）。
kernel = np.ones((5, 5), np.uint8)

# 将图像转换为灰度图。
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 对灰度图进行高斯模糊。
blurred_img = cv2.GaussianBlur(gray_img, (5, 5), 0)

# 对模糊图进行Canny边缘检测。
edges_img = cv2.Canny(blurred_img, 30, 150)

# 使用定义的核进行膨胀操作。
dilated_img = cv2.dilate(edges_img, kernel, iterations=1)

# 显示处理后的图像。
cv2.imshow('Dilated Image', dilated_img)
cv2.imshow('Gray Image', gray_img)
cv2.imshow('Blurred Image', blurred_img)
cv2.imshow('Edges Image', edges_img)

# 循环等待用户输入"q"，表示退出程序。
while True:
    # 如果用户按下"q"键，退出程序
    if cv2.waitKey(1) & 0xFF == ord('q'):
        sys.exit()

# 销毁所有打开的窗口。
cv2.destroyAllWindows()

图像裁剪和像素重构

import cv2
import numpy as np
img=cv2.imread('F:\\Opencv\\2.png')#读图像
print(img.shape)#打印尺寸
imgResize=cv2.resize(img,(1000,500))
imgCropped=imgResize[0:200,200:500]
cv2.imshow('Image',imgResize)
time.sleep(10)
cv2.destroyAllWindows()

这段Python代码的功能是裁剪并显示一个图像，然后等待10秒后关闭所有窗口。以下是代码的详细解释：

imgCropped=imgResize[0:200,200:500]：这行代码表示裁剪图像imgResize，从第一行到第200行，从第200列到第500列。裁剪后的图像保存在imgCropped变量中。
cv2.imshow('Image',imgResize)：这行代码使用cv2库显示图像imgResize，窗口标题为"Image"。
time.sleep(10)：这行代码使程序暂停10秒。
cv2.destroyAllWindows()：这行代码关闭所有使用cv2库显示的窗口。

在图像上进行操作

import cv2
import numpy as np
img=np.zeros((512,512,3))
cv2.line(img,(0,0),(300,300),(0,255,0),3)
cv2.circle(img,(400,50),30,(255,255,0),5)
cv2.putText(img,"OPENCV",(300,200),cv2.FONT_HERSHEY_COMPLEX,1,(0,150,0),2)
cv2.imshow("Image",img)
cv2.waitKey(0)

这段Python代码是用OpenCV库绘制了一个矩形、圆形和文本的图像。以下是代码的详细解释：
1. 导入所需库：cv2（OpenCV）和numpy（数值计算库）。
2. 创建一个空白图像，大小为512x512像素，三维矩阵（512x512x3），这里每个像素的值为0（黑色）。
3. 使用cv2.line()函数在图像上绘制一条从(0,0)到(300,300)的绿色矩形线，线宽为3。
4. 使用cv2.circle()函数在图像上绘制一个半径为30的黄色圆形，圆心坐标为(400,50)。
5. 使用cv2.putText()函数在图像上添加一个名为"OPENCV"的绿色文本，字体为Hershey Complex，文本大小为1，距离文本区域左边为300，上边为200。
6. 使用cv2.imshow()函数显示图像，窗口名为"Image"。
7. 等待按键事件，直到用户按下任意键。
这段代码的主要功能是使用OpenCV库在图像上绘制一些图形和文本。这可以用于创建简单的图像编辑或绘图应用程序。

透视重构

import cv2
import numpy as np
img=cv2.imread()
width,height=250,350
pts1=np.float32([[111,219],[287,188],[154,482],[352,440]])
pts2=np.float32([[0,0],[width,0],[height,0],[width,height]])
matrix=cv2.getPerspectiveTransform(pts1,pts2)
imgOutput=cv2.warpPerspective(img,matrix,(width,height))

cv2.imshow("Image",img)
cv2.imshow(("Output",imgOutput))

cv2.waitKey(0)

这段Python代码的功能是将一个图像进行透视变换。透视变换是一种图像几何变换，它将一个图像透视变换到另一个图像。这在摄影和 surveying 等领域中非常有用。

代码的主要步骤如下：

导入所需库：OpenCV 和 NumPy。
读取图像并将其存储在变量 img 中。
定义变换后的图像尺寸 width 和 height。
定义原始图像中的四个点坐标 pts1，这些点将在变换过程中使用。
定义变换后的图像中的四个点坐标 pts2，这些点将在变换过程中使用。
使用 getPerspectiveTransform 函数计算变换矩阵 matrix。
使用 warpPerspective 函数应用变换，将原始图像转换为变换后的图像，结果存储在变量 imgOutput 中。
显示原始图像和变换后的图像。
等待用户按下任意键，然后关闭窗口。

注意：在运行此代码之前，请确保已安装 OpenCV 库并正确配置了环境变量。此外，还需要将文件路径放在代码中，例如 F:\\Opencv\\2.png
在OpenCV中，有许多基本的图像操作技术可以用来编辑和转换图像。这些操作是图像处理和计算机视觉应用的基础。以下是一些最常见的基本图像操作：

1. 读取和保存图像

读取图像：使用cv2.imread()函数。
保存图像：使用cv2.imwrite()函数。

2. 显示图像

显示图像：使用cv2.imshow()函数。

3. 基础图像信息

当你开始使用OpenCV处理图像时，了解图像的基础属性是非常重要的。这些属性包括图像的尺寸、形状、像素数以及数据类型。这些信息可以帮助你更好地理解如何操作图像以及如何应用不同的图像处理技术。

获取图像的基础信息

1. 图像尺寸和形状

图像的形状可以通过图像矩阵的维度来了解。在OpenCV中，图像被存储为一个多维NumPy数组。对于彩色图像（假设使用BGR颜色空间），这个数组的形状会有三个维度：高度、宽度和颜色通道数。

import cv2

# 读取图像
image = cv2.imread('path_to_image.jpg')

# 获取图像的形状
h, w, c = image.shape

print(f"Height: {h} pixels")
print(f"Width: {w} pixels")
print(f"Number of Channels: {c}")

对于灰度图像，数组只有两个维度：高度和宽度，因为颜色信息只需要一个通道就可以表示。

2. 像素数

图像的像素数等于图像的高度乘以宽度。对于彩色图像，你可能还想知道每个通道的像素数。

# 计算像素数
num_pixels = h * w
print(f"Number of Pixels: {num_pixels}")

3. 数据类型

每个像素的数据类型很重要，因为它影响图像的表示范围。例如，一个常见的数据类型是uint8，表示无符号的8位整数，每个像素的值可以在0到255之间。

# 获取数据类型
data_type = image.dtype
print(f"Data Type: {data_type}")

了解这些基础信息对进行图像处理和分析至关重要。它们不仅帮助你理解图像的基本构成，还能在进行图像操作（如裁剪、缩放、颜色空间转换等）时，提供必要的参数信息。此外，这些信息在调试程序时也非常有用，可以帮助你快速定位问题。是否有任何特定的图像操作或进一步的问题我可以帮助解答的？

获取图像的尺寸、像素数和图像数据类型。

4. 图像裁剪

通过数组切片来裁剪图像的特定区域。

5. 颜色空间转换

使用cv2.cvtColor()，常见的转换包括从BGR到灰度、从BGR到HSV等。
颜色空间转换是图像处理中的一个重要概念，它涉及将图像从一种颜色表示形式转换为另一种。在OpenCV中，颜色空间转换是通过cv2.cvtColor()函数完成的。这个函数非常强大，支持多种颜色空间之间的转换，例如从BGR到灰度、从BGR到HSV等。

常见的颜色空间

BGR：这是OpenCV中读取图像默认的颜色空间，其中颜色按蓝色、绿色、红色的顺序排列。
灰度：图像中的每个像素只有一个强度值，表示明暗程度，不包含颜色信息。
HSV：代表色调（Hue）、饱和度（Saturation）、明度（Value）。这种颜色空间对于颜色的描述更加直观。

颜色空间转换示例

1. BGR到灰度

将图像从BGR颜色空间转换为灰度空间，可以用于简化图像处理任务，因为它只处理亮度信息。

import cv2

# 读取图像
image = cv2.imread('path_to_image.jpg')

# 将BGR图像转换为灰度图像
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 显示图像
cv2.imshow('Gray Image', gray_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

2. BGR到HSV

HSV颜色空间对于处理颜色信息更加方便，特别是在颜色分割和颜色检测的应用中。

# 将BGR图像转换为HSV图像
hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

# 显示图像
cv2.imshow('HSV Image', hsv_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

使用颜色空间转换

颜色空间转换在许多图像处理应用中非常有用，例如：

图像分割和特征提取：某些颜色空间可能会使得特定颜色的分割或提取变得更容易。
图像增强：通过调整图像的色调、饱和度或明度来改善图像质量。
对象跟踪：在HSV空间中，通过色调来跟踪特定颜色的对象通常比在BGR空间中更为有效。

理解不同颜色空间的特点及其应用场景，可以帮助你更有效地处理图像数据。你有特定的应用或转换需求吗？

6. 图像缩放

使用cv2.resize()进行图像的缩放。

7. 图像旋转

使用cv2.getRotationMatrix2D()和cv2.warpAffine()进行图像旋转。

8. 图像翻转

使用cv2.flip()进行图像的翻转。

9. 边缘检测

使用Canny边缘检测算法cv2.Canny()。
边缘检测是计算机视觉和图像处理中的一个基本任务，旨在识别图像中对象边界的位置。它通过检测图像亮度的突变来工作，这些突变通常对应于物体的边缘。在OpenCV中，有几种常用的边缘检测算法，包括Sobel算子、Laplacian算子和Canny边缘检测算法。其中，Canny边缘检测算法因其鲁棒性而广泛使用。

Canny边缘检测算法

Canny边缘检测算法是John F. Canny在1986年提出的一种多级边缘检测技术。该算法的目标是找到一个最优的边缘检测方法，这个方法能满足以下三个标准：

低错误率：边缘被检测到的地方就应该存在边缘。
边缘点与实际边缘紧密相连：检测到的边缘应该尽可能接近真实的边缘。
最小化响应：图像中的边缘只能标记一次，并且在可能的情况下，图像噪声不应该产生假的边缘。

Canny边缘检测算法的步骤包括：

噪声降低：使用5x5的高斯滤波器平滑图像，以去除噪声。
计算图像梯度：用Sobel算子在水平和垂直方向上求导，以找到边缘的强度和方向。
非极大值抑制：去除非边缘像素，仅保留一系列细线条（潜在边缘）。
双阈值：确定潜在边缘是否真正为边缘，通过设置高阈值和低阈值来识别强边缘、弱边缘和非边缘。
边缘跟踪通过滞后阈值：通过分析强边缘和弱边缘之间的连接性，以确定哪些弱边缘真正属于边缘。

实现Canny边缘检测

import cv2
import numpy as np

# 读取图像
image = cv2.imread('path_to_your_image.jpg', cv2.IMREAD_GRAYSCALE)

# 应用Canny边缘检测
edges = cv2.Canny(image, threshold1=100, threshold2=200)

# 显示结果
cv2.imshow('Edges', edges)
cv2.waitKey(0)
cv2.destroyAllWindows()

在这个例子中，threshold1和threshold2分别是Canny函数的低阈值和高阈值。根据图像的不同，你可能需要调整这些阈值以获得最佳的边缘检测结果。

Canny边缘检测算法非常适合于那些需要高精度边缘信息的应用场景，比如物体检测、图像分割和跟踪等。掌握Canny边缘检测对于深入理解图像处理领域是非常有帮助的。

10. 图像阈值

应用固定阈值、自适应阈值和Otsu阈值法。
图像阈值（Thresholding）是图像处理中的一种基本技术，用于将图像转换为二值图像，即图像中的每个像素点非黑即白。这种技术通过比较图像像素值与预设的阈值大小来实现，根据比较结果将像素值设置为最大值（通常是255，表示白色）或最小值（通常是0，表示黑色）。图像阈值处理是许多复杂图像处理任务的前置步骤，例如轮廓检测、物体识别和跟踪。

常用的阈值方法

在OpenCV中，cv2.threshold()函数用于应用不同类型的阈值方法。以下是一些最常用的方法：

简单阈值：根据一个全局阈值将图像转换为二值图像。
自适应阈值：阈值是根据图像上每个点的邻域值计算得到的，因此可以针对图像不同区域的具体情况选择不同的阈值。
Otsu阈值：自动确定全局阈值，基于图像的灰度直方图计算得到。

简单阈值示例

import cv2

# 读取图像，转换为灰度图像
image = cv2.imread('path_to_image.jpg', cv2.IMREAD_GRAYSCALE)

# 应用简单阈值处理
ret, thresh = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)

# 显示结果
cv2.imshow('Threshold Image', thresh)
cv2.waitKey(0)
cv2.destroyAllWindows()

这里，127是阈值，255是超过阈值后要赋予的新值。cv2.THRESH_BINARY是阈值类型，表示简单的二值化操作。

自适应阈值示例

# 应用自适应阈值处理
thresh_adaptive = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_MEAN_C, 
                                        cv2.THRESH_BINARY, 11, 2)

# 显示结果
cv2.imshow('Adaptive Threshold Image', thresh_adaptive)
cv2.waitKey(0)
cv2.destroyAllWindows()

自适应阈值考虑了图像中的局部区域，使得在图像不同部分可以应用不同的阈值。

Otsu阈值示例

在使用cv2.threshold()函数时，将阈值参数设为0，并将阈值类型设为cv2.THRESH_BINARY + cv2.THRESH_OTSU。

# 应用Otsu阈值处理
ret2, thresh_otsu = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

# 显示结果
cv2.imshow('Otsu Threshold Image', thresh_otsu)
cv2.waitKey(0)
cv2.destroyAllWindows()

Otsu方法自动为整个图像选择一个阈值，适合图像的背景和前景具有较大对比度的情况。

图像阈值处理是一种非常强大的工具，能够简化许多图像分析任务。正确选择阈值方法和参数对于获取高质量的处理结果非常关键。

11. 图像平滑与滤波

使用不同的核（如均值滤波、高斯滤波、中值滤波）进行图像平滑和噪声去除。
图像平滑和滤波是图像处理中常用的技术，旨在减少图像中的噪声或是进行某种形式的图像增强。这些技术通过对图像的像素值进行数学操作来实现，通常涉及将每个像素值替换为邻近像素值的某种组合。在OpenCV中，有多种滤波器可用于图像平滑和滤波，每种滤波器都有其特定的应用场景。

常见的图像平滑和滤波技术

1. 均值滤波

均值滤波是最简单的滤波技术之一，通过用像素周围的像素的平均值来替换每个像素值。这种方法可以有效地去除随机噪声。

import cv2

# 读取图像
image = cv2.imread('path_to_image.jpg')

# 应用均值滤波
blurred = cv2.blur(image, (5, 5))  # 使用5x5的滤波器

# 显示结果
cv2.imshow('Blurred', blurred)
cv2.waitKey(0)
cv2.destroyAllWindows()

2. 高斯滤波

高斯滤波使用高斯核对图像进行平滑处理，相较于均值滤波，它给周围的像素赋予更低的权重。高斯滤波在去噪的同时，能更好地保留图像的边缘信息。

# 应用高斯滤波
gaussian_blur = cv2.GaussianBlur(image, (5, 5), 0)

# 显示结果
cv2.imshow('Gaussian Blurred', gaussian_blur)
cv2.waitKey(0)
cv2.destroyAllWindows()

3. 中值滤波

中值滤波将每个像素值替换为该像素周围（通常是正方形邻域）像素值的中值。这种方法特别适合于去除椒盐噪声，同时能较好地保持图像边缘。

# 应用中值滤波
median_blurred = cv2.medianBlur(image, 5)  # 使用5x5的滤波器

# 显示结果
cv2.imshow('Median Blurred', median_blurred)
cv2.waitKey(0)
cv2.destroyAllWindows()

4. 双边滤波

双边滤波同时考虑空间距离和像素差异，旨在在去除噪声的同时保留边缘。它对于去噪效果要求高且希望保持边缘清晰的应用场景非常适用。

# 应用双边滤波
bilateral_blurred = cv2.bilateralFilter(image, 9, 75, 75)

# 显示结果
cv2.imshow('Bilateral Blurred', bilateral_blurred)
cv2.waitKey(0)
cv2.destroyAllWindows()

这些滤波技术各有优劣，适用于不同的应用场景。选择哪种滤波技术取决于具体任务的需求，比如需要去除的噪声类型、是否需要保留边缘信息等。在实际应用中，可能需要尝试多种滤波技术，以找到最适合当前任务的方法。

12. 形态学操作

如腐蚀、膨胀、开运算、闭运算，用于图像的基本形状分析。
形态学操作是图像处理中基于形状的一系列技术，广泛用于图像预处理、特征提取、图像分割等领域。这些操作通常应用于二值图像，并依赖于图像中的结构元素（一个小的形状或模板）来定义操作的具体效果。OpenCV提供了多种形态学操作函数，包括腐蚀、膨胀、开运算、闭运算、形态学梯度、顶帽、黑帽等。

1. 腐蚀 (Erosion)

腐蚀操作的作用是侵蚀前景对象的边界，可以用来去除小的白噪声，分离相互连接的对象等。

import cv2
import numpy as np

# 读取图像，转换为二值图像
image = cv2.imread('path_to_image.jpg', 0)
_, binary_image = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)

# 定义结构元素
kernel = np.ones((5,5), np.uint8)

# 应用腐蚀操作
erosion = cv2.erode(binary_image, kernel, iterations = 1)

# 显示结果
cv2.imshow('Erosion', erosion)
cv2.waitKey(0)
cv2.destroyAllWindows()

2. 膨胀 (Dilation)

膨胀操作与腐蚀相反，用于增加前景对象的边界，常用于闭合前景对象内的小洞，或连接被腐蚀后分开的对象。

# 应用膨胀操作
dilation = cv2.dilate(binary_image, kernel, iterations = 1)

# 显示结果
cv2.imshow('Dilation', dilation)
cv2.waitKey(0)
cv2.destroyAllWindows()

3. 开运算 (Opening)

开运算是先腐蚀后膨胀的操作，用于去除小的对象。

# 应用开运算
opening = cv2.morphologyEx(binary_image, cv2.MORPH_OPEN, kernel)

# 显示结果
cv2.imshow('Opening', opening)
cv2.waitKey(0)
cv2.destroyAllWindows()

4. 闭运算 (Closing)

闭运算是先膨胀后腐蚀的操作，用于闭合前景对象内的小洞或小黑点。

# 应用闭运算
closing = cv2.morphologyEx(binary_image, cv2.MORPH_CLOSE, kernel)

# 显示结果
cv2.imshow('Closing', closing)
cv2.waitKey(0)
cv2.destroyAllWindows()

5. 形态学梯度 (Morphological Gradient)

形态学梯度是膨胀图像与腐蚀图像的差，结果看起来像是对象的轮廓。

# 应用形态学梯度
gradient = cv2.morphologyEx(binary_image, cv2.MORPH_GRADIENT, kernel)

# 显示结果
cv2.imshow('Morphological Gradient', gradient)
cv2.waitKey(0)
cv2.destroyAllWindows()

6. 顶帽 (Top Hat)

顶帽操作是原始图像与开运算结果的差，用于突出比邻近区域亮的区域。

# 应用顶帽操作
tophat = cv2.morphologyEx(binary_image, cv2.MORPH_TOPHAT, kernel)

# 显示结果
cv2.imshow('Top Hat', tophat)
cv2.waitKey(0)
cv2.destroyAllWindows()

7. 黑帽 (Black Hat)

黑帽操作是闭运算结果与原始图像的差，用于突出比邻近区域暗的区域。

# 应用黑帽操作
blackhat = cv2.morphologyEx(binary_image, cv2.MORPH_BLACKHAT, kernel)

# 显示结果
cv2.imshow('Black Hat', blackhat)
cv2.waitKey(0)
cv2.destroyAllWindows()

这些形态学操作是图像处理中非常强大的工具，能够帮助我们解决各种与形状相关的问题。在实际应用中，可以通过调整结构元素的大小和形状，以及操作的迭代次数，来达到预期的效果。

13. 图像轮廓检测

使用cv2.findContours()和cv2.drawContours()进行轮廓检测和绘制。
图像轮廓检测是在图像中寻找对象轮廓的过程，这对于对象的形状分析、对象检测和识别等应用非常重要。OpenCV提供了强大的工具来执行轮廓检测，主要通过cv2.findContours()函数来实现。这个函数可以检测图像中的轮廓，并将它们作为点的列表返回。

轮廓检测的基本步骤

1. 准备图像

首先，轮廓检测需要在二值图像上进行，因此通常先将图像转换为灰度图，然后应用阈值处理或Canny边缘检测等方法来获得二值图像。

2. 寻找轮廓

使用cv2.findContours()函数寻找二值图像中的轮廓。这个函数有三个参数：输入图像、轮廓检索模式和轮廓近似方法。它会返回轮廓列表和它们的层次结构。

3. 绘制轮廓

轮廓可以使用cv2.drawContours()函数在图像上绘制。这个函数可以在原图上绘制找到的轮廓，便于可视化分析。

示例代码

下面的示例展示了如何进行轮廓检测和绘制轮廓：

import cv2
import numpy as np

# 读取图像
image = cv2.imread('path_to_image.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 应用阈值处理或Canny边缘检测获取二值图像
_, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
# 或者使用Canny边缘检测：thresh = cv2.Canny(gray, 100, 200)

# 寻找轮廓
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

# 绘制所有轮廓
cv2.drawContours(image, contours, -1, (0, 255, 0), 3)

# 显示结果
cv2.imshow('Contours', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

关于`cv2.findContours()`的参数

输入图像：这应该是一个二值图像，通常是经过阈值处理或边缘检测的结果。
轮廓检索模式：决定轮廓之间的层次关系，如cv2.RETR_TREE会检索所有轮廓并重构整个层次结构。
轮廓近似方法：如cv2.CHAIN_APPROX_SIMPLE会压缩水平、垂直和对角线段，只保留它们的端点。

轮廓检测是图像处理中的一个强大工具，它为基于形状的分析和识别提供了基础。在实际应用中，轮廓的获取和使用可以根据具体的需求进行调整和优化。

14. 特征检测与匹配

如使用SIFT、SURF、ORB等检测图像中的关键点和特征。
特征检测与匹配是计算机视觉领域的核心技术之一，它们在图像识别、跟踪和三维重建等应用中扮演着关键角色。特征检测涉及到从图像中识别出独特的点或区域（即特征点），这些特征点应当在图像的不同视角、光照条件或尺度下依然保持可识别。而特征匹配则是找到两个图像之间相同特征点的对应关系。

特征检测

OpenCV提供了多种特征检测算法，如Harris角点检测、Shi-Tomasi角点检测、SIFT、SURF和ORB等。

1. SIFT (尺度不变特征变换)

SIFT是一种用于检测和描述局部特征的算法。它对旋转、尺度缩放、亮度变化保持不变性，对视角变化、仿射变换和噪声也具有一定的稳定性。

import cv2

# 读取图像
image = cv2.imread('path_to_image.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 初始化SIFT检测器
sift = cv2.SIFT_create()

# 检测SIFT特征点
keypoints = sift.detect(gray, None)

# 绘制关键点
img = cv2.drawKeypoints(gray, keypoints, image)

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

2. ORB (Oriented FAST and Rotated BRIEF)

ORB是另一种快速的特征点检测和描述子算法，它基于FAST关键点检测和BRIEF描述子的改进版。ORB是对SIFT和SURF算法的一种高效替代。

# 初始化ORB检测器
orb = cv2.ORB_create()

# 检测ORB关键点并计算描述子
keypoints, descriptors = orb.detectAndCompute(gray, None)

# 绘制关键点
img = cv2.drawKeypoints(gray, keypoints, None, color=(0, 255, 0), flags=0)

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

特征匹配

在检测到图像特征点之后，下一步是在不同图像间匹配这些特征点。特征匹配通常使用特征描述子完成，特征描述子是对特征点周围区域的一种数学描述。BF匹配器（Brute-Force matcher）和FLANN匹配器（Fast Library for Approximate Nearest Neighbors）是两种常见的匹配方法。

1. BF匹配器

# 创建BF匹配器对象
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)

# 匹配描述子
matches = bf.match(descriptors1, descriptors2)

# 根据距离排序
matches = sorted(matches, key = lambda x:x.distance)

# 绘制前N个匹配项
img3 = cv2.drawMatches(img1, keypoints1, img2, keypoints2, matches[:50], None, flags=2)

cv2.imshow('Matched Features', img3)
cv2.waitKey(0)
cv2.destroyAllWindows()

2. FLANN匹配器

# 创建FLANN匹配器
index_params = dict(algorithm = 6, table_number = 6, key_size = 12, multi_probe_level = 1)
search_params = dict(checks=50)

flann = cv2.FlannBasedMatcher(index_params, search_params)

matches = flann.knnMatch(descriptors1, descriptors2, k=2)

# 仅绘制好的匹配点
good = []
for m,n in matches:
    if m.distance < 0.7*n.distance:
        good.append(m)

img3 = cv2.drawMatches(img1, keypoints1, img2, keypoints2, good, None)

cv2.imshow('FLANN Matched Features', img3)
cv2.waitKey(0)
cv2.destroyAllWindows()

特征检测与匹配是一个强大而复杂的领域，需要根据具体的应用场景选择合适的算法和参数。在实践中，可能需要尝试不同的方法和参数调整，以达到最佳效果。

15. 直方图

计算和绘制图像的直方图。

这些操作为你在图像处理和计算机视觉项目中打下坚实的基础。每一项操作都有其独特的应用场景，例如图像预处理、特征提取、图像增强等。你对哪一项特别感兴趣，想深入了解或实践吗？

大写-凌祁

关注

8
点赞
踩
22

收藏

觉得还不错? 一键收藏
1
评论
Opencv基础

它们不仅帮助你理解图像的基本构成，还能在进行图像操作（如裁剪、缩放、颜色空间转换等）时，提供必要的参数信息。在实际应用中，可以通过调整结构元素的大小和形状，以及操作的迭代次数，来达到预期的效果。ORB是另一种快速的特征点检测和描述子算法，它基于FAST关键点检测和BRIEF描述子的改进版。特征检测与匹配是一个强大而复杂的领域，需要根据具体的应用场景选择合适的算法和参数。首先，轮廓检测需要在二值图像上进行，因此通常先将图像转换为灰度图，然后应用阈值处理或Canny边缘检测等方法来获得二值图像。
复制链接

扫一扫