> ## 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.

# Spezielle Funktionen von ABBYY FlexiLayout Studio zum Erstellen zusätzlicher FlexiLayouts

> Erstellen Sie zusätzliche Rechnungs-FlexiLayouts mit ABBYY FlexiLayout Studio: Fragen Sie Datensätze mit Funktionen wie RecordOfFCDataset ab und verwenden Sie XML-Parameterdateien.

ABBYY FlexiLayout Studio verfügt über mehrere spezielle Funktionen für die Entwicklung zusätzlicher FlexiLayouts für Rechnungsprojekte:

* Sie können die Positionen von Elementen relativ zu den Regionen von Feldern festlegen, die erkannt wurden, als das Haupt-FlexiLayout aus dem Rechnungsprojekt angewendet wurde.
* Bezeichner von Vendors und Geschäftsbereichen können in Anfragen an den Datensatz der Dokumentdefinition verwendet werden.
* Listen mit Schlüsselwörtern und anderen Parametern eines FlexiLayouts können in eine XML-Datei exportiert werden, sodass Sie sie bearbeiten können, ohne das FlexiLayout oder die Dokumentdefinition selbst zu bearbeiten.

<div id="create-an-additional-flexilayout">
  ## Zusätzliches FlexiLayout erstellen
</div>

<Steps>
  <Step title="Öffnen Sie einen Batch in FlexiCapture">
    Öffnen Sie einen Batch mit erkannten Rechnungen in FlexiCapture.
  </Step>

  <Step title="Erstellen Sie ein Projekt in FlexiLayout Studio">
    Erstellen Sie ein neues Projekt in ABBYY FlexiLayout Studio. Wählen Sie im Hauptmenü **Tools → Export Batch to FlexiLayout Studio → Create New FlexiLayout Studio Project...** aus.
  </Step>
</Steps>

<Note>
  Dieser Befehl ist nur für FlexiCapture-Projekte verfügbar, die auf Ihrem Computer gespeichert sind. Wenn Sie die Distributed-Version von FlexiCapture verwenden und das Projekt auf dem Server gespeichert ist, laden Sie es zunächst auf Ihren Computer herunter, indem Sie im Menü **Project** auf **Export Project...** klicken.
</Note>

<Note>
  Das Suffix des ABBYY FlexiLayout-Studio-Projekts gibt die Version der Dokumentdefinition zum Zeitpunkt der Projekterstellung an.
</Note>

Das ABBYY FlexiLayout-Studio-Projekt, das Sie gerade erstellt haben, enthält alle Dokumente aus dem FlexiCapture-Batch sowie die bei der Erkennung ermittelten Feldregionen in Form eines **Referenzlayouts**.

| Baum               | Knoten                   | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| ------------------ | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **SearchElements** | **CommonBlockRegions**   | Dieser Knoten enthält Elemente, die allen Feldern der Dokumentdefinition entsprechen. Die Koordinaten aller Blockregionen, die beim Anwenden von FlexiLayouts auf die einzelnen Dokumente in FlexiCapture erkannt wurden, sind im ABBYY FlexiLayout-Studio-Projekt gespeichert. Standardmäßig werden Regionen mit diesen Koordinaten Elementen zugeordnet, die denselben Namen wie die Felder in der Dokumentdefinition haben. Dadurch können sie verwendet werden, um relative Positionen von Elementen festzulegen und neue Elemente zu erstellen. |
| **SearchElements** | **CustomSearchElements** | Dieser Knoten enthält Beispielelemente. Sie sind standardmäßig deaktiviert, um Störungen beim Anwenden des FlexiLayouts zu vermeiden.<br /><br />**DataSetRequestSample** — Ein Beispiel für eine Anfrage an den in der Dokumentdefinition gespeicherten Datensatz mit Vendors und Geschäftsbereichen. Dieser Datensatz enthält Bezeichner von Vendors und Geschäftsbereichen.                                                                                                                                                                       |

