LLM open-source ou OpenCV pour analyser des images ?

Un ami m'a demandé de l'aide pour compter les pièces de monnaie posées sur une table, à partir d'une photo. J'ai d'abord envoyé l'image à un modèle de vision open-source. Réponse : "Il y a 11 pièces." Il y en avait 13. J'ai reposé la question. "12 pièces."

Vingt lignes d'OpenCV plus tard, le script en trouvait 13, à chaque fois, en 15 millisecondes. Puis mon ami a demandé : "et ça fait combien en euros ?". Là, OpenCV ne savait plus rien faire, et le LLM a reconnu chaque pièce sans effort.

Cette anecdote résume le sujet. OpenCV et les LLM open-source ne sont pas deux versions du même outil. Ce sont deux façons opposées de traiter une image.

Deux outils qui ne jouent pas le même jeu

OpenCV (Open Source Computer Vision Library) est une bibliothèque C++ avec des bindings Python, née chez Intel en 2000. Elle fournit plus de 2 500 algorithmes de traitement d'image : filtres, détection de contours, transformations géométriques, suivi de mouvement, calibration de caméra. Elle exécute des opérations mathématiques précises sur des pixels. Elle ne "comprend" rien.

Un LLM multimodal open-source, ou VLM (Vision-Language Model), est un modèle de langage auquel on a greffé un encodeur d'images. Qwen2.5-VL, Llama 3.2 Vision, Gemma 3 ou LLaVA en sont des exemples. On lui donne une image et une question en texte, il répond en texte. Il raisonne sur le sens de la scène, mais il ne mesure rien.

Pour comprendre ce qui se passe sous le capot des deux côtés, la reconnaissance d'images par deep learning explique filtres de convolution et réseaux de neurones. OpenCV utilise des filtres écrits à la main, les réseaux les apprennent.

Installer les deux

pip install opencv-python numpy
 
# Côté LLM : Ollama, puis un modèle de vision
ollama pull qwen2.5vl:7b
pip install ollama

Un utilitaire commun pour interroger le modèle de vision, qu'on réutilisera dans chaque comparaison :

import ollama
 
def ask(image_path: str, question: str) -> str:
    response = ollama.chat(
        model="qwen2.5vl:7b",
        messages=[{"role": "user", "content": question, "images": [image_path]}],
        options={"temperature": 0},
    )
    return response["message"]["content"]

temperature: 0 réduit la variabilité des réponses. Ça ne la supprime pas totalement, et ça ne rend pas le modèle plus juste.

Tâche 1 : compter des objets

Revenons aux pièces. Avec OpenCV, la transformée de Hough détecte les cercles :

import cv2
 
