Si vous avez besoin du code source, veuillez aimer et suivre la collection et laisser un message privé dans la zone de commentaire ~~~
OpenCV est non seulement capable de traiter des images, mais aussi de la vidéo. Une vidéo est construite à partir d'un grand nombre d'images, qui sont extraites de la vidéo à intervalles réguliers. De cette manière, le procédé de traitement d'image peut être utilisé pour traiter ces images, puis l'objectif de traitement vidéo peut être atteint. Pour traiter la vidéo, vous devez lire, afficher et enregistrer la vidéo et d'autres opérations connexes
1. Classe VideoCapture
La caméra fait référence à la vidéo lue à partir de la caméra en temps réel. Afin de lire et d'afficher la vidéo de la caméra, OpenCV fournit des méthodes associées de la classe VideoCapture. Ces méthodes incluent la méthode d'initialisation de la caméra et la méthode de vérification si l'initialisation De l'appareil photo La méthode de lecture des trames et la méthode d'arrêt de l'appareil photo, etc. sont expliquées tour à tour ci-dessous.
La classe VideoCapture fournit la méthode de construction VideoCapture, qui est utilisée pour terminer l'initialisation de la caméra. Le format de syntaxe est le suivant
capture=cv2.VideoCapture(index)
capture La caméra à ouvrir
index L'index de périphérique de la caméra
L'ordre du nombre de caméras et de leurs index de périphérique est déterminé par le système d'exploitation, car OpenCV ne fournit aucune méthode pour interroger le nombre de caméras et leurs index de périphérique.
Lorsque l'index est 0, cela signifie ouvrir la caméra intégrée, lorsque l'index est 1, cela signifie ouvrir la première caméra externe connectée à l'ordinateur
La méthode isOpened peut détecter si la caméra est ouverte avec succès
Une fois l'ouverture réussie, le cadre peut être lu à partir de la caméra
retval,image=cv2.VideoCapture.read()
retval s'il faut lire la trame
Le cadre lu par image peut être compris comme une image
Dans le manuel de documentation Opencv, il est particulièrement souligné que l'appareil photo doit être éteint lorsque l'appareil photo n'est pas nécessaire, et la méthode de libération est fournie à cet effet
2. Lire et afficher la vidéo de la caméra
Écrivez un programme ci-dessous pour ouvrir la caméra intégrée de l'ordinateur portable afin de lire et d'afficher la vidéo en temps réel. L'effet est le suivant
Pendant ce temps, si la barre d'espace est enfoncée, l'appareil photo s'éteindra
Une partie du code est la suivante
import cv2
capture = cv2(0) # 打开笔记本内置摄像头
while (capture.iened()): # 笔记本内置摄像头被打开后
retval, image = capture.read() # 从摄像头中实时读取视频
cv2.imshow("Video", image) # 在窗口中显示读取到的视频
key = cv2.waitK# 窗口的图像刷新时间为1毫秒
if key == 32: # 如果按下空格键
break
capture.release() # 关闭笔记本内置摄像头
cv2.destroyAllWindows() # 销毁显示摄像头视频的窗口
3. Convertissez la vidéo de la caméra de la vidéo couleur à la vidéo en niveaux de gris
La vidéo couleur qui est lue et affichée est convertie en une vidéo en niveaux de gris, et lorsque la barre d'espace est enfoncée, la caméra est éteinte
Une partie du code est la suivante
import cv2
capture = cv2.VideoCapture(0, cv2.CAP_DSHOW) # 打开笔记本内置摄像头
while (capture.()): # 笔记本内置摄像头被打开后
retval, image capture.read() # 从摄像头中实时读取视频
# 把彩色视频转灰度视频
image_Gray = cv2tColor(image,cv2.COLOR_BGR2GRAY)
if retval == True: # 读取到摄像头视频后
cv2.imshow("Video", image) # 在窗口中显示彩色视频
cv2.imshow("Video_Gray", image_Gray) # 在窗口中显示灰度视频
key = cv2.waitKey(1) # 窗口的图像刷新时间为1毫秒
if key == 32: # 如果按下空格键
break
capture.release() # 关闭笔记本内置摄像头
cv2.destroyAllWindows() # 销毁显示摄像头视频的窗口
4. Afficher et enregistrer l'image de la vidéo de la caméra à un certain moment
Lorsque vous appuyez sur la barre d'espace, fermez la caméra, enregistrez et affichez l'image dans la vidéo de la caméra à ce moment
Une partie du code est la suivante pour enregistrer le chemin peut être modifié par vous-même
import cv2
cap = cv2.VideoCapture(0, cv2.CAP_DSHOW) # 打开笔记本内置摄像头
while (cap.isOpened()): # 笔记本内置摄像头被打开后
ret, frame = cap.read() # 从摄像头中实时读取视频
cv2.imshow("Video", frame) # 在窗口中显示视频
k = cv2(1) # 图像的刷新时间为1毫秒
if k == 32: # 按下空格键
cap.release() # 关闭笔记本内置摄像头
cv2.destroyWindow("Video") # 销毁名为Video的窗口
cv2.imwte("D:/copy.png", frame) # 保存按下空格键时摄像头视频中的图像
cv2.ims'img', frame) # 显示按下空格键时摄像头视频中的图像
cv2.waitKey() # 刷新图像
break
cv2.destroyAllWindows() # 销毁显示图像的窗口
5. Lire et afficher 2 vidéos de caméra
Écrivez un programme ci-dessous. Lorsque la caméra intégrée du notebook est allumée pour lire et afficher la vidéo en temps réel, une caméra externe connectée au notebook est allumée. Lorsque la barre d'espace est enfoncée, les deux caméras sont détruites en même temps.
Une partie du code est la suivante
import cv2
cap_Inner = cv2.VideoCure(0, cv2.CAP_DSHOW) # 打开笔记本内置摄像头
cap_ter = cv2.VideoCare(1, cv2.CADSHOW) # 打开一个连接笔记本的外置摄像头
while (cap_Inner.isOpened() & cap_Outer.isOpened()): # 两个摄像头都被打开后
retval, img_Inner = cap_Inner.read() # 从笔记本内置摄像头中实时读取视频
ret, img_Outer = cap_Outer.read() # 从连接笔记本的外置摄像头中实时读取视频
# 在窗口中显示笔记本内置摄像头读取到的视频
cv2.imshow("Vi_Inner", img_Inner)
# 在窗口中显示连接笔记本的外置摄像头读取到的视频
cv2.imshow("Video_Outer", img_Outer)
key = cv2.waitKey(1) # 窗口的图像刷新时间为1毫秒
if key == 32: # 如果按下空格键
brea
cap_Inner.release() # 关闭笔记本内置摄像头
cap_Outerelease( # 关闭连接笔记本的外置摄像头
cv2.deroyAllWdows() # 销毁显示摄像头视频的窗口
Ce n'est pas facile à créer et à le trouver utile, veuillez aimer, suivre et collecter ~~~