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

# Funktionen zum Erstellen eines Fuzzy-Rectangle

> Funktionen der FlexiLayout language, die ein FuzzyRect für RestrictSearchArea zurückgeben: AreaLeftOf, AreaAbove, ImageBelow und andere Hilfsfunktionen für Suchbereichsgrenzen.

Mit der in [Funktionen, die den Suchbereich einschränken](/de/flexi-capture/fls/language/search-functions) beschriebenen Funktion `RestrictSearchArea( FuzzyRect fuzzyRect )` können Sie den Suchbereich auf ein beliebiges Fuzzy-Rectangle beschränken.

<div id="fuzzy-rectangle-functions">
  ## Funktionen für Fuzzy-Rectangle
</div>

Die FlexiLayout language stellt die folgenden Funktionen zum Erzeugen eines Fuzzy-Rectangle bereit.

| Definition                                                               | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| ------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `HorSearchAreaBound LeftBound()`                                         | Dient zum Festlegen einer Einschränkung für die linke Begrenzung des Suchbereichs. Ausdrücke vom Typ `LeftBound() > XCoordinate` geben `FuzzyRect` zurück.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `VertSearchAreaBound TopBound()`                                         | Dient zum Festlegen einer Einschränkung für die obere Begrenzung des Suchbereichs. Ausdrücke vom Typ `TopBound() > YCoordinate` geben `FuzzyRect` zurück.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `HorSearchAreaBound RightBound()`                                        | Dient zum Festlegen einer Einschränkung für die rechte Begrenzung des Suchbereichs. Ausdrücke vom Typ `RightBound() > XCoordinate` geben `FuzzyRect` zurück.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `VertSearchAreaBound BottomBound()`                                      | Dient zum Festlegen einer Einschränkung für die untere Begrenzung des Suchbereichs. Ausdrücke vom Typ `BottomBound() > YCoordinate` geben `FuzzyRect` zurück.                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `FuzzyRect AreaLeftOf( XInterval x, Distance offset = 0 )`               | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine vertikale Halbebene links vom Punkt `x.End - offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `FuzzyRect AreaLeftOf( FuzzyRect rect, Distance offset = 0 )`            | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine vertikale Halbebene links vom Punkt `rect.Left.End - offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `FuzzyRect AreaLeftOf( Hypothesis hyp, Distance offset = 0 )`            | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine vertikale Halbebene links vom Punkt `hyp.Rect.Left.End - offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `FuzzyRect AreaLeftOf( HypothesisInstances hyps, Distance offset = 0 )`  | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine vertikale Halbebene links vom Punkt `hyps.Rect.Left.End - offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `FuzzyRect AreaRightOf( XInterval x, Distance offset = 0 )`              | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine vertikale Halbebene rechts vom Punkt `x.Start + offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `FuzzyRect AreaRightOf( FuzzyRect rect, Distance offset = 0 )`           | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine vertikale Halbebene rechts vom Punkt `rect.Right.Start + offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `FuzzyRect AreaRightOf( Hypothesis hyp, Distance offset = 0 )`           | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine vertikale Halbebene rechts vom Punkt `hyp.rect.Right.Start + offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `FuzzyRect AreaRightOf( HypothesisInstances hyps, Distance offset = 0 )` | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine vertikale Halbebene rechts vom Punkt `hyps.Rect.Right.Start + offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `FuzzyRect AreaAbove( YInterval y, Distance offset = 0 )`                | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine horizontale Halbebene oberhalb des Punkts `y.End - offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `FuzzyRect AreaAbove( FuzzyRect rect, Distance offset = 0 )`             | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine horizontale Halbebene oberhalb des Punkts `rect.top.End - offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `FuzzyRect AreaAbove( Hypothesis hyp, Distance offset = 0 )`             | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine horizontale Halbebene oberhalb des Punkts `hyp.rect.top.End - offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `FuzzyRect AreaAbove( HypothesisInstances hyps, Distance offset = 0 )`   | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine horizontale Halbebene oberhalb des Punkts `hyps.Rect.top.End - offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `FuzzyRect AreaBelow( YInterval y, Distance offset = 0 )`                | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine horizontale Halbebene unterhalb des Punkts `y.Start + offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `FuzzyRect AreaBelow( FuzzyRect rect, Distance offset = 0 )`             | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine horizontale Halbebene unterhalb des Punkts `rect.Bottom.Start + offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `FuzzyRect AreaBelow( Hypothesis hyp, Distance offset = 0 )`             | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine horizontale Halbebene unterhalb des Punkts `hyp.rect.Bottom.Start + offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `FuzzyRect AreaBelow( HypothesisInstances hyps, Distance offset = 0 )`   | Gibt ein Fuzzy-Rechteck in globalen Koordinaten zurück, das eine horizontale Halbebene unterhalb des Punkts `hyps.Rect.Bottom.Start + offset` darstellt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `FuzzyRect ImageLeftOf( XInterval x, Distance offset = 0 )`              | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der vertikalen Halbebene links vom Punkt `x.End - offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die minimale und maximale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayout zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaLeftOf( XInterval x, Distance offset = 0 )`.                               |
| `FuzzyRect ImageLeftOf( FuzzyRect rect, Distance offset = 0 )`           | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der vertikalen Halbebene links vom Punkt `rect.Left.End - offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die minimale und maximale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayout zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaLeftOf( FuzzyRect rect, Distance offset = 0 )`.                    |
| `FuzzyRect ImageLeftOf( Hypothesis hyp, Distance offset = 0 )`           | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der vertikalen Halbebene links vom Punkt `hyp.Rect.Left.End - offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die minimale und maximale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayout zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaLeftOf( Hypothesis hyp, Distance offset = 0 )`.                |
| `FuzzyRect ImageRightOf( XInterval x, Distance offset = 0 )`             | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der vertikalen Halbebene rechts vom Punkt `x.Start + offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die minimale und maximale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayout zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaRightOf( XInterval x, Distance offset = 0 )`.                           |
| `FuzzyRect ImageRightOf( FuzzyRect rect, Distance offset = 0 )`          | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der vertikalen Halbebene rechts vom Punkt `rect.Right.Start + offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die minimale und maximale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayout zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaRightOf( FuzzyRect rect, Distance offset = 0 )`.               |
| `FuzzyRect ImageRightOf( Hypothesis hyp, Distance offset = 0 )`          | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der vertikalen Halbebene rechts vom Punkt `hyp.rect.Right.Start + offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die minimale und maximale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayout zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaRightOf( Hypothesis hyp, Distance offset = 0 )`.           |
| `FuzzyRect ImageAbove( YInterval y, Distance offset = 0 )`               | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der horizontalen Halbebene oberhalb des Punkts `y.End - offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die minimale und maximale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayout zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaAbove( YInterval y, Distance offset = 0 )`.                          |
| `FuzzyRect ImageAbove( FuzzyRect rect, Distance offset = 0 )`            | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der horizontalen Halbebene oberhalb des Punkts `rect.top.End - offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die minimale und maximale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayout zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaAbove( FuzzyRect rect, Distance offset = 0 )`.                |
| `FuzzyRect ImageAbove( Hypothesis hyp, Distance offset = 0 )`            | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der horizontalen Halbebene oberhalb des Punkts `hyp.rect.top.End - offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die minimale und maximale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayout zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaAbove( Hypothesis hyp, Distance offset = 0 )`.            |
| `FuzzyRect ImageBelow( YInterval y, Distance offset = 0 )`               | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der horizontalen Halbebene unterhalb des Punkts `y.Start + offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die minimale und maximale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayout zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaBelow( YInterval y, Distance offset = 0 )`.                       |
| `FuzzyRect ImageBelow( FuzzyRect rect, Distance offset = 0 )`            | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der horizontalen Halbebene unterhalb des Punkts `rect.Bottom.Start + offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die maximale und die minimale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayouts zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaBelow( FuzzyRect rect, Distance offset = 0 )`.     |
| `FuzzyRect ImageBelow( Hypothesis hyp, Distance offset = 0 )`            | Gibt ein Fuzzy-Rechteck zurück, das die Schnittmenge aus dem Rechteck der Seite und der horizontalen Halbebene unterhalb des Punkts `hyp.rect.Bottom.Start + offset` ist.<br />**Wichtig!** Die Funktion darf nur verwendet werden, wenn die maximale und die minimale Seitenanzahl im Dokument auf 1 gesetzt sind, das heißt, das erkannte Dokument hat nur eine Seite. Wenn Sie diese Funktion für ein mehrseitiges Dokument verwenden, führt das Matching eines FlexiLayouts zu einem Fehler.<br />Verwenden Sie für ein mehrseitiges Dokument die Funktion `FuzzyRect AreaBelow( Hypothesis hyp, Distance offset = 0 )`. |