Auteur/autrice : christian

l’utilisation de camera USB ou de PIcamera avec Open CV peut necessiter de regler les parametres video tels que taille d’image, debit d’image , luminosité, contraste, saturation, etc ..

voyons avec un petit programme python comment faire ce type de reglage .

le programme ci dessous permet de regler les parametres classiques : luminosite , contraste, saturation, teinte d’une petite camera USB 640×480 ou d’une PIcam.

import cv2

cap1=cv2.VideoCapture(1) #sortie 1 Webcam USB
USBcamwin="USBcam"  # nom de la fenetre Webcam

while True:
    ret, frame1 = cap1.read()
    cap1.set(10,60) #luminosité
    cap1.set(11,60) #contraste
    cap1.set(12,60) #saturation
    cap1.set(13,60) #teinte
    cv2.imshow(USBcamwin, frame1)
    key=cv2.waitKey(1)
    if key & 0xFF == ord('q'):
        cv2.destroyAllWindows   
        break

la liste des parametres complets est disponible ici : flags video

la structure du paramètre est la suivante: cap1. set ( n° flag , valeur )

on trouve la liste des valeurs de flag dans le lien au dessus , les plus courants sont les suivants:

• 10 = luminosité
• 11 = contraste
• 12 = saturation
• 13 = teinte
• 14 = gain
• 20 = finesse
• 22 = gamma
• 30 = ISO

pour la valeur du parametre , il n’y a malheureusement pas de regle, elle depends de la camera utilisée , par exemple pour une PIcam :

• luminosité: de 0 a 100
• contrast de -100 a 100
• saturation de -100 a 100

en fonction de votre camera , il vous faudra donc faire soit une recherche sur le web soit tout simplement faire des essais .

et comme souvent , vous pourrez par exemple associer les valeurs a des parametres pilotés par des sliders ou des widgets TKinter au travers d’une fenetre de menu comme dans la vignette de cette page.

nous allons voir ici comment transformer , en temps réel, le flux vidéo en nuance de gris et en noir et blanc.

puis a partir de ces étapes préliminaires faire la détection de contour.

premier petit bout de programme Python, on récupère le flux vidéo d’une webcam USB et on l’affiche :

import cv2 
capture = cv2.VideoCapture(0) 
while (True):
    ret, frame = capture.read() 
    cv2.imshow('video original', frame)
    if cv2.waitKey(1) == 27:
        break 
capture.release()
cv2.destroyAllWindows()

la boucle « if + break  » permet d’arrêter l’affichage de la vidéo en appuyant sur la touche « Echap » du clavier ( code ascii 27). voici le résultat de ce bout de programme:

évolution du programme de base , on transforme le flux video RGB en nuance de gris et on affiche les 2 vidéos ensembles pour comparer le résultat:

import cv2  
capture = cv2.VideoCapture(0)

while True:  
    # extraction des images
    (ret, frame) = capture.read()     
    # conversion en nuance de gris
    grayFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    # affichage des 2 videos
    cv2.imshow('video original', frame)
    cv2.imshow('video grey', grayFrame)
    # fin du programme par appui de la touche Echap
    if cv2.waitKey(1) == 27:
        break
 
capture.release()
cv2.destroyAllWindows()

voila ce que ça donne:

variante suivante du deuxième programme , on récupère le flux vidéo de la webcam USB , on le transforme en nuance de gris et en noir et blanc binaire et on affiche les 3 vidéos ensembles pour comparer le résultat:

import cv2 
capture = cv2.VideoCapture(0)
 
while (True): 
    (ret, frame) = capture.read() 
    grayFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    # conversion en noir et blanc
    (thresh, blackAndWhiteFrame) = cv2.threshold(grayFrame, 127, 255, cv2.THRESH_BINARY)    
    cv2.imshow('video original', frame)
    cv2.imshow('video grey', grayFrame)
    cv2.imshow('video bw', blackAndWhiteFrame)
    if cv2.waitKey(1) == 27:
        break
 
capture.release()
cv2.destroyAllWindows()

copie d’écran du résultat avec les 3 flux vidéo affichés ensembles :

ensuite premier traitement du flux video , la recherche et le dessin du contour des objets tracé en rouge :

import cv2 
capture = cv2.VideoCapture(0)
 
while (True): 
    (ret, frame) = capture.read() 
    grayFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    # conversion en noir et blanc
    (thresh, blackAndWhiteFrame) = cv2.threshold(grayFrame, 127, 255, cv2.THRESH_BINARY)
    # recherche du controur
    contours = cv2.findContours(blackAndWhiteFrame, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) [-2]
    # dessin du contour en rouge
    for c in contours:
        cv2.drawContours(frame, [c], -1, (0,0,255), 2)        
    cv2.imshow('contour', frame)   
    if cv2.waitKey(1) == 27:
        break
 