<div id="add-a-field-to-an-additional-flexilayout">
  ## So fügen Sie einem zusätzlichen FlexiLayout ein Feld hinzu
</div>

Um einem zusätzlichen FlexiLayout ein Feld hinzuzufügen, müssen Sie einen Block für dieses Feld erstellen und dessen search element angeben.

Felder in der Dokumentdefinition müssen eindeutige Namen haben. Das bedeutet:

* Um die Suchlogik für ein Feld zu beschreiben, müssen Sie einen Block mit einem eindeutigen Namen erstellen.
* Um die Suchlogik für ein Feld zu ändern, das bereits in der Dokumentdefinition vorhanden ist, müssen Sie einen Block mit demselben Namen erstellen.

<div id="add-pages-to-an-additional-flexilayout">
  ## Seiten zu einem zusätzlichen FlexiLayout hinzufügen
</div>

Wenn Sie die Änderungen, die Sie an einem zusätzlichen FlexiLayout vorgenommen haben, mit neuen Bildern testen möchten, können Sie Ihre FlexiCapture-Batches in ein vorhandenes Rechnungsprojekt in ABBYY FlexiLayout Studio exportieren. Um Ihre Batches zu exportieren, klicken Sie auf **Tools → Export Batch to FlexiLayout Studio → Add to Existing FlexiLayout Studio Project...**.

* Sie können FlexiCapture-Batches nur in ABBYY FlexiLayout Studio-Projekte exportieren, die über **Tools → Export Batch to FlexiLayout Studio → Create New FlexiLayout Studio Project...** erstellt wurden.
* Wenn Sie einen FlexiCapture-Batch nach ABBYY FlexiLayout Studio exportieren, wird dort für diesen Batch ein neuer Batch erstellt.
* Wenn die neue Document Definition mehr Felder enthält als die Document Definition, die für das ABBYY FlexiLayout Studio-Projekt verwendet wurde, wird im Exportprotokoll für jedes zusätzliche Feld eine Warnung ausgegeben.
* Damit das Programm die zusätzlichen Felder exportiert, fügen Sie für jedes zusätzliche Feld im Knoten **CommonBlockRegions** des Baums **SearchElements** einen Block mit demselben Namen hinzu.

<div id="make-requests-to-data-sets-from-the-document-definition">
  ## Anfragen an Datensätze aus der Dokumentdefinition senden
</div>

Eine Beispielanfrage finden Sie im Element **DataSetRequestSample**. Dieses Element ist standardmäßig deaktiviert.

| Typ                                                 | Beschreibung                                                               |
| --------------------------------------------------- | -------------------------------------------------------------------------- |
| **NamedValue**                                      | Ein benannter Wert.                                                        |
| *Konstruktor*                                       |                                                                            |
| `NamedValue( String, String )`                      |                                                                            |
| *Methoden*                                          |                                                                            |
| `String Name()`                                     | Gibt den Namen eines benannten Werts zurück.                               |
| `String Value()`                                    | Gibt den Wert eines benannten Werts zurück.                                |
| **NamedValueArray**                                 | Ein Array benannter Werte.                                                 |
| *Konstruktoren*                                     |                                                                            |
| `NamedValueArray()`                                 |                                                                            |
| `NamedValueArray( NamedValue namedValue )`          |                                                                            |
| *Methoden*                                          |                                                                            |
| `Int Count()`                                       | Gibt die Gesamtzahl der Elemente im Array zurück.                          |
| `NamedValue GetAt( Int index )`                     | Gibt das Element mit der angegebenen Indexnummer zurück.                   |
| `Void Add( NamedValue namedValue )`                 | Fügt dem Array einen benannten Wert hinzu.                                 |
| `Void Add( NamedValueArray namedValueArray )`       | Fügt einem Array benannter Werte ein weiteres Array benannter Werte hinzu. |
| `Void InsertAt( Int index, NamedValue namedValue )` | Fügt den benannten Wert an der angegebenen Indexposition ein.              |
| `Void DeleteAll()`                                  | Löscht alle Elemente eines Arrays.                                         |
| `Void DeleteAt( Int index )`                        | Löscht das Element an der angegebenen Indexposition.                       |
| `Int FindByName( String name )`                     | Gibt die Position des Werts mit dem Namen name zurück.                     |

