《博主简介》
小伙伴们好，我是阿旭。专注于人工智能、AIGC、python、计算机视觉相关分享研究。
✌更多学习资源，可关注公-仲-hao:【阿旭算法与机器学习】，共同学习交流~
👍感谢小伙伴们点赞、关注！
《------往期经典推荐------》
二、机器学习实战专栏【链接】，已更新31期，欢迎关注，持续更新中~~
三、深度学习【Pytorch】专栏【链接】
四、【Stable Diffusion绘画系列】专栏【链接】
五、YOLOv8改进专栏【链接】，持续更新中~~
六、YOLO性能对比专栏【链接】，持续更新中~
《------正文------》
基本功能演示
基于YOLOv8深度学习的危险区域人员闯入检测与报警系统【python源码+Pyqt5界面+数据集+训练代码】YOLOv8、ByteTrack、目标追踪、区域闯
摘要：
危险区域人员闯入检测与报警系统对于保障生命和财产安全具有重大意义。它能够在第一时间检测到人员进入危险区域的行为，并发出及时警告，从而防止潜在事故的发生。本文基于YOLOv8深度学习框架，通过10000张图片，训练了一个人的目标检测模型，可检测人员1个类别；然后结合ByteTrack多目标跟踪算法，实现了目标的追踪效果，最终可以通过自行绘制任意封闭区域实现对自定义区域内的目标统计，当区域内目标数量达到设定阈值时，进行报警提示。基于以上内容开发了一款带UI界面的危险区域人员闯入检测与报警系统，可用于实时检测场景中的行人检测追踪与任意区域内目标统计与报警。该系统是基于python与PyQT5开发的，支持视频以及摄像头进行危险区域人员闯入检测与报警系统。本文提供了完整的Python代码和使用教程，给感兴趣的小伙伴参考学习，完整的代码资源文件获取方式见文末。
文章目录
前言
危险区域人员闯入检测与报警系统对于保障生命和财产安全具有重大意义。它能够在第一时间检测到人员进入危险区域的行为，并发出及时警告，从而防止潜在事故的发生。凭借YOLOv8深度学习框架的精确检测能力，这种系统可以显著提升工作场所的安全管理水平，确保在危险区域工作的人员得到有效保护。
危险区域人员闯入检测与报警系统的
应用场景包括：
工业制造现场：在有危险机器和设备的生产线上，确保非授权人员不靠近或进入操作区域。
建筑工地：防止施工场地周边的人员意外进入高危区域，从而避免由施工活动引发的伤害。
电力设施：如变电站和高压电线路维护区域，防止未经授权人员误入，避免触电等严重事故。
化工厂：对于有毒、有害或易燃易爆物质存储的区域进行严格的人员监控，确保进入者都是经过培训的专业人员。
港口和机场：在特定的装卸或维修区域，防止无关人员进入，保证工作安全和流程顺畅。
实验室和研究机构：在涉及危险化学品和高精密仪器的环境中，防止未经授权的人员进入，保障实验安全。
公共基础设施：如水处理厂或垃圾处理设施，避免公众或非专业人员因误入危险区域而受伤。
总结来说，危险区域人员闯入检测与报警系统利用YOLOv8深度学习框架实现高精度的区域监控，对于防止意外事故和提高工作场所的安全管理水平有着重要意义。实时检测和警告功能可以及时预防潜在危险，有效保护人员和财产的安全。这一技术的应用覆盖了工业、能源、建筑、交通等众多领域，推动了安全管理的智能化和精细化，为构建更加安全的工作环境提供了强有力的支持。
博主通过搜集行人的相关数据图片，根据YOLOv8的目标检测计数训练了一个人员检测模型，并基于ByteTrack多目标追踪技术对检测出的人员进行追踪，最终可以自行绘制任意区域，当区域内目标数达到设定阈值时，进行报警提示。最终基于python与Pyqt5开发了一款界面简洁的危险区域人员闯入检测与报警系统，可支持视频以及摄像头检测。本文详细的介绍了此系统的核心功能以及所使用到的技术原理与制作流程。
软件初始界面如下图所示：
检测结果界面如下：
一、软件核心功能介绍及效果演示
软件主要功能
1. 支持视频与摄像头中的人员这1个类别的多目标检测追踪；
2. 可自行绘制任意封闭区域，实现封闭区域内的目标计数，；
3. 当画面中自定义区域内的目标数达到设定阈值(默认1)时，会在界面进行警告，同时会发出警报音进行提示；
4. 界面可实时显示区域内目标数目、画面中目标总数、检测帧率、检测时长等信息;
5. 可选择画面中是否显示追踪轨迹、显示检测框与显示检测标签。
注：本系统区域内目标统计是依据目标中心点是否在区域内为判断依据的。
界面参数设置说明
置信度阈值：也就是目标检测时的conf参数，只有检测出的目标置信度大于该值，结果才会显示；交并比阈值：也就是目标检测时的iou参数，只有目标检测框的交并比大于该值，结果才会显示；区域内目标数报警阈值：当自定义区域内的目标检测数量达到设置阈值时，才会提示报警。默认1，表示只要有一个目标进入设定区域就会报警；显示追踪轨迹：用于设置检测的视频中是否显示目标追踪轨迹，默认勾选：表示显示追踪轨迹，不勾选则不显示追踪轨迹；显示检测框：用于设置检测的视频中是否显示目标检测框，默认勾选：表示显示检测框，不勾选则不显示检测框；显示标签：用于设置检测的视频中是否显示目标标签，默认勾选：表示显示检测标签，不勾选则不显示检测标签；
显示追踪轨迹、显示检测框与显示标签选项的功能效果如下：
主要功能说明
（1）视频检测说明
1.点击打开视频图标，打开选择需要检测的视频，就会自动显示检测结果。再次点击该按钮，会关闭视频。
2.打开视频后，点击绘制区域，用鼠标左键在显示的界面上点击至少3个点，会标记所点击的点用于绘制封闭区域；
3.需要的区域点绘制完成后,点击绘制完成按钮，即可实现对视频中封闭区域内的目标个数进行统计。
4.当自定义区域内目标数达到设定阈值时，会在界面进行警告，同时会发出警报音进行提示；
注：此时界面中显示的检测时长：表示当前已经检测的视频时间长度【与检测速度有关】，不是现实中已经过去的时间
（2）摄像头检测说明
1.点击打开摄像头图标，可以打开摄像头，可以实时进行检测，再次点击该按钮，可关闭摄像头。
2.打开摄像头后，点击绘制区域，用鼠标左键在显示的界面上点击至少3个点，会标记所点击的点用于绘制封闭区域；
3.需要的区域点绘制完成后,点击绘制完成按钮，即可实现对视频中封闭区域内的目标个数进行统计。
4.当自定义区域内目标数达到设定阈值时，会在界面进行警告，同时会发出警报音进行提示；
注：此时界面中显示的检测时长：表示当前现实中已经过去的时间。
二、目标检测模型的训练、评估与推理
1.YOLOv8的基本原理
YOLOv8是一种前沿的深度学习技术，它基于先前YOLO版本在目标检测任务上的成功，进一步提升了性能和灵活性，在精度和速度方面都具有尖端性能。在之前YOLO 版本的基础上，YOLOv8 引入了新的功能和优化，使其成为广泛应用中各种物体检测任务的理想选择。主要的创新点包括一个新的骨干网络、一个新的 Ancher-Free 检测头和一个新的损失函数，可以在从 CPU 到 GPU 的各种硬件平台上运行。
YOLO各版本性能对比：
Yolov8主要创新点
Yolov8主要借鉴了Yolov5、Yolov6、YoloX等模型的设计优点，其本身创新点不多，偏重在工程实践上，具体创新如下：
- 提供了一个全新的SOTA模型（包括P5 640和P6 1280分辨率的目标检测网络和基于YOLACT的实例分割模型）。并且，基于缩放系数提供了N/S/M/L/X不同尺度的模型，以满足不同部署平台和应用场景的需求。
- Backbone：同样借鉴了CSP模块思想，不过将Yolov5中的C3模块替换成了C2f模块，实现了进一步轻量化，同时沿用Yolov5中的SPPF模块，并对不同尺度的模型进行精心微调，不再是无脑式一套参数用于所有模型，大幅提升了模型性能。
- Neck：继续使用PAN的思想，但是通过对比YOLOv5与YOLOv8的结构图可以看到，YOLOv8移除了1*1降采样层。
- Head部分相比YOLOv5改动较大，Yolov8换成了目前主流的解耦头结构(Decoupled-Head)，将分类和检测头分离，同时也从Anchor-Based换成了Anchor-Free。
- Loss计算：使用VFL Loss作为分类损失(实际训练中使用BCE Loss)；使用DFL Loss+CIOU Loss作为回归损失。
标签分配：Yolov8抛弃了以往的IoU分配或者单边比例的分配方式，而是采用Task-Aligned Assigner正负样本分配策略。
其主要网络结构如下：
2. 数据集准备与训练
通过网络上搜集关于行人的各类图片，并使用LabelImg标注工具对每张图片中的目标边框（Bounding Box）及类别进行标注。一共包含10000张图片，其中训练集包含8000张图片，验证集包含2000张图片，部分图像及标注如下图所示。
图片数据的存放格式如下，在项目目录中新建datasets目录，同时将检测的图片分为训练集与验证集放入Data目录下。
同时我们需要新建一个data.yaml文件，用于存储训练数据的路径及模型需要进行检测的类别。YOLOv8在进行模型训练时，会读取该文件的信息，用于进行模型的训练与验证。data.yaml的具体内容如下：
train: E:\MyCVProgram\PersonDetection\datasets\Data\images\train
val: E:\MyCVProgram\PersonDetection\datasets\Data\images\val
# number of classes
nc: 1
# class names
names: ['person']
注：train与val后面表示需要训练图片的路径，建议直接写自己文件的绝对路径。
数据准备完成后，通过调用train.py文件进行模型训练，epochs参数用于调整训练的轮数，batch参数用于调整训练的批次大小【根据内存大小调整，最小为1】，代码如下：
#coding:utf-8
from ultralytics import YOLO
import matplotlib
matplotlib.use('TkAgg')
if __name__ == '__main__':
# 模型配置文件路径
model_yaml_path = 'ultralytics/cfg/models/v8/yolov8.yaml'
# 加载模型配置文件
model = YOLO(model_yaml_path)
# 加载官方预训练模型
model.load('yolov8n.pt')
# 训练模型
print("开始训练模型...")
results = model.train(data='datasets/Data/data.yaml',
epochs=150,
batch=4)
3. 训练结果评估
在模型训练结束后，可以在runs/目录下找到训练过程及结果文件，如下所示：
在深度学习中，我们通常用损失函数下降的曲线来观察模型训练的情况。YOLOv8在训练时主要包含三个方面的损失：定位损失(box_loss)、分类损失(cls_loss)和动态特征损失（dfl_loss）。
各损失函数作用说明：
定位损失box_loss：预测框与标定框之间的误差（GIoU），越小定位得越准；
分类损失cls_loss：计算锚框与对应的标定分类是否正确，越小分类得越准；
动态特征损失（dfl_loss）：DFLLoss是一种用于回归预测框与目标框之间距离的损失函数。在计算损失时，目标框需要缩放到特征图尺度，即除以相应的stride，并与预测的边界框计算Ciou Loss，同时与预测的anchors中心点到各边的距离计算回归DFLLoss。这个过程是YOLOv8训练流程中的一部分，通过计算DFLLoss可以更准确地调整预测框的位置，提高目标检测的准确性。
本文训练结果如下：
我们通常用PR曲线来体现精确率和召回率的关系，本文训练结果的PR曲线如下。mAP表示Precision和Recall作为两轴作图后围成的面积，m表示平均，@后面的数表示判定iou为正负样本的阈值。mAP@.5：表示阈值大于0.5的平均mAP，可以看到本文模型两类目标检测的mAP@0.5平均值为0.934，结果还是非常不错的。
4. 使用模型进行检测
模型训练完成后，我们可以得到一个最佳的训练结果模型best.pt文件，在runs/trian/weights目录下。我们可以使用该文件进行后续的推理检测。
图片检测代码如下：
#coding:utf-8
from ultralytics import YOLO
import cv2
# 所需加载的模型目录
path = 'models/best.pt'
# 需要检测的图片地址
img_path = "TestFiles/s123.jpg"
# 加载预训练模型
model = YOLO(path, task='detect')
# 检测图片
results = model(img_path)
print(results)
res = results[0].plot()
# res = cv2.resize(res,dsize=None,fx=2,fy=2,interpolation=cv2.INTER_LINEAR)
cv2.imshow("YOLOv8 Detection", res)
cv2.waitKey(0)
执行上述代码后，会将检测的结果直接标注在图片上，结果如下：
三、使用ByteTrack进行目标追踪
ByteTrack算法简介
论文地址:https://arxiv.org/abs/2110.06864
源码地址:https://github.com/ifzhang/ByteTrack
ByteTrack算法是一种十分强大且高效的追踪算法，和其他非ReID的算法一样，仅仅使用目标追踪所得到的bbox进行追踪。追踪算法使用了卡尔曼滤波预测边界框，然后使用匈牙利算法进行目标和轨迹间的匹配。
ByteTrack算法的最大创新点就是对低分框的使用，作者认为低分框可能是对物体遮挡时产生的框，直接对低分框抛弃会影响性能，所以作者使用低分框对追踪算法进行了二次匹配，有效优化了追踪过程中因为遮挡造成换id的问题。
- 没有使用ReID特征计算外观相似度
- 非深度方法，不需要训练
- 利用高分框和低分框之间的区别和匹配，有效解决遮挡问题
ByteTrack与其他追踪算法的对比如下图所示，可以看到ByteTrack的性能还是相当不错的。
ByteTrack的实现代码如下：
class ByteTrack:
"""
Initialize the ByteTrack object.
Parameters:
track_thresh (float, optional): Detection confidence threshold
for track activation.
track_buffer (int, optional): Number of frames to buffer when a track is lost.
match_thresh (float, optional): Threshold for matching tracks with detections.
frame_rate (int, optional): The frame rate of the video.
"""
def __init__(
self,
track_thresh: float = 0.25,
track_buffer: int = 30,
match_thresh: float = 0.8,
frame_rate: int = 30,
):
self.track_thresh = track_thresh
self.match_thresh = match_thresh
self.frame_id = 0
self.det_thresh = self.track_thresh + 0.1
self.max_time_lost = int(frame_rate / 30.0 * track_buffer)
self.kalman_filter = KalmanFilter()
self.tracked_tracks: List[STrack] = []
self.lost_tracks: List[STrack] = []
self.removed_tracks: List[STrack] = []
def update_with_detections(self, detections: Detections) -> Detections:
"""
Updates the tracker with the provided detections and
returns the updated detection results.
Parameters:
detections: The new detections to update with.
Returns:
Detection: The updated detection results that now include tracking IDs.
"""
tracks = self.update_with_tensors(
tensors=detections2boxes(detections=detections)
)
detections = Detections.empty()
if len(tracks) > 0:
detections.xyxy = np.array(
[track.tlbr for track in tracks], dtype=np.float32
)
detections.class_id = np.array(
[int(t.class_ids) for t in tracks], dtype=int
)
detections.tracker_id = np.array(
[int(t.track_id) for t in tracks], dtype=int
)
detections.confidence = np.array(
[t.score for t in tracks], dtype=np.float32
)
else:
detections.tracker_id = np.array([], dtype=int)
return detections
def update_with_tensors(self, tensors: np.ndarray) -> List[STrack]:
"""
Updates the tracker with the provided tensors and returns the updated tracks.
Parameters:
tensors: The new tensors to update with.
Returns:
List[STrack]: Updated tracks.
"""
self.frame_id += 1
activated_starcks = []
refind_stracks = []
lost_stracks = []
removed_stracks = []
class_ids = tensors[:, 5]
scores = tensors[:, 4]
bboxes = tensors[:, :4]
remain_inds = scores > self.track_thresh
inds_low = scores > 0.1
inds_high = scores < self.track_thresh
inds_second = np.logical_and(inds_low, inds_high)
dets_second = bboxes[inds_second]
dets = bboxes[remain_inds]
scores_keep = scores[remain_inds]
scores_second = scores[inds_second]
class_ids_keep = class_ids[remain_inds]
class_ids_second = class_ids[inds_second]
if len(dets) > 0:
"""Detections"""
detections = [
STrack(STrack.tlbr_to_tlwh(tlbr), s, c)
for (tlbr, s, c) in zip(dets, scores_keep, class_ids_keep)
]
else:
detections = []
""" Add newly detected tracklets to tracked_stracks"""
unconfirmed = []
tracked_stracks = [] # type: list[STrack]
for track in self.tracked_tracks:
if not track.is_activated:
unconfirmed.append(track)
else:
tracked_stracks.append(track)
""" Step 2: First association, with high score detection boxes"""
strack_pool = joint_tracks(tracked_stracks, self.lost_tracks)
# Predict the current location with KF
STrack.multi_predict(strack_pool)
dists = matching.iou_distance(strack_pool, detections)
dists = matching.fuse_score(dists, detections)
matches, u_track, u_detection = matching.linear_assignment(
dists, thresh=self.match_thresh
)
for itracked, idet in matches:
track = strack_pool[itracked]
det = detections[idet]
if track.state == TrackState.Tracked:
track.update(detections[idet], self.frame_id)
activated_starcks.append(track)
else:
track.re_activate(det, self.frame_id, new_id=False)
refind_stracks.append(track)
""" Step 3: Second association, with low score detection boxes"""
# association the untrack to the low score detections
if len(dets_second) > 0:
"""Detections"""
detections_second = [
STrack(STrack.tlbr_to_tlwh(tlbr), s, c)
for (tlbr, s, c) in zip(dets_second, scores_second, class_ids_second)
]
else:
detections_second = []
r_tracked_stracks = [
strack_pool[i]
for i in u_track
if strack_pool[i].state == TrackState.Tracked
]
dists = matching.iou_distance(r_tracked_stracks, detections_second)
matches, u_track, u_detection_second = matching.linear_assignment(
dists, thresh=0.5
)
for itracked, idet in matches:
track = r_tracked_stracks[itracked]
det = detections_second[idet]
if track.state == TrackState.Tracked:
track.update(det, self.frame_id)
activated_starcks.append(track)
else:
track.re_activate(det, self.frame_id, new_id=False)
refind_stracks.append(track)
for it in u_track:
track = r_tracked_stracks[it]
if not track.state == TrackState.Lost:
track.mark_lost()
lost_stracks.append(track)
"""Deal with unconfirmed tracks, usually tracks with only one beginning frame"""
detections = [detections[i] for i in u_detection]
dists = matching.iou_distance(unconfirmed, detections)
dists = matching.fuse_score(dists, detections)
matches, u_unconfirmed, u_detection = matching.linear_assignment(
dists, thresh=0.7
)
for itracked, idet in matches:
unconfirmed[itracked].update(detections[idet], self.frame_id)
activated_starcks.append(unconfirmed[itracked])
for it in u_unconfirmed:
track = unconfirmed[it]
track.mark_removed()
removed_stracks.append(track)
""" Step 4: Init new stracks"""
for inew in u_detection:
track = detections[inew]
if track.score < self.det_thresh:
continue
track.activate(self.kalman_filter, self.frame_id)
activated_starcks.append(track)
""" Step 5: Update state"""
for track in self.lost_tracks:
if self.frame_id - track.end_frame > self.max_time_lost:
track.mark_removed()
removed_stracks.append(track)
self.tracked_tracks = [
t for t in self.tracked_tracks if t.state == TrackState.Tracked
]
self.tracked_tracks = joint_tracks(self.tracked_tracks, activated_starcks)
self.tracked_tracks = joint_tracks(self.tracked_tracks, refind_stracks)
self.lost_tracks = sub_tracks(self.lost_tracks, self.tracked_tracks)
self.lost_tracks.extend(lost_stracks)
self.lost_tracks = sub_tracks(self.lost_tracks, self.removed_tracks)
self.removed_tracks.extend(removed_stracks)
self.tracked_tracks, self.lost_tracks = remove_duplicate_tracks(
self.tracked_tracks, self.lost_tracks
)
output_stracks = [track for track in self.tracked_tracks if track.is_activated]
return output_stracks
使用方法
1.创建ByteTrack跟踪器
# 创建跟踪器
byte_tracker = sv.ByteTrack(track_thresh=0.25, track_buffer=30, match_thresh=0.8, frame_rate=30)
2.对YOLOv8的目标检测结果进行追踪
model = YOLO(path)
results = model(frame)[0]
detections = sv.Detections.from_ultralytics(results)
detections = byte_tracker.update_with_detections(detections)
3.显示追踪结果ID、检测框及标签信息
labels = [
f"id{tracker_id} {model.model.names[class_id]}"
for _, _, confidence, class_id, tracker_id
in detections
]
annotated_frame = frame.copy()
annotated_frame = box_annotator.annotate(
scene=annotated_frame,
detections=detections,
labels=labels)
最终检测效果如下：
四、判断目标是否在区域内
本文直接使用opencv提供的cv2.pointPolygonTest()函数进行判断点是否在多边形区域内。下面对该函数进行详细说明，并给出具体示例。
cv2.pointPolygonTest()函数使用说明
代码示例：
result = cv2.pointPolygonTest(contour, test_point, measureDist)
参数说明
contour参数：某一轮廓点的列表，如：polygon = np.array([[10, 10], [100, 10], [100, 100], [10, 100]], dtype=np.int32)；
test_point参数：像素点坐标(x,y)；
measureDist参数：如果measureDist为True则输出该像素点到轮廓最近距离。当measureDist设置为false时，若返回值为+1，表示点在轮廓内部，返回值为-1，表示在轮廓外部，返回值为0，表示在轮廓上。
如果我们需要判断一个点是在多边形的内部，只需要将measureDist参数设为False即可,当输出结果为正时，即可判断点在多边形的内部。示例代码如下：
result = cv2.pointPolygonTest(polygon, test_point, measureDist=False)
print(result)
# 判断结果
if result > 0:
print("点在多边形内部")
elif result == 0:
print("点在多边形边界上")
else:
print("点在多边形外部")
算法原理说明
多边形，随便定一个点，然后通过这个点水平划一条线，先数数看这条横线和多边形的边相交几次，（或者说先排除那些不相交的边，第一个判断条件），然后再数这条横线穿越多边形的次数是否为奇数，如果是奇数，那么该点在多边形内，如果是偶数，则在多边形外。如下图所示：
定义点与多边形并展示
定义用于绘制封闭区域的多边形顶点，示例代码如下：
# 定义多边形的顶点
polygon = np.array([[10, 10], [100, 10], [100, 100], [10, 100]], dtype=np.int32)
# 要判断的点
test_point = [50, 50]
画出多边形及点进行展示
import matplotlib.pyplot as plt
import matplotlib
matplotlib.use('TkAgg')
# 定义多边形的顶点
polygon = np.array([[10, 10], [100, 10], [100, 100], [10, 100]], dtype=np.int32)
# 要判断的点
test_point = [50, 50]
# 画出点与多边形并展示
# 创建一个新的图像
fig, ax = plt.subplots()
# 绘制多边形
ax.plot(polygon[:,0], polygon[:,1], 'r-', lw=2, label='Polygon')
ax.fill(polygon[:,0], polygon[:,1], 'r', alpha=0.3)
# 绘制点
ax.plot(test_point[0], test_point[1], 'go', markersize=10, label='Test Point')
# 添加标签和轴限制
ax.set_xlabel('X-axis')
ax.set_ylabel('Y-axis')
ax.legend()
ax.set_xlim(0, 110) # 设置x轴范围
ax.set_ylim(0, 110) # 设置y轴范围
# 显示图像
plt.show()
判断点是否在多边形内部
import cv2
import numpy as np
# 定义多边形的顶点
polygon = np.array([[10, 10], [100, 10], [100, 100], [10, 100]], dtype=np.int32)
# 要判断的点
test_point = [50, 50]
# 判断test_point点是否在多边形内部
# 使用pointPolygonTest函数
result = cv2.pointPolygonTest(polygon, test_point, measureDist=False)
print(result)
# 判断结果
if result > 0:
print("点在多边形内部")
elif result == 0:
print("点在多边形边界上")
else:
print("点在多边形外部")
打印结果如下：
通过上述方法统计区域内部的目标数目，当数目达到设定阈值时，界面就会警告同时会有报警音提示。
以上便是关于此款危险区域人员闯入检测与报警系统的原理与代码介绍。基于以上内容，博主用python与Pyqt5开发了一个带界面的软件系统，即文中第二部分的演示内容，能够很好的通过视频及摄像头进行检测追踪，以及自定义任意区域内目标统计与报警。
关于该系统涉及到的完整源码、UI界面代码、数据集、训练代码、环境配置说明文档等相关文件，均已打包上传，感兴趣的小伙伴可以通过下载链接自行获取。
【获取方式】
本文涉及到的完整全部程序文件：包括python源码、数据集、训练代码、UI界面源码、环境配置说明文档等（见下图），获取方式见文末：
注意：该代码基于Python3.9开发，运行界面的主程序为
MainProgram.py，其他测试脚本说明见上图。为确保程序顺利运行，请按照程序运行说明文档txt配置软件运行所需环境。
结束语
以上便是博主开发的危险区域人员闯入检测与报警系统的全部内容，由于博主能力有限，难免有疏漏之处，希望小伙伴能批评指正。
关于本篇文章大家有任何建议或意见，欢迎在评论区留言交流！
觉得不错的小伙伴，感谢点赞、关注加收藏哦！
353
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