capture.release()
cv2.destroyAllWindows()

copie d’ecran du resultat:

petite variante du traitement précédent , juste en remplaçant le 2 en fin de la ligne de commande « drawContour » par -2 on remplis le contour au lieu de dessiner le contour.

cv2.drawContours(frame, [c], -1, (0,0,255), 2) 
remplacé par:
cv2.drawContours(frame, [c], -1, (0,0,255), -2)

voici le programme modifié:

import cv2 
capture = cv2.VideoCapture(0)
 
while (True): 
    (ret, frame) = capture.read() 
    grayFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    # conversion en noir et blanc
    (thresh, blackAndWhiteFrame) = cv2.threshold(grayFrame, 127, 255, cv2.THRESH_BINARY)
    contours = cv2.findContours(blackAndWhiteFrame, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) [-2]
    for c in contours:
        cv2.drawContours(frame, [c], -1, (0,0,255), -2)        
    cv2.imshow('contour', frame)   
    if cv2.waitKey(1) == 27:
        break
 
capture.release()
cv2.destroyAllWindows()

et voici le resultat sur le flux video en temps réel

nous allons aborder ici les rudiments d’utilisation de la souris avec Open CV.

pour cela un programme tres basique qui illustre les évènements de la souris et les traitements associés.

en préliminaire , voici la liste des évènements souris reconnus par OPENCV:

voyons maintenant le programme

import cv2      #import de la librairie openCV
import numpy	#import de la librairie numpy (maths sur les matrices d'ordre N)
# les images sont traitées comme des matrices d'ordre 3 (X,Y,couleurRGB)
# x pixels en largeur + Y pixels en hauteur + 3 bits de couleurs (RGB) 

# fonction qui defini les reactions aux evenements souris
def click_event(event,x,y,flags,param):     
    if event == cv2.EVENT_RBUTTONDOWN:
        cv2.circle(img,(x,y),20,(0,255,0),3)
        strXY = str(x) + ',' + str(y)
        cv2.putText(img, strXY, (x+21,y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,0),1)
    elif event == cv2.EVENT_LBUTTONDOWN:
        cv2.rectangle(img,(x-20,y-20),(x+20,y+20),(255,0,0),3)
        strXY = str(x) + ',' + str(y)
        cv2.putText(img, strXY, (x+21,y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,0),1)
 
# creation d'un fond noir (img)dans une fenetre('image')et liaison de la fonction setmoussecallback
img = numpy.zeros((480,640,3), numpy.uint8)  
cv2.namedWindow('image')
cv2.setMouseCallback('image',click_event)

while(1):
    cv2.imshow('image',img)
    if cv2.waitKey(1) == 27:
        break
cv2.destroyAllWindows()

ce qui donne comme exemple de résultat un programme qui ouvre une fentre a fond noir et dessine un rectangle bleu ou un cercle vert a l’endroit de la souris suivant qu’on clique sur le bouton droit ou gauche de la souris. il affiche en plus a droite de la figure les coordonnées (X,Y ) de la position de souris dans l’image ( coordonnées en pixels).

prenons quelques instants pour détailler et comprendre ce qui se passes:

au milieu de lignes de codes on trouve les 3 lignes suivantes :

img = numpy.zeros((480,640,3), numpy.uint8)  
cv2.namedWindow('image')
cv2.setMouseCallback('image',click_event)

• la première ligne défini une variable tableau « img » a partir de la librairie numpy qui met a zéro (numpy.zeros) les valeurs de la matrices d’ordre 3 définissant en fait une image de 480pixels de hauteur, par 640 pixels de largeur et 3 valeurs de couleurs BGR pour chaque pixel . les valeurs sont codées sur 8bits via le code ‘numpy.uint8’ . comme les valeur BGR sont mises a zéro par la fonction numpy, cela fait une image en noir
• la deuxième ligne crée une fenêtre OpenCV dont le nom est ‘image’
• la troisieme ligne affecte les évènements de la souris à la fenêtre ‘Image’ et a la fonction ‘clik_event’

faisant appel a une fonction ‘click_event’, il faut définir celle ci , c’est l’objet des lignes suivantes:

