Tutoriel OpenCV Python — Guide Complet

TUTORIEL OPENCV PYTHON

Guide Complet — Du Débutant à l'Expert
Vision par Ordinateur & Traitement d'Images

Version OpenCV 4.x (compatible 3.x)

Langage Python 3.7+
Niveau Débutant → Avancé
Chapitres 10 sections couvrant l'essentiel

Page
Tutoriel OpenCV Python — Guide Complet

1. Introduction à OpenCV
1.1 Qu'est-ce qu'OpenCV ?
OpenCV (Open Source Computer Vision Library) est une bibliothèque open-source dédiée à
la vision par ordinateur et au traitement d'images. Développée initialement par Intel en 1999,
elle est aujourd'hui maintenue par la communauté mondiale et compte plus de 2 500
algorithmes optimisés.

Domaines d'application
• Détection et reconnaissance de visages
• Traitement vidéo en temps réel
• Réalité augmentée
• Robotique et véhicules autonomes
• Contrôle qualité industriel
• Imagerie médicale

1.2 Installation
Installation standard
# Installation via pip
pip install opencv-python

# Avec les modules contribués (recommandé)

pip install opencv-contrib-python

# Vérification de l'installation
python -c "import cv2; print(cv2.__version__)"
💡 La version contrib inclut des algorithmes supplémentaires comme SIFT, SURF, les
trackers vidéo, etc.

1.3 Premier programme : Hello OpenCV

import cv2
import numpy as np

# Créer une image noire 400x400 en couleur (BGR)

img = [Link]((400, 400, 3), dtype=np.uint8)

# Ajouter du texte
[Link](img, 'Hello OpenCV!', (50, 200),
cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 255, 0), 3)

# Afficher l'image
[Link]('Ma premiere image', img)
[Link](0) # Attendre une touche
[Link]()

Page
Tutoriel OpenCV Python — Guide Complet

Page
Tutoriel OpenCV Python — Guide Complet

2. Manipulation des Images

2.1 Lire, afficher et sauvegarder
import cv2

# Lire une image

img = [Link]('[Link]') # BGR par defaut
img_gray = [Link]('[Link]', 0) # Niveaux de gris
img_rgba = [Link]('[Link]', -1) # Avec canal alpha

# Vérifier que l'image est chargée

if img is None:
print('Erreur : image non trouvee')
else:
print(f'Taille: {[Link]}') # (hauteur, largeur, canaux)
print(f'Type: {[Link]}') # uint8

# Afficher
[Link]('Image originale', img)
[Link](0)

# Sauvegarder
[Link]('[Link]', img)
[Link]('[Link]', img) # Sans compression

2.2 Propriétés et manipulation des pixels

import cv2
import numpy as np

img = [Link]('[Link]')

# Dimensions
hauteur, largeur, canaux = [Link]
print(f'Dimensions: {largeur} x {hauteur}, {canaux} canaux')

# Accéder à un pixel (ligne, colonne) → [B, G, R]

pixel = img[100, 200]
print(f'Pixel (100,200): B={pixel[0]}, G={pixel[1]}, R={pixel[2]}')

# Modifier un pixel
img[100, 200] = [255, 0, 0] # Bleu pur

# Extraire une région d'intérêt (ROI)

roi = img[50:150, 100:300] # [y1:y2, x1:x2]
[Link]('ROI', roi)
[Link](0)

2.3 Conversion de couleurs

import cv2

img = [Link]('[Link]')

Page
Tutoriel OpenCV Python — Guide Complet

# BGR → Niveaux de gris

gray = [Link](img, cv2.COLOR_BGR2GRAY)

# BGR → HSV (utile pour la détection de couleurs)

hsv = [Link](img, cv2.COLOR_BGR2HSV)

# BGR → RGB (pour Matplotlib)

rgb = [Link](img, cv2.COLOR_BGR2RGB)

# BGR → LAB
lab = [Link](img, cv2.COLOR_BGR2LAB)

# Afficher côte à côte

compare = [Link]([img, [Link](gray, cv2.COLOR_GRAY2BGR)])
[Link]('Original vs Gris', compare)
[Link](0)
💡 OpenCV utilise l'ordre BGR (pas RGB) pour les images couleur. Attention lors de
l'affichage avec Matplotlib !

