Tutoriel Pytesseract : Extrais le texte de n'importe quelle image avec Python

Récupérer la position des mots, pas seulement le texte

Parfois, le texte ne suffit pas : tu veux savoir où chaque mot se trouve dans l'image, par exemple pour cliquer dessus ou pour associer un mot à une zone. image_to_data() renvoie la position de chaque élément détecté, avec son niveau de confiance :

import pytesseract

data = pytesseract.image_to_data(image, lang="fra", output_type=pytesseract.Output.DICT)

# Filtrer les mots réellement détectés (conf > 0) et leur niveau de confiance
for i, mot in enumerate(data["text"]):
    if mot.strip() and int(data["conf"][i]) > 60:
        x, y = data["left"][i], data["top"][i]
        print(f"{mot:20} -> position ({x}, {y}), confiance {data['conf'][i]}")

Le niveau de confiance (conf) te dit à quel point Tesseract est sûr de sa détection : au-dessus de 90, c'est quasi certain ; en dessous de 60, méfie-toi. C'est un excellent moyen de filtrer automatiquement les zones douteuses et de ne garder que le texte fiable.

OCR sur un PDF : convertir les pages en images

Tesseract ne lit pas les PDF directement, mais c'est un obstacle facile à contourner : on convertit chaque page du PDF en image, puis on applique l'OCR page par page. La bibliothèque pdf2image (qui s'appuie sur poppler) fait la conversion, et Pillow fournit les images.

from pdf2image import convert_from_path
import pytesseract

# Convertir chaque page du PDF en image
pages = convert_from_path("document.pdf", dpi=300)

tout_le_texte = []
for i, page in enumerate(pages):
    texte = pytesseract.image_to_string(page, lang="fra")
    tout_le_texte.append(f"--- Page {i + 1} ---\n{texte}")

resultat = "\n".join(tout_le_texte)
with open("document.txt", "w", encoding="utf-8") as f:
    f.write(resultat)

La résolution de conversion (dpi) est cruciale : 300 dpi est un bon compromis entre qualité de reconnaissance et taille des images. Installe les prérequis avec pip install pdf2image et, sur Linux, le paquet système poppler-utils.

Automatiser : traiter tout un dossier d'images

Maintenant qu'on a les briques, on assemble le tout dans un script qui traite toutes les images d'un dossier et écrit les résultats dans des fichiers texte. C'est le genre d'outil qui te fait gagner des heures sur un lot de documents scannés.

import os
import pytesseract
from PIL import Image, ImageOps

DOSSIER = "images"
SORTIE = "textes"
os.makedirs(SORTIE, exist_ok=True)

for nom in sorted(os.listdir(DOSSIER)):
    if not nom.lower().endswith((".png", ".jpg", ".jpeg")):
        continue

    chemin = os.path.join(DOSSIER, nom)
    image = Image.open(chemin)
    image = ImageOps.grayscale(image)
    image = ImageOps.autocontrast(image)

    texte = pytesseract.image_to_string(image, lang="fra")

    with open(os.path.join(SORTIE, nom + ".txt"), "w", encoding="utf-8") as f:
        f.write(texte)

    print(f"Traité : {nom}")

Ce script est volontairement simple : il prétraite chaque image en niveaux de gris avec un auto-contraste, avant de lancer l'OCR. Pour un lot de documents homogènes — par exemple les scans d'un même type de formulaire — il suffit amplement, et tu peux toujours enrichir le prétraitement si les résultats sont décevants.

Restreindre la reconnaissance avec une liste de caractères

Quand tu connais la nature exacte du texte à lire — par exemple des numéros de série, des codes postaux ou des plaques d'immatriculation — tu peux guider Tesseract en limitant les caractères autorisés. Cette option, nommée tessedit_char_whitelist, réduit drastiquement les confusions (un « 0 » pris pour un « O », un « 1 » pour un « l »).

# Ne reconnaître que des chiffres (pour une plaque, un code, un numéro)
config_digits = "--psm 7 -c tessedit_char_whitelist=0123456789"
texte = pytesseract.image_to_string(image, config=config_digits)
print(texte.strip())

Ici, on combine un PSM 7 (une seule ligne de texte) avec une liste blanche limitée aux chiffres. Le résultat est spectaculaire sur les cas où la structure est connue : Tesseract ne peut plus inventer des lettres là où il n'y a que des nombres. Adapte la liste blanche à ton cas — lettres majuscules, chiffres, tirets — et la précision grimpe immédiatement.

À l'inverse, il existe aussi une liste noire (tessedit_char_blacklist) pour exclure certains caractères problématiques. Les deux options se combinent bien avec les PSM qu'on a vus plus haut : c'est en assemblant ces petits réglages qu'on obtient un OCR vraiment fiable sur un format de document précis.

Les limites de l'OCR, et comment les contourner

Aussi bon soit Tesseract, il reste des cas où l'OCR échoue. Le reconnaître te fera gagner du temps :

• Les textes manuscrits : Tesseract est entraîné sur du texte imprimé, l'écriture manuscrite le met en échec.
• Les polices très décoratives ou les logos : l'algorithme a besoin de caractères réguliers.
• Les tableaux complexes : la structure se perd, même si les cellules sont lues.
• Les images à très faible résolution : en dessous d'un certain seuil, les caractères sont illisibles.

Pour les documents manuscrits, il existe des modèles spécialisés ou des services cloud. Pour les tableaux, des outils comme Camelot ou des modèles de détection d'objets s'en sortent mieux. Mais pour l'immense majorité des documents imprimés — factures, livres, articles scannés — la combinaison Tesseract + prétraitement donne des résultats remarquables.

Redresser une image inclinée (deskew)

Un document scanné de travers est une cause fréquente d'échec : Tesseract s'attend à des lignes de texte horizontales. OpenCV permet de détecter l'angle d'inclinaison et de redresser l'image automatiquement. La méthode classique consiste à repérer les lignes de texte par transformation de Hough, puis à faire pivoter l'image de l'angle moyen.

import cv2
import numpy as np

def redresser(image_path):
    img = cv2.imread(image_path)
    gris = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # Binarisation pour faire ressortir le texte
    _, binaire = cv2.threshold(gris, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)

    # On repère les lignes horizontales dans l'image
    lignes = cv2.HoughLinesP(binaire, 1, np.pi / 180, 100,
                             minLineLength=100, maxLineGap=10)

    angles = []
    for ligne in lignes:
        x1, y1, x2, y2 = ligne[0]
        angles.append(np.degrees(np.arctan2(y2 - y1, x2 - x1)))

    # L'angle médian est robuste face aux valeurs aberrantes
    angle = np.median(angles)

    # Rotation inverse pour remettre le texte à l'horizontale
    h, w = img.shape[:2]
    centre = (w // 2, h // 2)
    M = cv2.getRotationMatrix2D(centre, angle, 1.0)
    redressee = cv2.warpAffine(img, M, (w, h), borderValue=255)
    return redressee

image_redressee = redresser("scan_incline.png")
texte = pytesseract.image_to_string(image_redressee, lang="fra")

Ce script est plus avancé, mais il illustre une idée simple : détecter l'angle dominant des lignes, puis pivoter en sens inverse. Pour des scans légèrement inclinés, le gain de précision peut être spectaculaire.

Comparer avant et après prétraitement

Pour juger objectivement si ton prétraitement est utile, mesure la confiance moyenne de l'OCR avant et après. C'est une métrique simple et efficace pour itérer sur tes transformations :

def confiance_moyenne(image):
    data = pytesseract.image_to_data(image, lang="fra", output_type=pytesseract.Output.DICT)
    confs = [int(c) for c, t in zip(data["conf"], data["text"]) if t.strip()]
    return sum(confs) / len(confs) if confs else 0

brute = Image.open("document.png")
preparee = ImageOps.autocontrast(ImageOps.grayscale(brute))

print(f"Confiance image brute : {confiance_moyenne(brute):.1f}")
print(f"Confiance image préparée : {confiance_moyenne(preparee):.1f}")

Une confiance moyenne en hausse confirme que ton prétraitement aide réellement, au-delà de l'impression visuelle. C'est ce genre de mesure qui te permet de converger rapidement vers le bon pipeline, plutôt que d'ajuster les seuils au hasard.

Conclusion

Tu sais désormais installer Tesseract et Pytesseract, extraire du texte d'une image, choisir la langue, configurer le moteur, prétraiter l'image avec Pillow ou OpenCV pour améliorer la reconnaissance, récupérer la position des mots, traiter des PDF et automatiser le tout sur un dossier entier. C'est un outil puissant et gratuit, qui ouvre la porte à la numérisation de documents, à l'extraction de données de factures, ou au tri automatique de captures d'écran.

Le conseil à retenir : ne te bats jamais contre une mauvaise image avec un meilleur moteur. Améliore l'image d'abord — niveaux de gris, contraste, binarisation, seuillage adaptatif — et tu verras que 90 % des difficultés disparaissent avant même d'atteindre Tesseract.

Ce qu'il faut retenir

Avant de te lancer, voici l'essentiel de ce tutoriel en quelques points :

• Installe Tesseract d'abord, Pytesseract ensuite, et vérifie que la commande tesseract est accessible.
• Commence toujours par l'image brute : si le texte est net et bien éclairé, l'OCR suffit sans prétraitement.
• Prétraite avec niveaux de gris, contraste et binarisation dès que l'image est imparfaite.
• Choisis la bonne langue (fra) et, si besoin, le bon PSM pour ta mise en page.
• Mesure la confiance pour valider objectivement tes réglages.

Sources et ressources

• Le dépôt officiel de Tesseract
• La documentation de Pytesseract sur PyPI
• La documentation officielle de Tesseract
• pdf2image, pour convertir les PDF en images