def click_event(event,x,y,flags,param):     
    if event == cv2.EVENT_RBUTTONDOWN:
        cv2.circle(img,(x,y),20,(0,255,0),3)
        strXY = str(x) + ',' + str(y)
        cv2.putText(img, strXY, (x+21,y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,0),1)
    elif event == cv2.EVENT_LBUTTONDOWN:
        cv2.rectangle(img,(x-20,y-20),(x+20,y+20),(255,0,0),3)
        strXY = str(x) + ',' + str(y)
        cv2.putText(img, strXY, (x+21,y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,0),1)

la premiere boucle if correspondant au bouton droit enfoncé , elle dessine un cercle dans la fenetre ‘img’ , dont le centre est aux coordonnées x,Y retournées par la souris , d’un rayon de 20 pixels, de la couleur BGR (0,255,0) soit le Vert (G). puis retourne une variable string ‘strXY’ constituée des coordonnées XY du pointeur de souris avec une virgule au milieu. et affiche le texte dans la fenetre’img’ constitué de la variable ‘strXY’ , affichée aux coordonnées (x+21,Y) en ulisant la police de caracteres arial taille 0.5 en couleur (255,255,0) soit un bleu clair et d’epaisseur 1 .

la deuxieme boucle If fait la meme chose si le bouton Gauche est enfoncé et dessine un rectangle bleu cantré sur la position de la souris de largeur et hauteur identique (20 pixels) de couleur bleu foncé et affiche a droite les coordonnées XY.

la derniere partie du programme :

while(1):
    cv2.imshow('image',img)
    if cv2.waitKey(1) == 27:
        break
cv2.destroyAllWindows()

effectue une boucle permanente qui affiche l’image ‘img’ resultante de toutes les operations dans la fenetre ‘image’ puis teste l’appui de touche au clavier et termine le programme si ‘echap » est appuyée la dernier ligne de commande ferme la fenêtre du programme .

SimpleBlobDetector est un utilitaire d’OpenCV permettant la détection automatique des « Blobs ». en Anglais un Blob est une tache . cet utilitaire est donc intéressant pour la détection de formes basiques circulaires, elliptiques ou rectangulaire. il trouve son intérêt par exemple en astronomie pour la détection d’étoiles sur un ciel noir avec une camera.

pour illustrer , ses possibilités , commençons par un programme simple utilisant une camera USB et une feuille blanche avec quelques taches faites au marqueur noir.

import numpy as np
import cv2
cap = cv2.VideoCapture(0)

