1. IronOCR
  2. Guides pratiques
  3. Utiliser une langue personnalisée

How to use Custom Language with Tesseract

Curtis Chau
Curtis Chau
Mis à jour:
This article was translated from English: Does it need improvement?
Translated
View the article in English

When it comes to optical character recognition (OCR), you sometimes need to deal with custom languages, specialized scripts, or ciphers. To read an input image containing a custom language, the Tesseract engine must be provided with training data for that specific language. This data is stored in a special .traineddata file.

While the complex process of creating (training) this file is done using Tesseract's own tools, IronOCR fully supports using these custom language files. This lets you apply your trained model to decipher and read text from any input. In this how-to guide, we'll showcase how to load and use a custom .traineddata file with IronOCR.

Get started with IronOCR

Commencez à utiliser IronOCR dans votre projet aujourd'hui avec un essai gratuit.

Première étape :
green arrow pointer

How to use Custom Languages with Tesseract

  1. Download a C# library for reading a custom language
  2. Initialize the OCR engine
  3. Load the custom language training data with UseCustomTesseractLanguageFile
  4. Load the input image with LoadImage
  5. Read and extracted the custom language input image with Read

Custom Language with Tesseract

To use a custom language with Tesseract, we must first load our .traineddata file by calling the UseCustomTesseractLanguageFile method. This is an essential step, as this file contains all the training data that allows Tesseract to recognize the custom language's unique characters.

Afterward, we load our input document just as we would for a regular OCR operation. In this instance, we are loading a PDF containing custom language paragraphs using LoadPdf.

Finally, we use the Read method to extract the text from the input. The result can then be printed to the console or, as the example shows, saved (piped) to a text file for reference.

Input

We'll use this sample PDF, which contains text in our custom language, as the input.

We'll be using this custom language .traindata for our example.

Code Example

:path=/static-assets/ocr/content-code-examples/how-to/ocr-custom-language.cs
using IronOcr;
using System;
using System.IO;

var ocrTesseract = new IronTesseract();

// Load the traineddata file for the custom language
ocrTesseract.UseCustomTesseractLanguageFile("AMGDT.traineddata");

using var ocrInput = new OcrInput();
// Load the PDF containing text in the custom language
ocrInput.LoadPdf("custom.pdf");

var ocrResult = ocrTesseract.Read(ocrInput);

// Print text to the console
Console.WriteLine("--- OCR Result ---");
Console.WriteLine(ocrResult.Text);
Console.WriteLine("------------------");

// Pipe text to a .txt file
string outputFilePath = "ocr_output.txt";
File.WriteAllText(outputFilePath, ocrResult.Text);

Console.WriteLine($"\nSuccessfully saved text to {outputFilePath}");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Output

OCR Output text

This output shows the result from our custom language model. As you can see, by providing the correct training data, IronOCR successfully deciphered the text, and the result is in plain English. Additionally, this is the txt output generated by the code.

Questions Fréquemment Posées

Quel est l'intérêt d'utiliser une langue personnalisée avec Tesseract dans IronOCR ?

L'utilisation d'un langage personnalisé avec Tesseract dans IronOCR permet de reconnaître et d'extraire du texte à partir d'images ou de PDF contenant des systèmes d'écriture ou des langues spécifiques non prises en charge par défaut. Pour ce faire, il suffit de charger un fichier `.traineddata` personnalisé contenant les données d'entraînement nécessaires à ce langage.

Comment charger un fichier de données d'entraînement linguistique personnalisé dans IronOCR ?

Vous pouvez charger un fichier de données d'entraînement personnalisé dans IronOCR à l'aide de la méthode `UseCustomTesseractLanguageFile`. Cette étape est cruciale car elle fournit au moteur Tesseract les données d'entraînement nécessaires à la reconnaissance des caractères uniques de la langue personnalisée.

Quelles sont les étapes à suivre pour effectuer une reconnaissance optique de caractères (OCR) sur une image comportant une langue personnalisée à l'aide d'IronOCR ?

Pour effectuer une reconnaissance optique de caractères (OCR) sur une image avec une langue personnalisée à l'aide d'IronOCR, commencez par télécharger la bibliothèque C#, initialisez le moteur OCR, chargez les données d'entraînement de la langue personnalisée avec `UseCustomTesseractLanguageFile`, chargez l'image d'entrée avec `LoadImage`, et enfin extrayez le texte à l'aide de la méthode `Read`.

IronOCR peut-il traiter les PDF contenant du texte en langue personnalisée ?

Oui, IronOCR peut traiter les PDF contenant du texte dans une langue personnalisée. Vous pouvez charger le PDF à l'aide de la méthode `LoadPdf` puis utiliser la méthode `Read` pour extraire le texte à partir des données d'entraînement fournies pour la langue personnalisée.

Qu'est-ce qu'un fichier `.traineddata` dans le contexte de Tesseract et IronOCR ?

Un fichier `.traineddata` est un fichier de données utilisé par Tesseract OCR qui contient les données d'entraînement pour une langue spécifique. Il permet au moteur OCR de reconnaître et de traiter les caractères de cette langue et peut être utilisé dans IronOCR pour gérer des langues personnalisées.

Dois-je créer mon propre fichier `.traineddata` pour chaque langue personnalisée dans IronOCR ?

Non, il n'est pas nécessaire de créer un fichier `.traineddata` pour chaque langage personnalisé. Vous pouvez utiliser les fichiers `.traineddata` existants, s'ils sont disponibles. Toutefois, si un langage spécifique n'est pas pris en charge, vous devrez peut-être en créer un à l'aide des outils de Tesseract.

Quels sont les formats de sortie pris en charge par IronOCR lors de l'utilisation de langues personnalisées ?

IronOCR prend en charge différents formats de sortie lors de l'utilisation de langues personnalisées, comme la sortie en texte brut qui peut être affichée dans la console ou enregistrée dans un fichier texte. Le texte extrait peut ensuite être manipulé selon les besoins.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite
Prêt à commencer?
Nuget Téléchargements 5,044,537 | Version : 2025.11 vient de sortir