<div id="functions">
  ### Funktionen
</div>

Syntax:

* Der Pfad zur Dokumentdefinition und der Name des Datensatzes werden verwendet, um auf den Datensatz zuzugreifen, wenn in ABBYY FlexiLayout Studio mit einem FlexiLayout gearbeitet wird.
* Nachdem ein kompiliertes FlexiLayout in FlexiCapture zu einer Dokumentdefinition hinzugefügt wurde, wird für den Zugriff auf den Datensatz nur noch dessen Name verwendet.
* Format von **connectionString**:

  ```
  "dbtype=FCDataset;fcTemplate=path_to_Document_Definition;datasetName=name_of_Data_Set;"
  ```

  **Hinweis:** Trennen Sie die Bestandteile des Pfads durch doppelte Backslashes (`\\`).
* **searchFields** — Array mit den Namen der Spalten, aus denen Werte abgerufen werden sollen.
* **searchCriteria** — Array von **Spalte-Eintrag**-Paaren; wenn leer, werden alle Werte zurückgegeben.
  * Wenn eine Abfrage mehrere Werte für ein Feld enthält, verwenden Sie den Operator **OR**.
  * Wenn eine Abfrage mehrere Werte enthält, die jeweils nur einem Feld entsprechen, verwenden Sie den Operator **AND**.
  * Wenn eine Abfrage mehrere Werte für ein Feld sowie Werte für mehrere Felder enthält, verwenden Sie den Operator **OR**, um mehrere Werte für ein Feld zu unterscheiden, und den Operator **AND**, um die Werte verschiedener Felder zu verknüpfen.

