---
title: "Comment fonctionne Tesseract OCR, sur le web et en local"
description: "Comment Tesseract OCR transforme une image en texte et comment l'utiliser dans le navigateur ou en local, avec du code JavaScript, TypeScript, Node et PHP."
url: "https://arbabnaseer.com/fr/articles/comment-fonctionne-tesseract-ocr/"
lang: "fr"
author: "Arbab Naseer"
datePublished: "2026-10-22T00:00:00+05:00"
dateModified: "2026-10-22T00:00:00+05:00"
tags: "Tesseract, OCR, JavaScript, TypeScript, WebAssembly, PHP"
---

# Comment fonctionne Tesseract OCR, sur le web et en local

> Comment Tesseract OCR transforme une image en texte et comment l'utiliser dans le navigateur ou en local, avec du code JavaScript, TypeScript, Node et PHP.

Arbab Naseer · 2026-10-22 · https://arbabnaseer.com/fr/articles/comment-fonctionne-tesseract-ocr/

**Réponse courte :** Tesseract est un moteur OCR gratuit et open source. Il nettoie l'image, repère les lignes de texte, puis lit chaque ligne avec un réseau de neurones LSTM entraîné pour une langue donnée. Vous pouvez le lancer sur votre propre ordinateur (`tesseract image.png stdout`) ou directement dans une page web avec Tesseract.js, qui compile le moteur en WebAssembly : l'image ne quitte jamais l'appareil.

J'ai construit [QuickImageToText](https://arbabnaseer.com/fr/projets/quick-image-to-text-outil-ocr-en-ligne/), un [outil gratuit pour convertir une image en texte](https://quickimagetotext.com/fr/convertir-image-en-texte), sur la base de Tesseract.js. Ce guide explique comment fonctionne le moteur, comment l'utiliser en local et depuis du code (JavaScript, TypeScript, Node.js, PHP et Python), ainsi que les problèmes que j'ai rencontrés en production et les corrections qui ont marché.

## Qu'est-ce que Tesseract OCR ?

L'OCR (reconnaissance optique de caractères) désigne un logiciel qui analyse une image et renvoie le texte qu'il y trouve.