while (True):
    ret, frame = cap.read()
    # entrée des parametres de SimpleBlobDetector
    params = cv2.SimpleBlobDetector_Params()    
    params.minThreshold = 10;     # Change thresholds
    params.maxThreshold = 300; 
    params.filterByColor = False    # Filter by color.
    params.BlobColor = 0   # 0 for darkcolor & 255 for light colors   
    params.filterByArea = True    # Filter by Area.
    params.minArea = 200
    params.maxArea = 600    
    params.filterByCircularity = False   # Filter by Circularity
    params.minCircularity = 0.1
    params.maxCircularity = 1    
    params.filterByConvexity = False    # Filter by Convexity
    params.minConvexity = 0.87
    params.maxConvexity = 2    
    params.filterByInertia = False     # Filter by Inertia
    params.minInertiaRatio = 0.01
    params.maxInertiaRatio = 0.1
    # utilisation de SimpleBlobDetector
    detector = cv2.SimpleBlobDetector_create(params)
    keypoints = detector.detect(frame)
    im_with_keypoints = cv2.drawKeypoints(frame, keypoints, np.array([]), (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
    cv2.imshow('frame', im_with_keypoints)
    
    if cv2.waitKey(1) == 27:
        break

voici le resultat avec les parametres saisis.

toutes les taches faites au feutre ne sont pas entourées , c’est tout simplement le resultat de la definition des lignes de filtre ci dessous qui fixent la taille mini et maxi des zone de pixels a choisir ( entre 200 et 600 pixels):

 params.filterByArea = True    # Filter by Area.
    params.minArea = 200
    params.maxArea = 600    

on active les differents type de filtre en mettant la valeur a  » True » ( pour desactiver , il faut mettre « False« ) et en choisissant une valeur pour les 2 lignes de seuils mini et maxi.

pour illustrer la fonction de chaque filtre , ci dessous une petite image de synthese:

nous allons maintenant sur le meme principe , determiner les coordonnées d’une tache blanche sur une feuille sombre . voici le programme:

import numpy as np
import cv2
cap = cv2.VideoCapture(0)

while (True):
    ret, frame = cap.read()    
    params = cv2.SimpleBlobDetector_Params()    
    params.minThreshold = 10;     
    params.maxThreshold = 300;
    params.filterByColor = True   
    params.blobColor = 255  
    params.filterByArea = True   
    params.minArea = 100
    params.maxArea = 600 
    detector = cv2.SimpleBlobDetector_create(params)
    keypoints = detector.detect(frame)    
    im_with_keypoints = cv2.drawKeypoints(frame, keypoints, np.array([]), (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)    
    cv2.imshow('frame', im_with_keypoints)
    for kp in keypoints:
     print (int(kp.pt[0]), int(kp.pt[1]))
    
    if cv2.waitKey(1) == 27:
        break

l’evolution majeure par rapport au premier programme , est l’activation du mode couleur et la prise en compte de couleurs lumineuses ( ici la tache blanche sur fond sombre) dans les 2 lignes en rouge. et l’ajout d’une boucle imprimant les coordonnées (en pixel de l’image) dans les 2 lignes bleues. si on fait tourner ce programme dans thonny python , et que l’on fait bouger l’image ou la camera voici 2 exemples du resultat ( a gauche les coordonnées qui s’affichent dans la fenêtre shell de thonny python):

nous avons ici les bases d’un programme python pour de l’autoguidage sur une monture équatoriale astronomique… ne reste qu’a transformer ces coordonnées « pixels » en deplacements AD/DEC au fur et a mesure du déplacement de l’étoile de référence dans l’image ….

la detection de mouvement est une option interressante par exemple dans le cas de video surveillance , ci dessous un programme basique qui fait le boulot.

NOTA: derriere les caractères # des ligne en bleu qui peuvent remplacer la ligne juste avant pour des tests au choix soit sur un fichier video soit sur le livestream d’une camera. et également soit en dessinant des rectangles autour des objets en mouvement soit en dessinant le contour de l’objet.

import cv2
import numpy as np

cap = cv2.VideoCapture(0)
#cap = cv2.VideoCapture('OPENCVmotiondetection.avi')

ret, frame1 = cap.read()
ret, frame2 = cap.read()

while cap.isOpened():
    diff = cv2.absdiff(frame1, frame2)
    gray = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
    blur = cv2.GaussianBlur(gray, (5,5), 0)
    _, thresh = cv2.threshold(blur, 20, 255, cv2.THRESH_BINARY)
    dilated = cv2.dilate(thresh, None, iterations=3)
    _, contours, _ = cv2.findContours(dilated, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    for contour in contours:
        (x, y, w, h) = cv2.boundingRect(contour)
        if cv2.contourArea(contour) < 500:
            continue
        cv2.rectangle(frame1, (x, y), (x+w, y+h), (0, 255, 0), 2)
        #cv2.drawContours(frame1, contours, -1, (0, 255, 0), 2)
    cv2.imshow("feed", frame1)
    frame1 = frame2
    ret, frame2 = cap.read()
    if cv2.waitKey(40) == 27:
        break

cv2.destroyAllWindows()
cap.release()

une copie d’ecran du resultat sur une video AVI et avec dessin de rectangles englobants sur les objets en mouvement:

examinons maintenant , une variante du programme précédent utilisant des fonction elaborées de OpenCV ainsi que le principe des masques , qui permet de n’appliquer la detection que sur la partie droite de la video

NOTA: les ligne en bleu sont des variantes du programme par rapport a la ligne en dessous ( il faut remplacer l’une par l’autre).

import cv2
import numpy as np

#cap = cv2.VideoCapture(1)
cap = cv2.VideoCapture('OPENCVmotiondetection.avi')
object_detector = cv2.createBackgroundSubtractorMOG2(history=100, varThreshold=10)

while True:
    ret, frame = cap.read()    
    roi = frame[0:480 , 320:640]        # def Region Off Interest   
    mask = object_detector.apply(roi)   # definission d'un masque avec la ROI
    _, mask = cv2.threshold(mask, 254, 255, 0)   # ne garde que les pixel blancs
    _, contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    for cnt in contours:
        area = cv2.contourArea(cnt)
        if area > 100 :
            #cv2.drawContours(roi, [cnt], -1, (0, 255, 0), 2)  #dessin contour
            x, y, w, h =cv2.boundingRect(cnt)    # definition rectangle englobant
            cv2.rectangle(roi, (x, y), (x+w, y+h), (0, 255, 0), 3) #dessin rectangle
    
    cv2.imshow("Frame", frame)
    cv2.imshow("ROI", roi)
    cv2.imshow("Mask", mask)
    
    if cv2.waitKey(40) == 27:
        break

cv2.destroyAllWindows()
cap.release()

le resultat avec l’affichage , de la video de base, du ROI et du masque N&B