Discussion :

[haku972]

Bonjour à tous, j'ai voulu faire du multithread, le début du thread se passe bien, puis en plein milieu arrêt brutal, je ne trouve pas pourquoi, sachant que hors thread le code s'exécute bien (je pense que c'est à cause de la boucle while, mais je n'arrive pas a comprendre pourquoi) pouvez vous m'aider s'il vous plait

ici c'est là où doit s'exécuter les différents thread :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
# -*-coding:Utf-8 -*
 
import os
from testcompte import *
from image_recognize import *
from os import system
import sys
import cv2
import threading
 
# Create one thread as follows
try:
    t1 = threading.Thread(target= compter_personne)
    t1.start()
 
except:
    print ("Error: unable to start thread")
 
 
print ("identité trouvé :")
print (identifie)
print ("nombre de connu :")
print (nbreidentite)
print ("nombre d'inconnu :")
print (compte)

ici c'est le code du thread qui pose problème:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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()

[tyrtamos]

Bonjour,

A mon avis, ce sont les instructions graphiques qui ne vont pas. Les bibliothèques graphiques sont rarement compatibles avec les threads.

Il est cependant possible dans ton cas que certains modules graphiques soient "thread-safe" et d'autres pas? A voir.

Le principe courant est qu'on fait les calculs longs par threads (ou en multiprocessing pour utiliser les CPU multicores), mais qu'on rapatrie leurs résultats dans le programme principal pour affichage graphique.

[haku972]

Vous me conseillez quoi ? Au départ je voulais que plusieurs programme aient certaines de leur variable disponible dans un seul programme sans passé par des sockets ...

[tyrtamos]

Bonjour,

Désolé, mais je ne connais pas les modules graphiques utilisés (opencv, imutils, ...) et je ne peux donc pas dire autre chose que:

Le principe courant est qu'on fait les calculs longs par threads (ou en multiprocessing pour utiliser les CPU multicores), mais qu'on rapatrie leurs résultats dans le programme principal pour affichage graphique.

Pour opencv, on arrive à trouver (avec difficulté), une petite phrase dans la doc => https://docs.opencv.org/master/d1/dfb/intro.html:

Multi-threading and Re-enterability

The current OpenCV implementation is fully re-enterable. That is, the same function or the same methods of different class instances can be called from different threads. Also, the same Mat can be used in different threads because the reference-counting operations use the architecture-specific atomic instructions.

Mais je n'en sais pas plus. Si personne ne peut aider, et s'il n'y a rien sur le web, il ne reste plus qu'à faire des tests sur un code d'essai spécifique jusqu'à ce que ça marche...

[haku972]

Ok je te remercie énormément, je vais mettre en séparé et utiliser des bases de données