2.4 Redimensionnement et transformations géométriques

import cv2

img = [Link]('[Link]')
h, w = [Link][:2]

# Redimensionner à une taille fixe

petit = [Link](img, (320, 240))

# Redimensionner par facteur

moitie = [Link](img, (w//2, h//2))
double = [Link](img, None, fx=2, fy=2,
interpolation=cv2.INTER_LINEAR)

# Rotation
centre = (w // 2, h // 2)
M = cv2.getRotationMatrix2D(centre, 45, 1.0) # 45 degrés, echelle 1
rotee = [Link](img, M, (w, h))

# Retournement
flip_h = [Link](img, 1) # Horizontal
flip_v = [Link](img, 0) # Vertical
flip_hv = [Link](img, -1) # Les deux

# Recadrage
crop = img[100:300, 50:250]

Page
Tutoriel OpenCV Python — Guide Complet

3. Dessin et Annotation
3.1 Formes géométriques
import cv2
import numpy as np

canvas = [Link]((500, 700, 3), dtype=np.uint8) * 255 # Fond blanc

# Ligne
[Link](canvas, (50, 50), (650, 50), (0, 0, 255), 3) # Rouge, ep=3

# Rectangle
[Link](canvas, (50, 80), (250, 200), (0, 255, 0), 2) # Vert,
bordure
[Link](canvas, (300, 80), (500, 200), (255, 0, 0), -1) # Bleu,
rempli

# Cercle
[Link](canvas, (150, 300), 80, (128, 0, 128), 3) # Violet,
bordure
[Link](canvas, (400, 300), 60, (0, 165, 255), -1) # Orange,
rempli

# Ellipse
[Link](canvas, (580, 150), (80, 40), 30, 0, 360, (0,255,255), 2)

# Polygone
pts = [Link]([[100, 400], [200, 350], [300, 420], [250, 480], [150,
480]])
[Link](canvas, [pts], True, (0, 0, 0), 2) # Ouvert → False
[Link](canvas, [pts + [Link]([300,0])], (200, 200, 0))

[Link]('Formes geometriques', canvas)

[Link](0)

3.2 Texte et annotations

import cv2
import numpy as np

img = [Link]((400, 700, 3), dtype=np.uint8) * 240

# Polices disponibles
polices = [
(cv2.FONT_HERSHEY_SIMPLEX, 'SIMPLEX'),
(cv2.FONT_HERSHEY_DUPLEX, 'DUPLEX'),
(cv2.FONT_HERSHEY_COMPLEX, 'COMPLEX'),
(cv2.FONT_HERSHEY_SCRIPT_SIMPLEX,'SCRIPT'),
(cv2.FONT_ITALIC, 'ITALIC'),
]

for i, (police, nom) in enumerate(polices):

[Link](img, f'Police: {nom}', (30, 60 + i*60),
police, 0.9, (20, 20, 150), 2)

Page
Tutoriel OpenCV Python — Guide Complet

# Mesurer la taille du texte

texte = 'Bonjour OpenCV'
(w_t, h_t), baseline = [Link](texte,
cv2.FONT_HERSHEY_SIMPLEX, 1, 2)
print(f'Taille texte: {w_t}x{h_t}, baseline: {baseline}')

[Link]('Texte', img)
[Link](0)

Page
Tutoriel OpenCV Python — Guide Complet

4. Traitement des Images

4.1 Opérations arithmétiques
import cv2
import numpy as np

img1 = [Link]('[Link]')
img2 = [Link]('[Link]')

# S'assurer que les images ont la même taille

img2 = [Link](img2, ([Link][1], [Link][0]))

# Addition (avec saturation à 255)

somme = [Link](img1, img2)

# Soustraction
diff = [Link](img1, img2)

# Fusion pondérée (fondu)

# alpha=0.7 pour img1, 0.3 pour img2
fusion = [Link](img1, 0.7, img2, 0.3, 0)

# Opérations bit à bit

masque = np.zeros_like(img1)
[Link](masque, (200, 200), 150, (255, 255, 255), -1)
result = cv2.bitwise_and(img1, masque)

[Link]('Fusion', fusion)
[Link](0)

4.2 Lissage et flou

import cv2
import numpy as np

img = [Link]('[Link]')

# Flou moyen (box filter)

flou_moyen = [Link](img, (5, 5))

# Flou gaussien (plus naturel)

flou_gauss = [Link](img, (15, 15), 0)

# Flou médian (excellent pour le bruit sel-et-poivre)

flou_median = [Link](img, 7)

# Flou bilatéral (préserve les contours)

flou_bilateral = [Link](img, 9, 75, 75)

# Comparaison
row1 = [Link]([img, flou_gauss])
row2 = [Link]([flou_median, flou_bilateral])
compare = [Link]([row1, row2])
compare = [Link](compare, None, fx=0.5, fy=0.5)
[Link]('Comparaison flous', compare)

Page
Tutoriel OpenCV Python — Guide Complet

[Link](0)

4.3 Seuillage (Thresholding)

import cv2
import numpy as np

img = [Link]('[Link]', 0) # Niveaux de gris

# Seuillage simple
_, thresh_bin = [Link](img, 127, 255, cv2.THRESH_BINARY)
_, thresh_bin_inv = [Link](img, 127, 255,
cv2.THRESH_BINARY_INV)
_, thresh_trunc = [Link](img, 127, 255, cv2.THRESH_TRUNC)
_, thresh_tozero = [Link](img, 127, 255, cv2.THRESH_TOZERO)

# Seuillage Otsu (automatique — recommandé !)

_, thresh_otsu = [Link](img, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
print(f'Seuil Otsu automatique: {_}')

# Seuillage adaptatif (gère les variations d'éclairage)

thresh_adapt_mean = [Link](
img, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)
thresh_adapt_gauss = [Link](
img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11,
2)

[Link]('Otsu', thresh_otsu)
[Link]('Adaptatif', thresh_adapt_gauss)
[Link](0)

Page
Tutoriel OpenCV Python — Guide Complet

5. Détection de Contours et Morphologie

5.1 Détection de bords
import cv2
import numpy as np

img = [Link]('[Link]')
gray = [Link](img, cv2.COLOR_BGR2GRAY)

# Détecteur de Canny (recommandé)

# Paramètres: image, seuil_bas, seuil_haut
canny = [Link](gray, 50, 150)

# Gradients de Sobel
sobelx = [Link](gray, cv2.CV_64F, 1, 0, ksize=3) # Gradient X
sobely = [Link](gray, cv2.CV_64F, 0, 1, ksize=3) # Gradient Y
sobel_mag = [Link](sobelx**2 + sobely**2).astype(np.uint8)

# Laplacien
laplacien = [Link](gray, cv2.CV_64F)
laplacien = [Link](laplacien).astype(np.uint8)

[Link]('Original', img)
[Link]('Canny', canny)
[Link]('Sobel', sobel_mag)
[Link](0)

5.2 Contours
import cv2
import numpy as np

img = [Link]('[Link]')
gray = [Link](img, cv2.COLOR_BGR2GRAY)
_, thresh = [Link](gray, 127, 255, cv2.THRESH_BINARY)

# Trouver les contours

contours, hierarchy = [Link](
thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

print(f'{len(contours)} contours trouves')

# Dessiner tous les contours

img_contours = [Link]()
[Link](img_contours, contours, -1, (0, 255, 0), 2)

# Analyser chaque contour

for i, cnt in enumerate(contours):
aire = [Link](cnt)
perimetre = [Link](cnt, True)
x, y, w, h = [Link](cnt) # Rectangle englobant
(cx, cy), rayon = [Link](cnt)

if aire > 500: # Ignorer les petits contours

# Approx polygonale

Page
Tutoriel OpenCV Python — Guide Complet

epsilon = 0.02 * perimetre

approx = [Link](cnt, epsilon, True)
nb_coins = len(approx)

# Déterminer la forme
if nb_coins == 3: forme = 'Triangle'
elif nb_coins == 4: forme = 'Rectangle'
elif nb_coins > 6: forme = 'Cercle'
else: forme = f'Polygone ({nb_coins})'

[Link](img_contours, forme, (x, y-10),

cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255,0,0), 2)

[Link]('Contours', img_contours)
[Link](0)

5.3 Morphologie
import cv2
import numpy as np

img = [Link]('[Link]', 0)
_, bin_img = [Link](img, 127, 255, cv2.THRESH_BINARY_INV)

# Elément structurant
kernel = [Link](cv2.MORPH_RECT, (5, 5))
kernel_ellipse = [Link](cv2.MORPH_ELLIPSE, (9, 9))

# Erosion (amincit les formes blanches)

erosion = [Link](bin_img, kernel, iterations=1)

# Dilatation (épaissit les formes blanches)

dilatation = [Link](bin_img, kernel, iterations=1)

# Ouverture = Erosion puis Dilatation (supprime le bruit)

ouverture = [Link](bin_img, cv2.MORPH_OPEN, kernel)

# Fermeture = Dilatation puis Erosion (comble les trous)

fermeture = [Link](bin_img, cv2.MORPH_CLOSE, kernel)

# Gradient morphologique (contours épais)

gradient = [Link](bin_img, cv2.MORPH_GRADIENT, kernel)

# Top-hat (détaille les petites structures claires)

tophat = [Link](img, cv2.MORPH_TOPHAT, kernel_ellipse)

Page
Tutoriel OpenCV Python — Guide Complet

6. Traitement Vidéo
6.1 Capture depuis webcam ou fichier
import cv2

# --- Webcam ---

cap = [Link](0) # 0 = première webcam

# Configurer la résolution
[Link](cv2.CAP_PROP_FRAME_WIDTH, 1280)
[Link](cv2.CAP_PROP_FRAME_HEIGHT, 720)
[Link](cv2.CAP_PROP_FPS, 30)

print(f'FPS: {[Link](cv2.CAP_PROP_FPS)}')

while True:
ret, frame = [Link]() # ret = succès de la lecture
if not ret:
print('Fin du flux')
break

# Traitement de la frame
gray = [Link](frame, cv2.COLOR_BGR2GRAY)

[Link]('Webcam', frame)
[Link]('Gris', gray)

# Quitter avec 'q'

if [Link](1) & 0xFF == ord('q'):
break

[Link]()
[Link]()

# --- Fichier video ---

cap_video = [Link]('video.mp4')
total_frames = int(cap_video.get(cv2.CAP_PROP_FRAME_COUNT))
print(f'Total frames: {total_frames}')

6.2 Enregistrement vidéo

import cv2

cap = [Link](0)

# Définir le codec et créer l'objet VideoWriter

fourcc = cv2.VideoWriter_fourcc(*'mp4v') # ou 'XVID', 'MJPG'
fps = 30.0
taille = (640, 480)

out = [Link]('enregistrement.mp4', fourcc, fps, taille)

while True:
ret, frame = [Link]()
if not ret: break

Page
Tutoriel OpenCV Python — Guide Complet

frame = [Link](frame, taille)

# Traitement optionnel
# frame = [Link](frame, 1) # Miroir

[Link](frame) # Écrire la frame

[Link]('Enregistrement', frame)

if [Link](1) & 0xFF == ord('q'):

break

[Link]()
[Link]()
[Link]()

Page
Tutoriel OpenCV Python — Guide Complet

7. Détection de Visages et d'Objets

7.1 Détection avec Haar Cascades
import cv2

# Charger le classificateur pré-entraîné

# Les fichiers XML sont dans opencv/data/haarcascades/
detecteur_visage = [Link](
[Link] + 'haarcascade_frontalface_default.xml')
detecteur_yeux = [Link](
[Link] + 'haarcascade_eye.xml')

img = [Link]('[Link]')
gray = [Link](img, cv2.COLOR_BGR2GRAY)

# Détecter les visages

# scaleFactor: facteur réduction pyramide (1.1 = 10% réduction à
chaque niveau)
# minNeighbors: nb de détections voisines requises (plus = moins de
faux positifs)
visages = detecteur_visage.detectMultiScale(
gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

print(f'{len(visages)} visage(s) détecté(s)')

for (x, y, w, h) in visages:

# Rectangle autour du visage
[Link](img, (x, y), (x+w, y+h), (0, 255, 0), 2)

# Détecter les yeux dans la zone du visage

roi_gray = gray[y:y+h, x:x+w]
roi_color = img[y:y+h, x:x+w]
yeux = detecteur_yeux.detectMultiScale(roi_gray, 1.1, 10)

for (ex, ey, ew, eh) in yeux:

[Link](roi_color, (ex+ew//2, ey+eh//2), ew//2, (255,0,0),
2)

[Link]('Détection visages', img)

[Link](0)

7.2 Détection de couleurs avec HSV

import cv2
import numpy as np

cap = [Link](0)

while True:
ret, frame = [Link]()
hsv = [Link](frame, cv2.COLOR_BGR2HSV)

# Plage HSV pour la couleur rouge

# Attention : le rouge est à deux extrémités du cercle HSV
bas_rouge1 = [Link]([0, 120, 70])

Page
Tutoriel OpenCV Python — Guide Complet

haut_rouge1 = [Link]([10, 255, 255])

bas_rouge2 = [Link]([170, 120, 70])
haut_rouge2 = [Link]([180, 255, 255])

masque1 = [Link](hsv, bas_rouge1, haut_rouge1)

masque2 = [Link](hsv, bas_rouge2, haut_rouge2)
masque_rouge = cv2.bitwise_or(masque1, masque2)

# Nettoyer le masque
kernel = [Link]((5, 5), np.uint8)
masque_rouge = [Link](masque_rouge, cv2.MORPH_OPEN,
kernel)

# Appliquer le masque
resultat = cv2.bitwise_and(frame, frame, mask=masque_rouge)

[Link]('Original', frame)
[Link]('Masque rouge', masque_rouge)
[Link]('Detection couleur', resultat)

if [Link](1) & 0xFF == ord('q'): break

[Link]()
[Link]()
💡 Plages HSV utiles: Vert [40-80, 50+, 50+], Bleu [100-140, 50+, 50+], Jaune [20-40,
50+, 50+]

Page
Tutoriel OpenCV Python — Guide Complet

8. Histogrammes et Correspondance
8.1 Calculer et afficher un histogramme
import cv2
import numpy as np
import [Link] as plt

img = [Link]('[Link]')

# Histogramme en niveaux de gris

gray = [Link](img, cv2.COLOR_BGR2GRAY)
hist_gray = [Link]([gray], [0], None, [256], [0, 256])

# Histogramme couleur (un par canal)

couleurs = ('b', 'g', 'r')
[Link](figsize=(10, 4))
for i, couleur in enumerate(couleurs):
hist = [Link]([img], [i], None, [256], [0, 256])
[Link](hist, color=couleur)
[Link]('Histogramme couleur')
[Link]('Valeur pixel')
[Link]('Frequence')
[Link]()

# Egalisation d'histogramme (améliore le contraste)

gray_eq = [Link](gray)

# CLAHE (Contrast Limited AHE — version locale, meilleure)

clahe = [Link](clipLimit=2.0, tileGridSize=(8, 8))
gray_clahe = [Link](gray)

[Link]('Original', gray)
[Link]('Egalisee', gray_eq)
[Link]('CLAHE', gray_clahe)
[Link](0)

Page
Tutoriel OpenCV Python — Guide Complet

9. Transformations Avancées
9.1 Transformation de perspective
import cv2
import numpy as np

img = [Link]('[Link]')
h, w = [Link][:2]

# Points source (coins du document dans l'image)

pts_src = np.float32([[120, 60], [680, 40], [700, 520], [100, 540]])

# Points destination (rectangle parfait)

pts_dst = np.float32([[0, 0], [600, 0], [600, 400], [0, 400]])

# Calculer la matrice de transformation

M = [Link](pts_src, pts_dst)

# Appliquer la transformation
resultat = [Link](img, M, (600, 400))

[Link]('Original (incline)', img)

[Link]('Corrige', resultat)
[Link](0)

9.2 Correspondance de templates (Template Matching)

import cv2
import numpy as np

img = [Link]('[Link]')
template = [Link]('[Link]')

h_t, w_t = [Link][:2]

# Méthodes disponibles:
# TM_CCOEFF_NORMED (recommandée), TM_CCORR_NORMED, TM_SQDIFF_NORMED
res = [Link](img, template, cv2.TM_CCOEFF_NORMED)

# Trouver la meilleure correspondance

min_val, max_val, min_loc, max_loc = [Link](res)
print(f'Confiance: {max_val:.3f}') # > 0.8 = bonne correspondance

if max_val > 0.7:

top_left = max_loc
bottom_right = (top_left[0] + w_t, top_left[1] + h_t)
[Link](img, top_left, bottom_right, (0, 255, 0), 3)
[Link](img, f'Match: {max_val:.2f}', (top_left[0],
top_left[1]-10),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)

[Link]('Resultat', img)
[Link](0)

Page
Tutoriel OpenCV Python — Guide Complet

Page
Tutoriel OpenCV Python — Guide Complet

10. Projet Complet : Détection de Mouvement

Ce projet complet combine plusieurs concepts : capture vidéo, soustraction de fond,
contours, et annotation. Il détecte les objets en mouvement devant une caméra.

import cv2
import numpy as np
from datetime import datetime

# ─── Configuration ───────────────────────────────────────

MIN_AIRE = 1000 # Taille minimale d'un objet détecté
SEUIL_DIFF = 25 # Sensibilité (plus bas = plus sensible)
FLOU_KERNEL = (21, 21) # Lissage pour réduire le bruit

cap = [Link](0)

# Image de référence (arrière-plan)

ref_frame = None

print('Démarrage... Appuyez sur R pour recalibrer, Q pour quitter')

while True:
ret, frame = [Link]()
if not ret: break

# Prétraitement
gray = [Link](frame, cv2.COLOR_BGR2GRAY)
gray = [Link](gray, FLOU_KERNEL, 0)

# Initialiser l'arrière-plan
if ref_frame is None:
ref_frame = [Link]()
continue

# Calculer la différence
delta = [Link](ref_frame, gray)
_, thresh = [Link](delta, SEUIL_DIFF, 255,
cv2.THRESH_BINARY)

# Nettoyage morphologique
kernel = [Link]((5, 5), np.uint8)
thresh = [Link](thresh, kernel, iterations=2)
thresh = [Link](thresh, kernel, iterations=1)

# Trouver les contours des zones de mouvement

contours, _ = [Link](
thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

mouvement_detecte = False

for cnt in contours:

if [Link](cnt) < MIN_AIRE:
continue

mouvement_detecte = True
x, y, w, h = [Link](cnt)
[Link](frame, (x, y), (x+w, y+h), (0, 255, 0), 2)

Page
Tutoriel OpenCV Python — Guide Complet

# Afficher statut
heure = [Link]().strftime('%H:%M:%S')
statut = 'MOUVEMENT !' if mouvement_detecte else 'Surveillance'
couleur_statut = (0, 0, 255) if mouvement_detecte else (0, 255,
0)

[Link](frame, f'{statut} {heure}', (10, 30),

cv2.FONT_HERSHEY_SIMPLEX, 0.8, couleur_statut, 2)
[Link](frame, 'R=Recalibrer | Q=Quitter', (10,
[Link][0]-10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (200, 200, 200), 1)

[Link]('Détecteur de mouvement', frame)

[Link]('Différence', thresh)

touche = [Link](30) & 0xFF

if touche == ord('q'):
break
elif touche == ord('r'):
ref_frame = [Link]() # Recalibrer l'arrière-plan
print('Arrière-plan recalibré')

[Link]()
[Link]()

Page
Tutoriel OpenCV Python — Guide Complet

Annexe : Référence Rapide

Fonctions essentielles

Fonction Description
[Link](path, flag) Lit une image depuis le disque
[Link](title, img) Affiche une image dans une fenêtre
[Link](path, img) Sauvegarde une image
[Link](img, code) Convertit l'espace de couleur
[Link](img, dsize) Redimensionne une image
[Link](img, k, s) Applique un flou gaussien
[Link](img, t, max, Seuillage d'image
t)
[Link](img, t1, t2) Détection de contours Canny
[Link](img, ...) Trouve les contours
[Link](img, ...) Dessine les contours
[Link](img, pt1, Dessine un rectangle
pt2, c)
[Link](img, ctr, r, c) Dessine un cercle
[Link](img, txt, Écrit du texte sur l'image
pt, ...)
[Link](src) Ouvre une source vidéo
[Link](...) Crée un fichier vidéo

Ressources utiles
• Documentation officielle : [Link]
• Tutoriels OpenCV : [Link]/4.x/d9/df8/tutorial_root.html
• PyImageSearch : [Link]
• Dépôt GitHub OpenCV : [Link]/opencv/opencv
• Forum : [Link]

Bon apprentissage avec OpenCV ! 🎉

Page