Cet article présente 20 cas sur OpenCV, notamment la reconnaissance faciale, la détection de cibles, la segmentation d'images, l'estimation du flux optique, l'extraction de caractéristiques, l'assemblage d'images, la réparation d'images, la transformation d'images, l'enregistrement d'images, l'analyse vidéo, la reconstruction tridimensionnelle, le traitement d'images, la reconnaissance d'images. , reconnaissance de texte, compression d'image, amélioration d'image, analyse d'image, comparaison d'image, conversion d'image et effets spéciaux d'image. Ces cas démontrent la large application d'OpenCV dans le domaine de la vision par ordinateur et peuvent aider les lecteurs à comprendre les fonctions et les scénarios d'application d'OpenCV. Ils fournissent également une source d'inspiration et d'inspiration aux lecteurs pour appliquer OpenCV pour le traitement et l'analyse d'images dans leurs propres projets.
1. Reconnaissance faciale : Grâce à l'algorithme de reconnaissance faciale d'OpenCV, les visages dans les images ou les vidéos peuvent être reconnus et suivis.
Voici un exemple de code pour un algorithme de reconnaissance faciale utilisant OpenCV :
import cv2
# 加载人脸识别分类器
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
# 加载图像或视频
img = cv2.imread('test.jpg')
# 将图像转换为灰度图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 检测图像中的人脸
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
# 在图像中标记人脸
for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
# 显示标记后的图像
cv2.imshow('img', img)
cv2.waitKey()
在此示例中，我们首先加载了OpenCV的人脸识别分类器（haarcascade_frontalface_default.xml），然后加载了一张测试图像（test.jpg）。我们将图像转换为灰度图像，并使用detectMultiScale函数检测图像中的人脸。最后，我们在图像中标记出检测到的人脸，并显示标记后的图像。
2. Détection de cible : grâce à l'algorithme de détection de cible d'OpenCV, les cibles dans les images ou les vidéos peuvent être détectées et suivies, telles que les véhicules, les piétons, etc.
Ce qui suit est un exemple de code utilisant l'algorithme de détection d'objets d'OpenCV pour détecter et suivre les véhicules dans des images ou des vidéos :
import cv2
# 加载车辆检测分类器
car_cascade = cv2.CascadeClassifier('cars.xml')
# 加载视频
cap = cv2.VideoCapture('cars.mp4')
# 循环读取视频帧
while True:
# 读取视频帧
ret, frame = cap.read()
# 将视频帧转换为灰度图像
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# 检测车辆
cars = car_cascade.detectMultiScale(gray, 1.1, 1)
# 在视频帧中标记车辆
for (x, y, w, h) in cars:
cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 255), 2)
# 显示标记后的视频帧
cv2.imshow('video', frame)
# 按下q键退出循环
if cv2.waitKey(25) & 0xFF == ord('q'):
break
# 释放视频
cap.release()
# 关闭所有窗口
cv2.destroyAllWindows()
Dans cet exemple, nous chargeons d'abord le classificateur de détection de véhicules d'OpenCV (cars.xml), puis chargeons une vidéo de test (cars.mp4). Nous lisons les images vidéo en boucle, convertissons chaque image vidéo en une image en niveaux de gris et détectons les véhicules à l'aide de la fonction detectorMultiScale. Enfin, nous étiquetons les véhicules détectés dans les images vidéo et affichons les images vidéo étiquetées. Appuyez sur la touche q pour quitter la boucle.
3. Segmentation d'image : grâce à l'algorithme de segmentation d'image d'OpenCV, l'image peut être divisée en plusieurs zones pour faciliter le traitement et l'analyse ultérieurs.
Voici un exemple de code pour l'algorithme de segmentation d'images utilisant OpenCV :
import cv2
import numpy as np
# 读取图像
img = cv2.imread('image.jpg')
# 转换为LAB颜色空间
lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
# 提取颜色通道
l, a, b = cv2.split(lab)
# 对L通道进行阈值分割
ret, thresh = cv2.threshold(l, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
# 对二值化后的图像进行形态学操作，去除噪声
kernel = np.ones((3,3), np.uint8)
opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)
# 执行距离变换，得到每个像素到最近背景像素的距离
dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
# 对距离变换结果进行阈值分割，得到前景区域
ret, foreground = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)
# 对前景区域进行形态学操作，得到更好的分割结果
kernel2 = np.ones((3,3), np.uint8)
foreground = cv2.morphologyEx(foreground, cv2.MORPH_CLOSE, kernel2, iterations=2)
# 显示结果
cv2.imshow('original', img)
cv2.imshow('segmentation', foreground)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans cet exemple, nous lisons d'abord une image (image.jpg), puis la convertissons en espace colorimétrique LAB et extrayons le canal L. Ensuite, nous effectuons une segmentation de seuil sur le canal L, supprimons le bruit et effectuons une transformation de distance pour obtenir la distance de chaque pixel au pixel d'arrière-plan le plus proche. Ensuite, nous effectuons une segmentation de seuil sur le résultat de la transformation de distance pour obtenir la zone de premier plan, et effectuons des opérations morphologiques sur la zone de premier plan pour obtenir de meilleurs résultats de segmentation. Enfin, nous montrons l’image originale et les résultats de segmentation.
4. Estimation du flux optique : grâce à l'algorithme d'estimation du flux optique d'OpenCV, le mouvement dans les images ou les vidéos peut être estimé, comme la vitesse et la direction des objets, etc.
Voici un exemple de code pour l'algorithme d'estimation du flux optique utilisant OpenCV :
import cv2
import numpy as np
# 读取视频
cap = cv2.VideoCapture('video.mp4')
# 读取第一帧
ret, prev_frame = cap.read()
prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
# 定义角点检测参数
feature_params = dict(maxCorners=100, qualityLevel=0.3, minDistance=7, blockSize=7)
# 定义LK光流参数
lk_params = dict(winSize=(15, 15), maxLevel=2, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))
# 获取角点
prev_corners = cv2.goodFeaturesToTrack(prev_gray, mask=None, **feature_params)
# 创建颜色
color = np.random.randint(0, 255, (100, 3))
# 循环处理每一帧
while True:
# 读取当前帧
ret, curr_frame = cap.read()
if not ret:
break
curr_gray = cv2.cvtColor(curr_frame, cv2.COLOR_BGR2GRAY)
# 计算光流
curr_corners, status, err = cv2.calcOpticalFlowPyrLK(prev_gray, curr_gray, prev_corners, None, **lk_params)
# 选择好的角点
good_new = curr_corners[status == 1]
good_old = prev_corners[status == 1]
# 绘制轨迹
for i, (new, old) in enumerate(zip(good_new, good_old)):
a, b = new.ravel()
c, d = old.ravel()
mask = cv2.line(mask, (a, b), (c, d), color[i].tolist(), 2)
frame = cv2.circle(curr_frame, (a, b), 5, color[i].tolist(), -1)
img = cv2.add(frame, mask)
# 显示结果
cv2.imshow('frame', img)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
# 更新变量
prev_gray = curr_gray.copy()
prev_corners = good_new.reshape(-1, 1, 2)
cv2.destroyAllWindows()
cap.release()
Dans cet exemple, nous lisons d'abord une vidéo (video.mp4), puis lisons la première image et la convertissons en image en niveaux de gris. Ensuite, nous définissons les paramètres de détection des coins et les paramètres de flux optique LK, et utilisons la fonction cv2.goodFeaturesToTrack() pour obtenir les points de coin. Nous parcourons ensuite chaque image, calculons le flux optique et sélectionnons les bons points de coin. Enfin, nous traçons les trajectoires de mouvement et affichons les résultats.
5. Extraction de fonctionnalités : à l'aide de l'algorithme d'extraction de fonctionnalités d'OpenCV, vous pouvez extraire certaines fonctionnalités de l'image, telles que les bords, les coins, etc., pour faciliter le traitement et l'analyse ultérieurs.
Voici un exemple de code utilisant l'algorithme d'extraction de fonctionnalités OpenCV, comprenant deux exemples de détection de contour et de détection de coin :
Exemple de code de détection de contour :
import cv2
import numpy as np
# 读取图像
img = cv2.imread('image.jpg', 0)
# Canny边缘检测
edges = cv2.Canny(img, 100, 200)
# 显示结果
cv2.imshow('Edges', edges)
cv2.waitKey(0)
cv2.destroyAllWindows()
Exemple de code de détection de coin :
import cv2
import numpy as np
# 读取图像
img = cv2.imread('image.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Shi-Tomasi角点检测
corners = cv2.goodFeaturesToTrack(gray, 25, 0.01, 10)
corners = np.int0(corners)
# 绘制角点
for i in corners:
x, y = i.ravel()
cv2.circle(img, (x, y), 3, (0, 0, 255), -1)
# 显示结果
cv2.imshow('Corners', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
Les exemples de codes ci-dessus pour deux algorithmes d'extraction de fonctionnalités de base, qui peuvent être modifiés et optimisés en fonction des besoins réels.
6. Assemblage d'images : grâce à l'algorithme d'assemblage d'images d'OpenCV, plusieurs images peuvent être assemblées en une seule grande image, comme un panorama.
Ce qui suit est un exemple de code utilisant l'algorithme d'assemblage d'images d'OpenCV, qui comprend un exemple d'assemblage de deux images dans un panorama :
import cv2
import numpy as np
# 读取两张图像
img1 = cv2.imread('image1.jpg')
img2 = cv2.imread('image2.jpg')
# 将两张图像转为灰度图像
gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
# 使用SIFT算法提取特征点和特征描述符
sift = cv2.xfeatures2d.SIFT_create()
kp1, des1 = sift.detectAndCompute(gray1, None)
kp2, des2 = sift.detectAndCompute(gray2, None)
# 使用FLANN算法进行特征点匹配
FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50)
flann = cv2.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(des1, des2, k=2)
# 选出最佳匹配的特征点
good = []
for m, n in matches:
if m.distance < 0.7 * n.distance:
good.append(m)
# 获取匹配的特征点的坐标
src_pts = np.float32([kp1[m.queryIdx].pt for m in good]).reshape(-1, 1, 2)
dst_pts = np.float32([kp2[m.trainIdx].pt for m in good]).reshape(-1, 1, 2)
# 使用RANSAC算法进行单应性矩阵估计
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
# 将第一张图像进行透视变换，拼接成全景图
result = cv2.warpPerspective(img1, M, (img1.shape[1] + img2.shape[1], img1.shape[0]))
result[0:img2.shape[0], img1.shape[1]:] = img2
# 显示结果
cv2.imshow('Panorama', result)
cv2.waitKey(0)
cv2.destroyAllWindows()
Ce qui précède est un exemple de code permettant de fusionner deux images dans un panorama, qui peut être modifié et optimisé en fonction des besoins réels. Il convient de noter que l'effet de l'algorithme d'assemblage d'images sera affecté par des facteurs tels que la qualité de l'image, la précision de l'extraction et de la correspondance des points caractéristiques, la précision de l'estimation de la matrice d'homographie, etc. Par conséquent, des tests et une optimisation suffisants sont nécessaires dans les applications pratiques.
7. Réparation d'image : grâce à l'algorithme de réparation d'image d'OpenCV, vous pouvez réparer les défauts de l'image, tels que la suppression du bruit, la restauration des pièces endommagées, etc.
Ce qui suit est un exemple de code utilisant l'algorithme de réparation d'image d'OpenCV, qui comprend un exemple de suppression du bruit d'une image :
import cv2
import numpy as np
# 读取图像
img = cv2.imread('image.jpg')
# 将图像转为灰度图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 使用高斯滤波去除噪声
gray = cv2.GaussianBlur(gray, (5, 5), 0)
# 使用自适应阈值法进行二值化处理
thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 11, 2)
# 使用形态学操作去除噪声
kernel = np.ones((3, 3), np.uint8)
opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)
# 使用轮廓检测获取图像中的物体轮廓
contours, hierarchy = cv2.findContours(opening, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# 遍历所有轮廓，去除面积较小的噪声
for i in range(len(contours)):
area = cv2.contourArea(contours[i])
if area < 100:
cv2.drawContours(opening, [contours[i]], -1, 0, -1)
# 使用形态学操作恢复图像中缺失的部分
closing = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel, iterations=2)
# 显示结果
cv2.imshow('Original', img)
cv2.imshow('Processed', closing)
cv2.waitKey(0)
cv2.destroyAllWindows()
Ce qui précède est un exemple de code pour supprimer le bruit des images, qui peut être modifié et optimisé en fonction des besoins réels. Il convient de noter que l'effet de l'algorithme de réparation d'image sera affecté par des facteurs tels que la qualité de l'image, le type et l'intensité du bruit, la sélection du seuil, etc., de sorte que des tests et une optimisation suffisants sont nécessaires dans les applications pratiques.
8. Transformation d'image : grâce à l'algorithme de transformation d'image d'OpenCV, les images peuvent être pivotées, mises à l'échelle, retournées, etc. pour faciliter le traitement et l'analyse ultérieurs.
Ce qui suit est un exemple de code utilisant l'algorithme de transformation d'image d'OpenCV, qui comprend des exemples de rotation, de mise à l'échelle, de retournement et d'autres opérations sur des images :
import cv2
import numpy as np
# 读取图像
img = cv2.imread('image.jpg')
# 获取图像大小
height, width = img.shape[:2]
# 旋转图像
M = cv2.getRotationMatrix2D((width/2, height/2), 45, 1)
rotated = cv2.warpAffine(img, M, (width, height))
# 缩放图像
resized = cv2.resize(img, (int(width/2), int(height/2)), interpolation=cv2.INTER_CUBIC)
# 翻转图像
flipped = cv2.flip(img, 1)
# 显示结果
cv2.imshow('Original', img)
cv2.imshow('Rotated', rotated)
cv2.imshow('Resized', resized)
cv2.imshow('Flipped', flipped)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans le code ci-dessus, la fonction cv2.getRotationMatrix2D est utilisée pour faire pivoter l'image et la fonction cv2.warpAffine est utilisée pour transformer l'image ; la fonction cv2.resize est utilisée pour redimensionner l'image ; la fonction cv2.flip est utilisée pour retourner l'image. Il convient de noter que l'effet de l'algorithme de transformation d'image sera affecté par des facteurs tels que la sélection des paramètres de transformation et la qualité de l'image, des tests et une optimisation suffisants sont donc nécessaires dans les applications pratiques.
9. Enregistrement d'images : grâce à l'algorithme d'enregistrement d'images d'OpenCV, plusieurs images peuvent être enregistrées pour faciliter le traitement et l'analyse ultérieurs.
Ce qui suit est un exemple de code utilisant l'algorithme d'enregistrement d'images d'OpenCV, qui comprend un exemple d'enregistrement de plusieurs images :
import cv2
import numpy as np
# 读取图像
img1 = cv2.imread('img1.jpg')
img2 = cv2.imread('img2.jpg')
# 将图像转为灰度图像
gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
# 获取特征点
sift = cv2.xfeatures2d.SIFT_create()
kp1, des1 = sift.detectAndCompute(gray1, None)
kp2, des2 = sift.detectAndCompute(gray2, None)
# 特征点匹配
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
# 筛选匹配点
good_matches = []
for m, n in matches:
if m.distance < 0.75 * n.distance:
good_matches.append(m)
# 获取匹配点坐标
src_pts = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
dst_pts = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
# 计算变换矩阵
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
# 对图像进行配准
result = cv2.warpPerspective(img1, M, (img2.shape[1], img2.shape[0]))
# 显示结果
cv2.imshow('Image 1', img1)
cv2.imshow('Image 2', img2)
cv2.imshow('Result', result)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans le code ci-dessus, l'algorithme SIFT est utilisé pour obtenir les points caractéristiques de l'image, l'algorithme BFMatcher est utilisé pour faire correspondre les points caractéristiques, la fonction findHomography est utilisée pour calculer la matrice de transformation et la fonction warpPerspective est utilisée pour enregistrer le image. Il convient de noter que l'effet de l'algorithme d'enregistrement d'image sera affecté par des facteurs tels que la sélection des points caractéristiques et la précision de la correspondance, de sorte que des tests et une optimisation suffisants sont nécessaires dans les applications pratiques.
10. Analyse vidéo : Grâce à l'algorithme d'analyse vidéo d'OpenCV, les vidéos peuvent être analysées, comme la détection de mouvement, l'analyse du comportement, etc.
Voici un exemple de code pour les algorithmes d'analyse vidéo utilisant OpenCV, qui inclut un exemple de détection de mouvement sur une vidéo :
import cv2
# 打开视频文件
cap = cv2.VideoCapture('video.mp4')
# 定义背景减除器
fgbg = cv2.createBackgroundSubtractorMOG2()
while True:
# 读取一帧图像
ret, frame = cap.read()
# 如果读取失败，则退出循环
if not ret:
break
# 对图像进行背景减除
fgmask = fgbg.apply(frame)
# 对背景减除后的图像进行二值化处理
thresh = cv2.threshold(fgmask, 127, 255, cv2.THRESH_BINARY)[1]
# 对二值化后的图像进行形态学操作，去除噪声
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
thresh = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)
# 寻找图像中的轮廓
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# 对轮廓进行遍历，检测运动物体
for contour in contours:
if cv2.contourArea(contour) < 1000: # 过滤掉面积小于1000的轮廓
continue
(x, y, w, h) = cv2.boundingRect(contour)
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
# 显示结果
cv2.imshow('frame', frame)
# 如果按下q键，则退出循环
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# 释放资源
cap.release()
cv2.destroyAllWindows()
Dans le code ci-dessus, l'algorithme BackgroundSubtractorMOG2 est utilisé pour la soustraction d'arrière-plan, la fonction seuil est utilisée pour la binarisation, la fonction morphologyEx est utilisée pour les opérations morphologiques, la fonction findContours est utilisée pour trouver le contour dans l'image, la fonctionboundingRect est utilisée pour obtenez la boîte englobante du contour, et enfin le dessin de boîtes rectangulaires sur l'image originale pour marquer les objets en mouvement. Il convient de noter que l'effet de l'algorithme d'analyse vidéo sera affecté par des facteurs tels que la soustraction de l'arrière-plan et la détection des contours, des tests et une optimisation suffisants sont donc nécessaires dans les applications pratiques.
11. Reconstruction 3D : Grâce à l'algorithme de reconstruction 3D d'OpenCV, les modèles 3D, tels que les bâtiments, les sculptures, etc., peuvent être restaurés à partir de plusieurs images.
Ce qui suit est un exemple de code utilisant l'algorithme de reconstruction 3D d'OpenCV, qui comprend un exemple de récupération d'un modèle 3D à partir de plusieurs images :
import cv2
import numpy as np
import os
# 读取图像
image_dir = 'image_dir/'
images = []
for filename in os.listdir(image_dir):
img = cv2.imread(os.path.join(image_dir, filename))
if img is not None:
images.append(img)
# 提取图像特征点
sift = cv2.xfeatures2d.SIFT_create()
keypoints = []
descriptors = []
for img in images:
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
kp, des = sift.detectAndCompute(gray, None)
keypoints.append(kp)
descriptors.append(des)
# 匹配特征点
matcher = cv2.BFMatcher()
matches = []
for i in range(len(images) - 1):
matches.append(matcher.match(descriptors[i], descriptors[i+1]))
# 三维重建
camera_matrix = np.array([[1000, 0, 500], [0, 1000, 500], [0, 0, 1]], dtype=np.float32)
dist_coeffs = np.zeros((4,1))
obj_points = []
img_points = []
for i in range(len(matches)):
points_3d = []
points_2d = []
for m in matches[i]:
pt1 = keypoints[i][m.queryIdx].pt
pt2 = keypoints[i+1][m.trainIdx].pt
points_2d.append(pt1)
points_2d.append(pt2)
pt1 = np.array([pt1[0], pt1[1], 0])
pt2 = np.array([pt2[0], pt2[1], 0])
points_3d.append(pt1)
points_3d.append(pt2)
points_3d = np.array(points_3d, dtype=np.float32)
points_2d = np.array(points_2d, dtype=np.float32)
retval, rvec, tvec = cv2.solvePnP(points_3d, points_2d, camera_matrix, dist_coeffs)
obj_points.append(points_3d)
img_points.append(points_2d)
if i == 0:
prev_rvec = rvec
prev_tvec = tvec
else:
rvec_diff = np.abs(rvec - prev_rvec)
tvec_diff = np.abs(tvec - prev_tvec)
if np.mean(rvec_diff) > 0.1 or np.mean(tvec_diff) > 10:
obj_points.pop()
img_points.pop()
break
prev_rvec = rvec
prev_tvec = tvec
retval, camera_matrix, dist_coeffs, rvecs, tvecs = cv2.calibrateCamera(obj_points, img_points, images[0].shape[:2], None, None)
retval, rvec, tvec = cv2.solvePnP(points_3d, points_2d, camera_matrix, dist_coeffs)
points_3d = np.array(points_3d, dtype=np.float32)
points_2d = np.array(points_2d, dtype=np.float32)
retval, rvec, tvec, inliers = cv2.solvePnPRansac(points_3d, points_2d, camera_matrix, dist_coeffs)
# 保存结果
file_storage = cv2.FileStorage('reconstruction.xml', cv2.FILE_STORAGE_WRITE)
file_storage.write('camera_matrix', camera_matrix)
file_storage.write('dist_coeffs', dist_coeffs)
file_storage.write('rvecs', rvecs)
file_storage.write('tvecs', tvecs)
file_storage.release()
Dans le code ci-dessus, plusieurs images sont d'abord lues et l'algorithme SIFT est utilisé pour extraire les points caractéristiques et les descripteurs de caractéristiques de chaque image. Ensuite, utilisez l'algorithme BFMatcher pour faire correspondre les points caractéristiques de deux images adjacentes et obtenir les résultats correspondants. Ensuite, utilisez l'algorithme solvePnP pour effectuer une reconstruction tridimensionnelle des résultats de correspondance afin d'obtenir les coordonnées tridimensionnelles de chaque point caractéristique. Enfin, l'algorithme calibrateCamera est utilisé pour calibrer la caméra et l'algorithme solvePnPRansac est utilisé pour optimiser les coordonnées tridimensionnelles afin d'obtenir la posture finale de la caméra et les coordonnées tridimensionnelles. Enfin, enregistrez les résultats dans un fichier. Il convient de noter que l'effet de l'algorithme de reconstruction 3D sera affecté par des facteurs tels que la qualité de l'image, l'extraction et la correspondance des points caractéristiques, de sorte que des tests et une optimisation suffisants sont nécessaires dans les applications pratiques.
12. Traitement d'image : Grâce à l'algorithme de traitement d'image d'OpenCV, vous pouvez effectuer un filtrage, une détection des contours, des opérations morphologiques, etc. sur les images.
Ce qui suit est un exemple de code pour les algorithmes de traitement d'image utilisant OpenCV, qui comprend des exemples d'opérations de filtrage, de détection de contours et morphologiques :
- Fonctionnement du filtre :
import cv2
import numpy as np
# 读取图像
img = cv2.imread('image.png')
# 高斯滤波
blur = cv2.GaussianBlur(img, (5, 5), 0)
# 中值滤波
median = cv2.medianBlur(img, 5)
# 展示结果
cv2.imshow('Original Image', img)
cv2.imshow('Gaussian Blur', blur)
cv2.imshow('Median Blur', median)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans le code ci-dessus, la fonction cv2.imread() est d'abord utilisée pour lire l'image, puis les fonctions cv2.GaussianBlur() et cv2.medianBlur() sont utilisées pour effectuer des opérations de filtrage gaussien et de filtrage médian sur l'image, et enfin la fonction cv2.imshow() est utilisée Afficher les résultats.
2. Opération de détection de bord :
import cv2
import numpy as np
# 读取图像
img = cv2.imread('image.png', cv2.IMREAD_GRAYSCALE)
# Canny边缘检测
edges = cv2.Canny(img, 100, 200)
# Laplacian边缘检测
laplacian = cv2.Laplacian(img, cv2.CV_64F)
# Sobel边缘检测
sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=5)
sobely = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=5)
sobel = cv2.addWeighted(sobelx, 0.5, sobely, 0.5, 0)
# 展示结果
cv2.imshow('Original Image', img)
cv2.imshow('Canny Edge Detection', edges)
cv2.imshow('Laplacian Edge Detection', laplacian)
cv2.imshow('Sobel Edge Detection', sobel)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans le code ci-dessus, la fonction cv2.imread() est d'abord utilisée pour lire l'image en niveaux de gris, puis les fonctions cv2.Canny(), cv2.Laplacian() et cv2.Sobel() sont utilisées pour effectuer des opérations de détection de contours sur l'image. image, et enfin cv2. La fonction imshow() affiche les résultats.
3. Opérations morphologiques :
import cv2
import numpy as np
# 读取图像
img = cv2.imread('image.png', cv2.IMREAD_GRAYSCALE)
# 膨胀操作
kernel = np.ones((5, 5), np.uint8)
dilation = cv2.dilate(img, kernel, iterations=1)
# 腐蚀操作
erosion = cv2.erode(img, kernel, iterations=1)
# 开运算
opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
# 闭运算
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
# 形态学梯度
gradient = cv2.morphologyEx(img, cv2.MORPH_GRADIENT, kernel)
# 顶帽操作
tophat = cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel)
# 黑帽操作
blackhat = cv2.morphologyEx(img, cv2.MORPH_BLACKHAT, kernel)
# 展示结果
cv2.imshow('Original Image', img)
cv2.imshow('Dilation', dilation)
cv2.imshow('Erosion', erosion)
cv2.imshow('Opening', opening)
cv2.imshow('Closing', closing)
cv2.imshow('Morphological Gradient', gradient)
cv2.imshow('Top Hat', tophat)
cv2.imshow('Black Hat', blackhat)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans le code ci-dessus, la fonction cv2.imread() est d'abord utilisée pour lire l'image en niveaux de gris, puis les fonctions cv2.dilate(), cv2.erode() et cv2.morphologyEx() sont utilisées pour développer, éroder, ouvrez et fermez l'opération image., le dégradé morphologique, l'opération chapeau haut de forme et l'opération chapeau noir, et enfin utilisez la fonction cv2.imshow() pour afficher les résultats.
13. Reconnaissance d'image : grâce à l'algorithme de reconnaissance d'image d'OpenCV, les objets dans les images peuvent être reconnus, tels que la reconnaissance de plaque d'immatriculation, les chiffres manuscrits, etc.
Ce qui suit est un exemple de code pour l'algorithme de reconnaissance d'image utilisant OpenCV, qui comprend des exemples de reconnaissance de plaque d'immatriculation et de reconnaissance de chiffres manuscrits :
- Reconnaissance de plaque d'immatriculation :
import cv2
import pytesseract
# 读取图像
img = cv2.imread('car_plate.jpg')
# 转换为灰度图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 进行高斯滤波
blur = cv2.GaussianBlur(gray, (5, 5), 0)
# 进行边缘检测
edges = cv2.Canny(blur, 100, 200)
# 查找轮廓
contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
# 对轮廓进行筛选
for contour in contours:
area = cv2.contourArea(contour)
if area > 1000 and area < 50000:
x, y, w, h = cv2.boundingRect(contour)
if w / h > 2 and w / h < 6:
# 截取车牌区域
plate = gray[y:y+h, x:x+w]
# 进行二值化处理
ret, thresh = cv2.threshold(plate, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
# 识别车牌号码
plate_number = pytesseract.image_to_string(thresh, lang='chi_sim')
print('车牌号码：', plate_number)
# 展示结果
cv2.imshow('Original Image', img)
cv2.imshow('Gray Image', gray)
cv2.imshow('Edges Image', edges)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans le code ci-dessus, la fonction cv2.imread() est d'abord utilisée pour lire l'image, puis l'image est convertie en une image en niveaux de gris, le filtrage gaussien et la détection des bords sont effectués, puis la fonction cv2.findContours() est utilisée. pour trouver le contour et la zone de la plaque d'immatriculation est déterminé par les conditions de filtrage. , puis binarisez la zone de la plaque d'immatriculation, utilisez la bibliothèque pytesseract pour identifier le numéro de plaque d'immatriculation, et enfin utilisez la fonction cv2.imshow() pour afficher les résultats.
2. Reconnaissance des chiffres manuscrits :
import cv2
import numpy as np
from keras.models import load_model
# 加载模型
model = load_model('mnist.h5')
# 读取图像
img = cv2.imread('digit.png')
# 转换为灰度图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 进行二值化处理
ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
# 查找轮廓
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# 对轮廓进行筛选
for contour in contours:
x, y, w, h = cv2.boundingRect(contour)
if w * h > 100:
# 截取数字区域
digit = thresh[y:y+h, x:x+w]
# 调整大小
digit = cv2.resize(digit, (28, 28))
digit = digit.reshape((1, 28, 28, 1))
digit = digit.astype('float32') / 255
# 预测数字
prediction = model.predict(digit)
digit_number = np.argmax(prediction)
print('识别结果：', digit_number)
# 展示结果
cv2.imshow('Original Image', img)
cv2.imshow('Gray Image', gray)
cv2.imshow('Binary Image', thresh)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans le code ci-dessus, la fonction load_model() est d'abord utilisée pour charger le modèle de reconnaissance de chiffres manuscrits pré-entraîné, puis la fonction cv2.imread() est utilisée pour lire l'image, l'image est convertie en une image en niveaux de gris et binarisée. , puis cv2 est utilisé. La fonction findContours() recherche les contours et détermine la zone numérique via des conditions de filtrage. Ensuite, la zone numérique est redimensionnée et normalisée, et le modèle est utilisé pour la prédiction. Enfin, la fonction cv2.imshow() est utilisé pour afficher les résultats.
14. Reconnaissance de texte : grâce à l'algorithme de reconnaissance de texte d'OpenCV, vous pouvez reconnaître du texte dans des images, comme des numéros d'identification, des codes de vérification d'identification, etc.
Ce qui suit est un code de cas pour utiliser l'algorithme de reconnaissance de texte d'OpenCV pour identifier les numéros de carte d'identité :
import cv2
import pytesseract
# 读取身份证图片
img = cv2.imread('id_card.jpg')
# 将图片转换为灰度图像
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 对灰度图像进行二值化处理
ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# 对二值化图像进行膨胀操作
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
dilation = cv2.dilate(thresh, kernel, iterations=1)
# 在膨胀后的图像中查找轮廓
contours, hierarchy = cv2.findContours(dilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
# 遍历轮廓，找到身份证号码所在的矩形区域
for contour in contours:
x, y, w, h = cv2.boundingRect(contour)
if w > 100 and h > 20 and w < 200 and h < 50:
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
roi = gray[y:y + h, x:x + w]
text = pytesseract.image_to_string(roi, lang='chi_sim')
print('身份证号码为：', text)
# 显示识别结果
cv2.imshow('result', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans ce cas de code, nous lisons d'abord une image de carte d'identité, puis la convertissons en une image en niveaux de gris et effectuons des opérations de binarisation et d'expansion. Ensuite, utilisez la fonction findContours d'OpenCV pour rechercher les contours dans l'image et parcourez les contours pour trouver la zone rectangulaire où se trouve le numéro d'identification. Enfin, utilisez la bibliothèque pytesseract pour effectuer une reconnaissance de texte sur la zone rectangulaire où se trouve le numéro d'identification et afficher les résultats de la reconnaissance.
Il convient de noter que lors de l'utilisation de la bibliothèque pytesseract pour la reconnaissance de texte, le package linguistique correspondant doit être fourni. Dans ce cas, nous utilisons le package linguistique chi_sim, qui contient le modèle de reconnaissance du chinois simplifié. Si vous devez reconnaître du texte dans d'autres langues, vous devez utiliser le package linguistique correspondant.
15. Compression d'image : grâce à l'algorithme de compression d'image d'OpenCV, les images peuvent être compressées en tailles plus petites pour faciliter le stockage et la transmission.
Ce qui suit est un code de cas qui utilise l'algorithme de compression d'image d'OpenCV pour compresser une image dans une taille plus petite :
import cv2
# 读取原始图像
img = cv2.imread('test.jpg')
# 将图像压缩至指定尺寸
resized_img = cv2.resize(img, (640, 480), interpolation=cv2.INTER_AREA)
# 将压缩后的图像保存到本地
cv2.imwrite('compressed.jpg', resized_img)
Dans ce cas de code, nous utilisons d'abord la fonction imread d'OpenCV pour lire une image originale, puis utilisons la fonction cv2.resize pour compresser l'image à la taille spécifiée. Ici, nous compressons l'image à la taille de 640x480. Enfin, utilisez la fonction cv2.imwrite pour enregistrer l'image compressée localement.
Il convient de noter que lors de l'utilisation de la fonction cv2.resize pour la compression d'images, vous devez spécifier la méthode d'interpolation. Dans ce cas, nous utilisons la méthode d'interpolation INTER_AREA, qui convient au rétrécissement des images et peut réduire efficacement la distorsion de l'image. Si vous devez agrandir l'image, vous devez utiliser d'autres méthodes d'interpolation, telles que INTER_CUBIC ou INTER_LINEAR.
16. Amélioration de l'image : grâce à l'algorithme d'amélioration de l'image d'OpenCV, les images peuvent être améliorées, par exemple en augmentant le contraste, en ajustant la luminosité, etc.
Ce qui suit est un code de cas pour l'amélioration d'image à l'aide de l'algorithme d'amélioration d'image d'OpenCV :
import cv2
# 读取原始图像
img = cv2.imread('test.jpg')
# 增加对比度
alpha = 1.5 # 对比度增强系数
beta = 0 # 亮度调整系数
enhanced_img = cv2.convertScaleAbs(img, alpha=alpha, beta=beta)
# 调整亮度
gamma = 1.5 # 亮度增强系数
adjusted_img = cv2.addWeighted(enhanced_img, gamma, 0, 0, 0)
# 将增强后的图像保存到本地
cv2.imwrite('enhanced.jpg', adjusted_img)
Dans ce cas de code, nous utilisons d'abord la fonction imread d'OpenCV pour lire une image originale, puis utilisons la fonction cv2.convertScaleAbs pour augmenter le contraste. Le premier paramètre de cette fonction est l'image originale, le deuxième paramètre est le coefficient d'amélioration du contraste et le troisième paramètre est le coefficient de réglage de la luminosité. Ici, nous fixons le coefficient d'amélioration du contraste à 1,5 et le coefficient de réglage de la luminosité à 0.
Ensuite, nous utilisons la fonction cv2.addWeighted pour ajuster la luminosité. Le premier paramètre de cette fonction est l'image améliorée, le deuxième paramètre est le coefficient d'amélioration de la luminosité et le troisième paramètre est le coefficient de réglage de la luminosité. Ici, nous définissons le coefficient d'amélioration de la luminosité sur 1,5 et le coefficient de réglage de la luminosité sur 0.
Enfin, utilisez la fonction cv2.imwrite pour enregistrer l'image améliorée localement.
Il convient de noter que lors de l'utilisation de la fonction cv2.convertScaleAbs pour augmenter le contraste, si le coefficient d'amélioration du contraste est inférieur à 1, cela entraînera une distorsion de l'image. Lorsque vous utilisez la fonction cv2.addWeighted pour régler la luminosité, si le coefficient d'amélioration de la luminosité est inférieur à 1, l'image deviendra plus sombre. Par conséquent, lorsque vous utilisez ces fonctions, vous devez les ajuster en fonction des besoins réels.
17. Analyse d'image : à l'aide de l'algorithme d'analyse d'image d'OpenCV, les images peuvent être analysées, par exemple en comptant le nombre de pixels, en calculant la valeur moyenne de l'image, etc.
Ce qui suit est un code de cas pour analyser des images à l'aide de l'algorithme d'analyse d'images d'OpenCV :
import cv2
# 读取图像
img = cv2.imread('test.jpg')
# 统计像素数量
num_pixels = img.shape[0] * img.shape[1]
# 计算图像的平均值
mean_value = cv2.mean(img)
# 输出结果
print('像素数量：', num_pixels)
print('图像的平均值：', mean_value)
Dans ce cas de code, nous utilisons d'abord la fonction imread d'OpenCV pour lire une image. Ensuite, utilisez img.shape[0] * img.shape[1] pour calculer le nombre de pixels, img.shape[0] représente la hauteur de l'image et img.shape[1] représente la largeur de l'image. Ensuite, utilisez la fonction cv2.mean pour calculer la moyenne de l'image et enregistrez le résultat dans Mean_value. Enfin, utilisez la fonction d'impression pour afficher les résultats.
A noter que lors de l'utilisation de la fonction cv2.mean pour calculer la moyenne d'une image, un tuple contenant la moyenne de chaque canal est renvoyé. Si l'image est une image en niveaux de gris, il n'y a qu'un seul élément dans le tuple, représentant la moyenne des niveaux de gris de l'image. Si l'image est une image couleur, il y a trois éléments dans le tuple, représentant les valeurs moyennes des canaux bleu, vert et rouge de l'image.
Dans des applications pratiques, d'autres algorithmes d'analyse d'image peuvent être utilisés selon les besoins, comme le calcul de la variance de l'image, le calcul de l'histogramme de l'image, etc.
18. Comparaison d'images : grâce à l'algorithme de comparaison d'images d'OpenCV, plusieurs images peuvent être comparées, par exemple, pour détecter si le même objet existe dans l'image.
Ce qui suit est un code de cas pour comparer plusieurs images à l'aide de l'algorithme de comparaison d'images d'OpenCV :
import cv2
# 读取模板图像和待比对图像
template = cv2.imread('template.jpg')
image = cv2.imread('image.jpg')
# 将模板图像转换为灰度图像
template_gray = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
# 使用模板匹配算法进行比对
result = cv2.matchTemplate(image, template_gray, cv2.TM_CCOEFF_NORMED)
# 设置比对的阈值
threshold = 0.8
# 获取比对结果中大于阈值的位置
locations = cv2.findNonZero(result > threshold)
# 在待比对图像中标记出匹配的位置
for loc in locations:
x, y = loc[0]
cv2.rectangle(image, (x, y), (x + template.shape[1], y + template.shape[0]), (0, 0, 255), 2)
# 显示结果图像
cv2.imshow('result', image)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans ce cas de code, nous utilisons d'abord la fonction imread d'OpenCV pour lire une image modèle et une image à comparer. Ensuite, convertissez l'image modèle en image en niveaux de gris, utilisez la fonction matchTemplate pour la comparaison et obtenez le résultat de la comparaison. Ensuite, définissez le seuil de comparaison et utilisez la fonction findNonZero pour obtenir la position dans le résultat de la comparaison qui est supérieure au seuil. Enfin, marquez la position correspondante dans l'image à comparer et utilisez la fonction imshow pour afficher l'image résultante.
Il convient de noter que dans les applications pratiques, il est nécessaire de sélectionner un algorithme de comparaison et un seuil appropriés en fonction de la situation spécifique, et d'effectuer un post-traitement sur les résultats de la comparaison, par exemple en supprimant les positions correspondantes en double.
19. Conversion d'image : grâce à l'algorithme de conversion d'image d'OpenCV, les images peuvent être converties en différents espaces colorimétriques, par exemple de RVB à HSV.
Ce qui suit est un code de cas pour convertir une image de RVB en HSV à l'aide de l'algorithme de conversion d'image d'OpenCV :
import cv2
# 读取图像
image = cv2.imread('image.jpg')
# 将图像转换为HSV颜色空间
hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
# 显示结果图像
cv2.imshow('RGB Image', image)
cv2.imshow('HSV Image', hsv_image)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans ce cas de code, nous utilisons d'abord la fonction imread d'OpenCV pour lire une image. Ensuite, utilisez la fonction cvtColor pour convertir l'image de l'espace colorimétrique RVB en espace colorimétrique HSV. Enfin, utilisez la fonction imshow pour afficher les images originales et converties.
Il convient de noter que dans les applications réelles, il est nécessaire de sélectionner un espace colorimétrique approprié pour la conversion en fonction de la situation spécifique et d'effectuer un post-traitement sur l'image convertie, comme le réglage de la luminosité, du contraste, etc.
20. Effets spéciaux d'image : à l'aide de l'algorithme d'effets spéciaux d'image d'OpenCV, vous pouvez effectuer un traitement d'effets spéciaux sur les images, comme l'ajout de filtres, l'ajout de filigranes, etc.
Ce qui suit est un code de cas pour utiliser l'algorithme d'effets spéciaux d'image d'OpenCV pour effectuer un traitement d'effets spéciaux sur des images :
import cv2
# 读取图像
img = cv2.imread('image.jpg')
# 添加滤镜
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (5, 5), 0)
# 添加水印
cv2.putText(img, 'Watermark', (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
# 显示结果图像
cv2.imshow('Original Image', img)
cv2.imshow('Filtered Image', blurred)
cv2.waitKey(0)
cv2.destroyAllWindows()
Dans ce cas de code, nous utilisons d'abord la fonction imread d'OpenCV pour lire une image. Ensuite, utilisez la fonction cvtColor pour convertir l'image de l'espace colorimétrique BGR en une image en niveaux de gris. Ensuite, utilisez la fonction GaussianBlur pour ajouter un filtre gaussien afin d'obtenir l'effet de flou. Enfin, utilisez la fonction putText pour ajouter un filigrane à l'image.
Il convient de noter que dans les applications réelles, différents algorithmes d'effets spéciaux d'image peuvent être utilisés selon les besoins, tels que la détection des contours, l'égalisation d'histogramme, etc., pour obtenir différents effets spéciaux.