| Definition                                                                                                                                                                                                                            | Beschreibung                                                                                                                                                                                                                                                                                                                         |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Logic TestAccessToFCDataSet( String connectionString )`                                                                                                                                                                              | Testet die Verbindung zum Datensatz.                                                                                                                                                                                                                                                                                                 |
| `Logic TestFCDataSetSearchCriteria( String connectionString, StringArray searchFields, NamedValueArray searchCriteria )`                                                                                                              | Testet die Suchbedingungen für den Datensatz.                                                                                                                                                                                                                                                                                        |
| `StringArray FieldNamesOfFCDataset( String connectionString )`                                                                                                                                                                        | Gibt eine Liste aller Felder aus dem Datensatz zurück, sortiert in aufsteigender Reihenfolge ihrer Indexnummern.                                                                                                                                                                                                                     |
| `StringArray FieldNamesOfFCDataset( String connectionString, StringArray searchFields )`                                                                                                                                              | Gibt eine Liste der Felder aus dem angegebenen Datensatz in aufsteigender Reihenfolge ihrer Indexnummern zurück. Sollte zusammen mit der Funktion RecordOfFCDataset verwendet werden, wenn komplexe Spalten vorhanden sind.                                                                                                          |
| `Int RecordCountOfFCDataset( String connectionString, StringArray searchFields, NamedValueArray searchCriteria )`                                                                                                                     | Gibt die Anzahl der Datensätze aus dem Datensatz zurück, die in den Suchbedingungen angegeben sind. Dient dazu, zu ermitteln, wie viele Datensätze mit der Funktion RecordOfFCDataset zurückgegeben werden können.                                                                                                                   |
| `Void PrepareRecordsetOfFCDataset( String connectionString, StringArray searchFields, NamedValueArray searchCriteria, Int maxRecordsCount = DefaultMaxRecordsCount )`                                                                 | Bereitet die Daten für eine Abfrage an den Datensatz vor. Dies muss vor dem Aufruf der Funktion RecordOfFCDataset für jeden neuen Satz von Suchbedingungen erfolgen.                                                                                                                                                                 |
| `StringArray RecordOfFCDataset( String connectionString, StringArray searchFields, NamedValueArray searchCriteria, Int rowIndex )`                                                                                                    | Gibt ein Array mit Werten aus dem Datensatz mit der Nummer *rowIndex* aus den Ergebnissen einer Abfrage an den Datensatz zurück. Die Anzahl der Werte entspricht der Anzahl der in searchFields übergebenen Felder (einschließlich komplexer Spalten).                                                                               |
| `Quality ValidateByFCDataSet( String word, String connectionString, Int fieldIndex, NamedValueArray searchCriteria, Int maxErrors, Rational maxErrorsPart, Logic ignoreSpaces = true, Int maxRecordsCount = DefaultMaxRecordsCount )` | Gibt die Quality der Zeichenfolge *word* zurück. Akzeptiert Indexnummern von Feldern. Sie können die Indexnummern durch Indizierung der Ausgabe der Funktion FieldNamesOfFCDataset abrufen.                                                                                                                                          |
| `Void SearchTextFromFCDataSet( String connectionString, Int fieldIndex, NamedValueArray searchCriteria, Int maxRecordsCount = DefaultMaxRecordsCount )`                                                                               | Wird verwendet, um Suchbedingungen für Wörter für die Funktion Static Text anzugeben. Wenn diese Funktion aufgerufen wird, werden vorhandene Suchbedingungen durch neue ersetzt. Akzeptiert Feldindexnummern. Sie können die Indexnummern durch Indizierung der Ausgabe der Funktion FieldNamesOfFCDataset abrufen.                  |
| `Void RegularExpressionFromFCDataSet( String connectionString, Int fieldIndex, NamedValueArray searchCriteria, Int maxRecordsCount = DefaultMaxRecordsCount )`                                                                        | Wird verwendet, um Suchbedingungen mithilfe regulärer Ausdrücke für die Funktion CharString anzugeben. Wenn diese Funktion aufgerufen wird, werden vorhandene Suchbedingungen durch neue ersetzt. Akzeptiert Feldindexnummern. Sie können die Indexnummern durch Indizierung der Ausgabe der Funktion FieldNamesOfFCDataset abrufen. |

<div id="search-for-rows-from-a-column-in-an-external-database-on-an-image">
  ### In einem Bild nach Einträgen aus einer Spalte in einer externen Datenbank suchen
</div>

<Steps>
  <Step title="Die Spalten auflisten">
    Verwenden Sie FieldNamesOfFCDataset, um eine nach den Indexnummern aufsteigend sortierte Liste der Spalten abzurufen.
  </Step>

  <Step title="Den Spaltenindex ermitteln">
    Ermitteln Sie die Indexnummer der Spalte, aus der Sie Daten suchen möchten.
  </Step>

  <Step title="Den Filter erstellen">
    Erstellen Sie ein array von Bedingungen, um Daten aus dem Datensatz zu filtern.
  </Step>

  <Step title="Die Suche ausführen">
    Übergeben Sie die Indexnummer der Spalte und die Filterbedingungen an SearchTextFromFCDataSet (oder an RegularExpressionFromFCDataSet, wenn Sie reguläre Ausdrücke verwenden möchten).
  </Step>
</Steps>

Dieser Code wird automatisch generiert, wenn ein erkannter Batch aus FlexiCapture exportiert wird.

<div id="search-an-image-for-entries-from-multiple-columns">
  ### In einem Bild nach Einträgen aus mehreren Spalten suchen
</div>

Da die Suchparameter bei jedem Aufruf der Funktion **SearchTextFromFCDataSet** ersetzt werden, hat ein wiederholter Aufruf keine Wirkung. Als Workaround können Sie strings aus einer externen Datenbank abrufen und an die Funktion **SearchText** übergeben. Diese fügt jeden string zu den vorhandenen Suchparametern hinzu, anstatt sie zu ersetzen.

<Steps>
  <Step title="Die Spalten auflisten">
    Erstellen Sie ein array mit den Namen der Spalten, in denen Sie Daten suchen möchten.
  </Step>

  <Step title="Den Filter erstellen">
    Erstellen Sie ein array mit Filterbedingungen, um Daten aus dem Datensatz zu filtern.
  </Step>

  <Step title="Die Einträge zählen">
    Ermitteln Sie mit der Funktion **RecordCountOfFCDataset** die Anzahl der zurückgegebenen Einträge.
  </Step>

  <Step title="Die Abfrage vorbereiten">
    Bereiten Sie die Abfragedaten mit der Funktion **PrepareRecordsetOfFCDataset** vor.
  </Step>

  <Step title="Jeden Datensatz lesen">
    Gehen Sie alle Datensätze durch und rufen Sie für jeden Datensatz mit der Methode **RecordOfFCDataset** das array ab.
  </Step>

  <Step title="Die Werte an SearchText übergeben">
    Übergeben Sie den Wert jedes Elements im array an die Funktion **SearchText**.
  </Step>
</Steps>

<div id="additional-considerations-for-complex-columns">
  ### Zusätzliche Hinweise zu komplexen Spalten
</div>

* Die Funktion **FieldNamesOfFCDataset** gibt ein Array zurück, das den Namen der komplexen Spalte mehrfach enthält. Die Anzahl der Vorkommen entspricht der Anzahl der Spalteninstanzen in einer kodierten externen Datenbank.

  *Beispiel*: `{VendorId, VATID, Name, Name, Name, City}`. In diesem Fall enthält die externe Datenbank drei Spalten für die eine komplexe Spalte **Name** im Datensatz.
* Wenn **SearchCriteria** eine Bedingung für ein Feld enthält, das einer komplexen Spalte entspricht (wie im obigen Beispiel), wird diese Bedingung verwendet, um alle diese Spalteninstanzen zu überprüfen.
* Wenn **searchFields** eine Bedingung für ein Feld enthält, das einer komplexen Spalte entspricht (wie im obigen Beispiel), enthält das Ergebnis ein Array mit den Werten aus jeder Spalteninstanz.

  Wenn Sie zum Beispiel für `{VendorId, VATID, Name, Name, Name, City}` Folgendes anfordern:

  ```
  searchFields = { VATID, Name, City}, erhalten Sie
  {VATID_value, Name_valueInColumn1, Name_valueInColumn2, Name_valueInColumn3, City_value}
  ```
* Sie können eine Liste der zurückgegebenen Spalten abrufen, indem Sie das Array **searchFields** an die Funktion **FieldNamesOfFCDataset** übergeben.

<div id="make-a-request-to-an-xml-file-that-contains-flexilayout-settings">
  ## Eine Anfrage an eine XML-Datei mit FlexiLayout-Einstellungen senden
</div>

Sie können mithilfe von zwei Standardfunktionen, die in der Dokumentation zu ABBYY FlexiLayout Studio beschrieben sind, Anfragen an eine XML-Datei mit FlexiLayout-Einstellungen senden:

```
StringArray ReadFromXML(String filename, String xPathQuery)
String ReadSingleStringFromXML(String filename, String xPathQuery)
```

Um diese Datei zu verwenden, wenn Sie in ABBYY FlexiLayout Studio an einem FlexiLayout arbeiten, legen Sie sie im Projektordner oder in einem seiner Unterordner ab. Der Pfad zur Datei ist relativ zur Projektdatei von ABBYY FlexiLayout Studio.

Wenn Sie ein kompiliertes FlexiLayout in FlexiCapture in eine Dokumentdefinition laden und es als zusätzliches FlexiLayout verwenden, wird die XML-Datei im Ordner **Templates** abgelegt, und Sie können sie bearbeiten. Wenn das FlexiLayout angewendet wird, verwaltet das Programm den Zugriff auf diese Datei automatisch.
