> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Fonctions globales
> Fonctions globales dans le langage FlexiLayout : assistants mathématiques et string, requêtes de base de données comme ExecuteSQL, fonctions de validation et appels à RecognizeText.
Le langage FlexiLayout fournit des fonctions globales pour les opérations mathématiques et de comparaison, les calculs de coordonnées et d’intervalles, le traitement des chaînes, la conversion et la validation, l’accès aux bases de données et aux fichiers, la gestion des pages et des documents, ainsi que la pré-reconnaissance.
N’utilisez pas de variables comme arguments des fonctions globales qui interagissent avec des fichiers externes ou des bases de données.
## Fonctions mathématiques et de comparaison
| Définition | Description |
| ------------------------------------------ | ------------------------------------------------------------------ |
| `Area Max( Area a1, Area a2 )` | Renvoie la valeur maximale entre `a1` et `a2`. |
| `Area Min( Area a1, Area a2 )` | Renvoie la valeur minimale entre `a1` et `a2`. |
| `Distance abs( Distance )` | Renvoie la valeur absolue d'une distance. |
| `Distance Min( Distance d1, Distance d2 )` | Renvoie la valeur minimale entre `d1` et `d2`. |
| `Distance Max( Distance d1, Distance d2 )` | Renvoie la valeur maximale entre `d1` et `d2`. |
| `Int abs( Int )` | Renvoie la valeur absolue d'un nombre. |
| `Int Ceil( Real )` | Renvoie le plus petit entier qui n'est pas inférieur à l'argument. |
| `Int Floor( Real )` | Renvoie le plus grand entier qui n'est pas supérieur à l'argument. |
| `Int Max( Int n1, Int n2 )` | Renvoie la valeur maximale entre `n1` et `n2`. |
| `Int Min( Int n1, Int n2 )` | Renvoie la valeur minimale entre `n1` et `n2`. |
| `Int Round( Real )` | Renvoie l'entier le plus proche de l'argument. |
| `Real Min( Real d1, Real d2 )` | Renvoie la valeur minimale entre `d1` et `d2`. |
| `Real Max( Real d1, Real d2 )` | Renvoie la valeur maximale entre `d1` et `d2`. |
## Fonctions de coordonnées et d'intervalles
| Définition | Description |
| ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Area ObjectsArea( Rect, ImageObjectType )` | Aire des objets du type spécifié à l'intérieur du rectangle spécifié. Fonctionne en coordonnées globales. |
| `Area ObjectsIntersectionArea( Rect, ImageObjectType )` | Aire des objets du type spécifié à l'intérieur du rectangle spécifié, ainsi que l'aire d'intersection des objets du type spécifié qui s'étendent au-delà du rectangle spécifié. Fonctionne en coordonnées globales. |
| `Logic IsOnSameLine( Hypothesis, Hypothesis )` | Vérifie si les hypothèses s'intersectent verticalement. |
| `Region FormRegion( RectArray included, RectArray excluded )` | Crée une région qui inclut le tableau de rectangles `included` et exclut le tableau de rectangles `excluded`. |
| `XCoordinate Min( XCoordinate x1, XCoordinate x2 )` | Renvoie la valeur minimale entre `x1` et `x2`. |
| `XCoordinate Max( XCoordinate x1, XCoordinate x2 )` | Renvoie la valeur maximale entre `x1` et `x2`. |
| `XCoordinate MiddleBetween( XCoordinate x1, XCoordinate x2 )` | Renvoie la coordonnée X calculée comme `( x1 + x2 ) / 2`. |
| `XCoordinate Between( XCoordinate x1, XCoordinate x2, Real ratio )` | Renvoie la coordonnée X calculée comme `x1 + ( x2 - x1 ) * ratio`. |
| `YCoordinate Min( YCoordinate y1, YCoordinate y2 )` | Renvoie la valeur minimale entre `y1` et `y2`. |
| `YCoordinate Max( YCoordinate y1, YCoordinate y2 )` | Renvoie la valeur maximale entre `y1` et `y2`. |
| `YCoordinate MiddleBetween( YCoordinate y1, YCoordinate y2 )` | Renvoie YInterval calculé comme `( y1 + y2 ) / 2`. |
| `YCoordinate Between( YCoordinate y1, YCoordinate y2, Real ratio )` | Renvoie YInterval calculé comme `y1 + ( y2 - y1 ) * ratio`. |
| `XInterval MiddleBetween( XInterval x1, XInterval x2 )` | Renvoie XInterval calculé comme `( x1 + x2 ) / 2`. |
| `XInterval Between( XInterval x1, XInterval x2, Real ratio )` | Renvoie XInterval calculé comme `x1 + ( x2 - x1 ) * ratio`. |
| `YInterval MiddleBetween( YInterval y1, YInterval y2 )` | Renvoie YInterval calculé comme `( y1 + y2 ) / 2`. |
| `YInterval Between( YInterval y1, YInterval y2, Real ratio )` | Renvoie YInterval calculé comme `y1 + ( y2 - y1 ) * ratio`. |
## Fonctions de chaîne
| Définition | Description |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `String Chr( Int )` | Renvoie une chaîne à partir du code Unicode spécifié du caractère (le code doit être écrit en base décimale). |
| `String LCase( String )` | Renvoie une chaîne obtenue à partir de la chaîne spécifiée en convertissant tous ses caractères en minuscules. |
| `String RealToStrVariants( Real value, String fractionalPartSeparators, Int maxDigitsCountInFractionalPart = 2 )` | Crée des représentations sous forme de chaîne, séparées par une barre verticale (`\|`), pour la valeur réelle `value`, les séparateurs décimaux `fractionalPartSeparators` et le nombre maximal de chiffres dans la partie fractionnaire. Par exemple, pour les arguments `19`, `".,"`, `2`, le résultat est `"19\|19.0\|19.00\|19,0\|19,00"`. |
| `String Str( Int )`
`String Str( Logic )`
`String Str( Real )`
`String Str( XInterval )`
`String Str( YInterval )`
`String Str( DistInterval )`
`String Str( FuzzyRect )`
`String Str( Hypothesis )`
`String Str( RectArray )`
`String Str( Region )`
`String Str( Area )`
`String Str( Quality )`
`String Str( Distance )`
`String Str( PageInterval )` | Représentation sous forme de chaîne d’un type de données. |
| `String RemoveSpaces( String )` | Renvoie une chaîne obtenue à partir de la chaîne spécifiée en supprimant tous les espaces qu’elle contient. |
| `String UCase( String )` | Renvoie une chaîne obtenue à partir de la chaîne spécifiée en convertissant tous ses caractères en majuscules. |
## Fonctions de conversion et de validation
| Définition | Description |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Int LogicToInt( Logic value )` | Retourne `1` si `value` vaut `true` et `0` si `value` vaut `false`. |
| `Int StrToInt( String inputString, Logic isStrictMode = false )` | Renvoie le résultat de la conversion de la valeur string `inputString` en entier. Les espaces sont ignorés. Le paramètre `isStrictMode` (`false` par défaut) définit si la string peut contenir des caractères autres que des chiffres et des espaces. Si `isStrictMode = false` et que la string contient un caractère qui n’est ni un chiffre ni un espace, tous les caractères suivants sont ignorés. Vérifiez que la string peut être convertie avant d’appeler cette fonction. Pour cela, utilisez la fonction `IsInt`. |
| `Int StrToIntFuzzy( String, Logic isStrictMode = false )` | Retourne le résultat de la conversion de la valeur de la chaîne `inputString` en entier, en tenant compte des erreurs de reconnaissance possibles dans la chaîne (voir la description de la fonction `IsIntFuzzy`). Les espaces sont ignorés lors de la conversion. Le paramètre `isStrictMode` (défini par défaut sur `false`) indique si la chaîne peut contenir des caractères autres que des chiffres, des caractères ressemblant à des chiffres ou des espaces. Si `isStrictMode = false` et qu’un caractère autre qu’un chiffre est rencontré, tous les caractères qui suivent seront ignorés. Avant de lancer la conversion, appelez la fonction `IsIntFuzzy` pour vérifier que la chaîne peut être convertie en toute sécurité. |
| `Logic IsInt( String inputString, Logic isStrictMode = false )` | Vérifie que la chaîne `inputString` peut être convertie en entier en toute sécurité. Le paramètre `isStrictMode` (`false` par défaut) indique si la chaîne peut contenir des caractères autres que des chiffres et des espaces. |
| `Logic IsIntFuzzy( String inputString, Logic isStrictMode = false )` | Vérifie si la chaîne `inputString` peut être convertie de manière fiable en entier, en tenant compte d’éventuelles erreurs de reconnaissance dans la chaîne. Ce type de conversion convertit en entiers non seulement les chiffres (c’est-à-dire les caractères `0123456789`), mais aussi les caractères qui leur ressemblent (par exemple, `oOBsl`). Le paramètre `isStrictMode` (défini sur `false` par défaut) détermine si la chaîne peut contenir des caractères autres que des chiffres, des caractères qui ressemblent à des chiffres ou des espaces. |
| `Logic IsReal( String numberString, String separators = ".,", Logic isStrictMode = false )` | Vérifie que la chaîne `inputString` peut être convertie en un nombre réel. La liste des séparateurs décimaux autorisés est définie par l’argument `separators`. Par défaut, le point, la virgule et le séparateur défini par l’utilisateur (configuré dans les paramètres régionaux du système d’exploitation, voir `RegionalDecimalPoint`) sont autorisés. Le paramètre `isStrictMode` (`false` par défaut) indique si la chaîne peut inclure des caractères autres que des chiffres, des espaces et des séparateurs. |
| `Logic IsRealFuzzy( String, String separators = defaultDecimalSeparators, Logic isStrictMode = false )` | Vérifie si la chaîne `inputString` peut être convertie de manière fiable en nombre réel, en tenant compte d’éventuelles erreurs de reconnaissance dans la chaîne (voir la description de la fonction `IsIntFuzzy`). La liste des séparateurs décimaux autorisés est définie par l’argument `separators`. Par défaut, les séparateurs suivants sont autorisés : le point, la virgule et le séparateur spécifié dans les paramètres régionaux du système d’exploitation de l’utilisateur (voir `RegionalDecimalPoint`). Le paramètre `isStrictMode` (défini sur `false` par défaut) détermine si la chaîne peut contenir des caractères autres que des chiffres, des caractères ressemblant à des chiffres, des espaces ou des séparateurs. |
| `Quality ValidateByDB( String word, String connectionString, String selectString, Int maxErrors, Real maxErrorsPart, Logic ignoreSpaces, Int maxRecordsCount = 1000 )` | Vérifie le mot spécifié en le comparant à une base de données. Pour plus d’informations, voir [Bases de données et fichiers texte dans le langage FlexiLayout](/fr/flexi-capture/fls/language/bd-textfiles). L’argument `connectionString` définit la chaîne de connexion à la base de données. L’argument `selectString` définit une requête SQL commençant par la commande `SELECT`. L’argument `maxErrors` définit le nombre maximal absolu d’erreurs dans le mot, et `maxErrorsPart` définit le nombre maximal relatif d’erreurs dans le mot. L’argument `ignoreSpaces` détermine si les espaces doivent être pris en compte lors de la comparaison. Pour accélérer la recherche, seules les `maxRecordsCount` premières variantes sont utilisées (la valeur par défaut est 1000). Renvoie la qualité de correspondance entre le mot spécifié et la meilleure correspondance trouvée dans la base de données. Cette fonction peut être utilisée dans le champ **Advanced Post-Search Relations** pour la mise en correspondance approximative de la valeur textuelle d’une hypothèse renvoyée par la méthode `Value` avec les variantes spécifiées. |
| `Quality ValidateByFile( String word, String fileName, Int maxErrors, Real maxErrorsPart, Logic ignoreSpaces, Int maxRecordsCount = 1000 )` | Vérifie le mot spécifié en le comparant aux variantes du fichier `fileName`, qui répertorie les variantes de phrase possibles. Pour plus d’informations, voir [Bases de données et fichiers texte dans le langage FlexiLayout](/fr/flexi-capture/fls/language/bd-textfiles). L’argument `maxErrors` définit le nombre maximal absolu d’erreurs dans le mot, et `maxErrorsPart` définit le nombre maximal relatif d’erreurs dans le mot. L’argument `ignoreSpaces` détermine si les espaces doivent être pris en compte lors de la comparaison. Renvoie la qualité de la mise en correspondance entre le mot spécifié et la meilleure correspondance du fichier texte. Pour accélérer la recherche, seules les `maxRecordsCount` premières variantes sont utilisées (la valeur par défaut est 1000). Cette fonction peut être utilisée dans le champ **Advanced post-search relations** pour la mise en correspondance approximative de la valeur de chaîne d’une hypothèse renvoyée par la méthode `Value` avec les variantes spécifiées. |
| `Quality ValidateByText( String word, String variants, Int maxErrors, Real maxErrorsPart, Logic ignoreSpaces )` | Vérifie le mot spécifié en le comparant aux variantes de la liste. L’argument `maxErrors` définit le nombre maximal absolu d’erreurs dans le mot, et `maxErrorsPart` définit le nombre maximal relatif d’erreurs dans le mot. L’argument `ignoreSpaces` détermine si les espaces doivent être pris en compte lors de la comparaison. Renvoie la qualité de la mise en correspondance entre le mot spécifié et la meilleure correspondance parmi les variantes listées dans l’argument `variants`. Cette fonction peut être utilisée dans le champ **Advanced Post-Search Relations** pour la mise en correspondance approximative de la valeur string d’une hypothèse renvoyée par la méthode `Value` avec les variantes spécifiées. |
| `Real StrToReal( String numberString, String separators = ".,", Logic isStrictMode = false )` | Renvoie le résultat de la conversion de la chaîne `inputString` en nombre réel. Les espaces sont supprimés. Le paramètre `isStrictMode` (`false` par défaut) indique si la chaîne peut contenir des caractères autres que des chiffres, des espaces et des séparateurs. Si `isStrictMode = false` et que la chaîne contient un second séparateur décimal ou un caractère qui n’est ni un chiffre ni un espace, tous les caractères qui suivent sont supprimés. Vérifiez que la chaîne peut être convertie avant d’appeler cette fonction. Pour ce faire, utilisez la fonction `IsReal`. |
| `Real StrToRealFuzzy( String, String separators = defaultDecimalSeparators, Logic isStrictMode = false )` | Renvoie le résultat de la conversion de la valeur de la chaîne `inputString` en nombre réel, en tenant compte des erreurs de reconnaissance possibles dans la chaîne (voir la description de la fonction `IsIntFuzzy`). Les espaces sont ignorés lors de la conversion. Le paramètre `isStrictMode` (défini sur `false` par défaut) détermine si la chaîne peut contenir des caractères autres que des chiffres, des caractères ressemblant à des chiffres, des espaces ou des séparateurs. Si `isStrictMode = false` et qu’un second séparateur décimal ou un caractère autre qu’un chiffre est rencontré, tous les caractères suivants sont ignorés. Avant de lancer la conversion, appelez la fonction `IsRealFuzzy` pour vérifier que la chaîne peut être convertie sans risque. |
Exemple d’utilisation de `StrToInt` :
```text theme={null}
Int integralValue;
String valueFromDocument = SearchElements.StaticText.Value();
Logic canBeConverted = IsInt(valueFromDocument, true);
if(canBeConverted) then integralValue = StrToInt(valueFromDocument, true);
```
Exemple de `ValidateByDB` :
```text theme={null}
if not IsNull then ValidateByDB(Value(), "Provider=Microsoft.Jet.OLEDB.4.0; Data Source=D:\\FCS\\Companies.mdb", "SELECT Name FROM Companies", 1, 0.3, true, 500);
```
Exemple de `ValidateByFile` :
```text theme={null}
if not IsNull then ValidateByTextFile(Value(), "Companies.txt", 1, 0.3, true, 500);
```
Exemple de `ValidateByText` :
```text theme={null}
if not IsNull then ValidateByText (Value(), "ABBYY|Flexi Capture", 1, 0.3, true);
```
Exemple de `StrToReal` :
```text theme={null}
Real realValue;
String valueFromDocument = SearchElements.StaticText.Value();
Logic canBeConverted = IsReal(valueFromDocument, ".");
if(canBeConverted) then realValue = StrToReal(valueFromDocument, ".");
```
## Fonctions de base de données et de fichiers
| Définition | Description |
| --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Int RecordCount( String connectionString, String selectString )` | Renvoie le nombre d’enregistrements retournés par la requête. Voir l’exemple de la fonction `Record` dans cette section. |
| `Logic ExecuteSQL( String connectionString, String queryString )` | Exécute la requête SQL utilisateur `queryString`. L’argument `connectionString` définit la string de connexion à la base de données. |
| `Logic TestDBConnection( String connectionString )` | Teste la connexion à la base de données. L’argument `connectionString` contient la string de connexion. |
| `Logic TestDBSelect( String connectionString, String selectString )` | Vérifie que la base de données est accessible et que la requête SQL est correcte (autrement dit, que la table et le champ spécifiés existent). L’argument `connectionString` contient la string de connexion. L’argument `selectString` contient la requête SQL, qui commence par la commande `SELECT`. |
| `Logic TestFileAccess( String fileName )` | Vérifie que le fichier texte est accessible. |
| `Logic WriteToFile( String filename, String text )` | Ajoute la string `text` au fichier `filename`. Si aucun fichier de ce nom n’existe, un nouveau fichier est créé. |
| `StringArray ReadFromXML( String filename, String xPathQuery )` | Lit le tableau de strings depuis le fichier XML `filename`. Les strings sont obtenues en évaluant l’expression XPath `xPathQuery` transmise. |
| `StringArray Record( String connectionString, String selectString, Int index )` | Récupère les données d’un enregistrement spécifique. Pour une cellule de valeur `NULL`, une string vide est renvoyée. |
| `String ReadSingleStringFromXML( String filename, String xPathQuery )` | Lit une string depuis le fichier XML `filename`. La string est obtenue en évaluant l’expression XPath `xPathQuery` transmise. |
| `Void PrepareRecordset( String connectionString, String selectString, Int maxRecordsCount = 1000 )` | Prépare la requête pour un accès rapide. Voir l’exemple de la fonction `Record` dans cette section. |
Exemple pour `ExecuteSQL` :
```text theme={null}
ExecuteSQL("Provider=Microsoft.Jet.OLEDB.4.0; Data Source=D:\\FCS\\Companies.mdb", "UPDATE Companies SET total=0");
```
Exemple de `WriteToFile` :
```text theme={null}
WriteToFile("D:\\FCS\\logFile.txt", SearchElements.Tag.Value());
```
Exemple pour `Record` :
```text theme={null}
String connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=D:\\1.mdb;";
String selectString = "SELECT SearchText, LeftPos, TopPos, RightPos, BottomPos from SearchPositions WHERE ElementName = 'DocID'";
PrepareRecordset(connectionString, selectString);
Int recordCount = RecordCount(connectionString, selectString);
String searchString;
RectArray searchArea = RectArray();
for recordIndex from 0 to recordCount - 1 {
StringArray recordArray = Record(connectionString, selectString, recordIndex);
if recordIndex == 0 then {
searchString = recordArray.GetAt(0);
} else {
searchString = searchString + "|" + recordArray.GetAt(0);
}
searchArea.Add(Rect(StrToInt(recordArray.GetAt(1)) * dt, StrToInt(recordArray.GetAt(2)) * dt,StrToInt(recordArray.GetAt(3)) * dt, StrToInt(recordArray.GetAt(4)) * dt));
}
SearchText: searchString;
RSA: searchArea;
```
Dans cet exemple, une string de recherche **SearchText** ainsi que les coordonnées des rectangles de la zone de recherche **LeftPos**, **TopPos**, **RightPos** et **BottomPos** sont extraites du tableau **SearchPositions**. La valeur du champ **SearchText** est combinée en une string de recherche à l’aide de l’opérateur `|`. Les coordonnées **LeftPos**, **TopPos**, **RightPos** et **BottomPos** des champs du tableau sont utilisées pour générer, en dots, les coordonnées des rectangles. Les coordonnées générées sont ajoutées à la zone de recherche de l’élément **DocID**.
## Fonctions de page et de document
| Définition | Description |
| -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Distance AverageLineHeight()` | Hauteur moyenne des lignes de texte sur la page. Cette fonction ne peut être utilisée que si les nombres minimal et maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur. Pour un document multipage, utilisez la méthode correspondante du type `Page` : `Page( N ).AverageLineHeight`. |
| `Distance AverageInterLineInterval()` | Distance moyenne entre les lignes de texte sur la page. Cette fonction ne peut être utilisée que si les nombres minimal et maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur. Pour un document multipage, utilisez la méthode correspondante du type `Page` : `Page( N ).AverageInterLineInterval`. |
| `Int PagesCount()` | Renvoie le nombre de pages du document. |
| `Page Page( Int PageNumber )` | Renvoie le type qui décrit la page spécifiée. |
| `Rect DocumentRect()` | Renvoie le rectangle du document entier (en coordonnées globales). |
| `Rect PageRect()` | Renvoie le rectangle de l’image entière. Cette fonction ne peut être utilisée que si les nombres minimal et maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur. Pour un document multipage, cette fonction ne peut être utilisée que dans la section **Relations de pré-recherche**. Pour plus d’informations, voir [Fonctions qui limitent la zone de recherche](/fr/flexi-capture/fls/language/search-functions). |
| `Void SetPagesCount( Int pagesCount )` | Définit le nombre de pages du document. Cette fonction est utilisée dans les sections **Pré-recherche** ou **Code avancé de post-recherche**. Elle doit être appelée à partir des éléments d’en-tête ou de pied de page, ou de leurs sous-éléments. La fonction s’applique aux documents qui n’ont pas d’indicateur de fin de document (le pied de page est absent ou facultatif). |
Exemple d’utilisation de `SetPagesCount` :
Si l’élément donné a été trouvé, le document se termine sur la page suivante :
```text theme={null}
if IsFound then SetPagesCount(PagesCount + 1);
```
Le nombre de pages du document est indiqué dans le champ **PageNum** :
```text theme={null}
if PageNum.IsFound and IsInt(PageNum.Value) then SetPagesCount: StrToInt(PageNum.Value);
```
## Fonctions de pré-reconnaissance
Les fonctions suivantes invoquent la pré-reconnaissance lors de la mise en correspondance de FlexiLayout. Les lignes de texte qui recoupent une zone de pré-reconnaissance donnée sont reconnues dans leur intégralité (y compris les parties des lignes qui dépassent les limites de la zone).
| Définition | Description |
| ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Void RecognizeText()` | Reconnaît le texte dans le rectangle relatif spécifié dans la propriété **Zone de pré-reconnaissance** des paramètres du projet. Toutes les pages du document sont prises en compte lors de la reconnaissance. |
| `Void RecognizeText( IntArray pages )` | Reconnaît le texte dans le rectangle relatif spécifié dans la propriété **Zone de pré-reconnaissance** des paramètres du projet. Seules les pages spécifiées par l’argument `pages` sont prises en compte lors de la reconnaissance. |
| `Void RecognizeText( SearchAreaPageSetType pageSetType )` | Reconnaît le texte dans le rectangle relatif spécifié dans la propriété **Zone de pré-reconnaissance** des paramètres du projet. Seules les pages spécifiées par l’argument `pageSetType` sont prises en compte lors de la reconnaissance. |
| `Void RecognizeText( Rect rect )` | Reconnaît le texte dans le rectangle `rect`. |
| `Void RecognizeText( Rect rect, IntArray pages )` | Reconnaît le texte dans le rectangle `rect`. Seules les pages spécifiées par l’argument `pages` sont prises en compte lors de la reconnaissance. |
| `Void RecognizeText( Rect rect, SearchAreaPageSetType pageSetType )` | Reconnaît le texte dans le rectangle `rect`. Seules les pages spécifiées par l’argument `pageSetType` sont prises en compte lors de la reconnaissance. |
| `Void RecognizeText( RectArray rectArray )` | Reconnaît le texte dans le tableau de rectangles `rectArray`. |
| `Void RecognizeText( RectArray rectArray, IntArray pages )` | Reconnaît le texte dans le tableau de rectangles `rectArray`. Seules les pages spécifiées par l’argument `pages` sont prises en compte lors de la reconnaissance. |
| `Void RecognizeText( RectArray rectArray, SearchAreaPageSetType pageSetType )` | Reconnaît le texte dans le tableau de rectangles `rectArray`. Seules les pages spécifiées par l’argument `pageSetType` sont prises en compte lors de la reconnaissance. |
| `Void RecognizeText( Region region )` | Reconnaît le texte dans la région `region`. |
| `Void RecognizeText( Region region, IntArray pages )` | Reconnaît le texte dans la région `region`. Seules les pages spécifiées par l’argument `pages` sont prises en compte lors de la reconnaissance. |
| `Void RecognizeText( Region region, SearchAreaPageSetType pageSetType )` | Reconnaît le texte dans la région `region`. Seules les pages spécifiées par l’argument `pageSetType` sont prises en compte lors de la reconnaissance. |
| `RectArray RecognizedRects()` | Fonction de débogage permettant d’afficher un tableau de rectangles préreconnus. |