Traducteur | Zhu Xianzhong
Reviewer | Sun Shujuan
Étant donné que le langage de programmation Python fait face à plusieurs bibliothèques open source disponibles, il est donc facile de choisir le langage Python pour le développement de la détection de mouvement. Actuellement, la détection de mouvement a de nombreuses applications commerciales. Par exemple, il peut être utilisé pour surveiller des examens en ligne et à des fins de sécurité dans les magasins, les banques, etc.
Le langage de programmation Python est un langage open source doté de bibliothèques de support extrêmement riches. Aujourd'hui, un grand nombre d'applications ont été développées pour les utilisateurs basées sur ce langage et comptent un grand nombre d'utilisateurs. Pour cette raison, le langage Python connaît une croissance rapide sur le marché. Les avantages du langage Python sont nombreux, non seulement en raison de sa syntaxe simple et de la facilité de recherche des erreurs, mais également en raison de son processus de débogage très rapide, ce qui le rend plus convivial.
Pourquoi est-il recommandé d'apprendre Python ? Nous pouvons utiliser le schéma suivant pour expliquer simplement :
Python a été conçu en 1991 et développé par la Python Software Foundation. De nombreuses versions ont été publiées aujourd'hui. Parmi eux, Python2 et Python3 sont les plus connus. À l'heure actuelle, Python3 est largement utilisé et le nombre d'utilisateurs augmente également rapidement. Dans ce projet, nous utiliserons Python3 comme langage de développement.
Selon les principes de la physique, lorsqu'un objet est immobile et n'a pas de vitesse, il est considéré comme au repos et à l'inverse, lorsqu'un objet n'est pas complètement immobile et se déplace dans une certaine direction (que ce soit vers la gauche ou vers la gauche) ; à droite, avant ou arrière, ou Lorsqu'il y a un certain mouvement ou une certaine vitesse (vers le haut ou vers le bas), il est considéré comme en mouvement. Dans cet article, nous allons tenter de détecter le comportement des objets.
À l'heure actuelle, il existe déjà un grand nombre de mises en œuvre ou d'applications de détection de mouvement dans la vie réelle, ce qui prouve pleinement son énorme valeur applicative. Parmi elles, l'utilisation de webcams (que nous mettrons en œuvre dans cet article) comme agents de sécurité pour la surveillance des examens en ligne, etc. est l'application la plus courante.
Dans cet article, nous allons essayer d'implémenter un script. Avec ce script, nous utiliserons la webcam installée sur un ordinateur de bureau ou un ordinateur portable pour détecter le mouvement d'un objet. L'idée est que nous allons prendre deux images vidéo et essayer de trouver la différence entre elles. S’il y a une sorte de différence entre les deux images, alors il y a évidemment une sorte de mouvement de l’objet devant la caméra, ce qui fait la différence.
Avant de commencer à implémenter le code, examinons quelques modules ou bibliothèques que nous utiliserons dans le code pour faire fonctionner la webcam pour la détection de mouvement. Comme nous en avons discuté, ces bibliothèques open source jouent un rôle important dans la diffusion de la réputation de Python. Jetons un coup d'œil aux bibliothèques open source nécessaires dans l'exemple de projet de cet article :
Les deux bibliothèques ci-dessus OpenCV et Pandas sont des bibliothèques gratuites et open source purement basées sur Python. Nous les utiliserons. grâce à la version Python3 du langage Python, ils.
OpenCV est une bibliothèque open source très connue qui peut être utilisée avec de nombreux langages de programmation(tels que C++, Python, etc.) et est spécialement utilisée pour le traitement d'images et le développement de programmes vidéo. En intégrant des applications avec la bibliothèque open source Pandas ou la bibliothèque NumPy de Python, nous pouvons exploiter pleinement les fonctions d'OpenCV.
Pandas est une bibliothèque Python open source qui fournit de riches outils intégrés pour l'analyse des données ; elle a donc été largement utilisée dans les domaines de la science des données et de l'analyse des données ; Pandas fournit la structure de données sous forme de DataFrame, qui offre une prise en charge extrêmement pratique pour exploiter et stocker des données tabulaires dans une structure de données bidimensionnelle.
Aucun des deux modules ci-dessus n'est intégré à Python, nous devons les installer avant de les utiliser. En dehors de cela, nous utiliserons également deux autres modules dans notre projet.
Les deux modules sont intégrés à Python et n'ont pas besoin d'être installés à l'avenir. Ces modules sont utilisés pour gérer respectivement les fonctions liées à la date et à l'heure.
Jusqu'à présent, nous avons vu les bibliothèques que nous utiliserons dans le code. Ensuite, commençons par supposer qu'une vidéo est simplement une combinaison de plusieurs images fixes ou images, puis utilisons la combinaison de toutes ces images pour créer une vidéo.
Dans cette section, nous importerons d'abord toutes les bibliothèques comme Pandas et OpenCV. Ensuite, nous importons les fonctions time et DateTime depuis le module DateTime.
#导入Pandas库 import Pandas as panda # 导入OpenCV库 import cv2 #导入时间模块 import time #从datetime 模块导入datetime 函数 from datetime import datetime
Dans cette section, nous allons initialiser certaines variables et nous utiliserons ces variables plus loin dans le code. Tout d'abord, nous définissons l'état initial comme "Aucun", puis stockons le mouvement suivi via une autre variable motionTrackList.
此外，我们还定义了一个列表“motionTime”，用于存储发现运动的时间，并使用Panda的模块初始化数据帧列表。
# 对于初始帧，以变量initialState的形式将初始状态指定为None initialState = None # 帧中检测到任何运动时存储所有轨迹的列表 motionTrackList= [ None, None ] # 一个新的“时间”列表，用于存储检测到移动时的时间 motionTime = [] # 使用带有初始列和最终列的Panda库初始化数据帧变量“DataFrame” dataFrame = panda.DataFrame(columns = ["Initial", "Final"])
在本节中，我们将实现本文示例项目中最关键的运动检测步骤。下面，让我们分步骤进行解说：
# 使用cv2模块启动网络摄像头以捕获视频
video = cv2.VideoCapture(0)
# 使用无限循环从视频中捕获帧
while True:
# 使用read功能从视频中读取每个图像或帧
check, cur_frame = video.read()
#将'motion'变量定义为等于零的初始帧
var_motion = 0
# 从彩色图像创建灰色帧
gray_image = cv2.cvtColor(cur_frame, cv2.COLOR_BGR2GRAY)
# 从灰度图像中使用GaussianBlur函数找到变化部分
gray_frame = cv2.GaussianBlur(gray_image, (21, 21), 0)
# 在第一次迭代时进行条件检查
# 如果为None，则把grayFrame赋值给变量initalState
if initialState is None:
initialState = gray_frame
continue
# 计算静态（或初始）帧与我们创建的灰色帧之间的差异
differ_frame = cv2.absdiff(initialState, gray_frame)
# 静态或初始背景与当前灰色帧之间的变化将突出显示
thresh_frame = cv2.threshold(differ_frame, 30, 255, cv2.THRESH_BINARY)[1]
thresh_frame = cv2.dilate(thresh_frame, None, iterations = 2)
#对于帧中的移动对象，查找轮廓
cont,_ = cv2.findContours(thresh_frame.copy(),
cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
for cur in cont:
if cv2.contourArea(cur) < 10000:
continue
var_motion = 1
(cur_x, cur_y,cur_w, cur_h) = cv2.boundingRect(cur)
# 在移动对象周围创建一个绿色矩形
cv2.rectangle(cur_frame, (cur_x, cur_y), (cur_x + cur_w, cur_y + cur_h), (0, 255, 0), 3)
# 从帧中添加运动状态
motionTrackList.append(var_motion)
motionTrackList = motionTrackList[-2:]
# 添加运动的开始时间
if motionTrackList[-1] == 1 and motionTrackList[-2] == 0:
motionTime.append(datetime.now())
# 添加运动的结束时间
if motionTrackList[-1] == 0 and motionTrackList[-2] == 1:
motionTime.append(datetime.now())
# 在显示捕获图像的灰度级中
cv2.imshow("The image captured in the Gray Frame is shown below: ", gray_frame)
# 显示初始静态帧和当前帧之间的差异
cv2.imshow("Difference between theinital static frame and the current frame: ", differ_frame)
# 在框架屏幕上显示视频中的黑白图像
cv2.imshow("Threshold Frame created from the PC or Laptop Webcam is: ", thresh_frame)
#通过彩色框显示物体的轮廓
cv2.imshow("From the PC or Laptop webcam, this is one example of the Colour Frame:", cur_frame)
# 创建处于等待状态的键盘按键
wait_key = cv2.waitKey(1)
# 按下'm'键时，结束整个进程执行
if wait_key == ord('m'):
# 当屏幕上有东西移动时，将运动变量值添加到motiontime列表中
if var_motion == 1:
motionTime.append(datetime.now())
break
在结束循环体执行后，我们将从dataFrame和motionTime列表中添加数据到CSV文件中，最后关闭视频。这一部分代码的实现如下所示：
# 最后，我们在数据帧中添加运动时间
for a in range(0, len(motionTime), 2):
dataFrame = dataFrame.append({"Initial" : time[a], "Final" : motionTime[a + 1]}, ignore_index = True)
# 创建CSV文件记录下所有运动信息
dataFrame.to_csv("EachMovement.csv")
# 释放视频内存
video.release()
#现在，在openCV的帮助下关闭或销毁所有打开的窗口
cv2.destroyAllWindows()至此，我们已经成功地创建完所有代码。现在，让我们再次归纳一下整个过程。
首先，我们使用设备的网络摄像头捕捉视频，然后将输入视频的初始帧作为参考，并不时检查下一帧。如果发现与第一帧不同的帧，则说明存在运动。该信息将被标记在绿色矩形中。
现在，让我们把上面所有代码片断连接到一起，如下所示：
#导入Pandas库
import Pandas as panda
# 导入OpenCV库
import cv2
#导入时间模块
import time
#从datetime 模块导入datetime 函数
from datetime import datetime
# 对于初始帧，以变量initialState的形式将初始状态指定为None
initialState = None
# 帧中检测到任何运动时存储所有轨迹的列表
motionTrackList= [ None, None ]
# 一个新的“时间”列表，用于存储检测到移动时的时间
motionTime = []
# 使用带有初始列和最终列的Panda库初始化数据帧变量“DataFrame”
dataFrame = panda.DataFrame(columns = ["Initial", "Final"])
# 使用cv2模块启动网络摄像头以捕获视频
video = cv2.VideoCapture(0)
# 使用无限循环从视频中捕获帧
while True:
# 使用read功能从视频中读取每个图像或帧
check, cur_frame = video.read()
#将'motion'变量定义为等于零的初始帧
var_motion = 0
# 从彩色图像创建灰色帧
gray_image = cv2.cvtColor(cur_frame, cv2.COLOR_BGR2GRAY)
# 从灰度图像中使用GaussianBlur函数找到变化部分
gray_frame = cv2.GaussianBlur(gray_image, (21, 21), 0)
# 在第一次迭代时进行条件检查
# 如果为None，则把grayFrame赋值给变量initalState
if initialState is None:
initialState = gray_frame
continue
# 计算静态（或初始）帧与我们创建的灰色帧之间的差异
differ_frame = cv2.absdiff(initialState, gray_frame)
# 静态或初始背景与当前灰色帧之间的变化将突出显示
thresh_frame = cv2.threshold(differ_frame, 30, 255, cv2.THRESH_BINARY)[1]
thresh_frame = cv2.dilate(thresh_frame, None, iterations = 2)
#对于帧中的移动对象，查找轮廓
cont,_ = cv2.findContours(thresh_frame.copy(),
cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
for cur in cont:
if cv2.contourArea(cur) < 10000:
continue
var_motion = 1
(cur_x, cur_y,cur_w, cur_h) = cv2.boundingRect(cur)
# 在移动对象周围创建一个绿色矩形
cv2.rectangle(cur_frame, (cur_x, cur_y), (cur_x + cur_w, cur_y + cur_h), (0, 255, 0), 3)
# 从帧中添加运动状态
motionTrackList.append(var_motion)
motionTrackList = motionTrackList[-2:]
# 添加运动的开始时间
if motionTrackList[-1] == 1 and motionTrackList[-2] == 0:
motionTime.append(datetime.now())
# 添加运动的结束时间
if motionTrackList[-1] == 0 and motionTrackList[-2] == 1:
motionTime.append(datetime.now())
# 在显示捕获图像的灰度级中
cv2.imshow("The image captured in the Gray Frame is shown below: ", gray_frame)
# 显示初始静态帧和当前帧之间的差异
cv2.imshow("Difference between theinital static frame and the current frame: ", differ_frame)
# 在框架屏幕上显示视频中的黑白图像
cv2.imshow("Threshold Frame created from the PC or Laptop Webcam is: ", thresh_frame)
#通过彩色框显示物体的轮廓
cv2.imshow("From the PC or Laptop webcam, this is one example of the Colour Frame:", cur_frame)
# 创建处于等待状态的键盘按键
wait_key = cv2.waitKey(1)
# 借助'm'键结束我们系统的整个进行
if wait_key == ord('m'):
# 当屏幕上有物体运行时把运动变量值添加到列表motiontime中
if var_motion == 1:
motionTime.append(datetime.now())
break
# 最后，我们在数据帧中添加运动时间
for a in range(0, len(motionTime), 2):
dataFrame = dataFrame.append({"Initial" : time[a], "Final" : motionTime[a + 1]}, ignore_index = True)
# 记录下所有运行，并创建到一个CSV文件中
dataFrame.to_csv("EachMovement.csv")
# 释放视频内存
video.release()
#现在，在openCV的帮助下关闭或销毁所有打开的窗口
cv2.destroyAllWindows()运行上述代码后得到的结果与下面看到的结果类似。
从这个动画中，我们可以看到该男子在视频中的动作已经被跟踪。因此，可以相应地看到输出结果。
然而，在这段代码中，跟踪是在移动对象周围的矩形框的帮助下完成，类似于下面动画中所示的。这里要注意的一件有趣的事情是，这段视频是一个实际的安全摄像头的镜头，已经对其进行了检测处理。
最后来归纳一下。本文中所介绍的运动检测的主要思想是，每个视频只是许多静态图像（称为帧）的组合，我们是通过判断帧之间的差异来实现运行检测的。
朱先忠，51CTO社区编辑，51CTO专家博客、讲师，潍坊一所高校计算机教师，自由编程界老兵一枚。早期专注各种微软技术（编著成ASP.NET AJX、Cocos 2d-X相关三本技术图书），近十多年投身于开源世界（熟悉流行全栈Web开发技术），了解基于OneNet/AliOS+Arduino/ESP32/树莓派等物联网开发技术与Scala+Hadoop+Spark+Flink等大数据开发技术。
原文标题：How to Perform Motion Detection Using Python，作者：Vaishnavi Amira Yada
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