img = cv2.imread("pieces.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = cv2.medianBlur(gray, 5)
 
circles = cv2.HoughCircles(
    gray, cv2.HOUGH_GRADIENT, dp=1.2, minDist=30,
    param1=100, param2=40, minRadius=15, maxRadius=80,
)
 
count = 0 if circles is None else circles.shape[1]
print(f"{count} pièces détectées")

Côté LLM :

from vlm import ask
 
print(ask("pieces.jpg", "Combien de pièces de monnaie vois-tu ? Réponds par un nombre."))

Le code OpenCV est plus long, et ses paramètres (minRadius, param2) dépendent de la photo : changez la distance de la caméra, il faut les réajuster. Mais une fois réglé, il est exact et reproductible.

Le LLM n'a besoin d'aucun réglage. Il se trompe pourtant régulièrement au-delà d'une dizaine d'objets. Les VLM sont connus pour être mauvais en comptage : ils perçoivent "beaucoup de pièces" plus qu'ils ne les dénombrent.

Avantage : OpenCV, dès que les conditions de prise de vue sont maîtrisées.

Tâche 2 : identifier ce qu'il y a sur l'image

Demandez à OpenCV ce que montre une photo de vacances. Il n'a pas de réponse. Il faudrait charger un réseau de classification via son module dnn, ce qui revient déjà à utiliser du deep learning.

from vlm import ask
 
print(ask("photo.jpg", "Décris cette scène en deux phrases. Quel est le lieu probable ?"))

Une terrasse de café avec des tables en métal et des parasols rouges, au bord d'une place pavée.
Le lieu ressemble à une ville du sud de l'Europe, probablement en Italie ou en Espagne.

Le modèle identifie les objets, l'ambiance, le contexte, et formule des hypothèses. Aucune bibliothèque classique ne fait ça.

Avantage : LLM, sans discussion.

Tâche 3 : lire un QR code ou un texte

OpenCV embarque un décodeur de QR codes fiable :

import cv2
 
img = cv2.imread("ticket.jpg")
data, points, _ = cv2.QRCodeDetector().detectAndDecode(img)
print(data or "Aucun QR code trouvé")

Un VLM ne sait pas décoder un QR code : il voit un motif noir et blanc, pas les données encodées. Il peut même en inventer le contenu.

Pour du texte imprimé, le rapport s'inverse. OpenCV seul ne lit pas de texte : il prépare l'image (binarisation, redressement) pour un moteur OCR comme Tesseract. Un VLM, lui, lit directement le texte et comprend sa structure. C'est ce qui en fait un bon dernier recours pour extraire le contenu de PDF avec une IA open-source.

Avantage : OpenCV pour les codes, LLM pour le texte en contexte.

Tâche 4 : mesurer et localiser

Un contrôle qualité veut savoir si une pièce usinée fait bien 42 mm de large. OpenCV extrait le contour et mesure :

import cv2
 
img = cv2.imread("piece.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
_, mask = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
 
contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
largest = max(contours, key=cv2.contourArea)
x, y, w, h = cv2.boundingRect(largest)
 
PX_PER_MM = 11.8  # obtenu par calibration avec un objet de référence
print(f"Largeur : {w / PX_PER_MM:.1f} mm")

Un VLM peut donner des coordonnées de boîtes, et Qwen2.5-VL le fait plutôt bien. Mais ses estimations restent approximatives, de l'ordre de quelques pixels à quelques dizaines. Pour une mesure industrielle, c'est inutilisable.

Avantage : OpenCV, nettement.

Tâche 5 : traiter un flux vidéo

Une webcam produit 30 images par seconde. OpenCV les traite sans broncher, même sur un ordinateur modeste :

import cv2
 
detector = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)
cap = cv2.VideoCapture(0)
 
while True:
    ok, frame = cap.read()
    if not ok:
        break
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    for (x, y, w, h) in detector.detectMultiScale(gray, 1.1, 5):
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
    cv2.imshow("webcam", frame)
    if cv2.waitKey(1) == ord("q"):
        break
 
cap.release()
cv2.destroyAllWindows()

Les cascades de Haar datent de 2001 et ratent les visages de profil. Le détecteur YuNet, intégré à OpenCV via cv2.FaceDetectorYN, est plus précis et reste temps réel.

Un VLM qui prend deux secondes par image ne peut pas suivre. On peut l'interroger ponctuellement, une image toutes les dix secondes, mais pas analyser le flux en continu.

Avantage : OpenCV. C'est aussi pour ça qu'il domine sur les caméras et capteurs embarqués, là où l'edge computing traite les données au plus près de leur source.

Tâche 6 : répondre à une question ouverte

"Est-ce que quelqu'un sur cette photo de chantier ne porte pas de casque ?" "Ce colis est-il abîmé ?" "Cette capture d'écran contient-elle un message d'erreur ?"

Avec OpenCV, chaque question est un projet : collecter des images, entraîner un détecteur, régler des seuils. Avec un VLM, c'est une ligne :

from vlm import ask
 
print(ask("chantier.jpg", "Une personne sur cette image ne porte-t-elle pas de casque ? Réponds oui ou non, puis explique."))

C'est l'argument le plus fort des LLM. Le coût de développement d'une nouvelle tâche tombe de plusieurs semaines à quelques minutes. Pour un prototype ou une tâche à faible volume, rien ne rivalise.

Avantage : LLM, à condition d'accepter des erreurs et de les surveiller.

Le bilan, tâche par tâche

La vraie réponse : les deux ensemble

En production, je n'oppose jamais les deux. OpenCV fait le travail rapide et mécanique, le LLM intervient sur la petite partie qui demande du jugement.

Le schéma classique : OpenCV détecte un événement, isole la zone utile, et seul ce recadrage part au modèle de vision.

import cv2
from vlm import ask
 
cap = cv2.VideoCapture("camera_entrepot.mp4")
bg = cv2.createBackgroundSubtractorMOG2()
 
while True:
    ok, frame = cap.read()
    if not ok:
        break
 
    # OpenCV : détecter le mouvement, en temps réel et à coût quasi nul
    mask = bg.apply(frame)
    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    big = [c for c in contours if cv2.contourArea(c) > 5000]
    if not big:
        continue
 
    # Recadrer la zone en mouvement
    x, y, w, h = cv2.boundingRect(max(big, key=cv2.contourArea))
    cv2.imwrite("zone.jpg", frame[y:y + h, x:x + w])
 
    # LLM : interpréter uniquement ce qui a bougé
    print(ask("zone.jpg", "Qu'est-ce qui se déplace ? Personne, véhicule, animal ou autre ?"))

Sur une heure de vidéo, OpenCV analyse les 108 000 images. Le LLM n'en voit que quelques dizaines. On obtient la compréhension du modèle sans payer son coût sur chaque image. En pratique, on ajoute un délai minimal entre deux appels pour éviter d'interroger le modèle à chaque image d'un même mouvement.

Le recadrage améliore aussi la précision du VLM : une zone de 300 pixels centrée sur l'objet donne de meilleures réponses qu'une image 4K où l'objet occupe un coin.

Ce découpage entre code déterministe et appel au modèle est un réflexe à prendre pour intégrer un LLM dans une application en général, pas seulement en vision.

OpenCV ou un LLM open-source ? La question est mal posée. OpenCV est un outil de mesure : rapide, exact, bête. Le LLM est un outil de compréhension : lent, approximatif, intelligent. Quand la tâche se décrit en pixels, en millimètres ou en images par seconde, prenez OpenCV. Quand elle se décrit en mots, prenez le modèle. Et dès que le système grandit, faites travailler OpenCV en premier et réservez le modèle aux images qui en valent la peine.