> ## 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.
# Globale Funktionen
> Globale Funktionen in der FlexiLayout-Sprache: Mathematik- und String-Hilfsfunktionen, Datenbankabfragen wie ExecuteSQL, Validierungsfunktionen und RecognizeText-Aufrufe.
Die FlexiLayout-Sprache bietet globale Funktionen für mathematische und Vergleichsoperationen, Koordinaten- und Intervallberechnungen, String-Verarbeitung, Konvertierung und Validierung, Datenbank- und Dateizugriff, Seiten- und Dokumentverarbeitung sowie Vorerkennung.
Verwenden Sie keine Variablen als Argumente für globale Funktionen, die mit externen Dateien oder Datenbanken interagieren.
## Mathematische Funktionen und Vergleichsfunktionen
| Definition | Beschreibung |
| ------------------------------------------ | ---------------------------------------------------------------------------- |
| `Area Max( Area a1, Area a2 )` | Gibt den größeren Wert von `a1` und `a2` zurück. |
| `Area Min( Area a1, Area a2 )` | Gibt den kleineren Wert von `a1` und `a2` zurück. |
| `Distance abs( Distance )` | Gibt den Betrag einer Distanz zurück. |
| `Distance Min( Distance d1, Distance d2 )` | Gibt den kleineren Wert von `d1` und `d2` zurück. |
| `Distance Max( Distance d1, Distance d2 )` | Gibt den größeren Wert von `d1` und `d2` zurück. |
| `Int abs( Int )` | Gibt den Betrag einer Zahl zurück. |
| `Int Ceil( Real )` | Gibt die kleinste ganze Zahl zurück, die nicht kleiner als das Argument ist. |
| `Int Floor( Real )` | Gibt die größte ganze Zahl zurück, die nicht größer als das Argument ist. |
| `Int Max( Int n1, Int n2 )` | Gibt den größeren Wert von `n1` und `n2` zurück. |
| `Int Min( Int n1, Int n2 )` | Gibt den kleineren Wert von `n1` und `n2` zurück. |
| `Int Round( Real )` | Gibt die ganze Zahl zurück, die dem Argument am nächsten kommt. |
| `Real Min( Real d1, Real d2 )` | Gibt den kleineren Wert von `d1` und `d2` zurück. |
| `Real Max( Real d1, Real d2 )` | Gibt den größeren Wert von `d1` und `d2` zurück. |
## Koordinaten- und Intervallfunktionen
| Definition | Beschreibung |
| ------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Area ObjectsArea( Rect, ImageObjectType )` | Der Flächeninhalt der Objekte des angegebenen Typs innerhalb des angegebenen Rectangle. Verwendet globale Koordinaten. |
| `Area ObjectsIntersectionArea( Rect, ImageObjectType )` | Der Flächeninhalt der Objekte des angegebenen Typs innerhalb des angegebenen Rectangle sowie die Schnittfläche von Objekten des angegebenen Typs, die über das angegebene Rectangle hinausreichen. Verwendet globale Koordinaten. |
| `Logic IsOnSameLine( Hypothesis, Hypothesis )` | Prüft, ob sich die Hypothesen vertikal überschneiden. |
| `Region FormRegion( RectArray included, RectArray excluded )` | Erstellt eine Region, die das Array der `included`-Rectangles einschließt und das Array der `excluded`-Rectangles ausschließt. |
| `XCoordinate Min( XCoordinate x1, XCoordinate x2 )` | Gibt den kleineren Wert von `x1` und `x2` zurück. |
| `XCoordinate Max( XCoordinate x1, XCoordinate x2 )` | Gibt den größeren Wert von `x1` und `x2` zurück. |
| `XCoordinate MiddleBetween( XCoordinate x1, XCoordinate x2 )` | Gibt die X-Koordinate zurück, berechnet als `( x1 + x2 ) / 2`. |
| `XCoordinate Between( XCoordinate x1, XCoordinate x2, Real ratio )` | Gibt die X-Koordinate zurück, berechnet als `x1 + ( x2 - x1 ) * ratio`. |
| `YCoordinate Min( YCoordinate y1, YCoordinate y2 )` | Gibt den kleineren Wert von `y1` und `y2` zurück. |
| `YCoordinate Max( YCoordinate y1, YCoordinate y2 )` | Gibt den größeren Wert von `y1` und `y2` zurück. |
| `YCoordinate MiddleBetween( YCoordinate y1, YCoordinate y2 )` | Gibt YInterval zurück, berechnet als `( y1 + y2 ) / 2`. |
| `YCoordinate Between( YCoordinate y1, YCoordinate y2, Real ratio )` | Gibt YInterval zurück, berechnet als `y1 + ( y2 - y1 ) * ratio`. |
| `XInterval MiddleBetween( XInterval x1, XInterval x2 )` | Gibt XInterval zurück, berechnet als `( x1 + x2 ) / 2`. |
| `XInterval Between( XInterval x1, XInterval x2, Real ratio )` | Gibt XInterval zurück, berechnet als `x1 + ( x2 - x1 ) * ratio`. |
| `YInterval MiddleBetween( YInterval y1, YInterval y2 )` | Gibt YInterval zurück, berechnet als `( y1 + y2 ) / 2`. |
| `YInterval Between( YInterval y1, YInterval y2, Real ratio )` | Gibt YInterval zurück, berechnet als `y1 + ( y2 - y1 ) * ratio`. |
## String-Funktionen
| Definition | Beschreibung |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `String Chr( Int )` | Gibt anhand des angegebenen Unicode-Codes des Zeichens einen String zurück (der Code muss im Dezimalsystem angegeben werden). |
| `String LCase( String )` | Gibt einen String zurück, in dem alle Zeichen des angegebenen Strings in Kleinbuchstaben umgewandelt wurden. |
| `String RealToStrVariants( Real value, String fractionalPartSeparators, Int maxDigitsCountInFractionalPart = 2 )` | Erstellt durch einen senkrechten Strich (`\|`) getrennte String-Darstellungen für den angegebenen Real-Wert `value`, die Dezimaltrennzeichen `fractionalPartSeparators` und die maximale Anzahl von Ziffern im Nachkommateil. Für die Argumente `19`, `".,"`, `2` lautet das Ergebnis beispielsweise `"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 )` | String-Darstellung eines Datentyps. |
| `String RemoveSpaces( String )` | Gibt einen String zurück, in dem alle Leerzeichen aus dem angegebenen String entfernt wurden. |
| `String UCase( String )` | Gibt einen String zurück, in dem alle Zeichen des angegebenen Strings in Großbuchstaben umgewandelt wurden. |
## Konvertierungs- und Validierungsfunktionen
| Definition | Beschreibung |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Int LogicToInt( Logic value )` | Gibt `1` zurück, wenn der Wert `true` ist, und `0`, wenn der Wert `false` ist. |
| `Int StrToInt( String inputString, Logic isStrictMode = false )` | Gibt das Ergebnis der Konvertierung des Zeichenfolgenwerts `inputString` in eine Ganzzahl zurück. Leerzeichen werden ausgelassen. Der Parameter `isStrictMode` (standardmäßig `false`) legt fest, ob die Zeichenfolge andere Zeichen als Ziffern und Leerzeichen enthalten kann. Wenn `isStrictMode = false` ist und die Zeichenfolge ein Zeichen enthält, das weder eine Ziffer noch ein Leerzeichen ist, werden alle nachfolgenden Zeichen ausgelassen. Prüfen Sie vor dem Aufruf dieser Funktion, ob die Zeichenfolge konvertiert werden kann. Verwenden Sie dazu die Funktion `IsInt`. |
| `Int StrToIntFuzzy( String, Logic isStrictMode = false )` | Gibt das Ergebnis der Umwandlung des Werts der Zeichenfolge `inputString` in eine Ganzzahl zurück, wobei mögliche Erkennungsfehler in der Zeichenfolge berücksichtigt werden (siehe Beschreibung der Funktion `IsIntFuzzy`). Leerzeichen werden bei der Umwandlung ignoriert. Der Parameter `isStrictMode` (standardmäßig auf `false` gesetzt) legt fest, ob die Zeichenfolge andere Zeichen als Ziffern, ziffernähnliche Zeichen oder Leerzeichen enthalten darf. Wenn `isStrictMode = false` ist und ein anderes Zeichen als eine Ziffer gefunden wird, werden alle nachfolgenden Zeichen ignoriert. Bevor Sie die Umwandlung starten, rufen Sie die Funktion `IsIntFuzzy` auf, um zu prüfen, ob die Zeichenfolge sicher umgewandelt werden kann. |
| `Logic IsInt( String inputString, Logic isStrictMode = false )` | Prüft, ob die Zeichenfolge `inputString` sicher in eine Ganzzahl konvertiert werden kann. Der Parameter `isStrictMode` (standardmäßig `false`) legt fest, ob die Zeichenfolge neben Ziffern und Leerzeichen auch andere Zeichen enthalten darf. |
| `Logic IsIntFuzzy( String inputString, Logic isStrictMode = false )` | Prüft, ob die Zeichenfolge `inputString` unter Berücksichtigung möglicher Erkennungsfehler sicher in eine Ganzzahl umgewandelt werden kann. Diese Art der Umwandlung konvertiert nicht nur Ziffern (also die Zeichen `0123456789`) in Ganzzahlen, sondern auch Zeichen, die wie Ziffern aussehen (zum Beispiel `oOBsl`). Der Parameter `isStrictMode` (der standardmäßig auf `false` gesetzt ist) bestimmt, ob die Zeichenfolge außer Ziffern, ziffernähnlichen Zeichen oder Leerzeichen noch andere Zeichen enthalten darf. |
| `Logic IsReal( String numberString, String separators = ".,", Logic isStrictMode = false )` | Prüft, ob die Zeichenfolge `inputString` in eine reelle Zahl umgewandelt werden kann. Die Liste der zulässigen Dezimaltrennzeichen wird durch das Argument `separators` festgelegt. Standardmäßig sind der Punkt, das Komma und das benutzerdefinierte Trennzeichen zulässig (konfiguriert in den regionalen Einstellungen des Betriebssystems, siehe `RegionalDecimalPoint`). Der Parameter `isStrictMode` (`false` ist der Standardwert) legt fest, ob die Zeichenfolge andere Zeichen als Ziffern, Leerzeichen und Trennzeichen enthalten darf. |
| `Logic IsRealFuzzy( String, String separators = defaultDecimalSeparators, Logic isStrictMode = false )` | Prüft, ob die Zeichenfolge `inputString` unter Berücksichtigung möglicher Erkennungsfehler sicher in eine reelle Zahl konvertiert werden kann (siehe die Beschreibung der Funktion `IsIntFuzzy`). Die Liste der zulässigen Dezimaltrennzeichen wird durch das Argument `separators` festgelegt. Standardmäßig sind die folgenden Trennzeichen zulässig: Punkt, Komma und das Trennzeichen, das in den regionalen Einstellungen des Betriebssystems des Benutzers festgelegt ist (siehe `RegionalDecimalPoint`). Der Parameter `isStrictMode` (standardmäßig auf `false` gesetzt) legt fest, ob die Zeichenfolge andere Zeichen als Ziffern, Ziffern ähnlich sehende Zeichen, Leerzeichen oder Trennzeichen enthalten darf. |
| `Quality ValidateByDB( String word, String connectionString, String selectString, Int maxErrors, Real maxErrorsPart, Logic ignoreSpaces, Int maxRecordsCount = 1000 )` | Prüft das angegebene Wort, indem es mit einer Datenbank abgeglichen wird. Weitere Informationen finden Sie unter [Datenbanken und Textdateien in der FlexiLayout-Sprache](/de/flexi-capture/fls/language/bd-textfiles). Das Argument `connectionString` legt die Zeichenfolge für die Verbindung zur Datenbank fest. Das Argument `selectString` legt eine SQL-Abfrage fest, die mit dem Befehl `SELECT` beginnt. Das Argument `maxErrors` legt die absolute maximale Anzahl von Fehlern im Wort fest, und `maxErrorsPart` legt die relative maximale Anzahl von Fehlern im Wort fest. Das Argument `ignoreSpaces` bestimmt, ob Leerzeichen beim Vergleich berücksichtigt werden sollen. Um die Suche zu beschleunigen, werden nur die ersten `maxRecordsCount` Varianten verwendet (die Standardeinstellung ist 1000). Gibt die Quality des Matchings zwischen dem angegebenen Wort und der besten Übereinstimmung aus der Datenbank zurück. Diese Funktion kann im Feld **Erweiterte Nach-Suchbeziehungen** für fuzzy Matching des String-Werts einer von der Methode `Value` zurückgegebenen Hypothesis mit angegebenen Varianten verwendet werden. |
| `Quality ValidateByFile( String word, String fileName, Int maxErrors, Real maxErrorsPart, Logic ignoreSpaces, Int maxRecordsCount = 1000 )` | Prüft das angegebene Wort, indem es mit den Varianten in der Datei `fileName` verglichen wird, die mögliche Phrasenvarianten enthält. Weitere Informationen finden Sie unter [Datenbanken und Textdateien in der FlexiLayout-Sprache](/de/flexi-capture/fls/language/bd-textfiles). Das Argument `maxErrors` legt die absolute maximale Anzahl von Fehlern im Wort fest, und `maxErrorsPart` legt die relative maximale Anzahl von Fehlern im Wort fest. Das Argument `ignoreSpaces` bestimmt, ob Leerzeichen beim Vergleich berücksichtigt werden sollen. Gibt die Quality des Matchings zwischen dem angegebenen Wort und der besten Übereinstimmung aus der Textdatei zurück. Um die Suche zu beschleunigen, werden nur die ersten `maxRecordsCount` Varianten verwendet (die Standardeinstellung ist 1000). Diese Funktion kann im Feld **Erweiterte Nach-Suchbeziehungen** für das unscharfe Matching des string-Werts einer von der Methode `Value` zurückgegebenen Hypothese mit angegebenen Varianten verwendet werden. |
| `Quality ValidateByText( String word, String variants, Int maxErrors, Real maxErrorsPart, Logic ignoreSpaces )` | Prüft das angegebene Wort durch Vergleich mit den aufgeführten Varianten. Das Argument `maxErrors` legt die absolut zulässige Höchstzahl an Fehlern im Wort fest, und `maxErrorsPart` die relativ zulässige Höchstzahl an Fehlern im Wort. Das Argument `ignoreSpaces` bestimmt, ob Leerzeichen beim Vergleich berücksichtigt werden sollen. Gibt die Quality des Matchings zwischen dem angegebenen Wort und der besten Übereinstimmung aus den im Argument `variants` aufgeführten Varianten zurück. Diese Funktion kann im Feld **Erweiterte Nach-Suchbeziehungen** für das unscharfe Matching des String-Werts einer von der Methode `Value` zurückgegebenen Hypothese mit den angegebenen Varianten verwendet werden. |
| `Real StrToReal( String numberString, String separators = ".,", Logic isStrictMode = false )` | Gibt das Ergebnis der Konvertierung des Strings `inputString` in eine Zahl vom Typ Real zurück. Leerzeichen werden ignoriert. Der Parameter `isStrictMode` (`false` standardmäßig) legt fest, ob der String andere Zeichen als Ziffern, Leerzeichen und Trennzeichen enthalten darf. Wenn `isStrictMode = false` ist und der String ein zweites Dezimaltrennzeichen oder ein Zeichen enthält, das weder eine Ziffer noch ein Leerzeichen ist, werden alle nachfolgenden Zeichen ignoriert. Prüfen Sie vor dem Aufruf dieser Funktion, ob der String konvertiert werden kann. Verwenden Sie dazu die Funktion `IsReal`. |
| `Real StrToRealFuzzy( String, String separators = defaultDecimalSeparators, Logic isStrictMode = false )` | Gibt das Ergebnis der Umwandlung des Werts der Zeichenfolge `inputString` in eine reelle Zahl zurück, wobei mögliche Erkennungsfehler in der Zeichenfolge berücksichtigt werden (siehe Beschreibung der Funktion `IsIntFuzzy`). Leerzeichen werden bei der Umwandlung ignoriert. Der Parameter `isStrictMode` (der standardmäßig auf `false` gesetzt ist) bestimmt, ob die Zeichenfolge andere Zeichen als Ziffern, ziffernähnliche Zeichen, Leerzeichen oder Trennzeichen enthalten darf. Wenn `isStrictMode = false` und ein zweites Dezimaltrennzeichen oder ein anderes Zeichen als eine Ziffer erkannt wird, werden alle nachfolgenden Zeichen ignoriert. Rufen Sie vor dem Start der Umwandlung die Funktion `IsRealFuzzy` auf, um zu prüfen, ob die Zeichenfolge sicher umgewandelt werden kann. |
Beispiel für `StrToInt`:
```text theme={null}
Int integralValue;
String valueFromDocument = SearchElements.StaticText.Value();
Logic canBeConverted = IsInt(valueFromDocument, true);
if(canBeConverted) then integralValue = StrToInt(valueFromDocument, true);
```
Beispiel für `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);
```
Beispiel für `ValidateByFile`:
```text theme={null}
if not IsNull then ValidateByTextFile(Value(), "Companies.txt", 1, 0.3, true, 500);
```
Beispiel für `ValidateByText`:
```text theme={null}
if not IsNull then ValidateByText (Value(), "ABBYY|Flexi Capture", 1, 0.3, true);
```
Beispiel für `StrToReal`:
```text theme={null}
Real realValue;
String valueFromDocument = SearchElements.StaticText.Value();
Logic canBeConverted = IsReal(valueFromDocument, ".");
if(canBeConverted) then realValue = StrToReal(valueFromDocument, ".");
```
## Datenbank- und Dateifunktionen
| Definition | Beschreibung |
| --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Int RecordCount( String connectionString, String selectString )` | Gibt die Anzahl der Datensätze zurück, die von der Abfrage geliefert werden. Siehe das Beispiel für die Funktion `Record` in diesem Abschnitt. |
| `Logic ExecuteSQL( String connectionString, String queryString )` | Führt die SQL-Abfrage des Benutzers `queryString` aus. Das Argument `connectionString` gibt die Datenbank-Verbindungszeichenfolge an. |
| `Logic TestDBConnection( String connectionString )` | Testet die Datenbankverbindung. Das Argument `connectionString` enthält die Verbindungszeichenfolge. |
| `Logic TestDBSelect( String connectionString, String selectString )` | Prüft, ob die Datenbank erreichbar ist und ob die SQL-Abfrage korrekt ist (ob die angegebene Tabelle und das angegebene Feld vorhanden sind). Das Argument `connectionString` enthält die Verbindungszeichenfolge. Das Argument `selectString` enthält die SQL-Abfrage, die mit dem Befehl `SELECT` beginnt. |
| `Logic TestFileAccess( String fileName )` | Prüft, ob auf die Textdatei zugegriffen werden kann. |
| `Logic WriteToFile( String filename, String text )` | Fügt die Zeichenfolge `text` an die Datei `filename` an. Wenn keine Datei mit diesem Namen vorhanden ist, wird eine neue Datei erstellt. |
| `StringArray ReadFromXML( String filename, String xPathQuery )` | Liest das Array von Strings aus der XML-Datei `filename`. Die Strings werden durch Auswertung der übergebenen XPath-Abfrage `xPathQuery` ermittelt. |
| `StringArray Record( String connectionString, String selectString, Int index )` | Ruft die Daten eines bestimmten Datensatzes ab. Für eine Zelle mit dem Wert `NULL` wird eine leere Zeichenfolge zurückgegeben. |
| `String ReadSingleStringFromXML( String filename, String xPathQuery )` | Liest die Zeichenfolge aus der XML-Datei `filename`. Die Zeichenfolge wird durch Auswertung der übergebenen XPath-Abfrage `xPathQuery` ermittelt. |
| `Void PrepareRecordset( String connectionString, String selectString, Int maxRecordsCount = 1000 )` | Bereitet die Abfrage für einen schnellen Zugriff vor. Siehe das Beispiel für die Funktion `Record` in diesem Abschnitt. |
Beispiel für `ExecuteSQL`:
```text theme={null}
ExecuteSQL("Provider=Microsoft.Jet.OLEDB.4.0; Data Source=D:\\FCS\\Companies.mdb", "UPDATE Companies SET total=0");
```
Beispiel für `WriteToFile`:
```text theme={null}
WriteToFile("D:\\FCS\\logFile.txt", SearchElements.Tag.Value());
```
Beispiel für `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;
```
In diesem Beispiel werden aus der Tabelle **SearchPositions** eine Suchzeichenfolge **SearchText** sowie die Rechteckkoordinaten für den Suchbereich **LeftPos**, **TopPos**, **RightPos** und **BottomPos** extrahiert. Der Wert des Felds **SearchText** wird mithilfe des Operators `|` zu einer Suchzeichenfolge kombiniert. Die Koordinaten **LeftPos**, **TopPos**, **RightPos** und **BottomPos** aus den Tabellenfeldern werden verwendet, um Koordinaten in dots für die Rechtecke zu erzeugen. Die erzeugten Koordinaten werden dem Suchbereich des Elements **DocID** hinzugefügt.
## Seiten- und Dokumentfunktionen
| Definition | Beschreibung |
| -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Distance AverageLineHeight()` | Die durchschnittliche Höhe der Textzeilen auf der Seite. Die Funktion kann nur verwendet werden, wenn die maximale und minimale Seitenanzahl im Dokument auf 1 festgelegt ist, d. h. das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt der Abgleich des FlexiLayouts zu einem Fehler. Verwenden Sie für ein mehrseitiges Dokument die entsprechende Methode des Typs `Page`: `Page( N ).AverageLineHeight`. |
| `Distance AverageInterLineInterval()` | Der durchschnittliche Abstand zwischen den Textzeilen auf der Seite. Die Funktion kann nur verwendet werden, wenn die maximale und minimale Seitenanzahl im Dokument auf 1 festgelegt ist, d. h. das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt der Abgleich des FlexiLayouts zu einem Fehler. Verwenden Sie für ein mehrseitiges Dokument die entsprechende Methode des Typs `Page`: `Page( N ).AverageInterLineInterval`. |
| `Int PagesCount()` | Gibt die Anzahl der Seiten im Dokument zurück. |
| `Page Page( Int PageNumber )` | Gibt den Typ zurück, der die angegebene Seite beschreibt. |
| `Rect DocumentRect()` | Gibt das Rectangle des gesamten Dokuments zurück (in globalen Koordinaten). |
| `Rect PageRect()` | Das Rectangle des gesamten Bildes. Die Funktion kann nur verwendet werden, wenn die maximale und minimale Seitenanzahl im Dokument auf 1 festgelegt ist, d. h. das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt der Abgleich des FlexiLayouts zu einem Fehler. Bei einem mehrseitigen Dokument darf diese Funktion nur im Abschnitt **Pre-search relations** verwendet werden. Weitere Informationen finden Sie unter [Funktionen, die den Suchbereich einschränken](/de/flexi-capture/fls/language/search-functions). |
| `Void SetPagesCount( Int pagesCount )` | Legt die Anzahl der Seiten im Dokument fest. Sie wird in den Abschnitten **Pre-search** oder **Post-search advanced code** verwendet. Diese Funktion muss von den Header- oder Footer-Elementen bzw. deren Unterelementen aufgerufen werden. Die Funktion gilt für Dokumente, die keine Ende-des-Dokuments-Markierung haben (die Fußzeile fehlt entweder oder ist optional). |
Beispiel für `SetPagesCount`:
Wenn das angegebene Element gefunden wurde, endet das Dokument auf der nächsten Seite:
```text theme={null}
if IsFound then SetPagesCount(PagesCount + 1);
```
Die Anzahl der Seiten im Dokument ist im Feld **PageNum** ersichtlich:
```text theme={null}
if PageNum.IsFound and IsInt(PageNum.Value) then SetPagesCount: StrToInt(PageNum.Value);
```
## Funktionen zur Vorerkennung
Die folgenden Funktionen rufen die Vorerkennung während des Abgleichs des FlexiLayouts auf. Die Textzeilen, die einen angegebenen Vorerkennungsbereich schneiden, werden vollständig erkannt (einschließlich der Zeilenteile, die außerhalb der Bereichsgrenzen liegen).
| Definition | Beschreibung |
| ------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Void RecognizeText()` | Erkennt Text in dem relativen Rectangle, das in den Projekteinstellungen in der Eigenschaft **Pre-recognition area** angegeben ist. Alle Dokumentseiten werden in die Erkennung einbezogen. |
| `Void RecognizeText( IntArray pages )` | Erkennt Text in dem relativen Rectangle, das in den Projekteinstellungen in der Eigenschaft **Pre-recognition area** angegeben ist. Nur die durch das Argument `pages` angegebenen Seiten werden in die Erkennung einbezogen. |
| `Void RecognizeText( SearchAreaPageSetType pageSetType )` | Erkennt Text in dem relativen Rectangle, das in den Projekteinstellungen in der Eigenschaft **Pre-recognition area** angegeben ist. Nur die durch das Argument `pageSetType` angegebenen Seiten werden in die Erkennung einbezogen. |
| `Void RecognizeText( Rect rect )` | Erkennt Text in dem Rectangle `rect`. |
| `Void RecognizeText( Rect rect, IntArray pages )` | Erkennt Text in dem Rectangle `rect`. Nur die durch das Argument `pages` angegebenen Seiten werden in die Erkennung einbezogen. |
| `Void RecognizeText( Rect rect, SearchAreaPageSetType pageSetType )` | Erkennt Text in dem Rectangle `rect`. Nur die durch das Argument `pageSetType` angegebenen Seiten werden in die Erkennung einbezogen. |
| `Void RecognizeText( RectArray rectArray )` | Erkennt Text in dem RectArray `rectArray`. |
| `Void RecognizeText( RectArray rectArray, IntArray pages )` | Erkennt Text in dem RectArray `rectArray`. Nur die durch das Argument `pages` angegebenen Seiten werden in die Erkennung einbezogen. |
| `Void RecognizeText( RectArray rectArray, SearchAreaPageSetType pageSetType )` | Erkennt Text in dem RectArray `rectArray`. Nur die durch das Argument `pageSetType` angegebenen Seiten werden in die Erkennung einbezogen. |
| `Void RecognizeText( Region region )` | Erkennt Text in der Region `region`. |
| `Void RecognizeText( Region region, IntArray pages )` | Erkennt Text in der Region `region`. Nur die durch das Argument `pages` angegebenen Seiten werden in die Erkennung einbezogen. |
| `Void RecognizeText( Region region, SearchAreaPageSetType pageSetType )` | Erkennt Text in der Region `region`. Nur die durch das Argument `pageSetType` angegebenen Seiten werden in die Erkennung einbezogen. |
| `RectArray RecognizedRects()` | Eine Debugging-Funktion, mit der ein Array vorerkannter Rectangles ausgegeben werden kann. |