Bonjour, pour un projet scolaire de fin d'étude j'ai à réaliser un programme de détection de rond rouge ou vers avec la librairie opencv. Afin de rendre un projet aussi propre et fonctionnel que possible, j'utilise la syntaxe objet mais je me retrouve ici bloqué, je possède 3 fichiers python :
-Un main
-Un fichier contenant une classe DetectColor
-Un fichier contenant une classe Camera

L'objectif étant de lancé 2 instances de DetectColor ( pour le rouge et le vert ), et chaque instance doit accéder à la caméra et faire une copie de la matrice de cette dernière pour pouvoir la réutiliser afin de détecter la couleur.

Voici le main.py

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
import logging
from DetectGreen import DetectGreen
from camera import Camera
import sys
from time import sleep
import threading
LOGGER = logging.getLogger(__name__)
 
 
class Main(object):
 
    camera = Camera()
    detectred = DetectGreen(hLower=0, uLower=0, vLower=0,
                            hUpper=255, uUpper=255, vUpper=255)
 
    detectgreen = DetectGreen(hLower=154, uLower=66, vLower=250,
                              hUpper=179, uUpper=132, vUpper=255)
 
    logging.basicConfig(level=logging.DEBUG,
                        format="%(levelname)s %(asctime)s [%(process)d] %(name)s %(filename)s:%(lineno)d %(message)s",
                        )
 
    def __init__(self):
        """Initialize MyClassManager instance."""
        LOGGER.debug("Create instance of MyClassManager")
        super(Main, self).__init__()
        self._worker = None
        LOGGER.info("End of init...")
 
    camera.start()
    sleep(5)
    detectred.start()
    detectgreen.start()
Le Camera.py

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
import cv2
import numpy as np
import threading
from time import sleep
import logging
 
LOGGER = logging.getLogger(__name__)
 
 
class Camera(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.end = False
        self.ret = True
        self.frame = ["", ""]
 
    def run(self):
        self.instantiate()
        while not self.end:
            # Read image
            self.ret, self.frame = self.cam.read()
            cv2.imshow('frame', self.frame)
            if cv2.waitKey(1) & 0xFF == ord('q'):
                self.end = True
                LOGGER.info("Clean before finish working...")
 
    def afficher(self):
        print("Resultat methode affichage")
 
    def instantiate(self):
        self.cam = cv2.VideoCapture(0)
Le ColorGreen.py Je le renommerai en ColorDetect.py en fin de projet ( oui c'est mal )

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
import cv2
import numpy as np
import threading
from time import sleep
import logging
from camera import Camera
 
LOGGER = logging.getLogger(__name__)
 
 
class DetectGreen(threading.Thread):
    def __init__(self,
                 hLower, uLower, vLower,
                 hUpper, uUpper, vUpper):
        self._camera = Camera()
        threading.Thread.__init__(self)
        # self._stopper = threading.Event()
        LOGGER.info("Create thread DetectGreen")
        self._hLower = hLower
        self._hUpper = hUpper
        self._uLower = uLower
        self._uUpper = uUpper
        self._vLower = vLower
        self._vUpper = vUpper
 
    def run(self):
        mask = (0, 0, 0)
        end = False
        print("lancement")
        LOGGER.info("DetectGreen Start worker...")
        while not end:
            LOGGER.info("DetectGreen Working...")
            sleep(1)
            # Read image
            # cam = cv2.VideoCapture(0)
 
            while(1):
                if not self._camera.ret:
                    break
 
                canvas = self._camera.frame.copy()
                print("132")
                hsv = cv2.cvtColor(self._camera.frame, cv2.COLOR_BGR2HSV)
                lower = (self._hLower, self._uLower, self._vLower)  # 130,150,80
                upper = (self._hUpper, self._uUpper, self._vUpper)  # 250,250,120
                mask = cv2.inRange(hsv, lower, upper)
                mask = cv2.erode(mask, None, iterations=6)
                mask = cv2.dilate(mask, None, iterations=4)
                cv2.imshow('frame', self.frame)
                try:
                    # NB: using _ as the variable name for two of the outputs, as they're not used
                    _, contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
                    blob = max(contours, key=lambda el: cv2.contourArea(el))
                    M = cv2.moments(blob)
                    center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
 
                    cv2.circle(canvas, center, 10, (0, 0, 255), -1)
                except (ValueError, ZeroDivisionError):
                    pass

L'erreur actuelle c'est que je n'arrive pas a obtenir la matrice "frame" que j'ai "overwritten", j'ai essayé de résoudre le problème en utilisant un get mais j'obtiens la même chose, je n'ai pas réussi a construire un héritage ( c'est peut-être la solution ) Toutes les idées sont les bienvenues

Merci de votre aide.


Edit : Petite précision, j'utilise OpenCV 3.2 ce n'est pas très important mais je préfère le préciser.