[Tesseract](https://github.com/tesseract-ocr/tesseract) est né chez Hewlett-Packard dans les années 1980 et 1990, est devenu open source en 2005, a été développé par Google pendant de nombreuses années et est aujourd'hui maintenu par sa communauté sur GitHub. Il est publié sous licence Apache 2.0, vous pouvez donc l'utiliser gratuitement dans des projets personnels comme commerciaux.

| Point | Détail |
|---|---|
| Licence | Apache 2.0 (gratuit pour un usage commercial) |
| Écrit en | C++ |
| Reconnaissance | Réseau de neurones LSTM depuis la version 4, plus l'ancien moteur "legacy" |
| Langues | Plus de 100 langues et écritures entraînées |
| Plateformes | Windows, macOS, Linux, et dans le navigateur grâce à WebAssembly (Tesseract.js) |
| Entrée | PNG, JPG, TIFF, BMP, GIF, WebP et d'autres (via Leptonica) |
| Sortie | Texte brut, hOCR, TSV, ALTO XML, PDF avec texte cherchable |

## Comment Tesseract lit le texte, étape par étape

Tesseract ne regarde pas une image comme vous le faites. Il fait passer l'image par cinq étapes et renvoie du texte accompagné d'un score de confiance.

### 1. Prétraitement (binarisation)

Tesseract convertit l'image en noir et blanc avec un seuillage d'Otsu. Chaque pixel devient soit de "l'encre", soit du "papier". C'est pour ça que les ombres, les fonds colorés et le manque de contraste dégradent les résultats : quand la séparation se passe mal, les lettres se cassent ou se collent entre elles.

### 2. Analyse de la mise en page (segmentation de la page)

Ensuite, il cherche où se trouve le texte : colonnes, paragraphes, blocs de texte, et images à ignorer. Vous pouvez indiquer à Tesseract à quoi s'attendre avec le mode de segmentation de page (PSM), par exemple "un seul bloc de texte" ou "une seule ligne". Un mauvais PSM est une cause très fréquente de résultats ratés, c'est pourquoi il a [sa propre section plus bas](#les-modes-de-segmentation-de-page-psm-expliqués).

### 3. Repérage des lignes et des mots

Dans chaque bloc, il trouve la ligne de base de chaque ligne de texte, même quand elle est légèrement courbée ou penchée, puis découpe les lignes en mots.

### 4. Reconnaissance avec un réseau de neurones LSTM

Depuis Tesseract 4, chaque ligne de texte passe par un réseau LSTM (long short-term memory). Au lieu de reconnaître une lettre isolée après l'autre, il lit toute la ligne comme une séquence, de gauche à droite (ou de droite à gauche pour l'arabe et l'ourdou), ce qui lui permet d'utiliser les caractères voisins comme contexte. C'est la principale raison pour laquelle le Tesseract moderne fait bien mieux que les anciens OCR.

Tout ce que le réseau sait tient dans un fichier `.traineddata` par langue : `eng.traineddata`, `fra.traineddata`, `jpn.traineddata`, etc. Pas de traineddata, pas de reconnaissance. Le fichier du modèle, c'est la prise en charge de la langue.

### 5. Modèle de langue et sortie

Les listes de mots et les statistiques de caractères contenues dans le traineddata aident à trancher entre des formes proches, comme `rn` et `m`, ou `0` et `O`. Le résultat, c'est du texte plus un score de confiance de 0 à 100 pour la page, pour chaque ligne et pour chaque mot. Un score faible veut généralement dire que l'image est trop floue ou que la mauvaise langue a été choisie.

### OSD : détection de l'orientation et de l'écriture

Tesseract fournit aussi un petit modèle spécial appelé `osd`. Il ne lit pas le texte. Il répond à deux questions : l'image est-elle tournée de 90, 180 ou 270 degrés, et de quel système d'écriture s'agit-il (latin, cyrillique, arabe, han, devanagari) ? QuickImageToText s'en sert pour son mode de langue Auto.

## Tesseract vs Tesseract.js : sur l'appareil ou dans le navigateur

Il existe deux façons courantes de faire tourner Tesseract.

| | Tesseract (natif) | Tesseract.js |
|---|---|---|
| Ce que c'est | Le programme C++ d'origine | Tesseract compilé en WebAssembly, avec une API JavaScript |
| Où il tourne | Votre ordinateur ou votre serveur (CLI ou bibliothèque) | N'importe quel navigateur moderne, et Node.js |
| Installation | `brew`, `apt` ou l'installeur Windows | `npm install tesseract.js` ou une balise `<script>` |
| Vitesse | Le plus rapide | Un peu plus lent, suffisant pour des images classiques |
| Confidentialité | Les fichiers restent sur votre machine | Les fichiers restent dans le navigateur du visiteur |
| Fonctionne hors ligne | Oui | Oui, une fois le moteur et les modèles en cache, si l'application est conçue pour |
| Idéal pour | Traitements par lots, scripts, serveurs | Sites web, applications web, extensions de navigateur |

### Comment Tesseract.js tourne dans un navigateur

1. Le moteur C++ est compilé en fichier `.wasm` avec Emscripten. Les navigateurs exécutent le WebAssembly à une vitesse proche du natif. Il existe des builds avec et sans SIMD, et [Tesseract.js](https://github.com/naptha/tesseract.js) choisit celle que votre navigateur prend en charge.
2. L'OCR tourne dans un Web Worker, un thread en arrière-plan, donc la page ne se fige pas pendant le traitement.
3. Le fichier traineddata de la langue choisie est téléchargé (en général compressé en gzip) puis stocké dans l'IndexedDB du navigateur, pour ne pas être retéléchargé à la prochaine exécution.
4. Votre image (un `File`, un `Blob`, un `<canvas>`, une `<img>` ou une URL) est transmise au worker, reconnue, et le texte revient à la page.

L'image n'a jamais besoin de quitter l'appareil. C'est la raison principale pour laquelle je l'ai choisi pour QuickImageToText : pas d'envoi, pas de stockage et aucun coût serveur par image.

## Comment QuickImageToText utilise Tesseract

QuickImageToText est construit en PHP simple, en JavaScript vanilla et avec Tesseract.js 5.1.1. Toute l'OCR se fait dans le navigateur. PHP ne sert qu'à générer les pages et leurs versions dans chaque langue. Il n'y a aucun endpoint d'upload, donc les fichiers ne sont jamais envoyés à mon serveur.

Ce qu'il prend en charge aujourd'hui :

- 19 langues d'OCR : anglais, espagnol, français, allemand, italien, portugais, russe, ukrainien, turc, arabe, chinois (simplifié et traditionnel), japonais, coréen, ourdou, persan, hindi, bengali et thaï.
- Un mode Auto qui détecte le système d'écriture, ou un choix manuel de 3 langues maximum pour un texte mélangé, par exemple français et anglais.
- Des images jusqu'à 10 Mo : JPG, PNG, GIF, BMP, WebP, TIFF et [HEIC/HEIF](https://quickimagetotext.com/heic-to-text) d'iPhone.
- L'[OCR par lots](https://quickimagetotext.com/multi-image-ocr) de 20 images maximum à la fois.
- La conversion [PDF en texte](https://quickimagetotext.com/pdf-to-text) jusqu'à 50 Mo. La couche texte existante est lue directement, et jusqu'à 20 pages scannées par exécution passent par l'OCR.
- Un score de confiance sur chaque résultat, avec un conseil pour reprendre la photo quand il est faible.

### Ce qui se passe quand vous déposez une image

1. Le serveur a déjà envoyé la page avec sa configuration : limites de taille, langues et chemins des modèles.
2. Quand vous choisissez, collez ou déposez un fichier, un worker de prétraitement démarre. Il utilise OffscreenCanvas pour passer l'image en niveaux de gris, corriger le contraste, la faire pivoter, appliquer le deskew et l'agrandir, et il télécharge, décompresse et met en cache les modèles de langue.
3. Un worker OSD détecte le système d'écriture et un éventuel quart de tour.
4. Un seul worker Tesseract.js lit l'image nettoyée. Les tâches font la queue sur ce worker au lieu d'en créer un nouveau à chaque fois.
5. Le texte, le score de confiance et le nombre de mots s'affichent dans la zone de résultat. Rien n'a été envoyé à aucune étape.

Les choix de conception qui ont fait la plus grande différence :

- **Moteur et modèles auto-hébergés.** Tesseract.js, son worker, le cœur WebAssembly et tous les fichiers traineddata sont servis depuis mon propre domaine, dans des dossiers versionnés (`/assets/tesseract/5.1.1/`, `/tessdata/4.1.0/`). Aucun CDN n'est nécessaire au moment de l'OCR, les fichiers sont mis en cache pendant un an, et changer de modèle veut dire créer un nouveau dossier, jamais écraser un fichier.
- **Le bon modèle pour chaque écriture.** Des modèles petits et rapides issus de [`tessdata_fast`](https://github.com/tesseract-ocr/tessdata_fast) pour le latin et le cyrillique. Les modèles plus gros et plus précis de [`tessdata_best`](https://github.com/tesseract-ocr/tessdata_best) pour l'arabe, l'ourdou, le persan, le hindi, le bengali, le chinois, le japonais, le coréen et le thaï, où les modèles rapides faisaient trop d'erreurs.
- **Chargement différé.** Rien de lié à l'OCR n'est téléchargé à l'ouverture de la page. Le préchauffage démarre quand un fichier est choisi, donc les visiteurs qui ne font que lire la page ne paient rien.
- **Aucun travail lourd sur le thread principal.** Le nettoyage de l'image et la gestion des modèles se font dans un Web Worker, donc le défilement et la saisie restent fluides pendant l'OCR.
- **Un seul worker de reconnaissance, réutilisé.** Créer un worker Tesseract coûte cher. J'en crée un, je mets les tâches en file dessus et je ne change ses langues que lorsque c'est nécessaire.
- **Une seule source de vérité pour les chiffres.** Les limites comme 10 Mo ou 20 images sont définies dans un seul fichier de configuration PHP. PHP les écrit dans la page et le JavaScript lit les mêmes valeurs, donc le texte affiché et le comportement réel ne peuvent pas se contredire.

## Utiliser Tesseract sur votre ordinateur (gratuit, en local)

Vous n'avez pas besoin d'un site web pour utiliser Tesseract. Installé en local, il est gratuit, respecte votre vie privée et fonctionne sans connexion internet.

### Installation

Sur macOS avec Homebrew :

```bash
brew install tesseract          # moteur + anglais
brew install tesseract-lang     # toutes les autres langues (facultatif)
```

Sur Ubuntu ou Debian :

```bash
sudo apt update
sudo apt install tesseract-ocr                  # moteur + anglais
sudo apt install tesseract-ocr-fra tesseract-ocr-ara tesseract-ocr-jpn   # langues supplémentaires
```

Sur Windows, téléchargez l'installeur depuis la [build de l'UB Mannheim](https://github.com/UB-Mannheim/tesseract/wiki), vers laquelle renvoie le [guide d'installation officiel](https://tesseract-ocr.github.io/tessdoc/Installation.html). Cochez les langues supplémentaires dont vous avez besoin pendant l'installation, puis ajoutez le dossier d'installation (par exemple `C:\Program Files\Tesseract-OCR`) à votre `PATH`.

Vérifiez que tout fonctionne :

```bash
tesseract --version
tesseract --list-langs
```

### Extraire le texte d'une image en ligne de commande

```bash
# afficher le texte dans le terminal
tesseract receipt.jpg stdout

# l'enregistrer dans output.txt
tesseract receipt.jpg output

# texte en français et en anglais, un seul bloc uniforme
tesseract page.png stdout -l fra+eng --psm 6

# PDF cherchable à partir d'une image scannée
tesseract scan.png scan pdf

# données mot par mot avec la confiance (TSV)
tesseract photo.jpg stdout tsv
```

### Traiter tout un dossier

```bash
# macOS / Linux
for f in *.png; do tesseract "$f" "${f%.*}" -l eng; done
```

```powershell
# Windows PowerShell
Get-ChildItem *.png | ForEach-Object { tesseract $_.FullName $_.BaseName -l eng }
```

## Extraire le texte d'une image en JavaScript

Le code de ce guide utilise Tesseract.js 5.1.1, la version qui tourne sur QuickImageToText. Il existe des versions majeures plus récentes, donc consultez la [documentation de l'API](https://github.com/naptha/tesseract.js/blob/master/docs/api.md) si vous installez la dernière.

C'est la façon la plus simple d'ajouter de l'OCR à un site. Enregistrez ce code dans un fichier HTML et ouvrez-le depuis un serveur web local (par exemple `npx serve` ou `php -S localhost:8000`) :

```html
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Image to text demo</title>
  <script src="https://cdn.jsdelivr.net/npm/tesseract.js@5.1.1/dist/tesseract.min.js"></script>
</head>
<body>
  <input type="file" id="file" accept="image/*">
  <p id="status"></p>
  <pre id="output"></pre>

  <script>
    const status = document.getElementById('status');
    const output = document.getElementById('output');

    document.getElementById('file').addEventListener('change', async (event) => {
      const file = event.target.files[0];
      if (!file) return;

      // v5 : createWorker(languages, oem, options). OEM 1 = LSTM uniquement.
      const worker = await Tesseract.createWorker('eng', 1, {
        logger: (m) => {
          if (m.status === 'recognizing text') {
            status.textContent = `Reading... ${Math.round(m.progress * 100)}%`;
          }
        },
      });

      const { data } = await worker.recognize(file);
      output.textContent = data.text;
      status.textContent = `Done. Confidence: ${Math.round(data.confidence)}%`;

      await worker.terminate();
    });
  </script>
</body>
</html>
```

### Auto-héberger les fichiers plutôt que passer par un CDN

Pour un vrai site, servez les fichiers vous-même. Vous y gagnez en confidentialité, en cache et en fiabilité :

```js
const worker = await Tesseract.createWorker('eng', 1, {
  workerPath: '/vendor/tesseract/worker.min.js',
  corePath: '/vendor/tesseract/core/', // dossier contenant les builds .wasm(.js)
  langPath: '/tessdata/4.1.0',         // dossier contenant eng.traineddata.gz et les autres
});
```

### Réutiliser un seul worker pour plusieurs images

```js
const worker = await Tesseract.createWorker('eng', 1);

for (const file of files) {
  const { data } = await worker.recognize(file);
  console.log(file.name, data.text);
}

// changer de langue sans créer de nouveau worker
await worker.reinitialize(['fra', 'eng']);

await worker.terminate();
```

### Définir le mode de segmentation de page

```js
await worker.setParameters({
  tessedit_pageseg_mode: Tesseract.PSM.SINGLE_LINE, // par ex. un code ou un numéro de série
  tessedit_char_whitelist: '0123456789ABCDEF',       // facultatif : uniquement ces caractères
});
```

### Lire le texte d'une capture d'écran collée

```js
document.addEventListener('paste', async (event) => {
  const item = [...event.clipboardData.items].find((i) => i.type.startsWith('image/'));
  if (!item) return;
  const { data } = await worker.recognize(item.getAsFile());
  console.log(data.text);
});
```

## Utiliser Tesseract.js avec TypeScript

Tesseract.js fournit ses propres définitions de types, vous n'avez donc pas besoin d'un paquet `@types` en plus.

```bash
npm install tesseract.js@5.1.1
```

```ts
// ocr.ts
import { createWorker, PSM, type Worker } from 'tesseract.js';

export interface OcrResult {
  text: string;
  confidence: number;
}

let worker: Worker | null = null;

async function getWorker(langs: string[]): Promise<Worker> {
  if (!worker) {
    worker = await createWorker(langs, 1);
    await worker.setParameters({ tessedit_pageseg_mode: PSM.AUTO });
  } else {
    await worker.reinitialize(langs);
  }
  return worker;
}

export async function imageToText(
  image: File | Blob | HTMLCanvasElement | string,
  langs: string[] = ['eng'],
): Promise<OcrResult> {
  const w = await getWorker(langs);
  const { data } = await w.recognize(image);
  return { text: data.text.trim(), confidence: data.confidence };
}

export async function disposeOcr(): Promise<void> {
  await worker?.terminate();
  worker = null;
}
```

Pour l'utiliser dans un composant React :

```tsx
import { useState } from 'react';
import { imageToText } from './ocr';

export function ImageToText() {
  const [text, setText] = useState('');
  const [busy, setBusy] = useState(false);

  async function onChange(e: React.ChangeEvent<HTMLInputElement>) {
    const file = e.target.files?.[0];
    if (!file) return;
    setBusy(true);
    try {
      const result = await imageToText(file, ['eng']);
      setText(result.text);
    } finally {
      setBusy(false);
    }
  }

  return (
    <div>
      <input type="file" accept="image/*" onChange={onChange} disabled={busy} />
      <textarea value={text} readOnly rows={12} />
    </div>
  );
}
```

Le même `ocr.ts` fonctionne avec Vue, Svelte, Angular ou du TypeScript pur, puisqu'il ne dépend que de Tesseract.js.

## Utiliser Tesseract avec Node.js

Tesseract.js tourne aussi sous Node.js, sans aucune installation native :

```js
// ocr.mjs, à lancer avec : node ocr.mjs invoice.png
import { createWorker } from 'tesseract.js';

const worker = await createWorker('eng');
const { data } = await worker.recognize(process.argv[2]);
console.log(data.text);
await worker.terminate();
```

Pour de grosses charges côté serveur, la CLI native `tesseract` est plus rapide. Vous pouvez l'appeler depuis Node avec `child_process.execFile('tesseract', [file, 'stdout', '-l', 'eng'])`. Passez toujours les arguments sous forme de tableau, et ne construisez jamais une chaîne shell à partir de ce que saisit l'utilisateur.

## Utiliser Tesseract avec PHP

PHP ne peut pas faire tourner Tesseract dans le navigateur, il y a donc deux approches différentes. Choisissez celle qui correspond à vos besoins en matière de confidentialité.

### Approche A : OCR sur le serveur avec Tesseract natif

Installez Tesseract sur le serveur (voir plus haut), puis utilisez le wrapper [`thiagoalessio/tesseract_ocr`](https://github.com/thiagoalessio/tesseract-ocr-for-php) :

```bash
composer require thiagoalessio/tesseract_ocr
```

```php
<?php
require __DIR__ . '/vendor/autoload.php';

use thiagoalessio\TesseractOCR\TesseractOCR;

$text = (new TesseractOCR('uploads/receipt.jpg'))
    ->lang('eng', 'fra')
    ->psm(6)
    ->run();

echo nl2br(htmlspecialchars($text));
```

Sans Composer, appelez directement le binaire et échappez le chemin avec `escapeshellarg()` :

```php
<?php
$image = '/var/www/uploads/receipt.jpg';
$cmd = 'tesseract ' . escapeshellarg($image) . ' stdout -l eng 2>/dev/null';
$text = (string) shell_exec($cmd);
```

Avant de mettre de l'OCR côté serveur en production :

- validez le fichier envoyé (vrai type MIME d'image, limite de taille),
- stockez les fichiers en dehors de la racine web et supprimez-les après l'OCR,
- limitez le nombre de traitements simultanés, car Tesseract consomme beaucoup de CPU,
- dites aux utilisateurs que leur fichier est envoyé sur le serveur et combien de temps vous le gardez.

### Approche B : PHP génère la page, l'OCR tourne dans le navigateur

C'est comme ça que fonctionne QuickImageToText. PHP ne touche jamais à l'image. Il se contente d'écrire le HTML et la configuration dont le JavaScript a besoin, ce qui permet de définir les limites et les langues à un seul endroit :

```php
<?php
// config.php : la source unique de vérité
return [
    'max_image_mb'  => 10,
    'ocr_languages' => ['eng' => 'English', 'fra' => 'French', 'ara' => 'Arabic'],
    'tessdata_path' => '/tessdata/4.1.0',
];
```

```php
<?php
// page.php
$config = require __DIR__ . '/config.php';
?>
<input type="file" id="file" accept="image/*">
<pre id="output"></pre>

<script>
  window.OCR_CONFIG = <?= json_encode($config, JSON_HEX_TAG | JSON_UNESCAPED_UNICODE) ?>;
</script>
<script src="/vendor/tesseract/tesseract.min.js" defer></script>
<script src="/js/ocr.js" defer></script>
```

```js
// /js/ocr.js
document.getElementById('file').addEventListener('change', async (e) => {
  const file = e.target.files[0];
  if (!file) return;
  if (file.size > OCR_CONFIG.max_image_mb * 1024 * 1024) {
    alert(`Max ${OCR_CONFIG.max_image_mb} MB`);
    return;
  }
  const worker = await Tesseract.createWorker('eng', 1, { langPath: OCR_CONFIG.tessdata_path });
  const { data } = await worker.recognize(file);
  document.getElementById('output').textContent = data.text;
  await worker.terminate();
});
```

Résultat : aucun envoi de fichier, aucun CPU serveur consommé par image, aucun fichier utilisateur stocké, et ça tourne sur un hébergement mutualisé bon marché.

## Python en quelques lignes

[pytesseract](https://github.com/madmaze/pytesseract) encapsule le binaire natif, donc installez d'abord Tesseract :

```bash
pip install pytesseract pillow
```

```python
from PIL import Image
import pytesseract

print(pytesseract.image_to_string(Image.open("page.png"), lang="eng+fra"))
```

## Langues et modèles traineddata

Chaque langue correspond à un fichier `.traineddata` distinct. Il existe trois jeux officiels :

| Jeu | Taille par langue | Précision | Vitesse | Adapté à |
|---|---|---|---|---|
| [`tessdata_fast`](https://github.com/tesseract-ocr/tessdata_fast) | environ 0,6 à 2 Mo | Bonne | La plus rapide | Latin, cyrillique, applications web |
| [`tessdata`](https://github.com/tesseract-ocr/tessdata) (par défaut) | moyenne | Meilleure | Moyenne | Usage général, inclut les données du moteur legacy |
| [`tessdata_best`](https://github.com/tesseract-ocr/tessdata_best) | environ 3 à 13 Mo | La meilleure | La plus lente | Arabe, ourdou, hindi, bengali, chinois, japonais, coréen, thaï |

Quelques points à connaître :

- Combinez les langues avec `+`, comme `fra+eng` ou `ara+eng`. Deux ou trois, ça va. Au-delà, c'est plus lent et la précision peut baisser.
- Les codes de langue font trois lettres, pas deux : `eng`, `fra`, `deu`, `spa`, `ara`, `chi_sim`, `chi_tra`, `jpn`, `kor`, `hin`, `urd`.
- Le chinois et le japonais ont aussi des modèles pour le texte vertical, comme `jpn_vert`.
- Pour le web, compressez les modèles en gzip et servez-les avec des en-têtes de cache longs.

## Les modes de segmentation de page (PSM) expliqués

| PSM | Signification | À utiliser pour |
|---|---|---|
| 0 | Détection de l'orientation et de l'écriture uniquement | Trouver la rotation ou le système d'écriture |
| 1 | Automatique avec OSD | Scans tournés |
| 3 | Entièrement automatique (par défaut) | Documents, mises en page mixtes |
| 4 | Une seule colonne, tailles variables | Tickets de caisse, factures |
| 6 | Un seul bloc uniforme | Captures d'écran, paragraphes, pages de livre |
| 7 | Une seule ligne de texte | Un titre, un numéro de série, une ligne de code |
| 8 | Un seul mot | Un mot dans une image recadrée |
| 11 | Texte épars, dans n'importe quel ordre | Panneaux, affiches, étiquettes, mèmes |
| 13 | Ligne brute, sans heuristiques | Polices inhabituelles sur une seule ligne |

Si le résultat est vide ou incohérent, essayez les PSM 6, 4 et 11 avant toute autre chose.

## Les problèmes que j'ai rencontrés et comment je les ai corrigés

Ce sont de vrais problèmes rencontrés en construisant QuickImageToText. Ils s'appliquent à presque n'importe quel projet Tesseract.

### 1. Le texte non anglais ressortait illisible

**Problème :** quelqu'un qui lisait une image en russe ou en arabe sur la page anglaise obtenait du charabia, parce que l'OCR utilisait l'anglais sans rien dire. Cinq langues que les gens demandaient (ourdou, persan, hindi, bengali, thaï) n'étaient pas proposées du tout, donc elles étaient lues avec le mauvais modèle.

**Correction :** j'ai ajouté ces langues et passé les écritures complexes sur les modèles `tessdata_best`. Ensuite, j'ai construit un mode Auto. L'OSD détecte le système d'écriture, et l'outil essaie dans l'ordre les combinaisons de langues les plus probables : l'écriture détectée, les langues du navigateur du visiteur, les langues proches comme le russe et l'ukrainien ou l'arabe, l'ourdou et le persan, et l'anglais en dernier. Un résultat est accepté quand il est fiable et que la plupart de ses lettres appartiennent bien à l'écriture attendue. Sinon, le meilleur de 3 tentatives maximum l'emporte. Un texte latin lu comme de l'anglais est relu en français, espagnol, allemand, italien ou portugais quand des mots courants trahissent la langue. Les utilisateurs peuvent toujours choisir jusqu'à 3 langues à la main.

Choisir la bonne langue compte plus que n'importe quel autre réglage. Si vous construisez un outil d'OCR, ne cachez jamais le choix de la langue.

### 2. Les photos tournées ou penchées échouaient complètement

**Problème :** une photo de téléphone tournée de 90 ou 180 degrés ne donnait presque rien, et les pages légèrement penchées perdaient beaucoup de mots.

**Correction :** l'OSD signale les quarts de tour (90, 180, 270), que j'applique avant la reconnaissance. Une rotation détectée avec une faible confiance n'est conservée que si elle donne vraiment une meilleure lecture. Ensuite, une étape de deskew trouve la légère inclinaison, jusqu'à 15 degrés dans un sens ou dans l'autre, à l'aide d'un profil de projection, et redresse l'image.

### 3. Les photos de téléphone avec des ombres et le bureau autour de la page

**Problème :** l'étape de noir et blanc intégrée à Tesseract se faisait piéger par un éclairage inégal. Les coins sombres devenaient de "l'encre" et le texte pâle disparaissait.

**Correction :** une étape de prétraitement avant Tesseract. Elle convertit en niveaux de gris, détecte le texte clair sur fond sombre et l'inverse, normalise l'éclairage (le bureau dans l'ombre autour d'une page photographiée est peint en blanc), étire le contraste et agrandit l'image quand les lignes de texte font moins d'environ 20 pixels de haut. Cela correspond à peu près à 300 dpi, la résolution où Tesseract donne le meilleur de lui-même. Une option noir et blanc (Otsu) facultative aide sur les scans bruités.

### 4. La page se figeait pendant l'OCR

**Problème :** le traitement de l'image et le téléchargement des modèles sur le thread principal bloquaient le défilement et les clics.

**Correction :** tout ce qui est lourd tourne dans des Web Workers. Le prétraitement utilise OffscreenCanvas dans un worker, qui télécharge, décompresse et met aussi les modèles en cache. Je n'ai mesuré aucune pause du thread principal au-delà de 25 ms pendant l'OCR, même avec un modèle japonais de 13 Mo pas encore en cache. Les navigateurs sans OffscreenCanvas se rabattent sur l'envoi de l'image d'origine à Tesseract, avec sa propre rotation automatique.

### 5. De gros téléchargements de modèles à chaque visite

**Problème :** les meilleurs modèles pèsent plusieurs Mo chacun. Les télécharger au chargement de la page ralentirait tous les visiteurs, même ceux qui ne lancent jamais d'OCR.

**Correction :** rien ne se charge à l'ouverture de la page. Le préchauffage démarre quand un fichier est choisi, collé ou déposé. Les modèles sont compressés en gzip, servis avec un cache immuable d'un an depuis des dossiers versionnés et stockés dans IndexedDB, donc un visiteur qui revient ne télécharge rien. La barre de progression affiche les vrais octets, pour qu'une connexion lente n'ait pas l'air d'un bug.

### 6. Les résultats semblaient faux alors que l'OCR était juste

**Problème :** du texte chinois, japonais ou ourdou correct s'affichait parfois avec le mauvais style de police, et les modèles CJK `best` ajoutaient des espaces entre les caractères.

**Correction :** la zone de résultat reçoit le bon attribut `lang` (`ja`, `zh-Hant`, `ur`) pour que le navigateur choisisse les bonnes formes de glyphes. Une pile de polices Noto auto-hébergée ne charge que les écritures présentes à l'écran. Les espaces en trop entre les caractères CJK sont supprimés, sauf en coréen, qui utilise de vrais espaces.

### 7. Les photos HEIC d'iPhone

**Problème :** la plupart des navigateurs ne savent pas décoder le HEIC, donc les photos d'iPhone échouaient.

**Correction :** les fichiers HEIC et HEIF sont convertis en JPEG dans le navigateur avec une copie auto-hébergée de [heic2any](https://github.com/alexcorvi/heic2any) avant l'OCR. Le fichier ne quitte toujours pas l'appareil.

### 8. Le texte téléchargé s'ouvrait avec des caractères cassés

**Problème :** un fichier `.txt` contenant de l'arabe ou du chinois s'ouvrait en mojibake dans certains éditeurs, surtout sous Windows.

**Correction :** les téléchargements sont écrits en UTF-8 avec un BOM, qui indique l'encodage aux éditeurs.

### 9. Le nombre de mots et de caractères était faux pour les langues asiatiques

**Problème :** découper sur les espaces compte tout un paragraphe chinois ou thaï comme un seul mot.

**Correction :** `Intl.Segmenter` compte les vrais mots et caractères (graphèmes) dans toutes les langues.

### 10. Les scripts publicitaires cassaient le bouton principal

**Problème :** certaines zones publicitaires tierces ajoutaient des calques de popup invisibles sur la page, si bien qu'un clic sur "Extract text" ouvrait une pub à la place.

**Correction :** j'ai désactivé ces zones. Si votre outil d'OCR affiche des pubs, testez l'action principale avec les pubs actives.

### Le résultat

Sur mon jeu de 40 images de test dans 16 langues (scans propres, photos de téléphone et pages tournées), le taux d'erreur moyen par caractère est passé d'environ 42 % à moins de 2 % quand la bonne langue est choisie ou détectée. Le seul cas difficile qui reste est l'ourdou en nastaliq, le style calligraphique et fluide de cette écriture, parce que le modèle ourdou de Tesseract a été entraîné surtout sur le style naskh, plus simple.

## Conseils pour de meilleurs résultats OCR

1. Choisissez la langue, ou une combinaison comme `fra+eng`, au lieu de deviner.
2. Prenez la photo sous une bonne lumière, sans ombres, en tenant le téléphone parallèle à la page.
3. Recadrez sur le texte dont vous avez besoin.
4. Visez un texte de 20 à 40 pixels de haut. Agrandissez les petits textes, et n'envoyez pas d'énormes photos de 50 MP.
5. Redressez l'image : rotation et deskew avant l'OCR.
6. Gardez un contraste élevé : texte foncé sur fond clair. Inversez les captures d'écran en blanc sur noir.
7. Essayez le noir et blanc (binarisation) pour les scans bruités et les impressions délavées.
8. Choisissez le bon PSM : 6 pour un bloc, 7 pour une ligne, 11 pour du texte dispersé.
9. Utilisez le PNG pour les captures d'écran. Les artefacts JPEG autour des petites lettres nuisent à la précision.
10. Surveillez le score de confiance. En dessous d'environ 60 %, reprenez la photo ou changez de langue.

La page officielle [Improving the quality of the output](https://tesseract-ocr.github.io/tessdoc/ImproveQuality.html) détaille chacun de ces points.

## Les limites à connaître

- **Écriture manuscrite :** Tesseract est entraîné sur du texte imprimé. Des majuscules d'imprimerie bien tracées peuvent passer, l'écriture cursive ne passe généralement pas. QuickImageToText a une page dédiée [écriture manuscrite en texte](https://quickimagetotext.com/handwritten-to-text) avec des conseils pour ce cas.
- **Mises en page complexes :** les tableaux, les formulaires et les magazines sur plusieurs colonnes peuvent demander un recadrage ou un post-traitement. La sortie TSV vous donne la position des mots pour travailler.
- **Polices stylisées et logos :** les polices décoratives ou très fines peuvent échouer.
- **Ourdou en nastaliq :** lisible, mais moins précis que l'écriture arabe de style naskh.
- **Formules mathématiques et partitions de musique :** non pris en charge.
- **Images en très basse résolution ou floues :** aucun réglage ne peut récupérer un texte que les pixels ne contiennent pas.

## Questions fréquentes

### Tesseract OCR est-il gratuit ?

Oui. Tesseract et Tesseract.js sont open source sous licence Apache 2.0, gratuits pour un usage personnel comme commercial. [QuickImageToText](https://quickimagetotext.com/fr/convertir-image-en-texte) est gratuit lui aussi, sans inscription.

### Comment Tesseract fonctionne-t-il dans un navigateur ?

Tesseract.js compile le moteur Tesseract en WebAssembly et le fait tourner dans un Web Worker. Le modèle de langue est téléchargé une fois puis mis en cache, et l'image est ensuite lue entièrement sur votre appareil.

### Tesseract envoie-t-il mon image sur un serveur ?

Non, quand il tourne sous forme de Tesseract.js dans le navigateur ou comme programme sur votre ordinateur. Sur QuickImageToText, l'image est traitée dans votre navigateur et n'est jamais envoyée.

### Comment extraire gratuitement le texte d'une image ?

Ouvrez [QuickImageToText](https://quickimagetotext.com/fr/convertir-image-en-texte), puis choisissez, collez ou glissez une image. Le texte apparaît quelques secondes plus tard. Pour le faire en local, installez Tesseract et lancez `tesseract image.png stdout`.

### Comment utiliser Tesseract en JavaScript ?

Installez `tesseract.js` ou ajoutez sa balise script, créez un worker avec `createWorker('eng')`, appelez `worker.recognize(image)` et lisez `data.text`. La [section JavaScript](#extraire-le-texte-dune-image-en-javascript) contient un exemple complet.

### Peut-on utiliser Tesseract avec TypeScript ?

Oui. Tesseract.js inclut ses propres types TypeScript. Importez `createWorker` et `PSM` depuis `tesseract.js`.

### Comment utiliser Tesseract avec PHP ?

Soit vous installez Tesseract sur le serveur et utilisez le paquet Composer `thiagoalessio/tesseract_ocr`, soit vous laissez PHP générer la page et faites tourner Tesseract.js dans le navigateur, pour que rien ne soit envoyé.

### Quelles langues Tesseract prend-il en charge ?

Plus de 100 langues et écritures. QuickImageToText en propose 19, dont l'arabe, le chinois, le japonais, le coréen, le hindi, l'ourdou et le thaï.

### Tesseract peut-il détecter la langue automatiquement ?

Son modèle OSD détecte le système d'écriture (latin, arabe, han, etc.), pas la langue exacte. Des outils comme QuickImageToText combinent la détection de l'écriture avec d'autres indices pour choisir une langue.

### Pourquoi mon résultat OCR est-il faux ou vide ?

En général, c'est la mauvaise langue, une photo tournée ou floue, un texte trop petit, ou le mauvais mode de segmentation de page. Les [conseils plus haut](#conseils-pour-de-meilleurs-résultats-ocr) couvrent chacun de ces cas.

### Tesseract sait-il lire l'écriture manuscrite ?

Seulement une écriture soignée, proche de l'imprimé, et sans fiabilité. Il est conçu pour le texte imprimé.

### Tesseract sait-il lire les PDF ?

Pas directement. Convertissez d'abord chaque page en image, ou utilisez un outil qui lit la couche texte du PDF et ne lance l'OCR que sur les pages scannées, comme l'[outil PDF en texte de QuickImageToText](https://quickimagetotext.com/pdf-to-text).

### Quelle est la différence entre tessdata_fast et tessdata_best ?

Les modèles `fast` sont petits et rapides. Les modèles `best` sont plus gros et plus précis. Utilisez `best` pour les écritures complexes comme l'arabe, le hindi et le chinois.

### Tesseract.js est-il plus lent que Tesseract natif ?

Un peu, parce que le WebAssembly tourne dans le bac à sable du navigateur. Pour des photos et des captures d'écran classiques, ça ne prend quand même que quelques secondes, et vous économisez le temps d'envoi.

### Tesseract fonctionne-t-il hors ligne ?

Installé sur votre ordinateur, oui. Tesseract.js peut fonctionner hors ligne une fois ses fichiers en cache, si l'application est conçue pour. QuickImageToText lui-même a besoin d'une connexion pour charger la page et les modèles.

---

Envie de voir tout ça en action ? [Extrayez le texte d'une image](https://quickimagetotext.com/fr/convertir-image-en-texte) directement dans votre navigateur, sans envoi de fichier et sans inscription. Si vous avez besoin d'intégrer de l'OCR ou un autre outil qui tourne dans le navigateur à votre propre produit, [contactez-moi](/fr/contact/).
