> ## 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.
# Table
> Durchsuchen Sie Tabellen mit dem Table-Element in der FlexiLayout language: Parameter für Spalten, Kopfzeile, Fußzeile und Tabellenkörper, Zeilenerkennung und mehrseitige Tabellen.
Das **Table**-Element unterstützt in der FlexiLayout language die folgenden Parameter. Verwenden Sie sie, um die Erkennung von Spalten, Kopfzeile, Fußzeile und Tabellenkörper zu konfigurieren sowie Zeilen aufzuteilen und mehrseitige Tabellen zu verarbeiten.
## Parameter für die Spaltensuche
| Parameter | Beschreibung |
| -------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Void AddHeaderKeyWord( String keyWord, TableBlockColumn column, Real omissionQuality, Logic wholeWordMode, Logic multiLine )` | Gibt das Schlüsselwort für den Spaltennamen an. Siehe im Dialogfeld des Elements **Table** die [**Spalteneigenschaften**](/de/flexi-capture/fls/tables/column), Option **Durch Schlüsselwort im Namen erkennen**. |
| `Void AddHeaderKeyHypothesis( Hypothesis hypothesis, TableBlockColumn column )` | Gibt den Spaltennamen anhand der erkannten Hypothese an. Siehe im Dialogfeld des Elements **Table** die [**Spalteneigenschaften**](/de/flexi-capture/fls/tables/column), Option **Gefundenes Element als Spaltennamen verwenden**. |
| `Void AddHeaderKeyHypothesis( DistInterval left, DistInterval top, DistInterval right, DistInterval bottom, TableBlockColumn column )` | Gibt die Koordinaten des Spaltennamens an. |
| `Void AddColumnType( TableColumnType type, TableBlockColumn column, String regExp )` | Gibt den Spaltentyp an. Der dritte Parameter darf nur angegeben werden, wenn der Spaltentyp ein regulärer Ausdruck ist. Siehe im Dialogfeld des Elements **Table** die [**Spalteneigenschaften**](/de/flexi-capture/fls/tables/column), Eigenschaft **Typ des Spalteninhalts**. |
| `Void ColumnOmissionQuality( Real quality, TableBlockColumn column )` | Wenn feste Spaltenreihenfolgen verwendet werden, legt dieser Parameter den Abzug für die Hypothesen fest. Das ist der Koeffizient (eine Zahl von `0` bis `1`), mit dem die Quality der Hypothese multipliziert wird, wenn die in der festen Spaltenreihenfolge angegebene Spalte nicht erkannt wird. Wenn der Parameter nicht festgelegt ist, lautet sein Standardwert `0.9`. |
| `Void MissingContentPenalty( Real quality, TableBlockColumn column )` | Legt den Abzug für die Hypothesen fest. Das ist der Koeffizient (eine Zahl von `0` bis `1`), mit dem die Quality der Hypothese multipliziert wird, wenn der tatsächliche Datentyp in der Spalte nicht mit dem vom Benutzer angegebenen Datentyp übereinstimmt. Siehe im Dialogfeld des Elements **Table** die [**Spalteneigenschaften**](/de/flexi-capture/fls/tables/column), **Abzug bei fehlendem Inhalt**. Wenn der Parameter nicht festgelegt ist, lautet sein Standardwert `0.98`. Wenn Regeln für die Spaltenreihenfolge verwendet werden, gibt er den Abzug für das Fehlen der Spalte in der Tabelle an. |
| `Void ColumnBounds( Distance left, Distance right, TableBlockColumn column )` | Legt die linke und rechte Begrenzung des Suchbereichs fest, der für die Suche nach der Spalte verwendet wird. Siehe im Dialogfeld des Elements **Table** die [**Spalteneigenschaften**](/de/flexi-capture/fls/tables/column), **Absolute Bereichsbeschränkungen**. |
| `Void ExactColumnBorders( XCoordinate left, XCoordinate right, TableBlockColumn )` | Legt die exakten Spaltenbegrenzungen fest. **Hinweis.** Dieser Parameter kann verwendet werden, um nach einer Tabelle zu suchen, bei der die Position einiger oder aller Spalten im Voraus bekannt ist. |
## Parameter für die Spaltenreihenfolge
| Parameter | Beschreibung |
| ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Void AddPossibleColumnsOrder( String orderName, TableBlockColumnArray array )` | Gibt eine Variante der festen Spaltenreihenfolge an. Siehe im Dialogfeld des **Table**-Elements auf der Registerkarte [**Reihenfolge**](/de/flexi-capture/fls/tables/order) die Option **Feste Spaltenreihenfolge**. |
| `Void ColumnsRelation( TableBlockColumnArray )` | Gibt eine Regel für die Spaltenreihenfolge an. Siehe im Dialogfeld des **Table**-Elements auf der Registerkarte [**Reihenfolge**](/de/flexi-capture/fls/tables/order) die Option **Regeln für Spaltenreihenfolge**. |
| Parameter | Beschreibung |
| ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Void HasHeader( Logic )` | Gibt an, ob FlexiLayout Studio nach einer Kopfzeile suchen soll. Siehe das Dialogfeld des **Table**-Elements, Registerkarte [**Kopfzeile**](/de/flexi-capture/fls/tables/header), **Nach Kopfzeile suchen**. |
| `Void HeaderOptional( Real q1, Real q2 )` | Gibt an, ob die Kopfzeile optional ist, ähnlich wie die Funktion `Void Optional( Real q1, Real q2 )` für Elemente. |
| `Void HeaderSearchArea( Rect )` | Gibt das Suchrechteck für die Kopfzeile an. Wenn diese Funktion verwendet wird, wird der Suchbereich der Kopfzeile als Schnittmenge dieses Rechtecks und des Rechtecks berechnet, das den Suchbereich der gesamten Tabelle umschließt. Siehe das Dialogfeld des **Table**-Elements, Registerkarte [**Kopfzeile**](/de/flexi-capture/fls/tables/header), **Absolute Bereichsbeschränkung**. |
| `Void MaxHeaderHypothesesCount( Int )` | Legt die maximale Anzahl von Hypothesen fest, die bei der Suche nach der Kopfzeile erzeugt werden. Siehe das Dialogfeld des **Table**-Elements, Registerkarte [**Kopfzeile**](/de/flexi-capture/fls/tables/header), **Anzahl der Hypothesen für die Kopfzeile**. |
| `Void MinHeaderKeyElements( Int )` | Legt die Mindestanzahl von Schlüsselelementen fest, die zum Erkennen der Kopfzeile erforderlich sind. Der Standardwert ist `2`. |
| `Void ExtendHeaderLocalization( XInterval, YInterval, XInterval, YInterval )` | Erweitert den Lokalisierungsbereich der Kopfzeile. Sie kann beispielsweise verwendet werden, um die Zeile mit unerwünschten Informationen auszuschließen, die sich zwischen der Kopfzeile und dem Tabellenkörper befindet. |
| Parameter | Beschreibung |
| --------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Void HasFooter( Logic )` | Gibt an, ob FlexiLayout Studio nach der Fußzeile suchen soll. Siehe das Dialogfeld des Elements **Table**, Registerkarte [**Fußzeile**](/de/flexi-capture/fls/tables/footer), **Nach Fußzeile suchen**. |
| `Void FooterOptional( Real q1, Real q2 )` | Gibt an, ob die Fußzeile optional ist, ähnlich wie bei der Funktion `Void Optional( Real q1, Real q2 )` für Elemente. |
| `Void FooterSearchArea( Rect )` | Gibt das Suchrechteck für die Fußzeile an. Wenn diese Funktion verwendet wird, wird der Suchbereich der Fußzeile als Schnittmenge dieses Rechtecks und des Rechtecks berechnet, das den Suchbereich der gesamten Tabelle umschließt. Siehe das Dialogfeld des Elements **Table**, Registerkarte [**Fußzeile**](/de/flexi-capture/fls/tables/footer), **Absolute Bereichsbeschränkungen**. |
| `Void FooterHasTopSeparator()` | Gibt an, dass sich zwischen der Fußzeile und dem Tabellenkörper ein Trennzeichen befindet. Das Trennzeichen kann Teil einer Tabellenbegrenzung sein. |
| `FooterWholeWordMode( Logic )` | Dieses Flag wird verwendet, wenn anhand von Schlüsselwörtern nach einer Fußzeile gesucht wird. Wenn dieses Flag auf `true` gesetzt ist, werden Hypothesen verworfen, die nur aus Wortteilen bestehen. Die Standardeinstellung ist `false`. Siehe das Dialogfeld des Elements **Table**, Registerkarte [**Fußzeile**](/de/flexi-capture/fls/tables/footer), Option **Nur ganze Wörter**. |
| `Void FooterNearestToTop( Logic )` | Dieses Flag wird verwendet, wenn anhand von Schlüsselwörtern nach einer Fußzeile gesucht wird. Wenn dieses Flag auf `true` gesetzt ist, wählt FlexiLayout Studio den obersten Kandidaten aus und verwirft die übrigen. Wenn dieses Flag auf `false` gesetzt ist, berücksichtigt FlexiLayout Studio alle möglichen Kandidaten. Die Quality der Fußzeile fließt in die Quality der Tabelle ein, und anschließend wird die Tabellenhypothese mit der höchsten Quality ausgewählt. Die Standardeinstellung ist `true`. |
| `Void AddFooterKeyWord( String )` | Gibt ein Schlüsselwort für die Fußzeile der Tabelle an. Siehe das Dialogfeld des Elements **Table**, Registerkarte [**Fußzeile**](/de/flexi-capture/fls/tables/footer), Option **Suche nach Schlüsselwort**. |
| `Void AddFooterKeyHypothesis( Hypothesis )` | Gibt die Fußzeile der Tabelle mithilfe der erkannten Hypothese an. Siehe das Dialogfeld des Elements **Table**, Registerkarte [**Fußzeile**](/de/flexi-capture/fls/tables/footer), Option **Gefundenes Element verwenden**. |
| `Void AddFooterKeyHypothesis( XInterval, YInterval, XInterval, YInterval )` | Gibt die Koordinaten der Fußzeile der Tabelle an. |
## Suchparameter für den Tabellenkörper
| Parameter | Beschreibung |
| --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Void DontFindBody()` | Ermöglicht es, die Suche nach dem Tabellenkörper zu überspringen. Wird zum Debugging verwendet. |
| `Void BodyOptional( Real q1, Real q2 )` | Gibt an, ob der Tabellenkörper optional ist, ähnlich wie bei der Funktion `Void Optional( Real q1, Real q2 )` für Elemente. |
| `Void IgnoreVerticalSeparators()` | Ignoriert vertikale Trennlinien im Tabellenkörper beim Unterteilen der Tabelle in Spalten. Standardmäßig werden Trennlinien berücksichtigt. |
| `Void IgnoreSeparatorsFromHeader()` | Ignoriert vertikale Trennlinien in der Kopfzeile der Tabelle beim Unterteilen der Tabelle in Spalten. Standardmäßig werden vertikale Trennlinien berücksichtigt. |
| `Void AutoDetectTopAndBottom( Logic )` | Sucht automatisch nach den oberen und unteren Begrenzungen der Tabelle. Die Standardeinstellung ist `true`. Wenn das Flag auf `false` gesetzt ist, wird der gesamte Text innerhalb des Suchbereichs des Table-Elements verwendet. |
## Parameter zur Zeilenerkennung
| Parameter | Beschreibung |
| ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Void SingleLineTable( Logic )` | Teilt FlexiLayout Studio mit, dass jede Textzeile genau einer Tabellenzeile entsprechen muss. Siehe Dialogfeld des Elements **Table**, Registerkarte [**Zeilen**](/de/flexi-capture/fls/tables/rows), Kontrollkästchen **Eine Textzeile entspricht einer Zeile** (wenn die Option **Zeilen automatisch erkennen** ausgewählt ist). |
| `Void SingleLineMasterColumn( Logic )` | Teilt FlexiLayout Studio mit, dass jede Textzeile genau einer Zeile in der Master-Spalte der Tabelle entsprechen muss. Siehe Dialogfeld des Elements **Table**, Registerkarte [**Zeilen**](/de/flexi-capture/fls/tables/rows), Kontrollkästchen **Eine Textzeile entspricht einer Zeile** (wenn die Option **Master-Spalten zum Erkennen von Zeilen verwenden** ausgewählt ist). |
| `Void MaxRowVerticalGap( Distance )` | Gibt den maximalen vertikalen Abstand zwischen zwei Zeilen in der Tabelle an. Wird der angegebene Abstand überschritten, bedeutet dies das Ende des Tabellenkörpers. Standardmäßig ist dieser Abstand nicht begrenzt. |
| `Void MinRowVerticalGap( Distance )` | Gibt den minimalen vertikalen Abstand zwischen zwei Zeilen in der Tabelle an. Ist der Abstand kleiner als der angegebene Wert, werden die Zeilen zu einer zusammengeführt. Der Standardwert ist `0`. |
| `Void MaxMasterColumnRowGap( Distance )` | Gibt den maximalen vertikalen Abstand zwischen zwei Zeilen in der Master-Spalte der Tabelle an. Wird der angegebene Abstand überschritten, bedeutet dies das Ende des Tabellenkörpers. Standardmäßig ist dieser Abstand nicht begrenzt. |
| `Void MinMasterColumnRowGap( Distance )` | Gibt den minimalen vertikalen Abstand zwischen zwei Tabellenzeilen in einer bestimmten Spalte an. Ist der Abstand kleiner als der angegebene Wert, werden die Zeilen zu einer zusammengeführt. Der Standardabstand ist `0`. |
| `Void IgnoreHorizontalSeparators()` | Ignoriert horizontale Trennlinien beim Unterteilen der Tabelle in Zeilen. |
| `Void DivideRowsBySeparators()` | Erkennt Zeilen ausschließlich anhand von Trennlinien und ignoriert dabei den Text. |
| `Void DivideRowsByMasterColumn( TableBlockColumn )` | Teilt FlexiLayout Studio mit, dass beim Unterteilen der Tabelle in Zeilen der Text der Spalte verwendet werden soll. Diese Funktion kann mehrfach aufgerufen werden. Wenn eine Tabelle in einem Bild nicht über die erforderliche Spalte verfügt, wird die Spalte aus dem nächsten Funktionsaufruf verwendet und so weiter. Wenn keine der Spalten verfügbar ist, werden die Zeilen in der gesamten Tabelle erkannt. Siehe die Option **Master-Spalten zum Erkennen von Zeilen verwenden** im Dialogfeld des Elements **Table** auf der Registerkarte [**Zeilen**](/de/flexi-capture/fls/tables/rows). |
| `Void MasterColumnTextAlignment( TextAlignmentInTableCell )` | Gibt die Textausrichtung in einer Tabellenzelle der Master-Spalte an. Kann `TextAlignment_CellTop` oder `TextAlignment_CellBottom` sein. Zum Beispiel richtet `MasterColumnTextAlignment: TextAlignment_CellBottom;` den Text an der unteren Zellgrenze aus. |
| `Void AddStopWord( String )` | Gibt die Wörter an, für die keine separaten Zeilen erzeugt werden dürfen. Siehe Dialogfeld des Elements **Table**, Registerkarte [**Zeilen**](/de/flexi-capture/fls/tables/rows), **Stoppwörter**. |
| `Void RowSplitters( YCoordinateArray, Logic isBodyTopIncluded = true, Logic isBodyBottomIncluded = true )` | Gibt Trennlinien zum Unterteilen der Tabelle in Zeilen an. `isBodyTopIncluded == true` gibt die Oberkante des Tabellenkörpers an, `isBodyBottomIncluded == true` gibt die Unterkante des Tabellenkörpers an, `isBodyTopIncluded == false` erkennt die Oberkante des Tabellenkörpers automatisch und `isBodyBottomIncluded == false` erkennt die Unterkante des Tabellenkörpers automatisch. Alle angegebenen Trennlinien außerhalb des Suchbereichs der Tabelle werden ignoriert. |
Beispiel für `RowSplitters`:
```text theme={null}
let yArray = RepeatingGroup.AllInstances.GetYArray(1);
RowSplitters( yArray );
```
## Parameter für mehrseitige Tabellen
| Parameter | Beschreibung |
| ---------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Void HeaderOnEachPage( Logic has = true )` | Gibt an, dass die Tabellenkopfzeile auf jeder Seite am Anfang jeder einseitigen Untertabelle vorhanden ist. Siehe Dialogfeld des **Table**-Elements, Registerkarte [**Kopfzeile**](/de/flexi-capture/fls/tables/header), Eigenschaft **Kopfzeile occurs on every page**. |
| `Void AddHeaderKeyHypotheses( HypothesisInstances, TableBlockColumn )` | Gibt einen Spaltennamen auf mehreren Seiten mithilfe einer Menge von Hypothesen für ein Subelement einer wiederholbaren Gruppe an. Siehe [**Dialogfeld des Column-Elements**](/de/flexi-capture/fls/tables/column), Eigenschaft **Use found element as column name**. |
| `Void FooterOnEachPage( Logic has = true )` | Gibt an, dass die Tabellenfußzeile auf jeder Seite vorhanden ist. Siehe Dialogfeld des **Table**-Elements, Registerkarte [**Fußzeile**](/de/flexi-capture/fls/tables/footer), Eigenschaft **Fußzeile is on every page**. |
| `Void AddFooterKeyHypotheses( HypothesisInstances )` | Gibt eine Tabellenfußzeile auf mehreren Seiten mithilfe einer Menge von Hypothesen für ein Subelement einer wiederholbaren Gruppe an. Siehe Dialogfeld des **Table**-Elements, Registerkarte [**Fußzeile**](/de/flexi-capture/fls/tables/footer), Eigenschaft **gefundenes Element als Fußzeile verwenden**. |
| `Void PreviousInstances( TableHypothesisInstances )` | Gibt die vorherigen Tabelleninstanzen an, wenn sich die Tabelle innerhalb einer wiederholbaren Gruppe befindet. Dabei wird angenommen, dass die Instanzen von oben nach unten verlaufen, die Spaltengrenzen innerhalb derselben Seite nicht verschoben sind und zwischen den Seiten horizontal leicht verschoben sein können. Die vorherigen Instanzen werden verwendet, um nach Spalten zu suchen oder die Spaltensuche zu verbessern, wenn die Tabelle keine Kopfzeile hat oder die Kopfzeile nicht erkannt wird. |