1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
from pyimagesearch.centroidtracker import CentroidTracker
from pyimagesearch.trackableobject import TrackableObject
from imutils.video import VideoStream
from imutils.video import FPS
import numpy as np
import imutils
import time
import dlib
import cv2
def compter_personne():
x = float (0.4)
a = int (30)
# initialiser la liste des étiquettes de classe MobileNet SSD a été formé pour
# detect
CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat",
"bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
"dog", "horse", "motorbike", "person", "pottedplant", "sheep",
"sofa", "train", "tvmonitor"]
# charger notre modèle sérialisé à partir du disque
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe("mobilenet_ssd/MobileNetSSD_deploy.prototxt", "mobilenet_ssd/MobileNetSSD_deploy.caffemodel")
# si un chemin vidéo n'a pas été fourni, saisissez une référence à la webcam
#if not "videos/example_01.mp4":
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
time.sleep(2.0)
# initialiser les dimensions du cadre (nous les définirons dès que nous lirons
# la première image de la vidéo)
W = None
H = None
# instanciez notre tracker centroïde, puis initialisez une liste pour stocker
# chacun de nos traqueurs de corrélation dlib, suivi d'un dictionnaire pour
# mappez chaque ID d'objet unique à un objet TrackableObject
ct = CentroidTracker(maxDisappeared=40, maxDistance=50)
trackers = []
trackableObjects = {}
# initialiser le nombre total d'images traitées jusqu'à présent, le long de
# avec le nombre total d'objets qui se sont déplacés vers le haut ou vers le bas
totalFrames = 0
totalDown = 0
totalUp = 0
# Démarrer l'estimateur du débit en trames par seconde
fps = FPS().start()
# Boucle sur les images du flux vidéo
while True:
# prendre le cadre suivant et le manipuler si nous lisons à partir de l'un ou l'autre de ces éléments
frame = vs.read()
# redimensionner le cadre pour qu'il ait une largeur maximale de 500 pixels (l'option
# Moins on a de données, plus vite on peut les traiter), puis les convertir
# the frame from BGR to RGB for dlib
frame = imutils.resize(frame, width=500)
rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# si les dimensions du cadre sont vides, définissez-les
if W is None or H is None:
(H, W) = frame.shape[:2]
# initialiser l'état actuel ainsi que notre liste de délimitation
# rectangles de boîtes retournés par (1) notre détecteur d'objets ou (2) notre détecteur d'objets
# (2) les traqueurs de corrélation
status = "Waiting"
rects = []
# pour voir si on ne devrait pas faire un calcul plus coûteux.
# méthode de détection d'objet pour aider notre traqueur
if totalFrames % a == 0:
# paramétrer l'état et initialiser notre nouvel ensemble de traqueurs d'objets
status = "Detecting"
trackers = []
# convertir le cadre en blob et passer le blob à travers la balise
# réseau et obtenir les détections
blob = cv2.dnn.blobFromImage(frame, 0.007843, (W, H), 127.5)
net.setInput(blob)
detections = net.forward()
# boucle sur les détections
for i in np.arange(0, detections.shape[2]):
# extraire la confiance (c.-à-d. la probabilité) associée à l
# with the prediction
confidence = detections[0, 0, i, 2]
# filtrer les détections faibles en exigeant un minimum
# confidence
if confidence > x :
# extraire l'index de l'étiquette de la classe du fichier
# Liste des détections
idx = int(detections[0, 0, i, 1])
# si l'étiquette de la classe n'est pas une personne, ignorez-la
if CLASSES[idx] != "person":
continue
# calculer les coordonnées (x, y) de la boîte de délimitation
# for the object
box = detections[0, 0, i, 3:7] * np.array([W, H, W, H])
(startX, startY, endX, endY) = box.astype("int")
# construire un objet rectangle dlib à partir de la délimitation
# Coordonnées de la case et lancez la corrélation dlib
# tracker
tracker = dlib.correlation_tracker()
rect = dlib.rectangle(startX, startY, endX, endY)
tracker.start_track(rgb, rect)
# ajouter le tracker à notre liste de trackers pour que nous puissions
# l'utiliser pendant le saut d'images
trackers.append(tracker)
# sinon, nous devrions utiliser notre objet *trackers* au lieu de
# objet *détecteurs* pour obtenir un débit de traitement de trame plus élevé
else:
# boucle sur les traqueurs
for tracker in trackers:
# de paramétrer le statut de notre système pour qu'il soit en mode "*suivi*" plutôt qu'en mode
# que'attendre' ou'détecter'.
status = "Tracking"
# mettre à jour le tracker et récupérer la position mise à jour
tracker.update(rgb)
pos = tracker.get_position()
# déballer l'objet de position
startX = int(pos.left())
startY = int(pos.top())
endX = int(pos.right())
endY = int(pos.bottom())
# ajouter les coordonnées de la zone de délimitation à la liste des rectangles
rects.append((startX, startY, endX, endY))
# tracer une ligne horizontale au centre du cadre -- une fois qu'une ligne
# objet franchit cette ligne, nous déterminerons si elles ont été
# moving'up' or'down'' moving'up' or'down'
cv2.line(frame, (0, H // 2), (W, H // 2), (0, 255, 255), 2)
# utiliser le tracker centroïde pour associer l'ancien objet (1)
# Centroïdes avec (2) les centroïdes de l'objet nouvellement calculé
objects = ct.update(rects)
# boucle sur les objets suivis
for (objectID, centroid) in objects.items():
# vérifiez s'il existe un objet trackable pour l'objet courant
# ID d'objet
to = trackableObjects.get(objectID, None)
# s'il n'y a pas d'objet trackable existant, créez-en un
if to is None:
to = TrackableObject(objectID, centroid)
# sinon, il y a un objet traçable pour que nous puissions l'utiliser
# pour déterminer la direction
else:
# la différence entre la coordonnée y du *courant* et la coordonnée y du *courant*.
# centroïde et la moyenne des centroïdes *précédents* le dira
# nous dans quelle direction l'objet se déplace (négatif pour
#'up' et positif pour'down')
y = [c[1] for c in to.centroids]
direction = centroid[1] - np.mean(y)
to.centroids.append(centroid)
# vérifier si l'objet a été compté ou non
if not to.counted:
# si la direction est négative (indiquant l'objet)
# se déplace vers le haut) ET le centroïde est au-dessus du centre
# line, count the object
if direction < 0 and centroid[1] < H // 2:
totalUp += 1
to.counted = True
# si la direction est positive (indiquant l'objet)
# se déplace vers le bas) ET le centroïde est en dessous de la position
# center line, count the object
elif direction > 0 and centroid[1] > H // 2:
totalDown += 1
to.counted = True
# stocker l'objet traçable dans notre dictionnaire
trackableObjects[objectID] = to
# dessiner à la fois l'ID de l'objet et le centroïde de l'objet.
# objet sur la trame de sortie
text = "ID {}".format(objectID)
cv2.putText(frame, text, (centroid[0] - 10, centroid[1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0), -1)
# construire un tuple d'informations que nous allons afficher sur le site
# frame
info = [
("Up", totalUp),
("Down", totalDown),
("Status", status),
]
# bouclez les info tuples et dessinez-les sur notre cadre
for (i, (k, v)) in enumerate(info):
text = "{}: {}".format(k, v)
cv2.putText(frame, text, (10, H - ((i * 20) + 20)),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
# afficher la trame de sortie
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# incrémenter le nombre total d'images traitées jusqu'à présent et
# puis mettre à jour le compteur FPS
totalFrames += 1
fps.update()
# arrêter la minuterie et afficher les informations FPS
fps.stop()
print("[INFO] elapsed time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
# fermer toutes les fenêtres ouvertes
cv2.destroyAllWindows()
vs.stop() |
