> ## 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. # Vordefinierte Typen > Referenz zu vordefinierten Typen in der FlexiLayout-Sprache – von Int, String und Distanz bis zu Rect, Region, FuzzyRect und Tabellenhypothese-Typen. Die FlexiLayout-Sprache stellt die folgenden vordefinierten Typen bereit. Für jeden Typ führen die Tabellen die unterstützten Operatoren, Methoden und Konstruktoren auf.
## Void
Der Typ Void wird verwendet, um Funktionen zu deklarieren, die keinen Wert zurückgeben.
## Logic
Boolescher Typ. Eine Variable dieses Typs kann die Werte `true` und `false` annehmen. Alle bedingten Ausdrücke geben einen Wert vom Typ Logic zurück. | Operator | Description | | :------- | :-------------------------------- | | `Not` | Logisches NICHT, unärer Operator. | | `And` | Logisches UND, binärer Operator. | | `Or` | Logisches ODER, binärer Operator. |
## String
Der Typ String stellt eine Folge von Unicode-Zeichen mit variabler Länge dar. | Methode | Beschreibung | | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Int Length()` | Gibt die Anzahl der Zeichen in der Zeichenfolge zurück. Schreibgeschützt. | | `Int Find(String subStr, Int startPos = 0)` | Gibt den Anfang der Teilzeichenfolge subStr innerhalb der Zeichenfolge zurück. Die Suche beginnt an der Position startPos. Kann ohne das Argument startPos verwendet werden; in diesem Fall wird der Standardwert 0 angenommen. Gibt -1 zurück, wenn die Zeichenfolge keine Teilzeichenfolge startPos enthält. | | `Int Compare( String str )` | Vergleicht die angegebene Zeichenfolge mit der durch das Argument festgelegten Zeichenfolge. Sind die Zeichenfolgen gleich, wird 0 zurückgegeben. Steht die angegebene Zeichenfolge alphabetisch vor str, gibt die Funktion -1 zurück; steht sie alphabetisch nach str, wird 1 zurückgegeben. | | `Int CompareNoCase( String str )` | Vergleicht die angegebene Zeichenfolge mit der durch das Argument festgelegten Zeichenfolge, wobei die Groß-/Kleinschreibung der Zeichen ignoriert wird. Sind die Zeichenfolgen gleich, wird 0 zurückgegeben. Steht die angegebene Zeichenfolge alphabetisch vor str, gibt die Funktion -1 zurück; steht sie alphabetisch nach str, wird 1 zurückgegeben. | | `String Mid ( Int start, Int count )` | Gibt eine Teilzeichenfolge der Zeichenfolge zurück, die 'count' Zeichen lang ist und mit dem Zeichen mit der Nummer start beginnt. | | `String Mid ( String subStr, Int startPos = 0 )` | Gibt den Anfang der Teilzeichenfolge subStr innerhalb der Zeichenfolge zurück. Kann ohne das Argument startPos verwendet werden; in diesem Fall wird der Standardwert 0 angenommen. Gibt -1 zurück, wenn die Zeichenfolge keine Teilzeichenfolge startPos enthält. | | `String SubstParam( String param0 ); String SubstParam( String param0, String param1 ); String SubstParam( String param0, String param1, String param2 ); String SubstParam( String param0, String param1, String param2, String param3 ); String SubstParam( String param0, String param1, String param2, String param3, String param4 )` | Gibt den Text der Zeichenfolge zurück, wobei alle Vorkommen der Zeichen %n (wobei n eine nichtnegative ganze Zahl ist) durch die entsprechenden Parameter ersetzt werden. Die Anzahl der Vorkommen der Zeichen %n in der Zeichenfolge muss der Anzahl der übergebenen Parameter entsprechen. Der Text der ursprünglichen Zeichenfolge wird dabei nicht verändert. | | `String SubstParam( StringArray params )` | Wie oben, jedoch werden die Parameter als array von strings übergeben. | | Operator | Beschreibung | | :------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `==` | Prüft, ob die beiden Zeichenfolgen gleich sind. Binärer Operator. Gibt ein Ergebnis vom Typ Logic zurück. Gibt `true` zurück, wenn die Zeichenfolgen gleich sind, andernfalls `false`. Berücksichtigt die Groß-/Kleinschreibung. | | `!=` | Prüft, ob die beiden Zeichenfolgen ungleich sind. Binärer Operator. Gibt ein Ergebnis vom Typ Logic zurück. Gibt `true` zurück, wenn die Zeichenfolgen ungleich sind, andernfalls `false`. Berücksichtigt die Groß-/Kleinschreibung. | | `+` | Verkettet zwei Zeichenfolgen. Gibt einen Wert vom Typ String zurück. |
## Int
Ganzzahltyp. Entspricht einer 32-stelligen Ganzzahl. | Methode | Beschreibung | | :--------------- | :------------------------------------------ | | `Int abs( Int )` | Gibt den Absolutwert einer Ganzzahl zurück. | | Operator | Beschreibung | | :--------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `-` | Ändert das Vorzeichen. Unärer Operator. | | `+` | Addiert Ganzzahlen. Binärer Operator. | | `-` | Subtrahiert eine Ganzzahl von einer anderen. Binärer Operator. | | `*` | Multipliziert Ganzzahlen. Binärer Operator. | | `/` | Dividiert Ganzzahlen. Binärer Operator. | | `<, <=, >, >=, ==, !=` | Vergleichsoperatoren: kleiner als, kleiner als oder entspricht, größer als, größer als oder entspricht, entspricht, entspricht nicht. Binäre Operatoren. Geben einen Wert vom Typ Logic zurück. |
## Distanz
Ganzzahltyp (gemessen in dots), der Abstände darstellt. | Methode | Beschreibung | | :------------------------- | :------------------------------------------ | | `Distance abs( Distance )` | Gibt den Absolutwert eines Abstands zurück. | | Operator | Beschreibung | | :--------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `-` | Ändert das Vorzeichen. Unärer Operator. | | `+` | Addiert Werte vom Typ Distance. Binärer Operator. | | `-` | Subtrahiert Werte vom Typ Distance. Binärer Operator. | | `*` | Multipliziert einen Wert vom Typ Distance mit einem Wert vom Typ Int. Binärer Operator. Gibt einen Wert vom Typ Distance zurück. | | `*` | Multipliziert Werte vom Typ Distance. Binärer Operator. Gibt einen Wert vom Typ Area zurück. | | `/` | Dividiert einen Wert vom Typ Distance durch einen Wert vom Typ Int. Binärer Operator. Gibt einen Wert vom Typ Distance zurück. | | `<, <=, >, >=, ==, !=` | Binäre Vergleichsoperatoren. Vergleichen zwei Werte vom Typ Distance: kleiner als, kleiner als oder gleich, größer als, größer als oder gleich, entspricht, ungleich. Geben einen Wert vom Typ Logic zurück. |
## XCoordinate
Ganzzahltyp zur Darstellung von X-Koordinaten. | Operator | Description | | :--------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `+` | Addiert einen Wert vom Typ XCoordinate zu einem Wert vom Typ Distanz. Binärer Operator. Gibt einen Wert vom Typ XCoordinate zurück. | | `-` | Subtrahiert einen Wert vom Typ Distanz von einem Wert vom Typ XCoordinate. Binärer Operator. Gibt einen Wert vom Typ XCoordinate zurück. | | `-` | Subtrahiert einen Wert vom Typ XCoordinate von einem Wert vom Typ XCoordinate. Binärer Operator. Gibt einen Wert vom Typ Distanz zurück. | | `<, <=, >, >=, ==, !=` | Vergleicht zwei Werte vom Typ XCoordinate: kleiner als, kleiner als oder entspricht, größer als, größer als oder entspricht, entspricht, entspricht nicht. Binäre Operatoren. Geben einen Wert vom Typ Logic zurück. |
## YCoordinate
Ganzzahltyp zur Darstellung von Y-Koordinaten. | Operator | Description | | :--------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `+` | Addiert einen Wert vom Typ YCoordinate zu einem Wert vom Typ Distanz. Binärer Operator. Gibt einen Wert vom Typ YCoordinate zurück. | | `-` | Subtrahiert einen Wert vom Typ Distanz von einem Wert vom Typ YCoordinate. Binärer Operator. Gibt einen Wert vom Typ YCoordinate zurück. | | `-` | Subtrahiert einen Wert vom Typ YCoordinate von einem Wert vom Typ YCoordinate. Binärer Operator. Gibt einen Wert vom Typ Distanz zurück. | | `<, <=, >, >=, ==, !=` | Operatoren, die zwei Werte vom Typ YCoordinate vergleichen: kleiner als, kleiner als oder entspricht, größer als, größer als oder entspricht, entspricht, entspricht nicht. Binäre Operatoren. Geben einen Wert vom Typ Logic zurück. |
## Real
Reelle Zahl. | Operator | Beschreibung | | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `-` | Ändert das Vorzeichen. Unärer Operator. | | `+` | Addiert zwei reelle Zahlen. Binärer Operator. | | `-` | Subtrahiert eine reelle Zahl von einer anderen reellen Zahl. Binärer Operator. | | `*` | Multipliziert zwei reelle Zahlen. Binärer Operator. | | `/` | Dividiert durch eine reelle Zahl. Binärer Operator. | | `<, <=, >, >=, ==, !=` | Vergleichen zwei reelle Zahlen: kleiner als, kleiner als oder entspricht, größer als, größer als oder entspricht, entspricht, entspricht nicht. Binäre Operatoren. Geben einen Wert vom Typ Logic zurück. |
## Quality
Reelle Zahl von 0 bis 1. Entspricht dem Rückgabewert der Methoden, die die Qualität einer Elementhypothese steuern.
## Area
Ganzzahliger Typ (gemessen in dot\*dot), der die Fläche einer Bildregion angibt. | Operator | Beschreibung | | :--------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `-` | Ändert das Vorzeichen. Unärer Operator. | | `+` | Addiert zwei Werte vom Typ Area. Binärer Operator. | | `-` | Subtrahiert einen Wert vom Typ Area von einem anderen Wert vom Typ Area. Binärer Operator. | | `*` | Multipliziert einen Wert vom Typ Area mit einer Zahl vom Typ Int. Binärer Operator. Gibt einen Wert vom Typ Area zurück. | | `*` | Multipliziert einen Wert vom Typ Area mit einer Zahl vom Typ Real. Binärer Operator. Gibt einen Wert vom Typ Area zurück. | | `/` | Binärer Divisionsoperator, der eine Zahl durch eine Ganzzahl vom Typ Int dividiert. Gibt einen Wert vom Typ Area zurück. | | `/` | Binärer Divisionsoperator, der eine Zahl vom Typ Area durch eine Zahl vom Typ Area dividiert. Gibt einen Wert vom Typ Real zurück. | | `<, <=, >, >=, ==, !=` | Vergleichen zwei Werte vom Typ Area: kleiner als, kleiner oder gleich, größer als, größer oder gleich, entspricht, ungleich. Binäre Operatoren. Geben einen Wert vom Typ Logic zurück. |
## ImageObjectType
Typ zur Darstellung klassifizierter Bildobjekte. | Operator | Description | | :------- | :-------------------------------------------- | | `+` | Verknüpft zwei Werte vom Typ ImageObjectType. |
## DateFormats
Ganzzahltyp, der das Format eines Datums darstellt. | Operator | Description | | :------- | :---------------------------------------- | | `+` | Verknüpft zwei Werte vom Typ DateFormats. |
## DayFormatVariants
Ganzzahltyp zur Darstellung des Tagesformats innerhalb des Datums. | Operator | Description | | :------- | :---------------------------------------------- | | `+` | Verknüpft zwei Werte vom Typ DayFormatVariants. |
## MonthFormatVariants
Ganzzahltyp zur Angabe des Monatsformats im Datum. | Operator | Description | | :------- | :------------------------------------------------- | | `+` | Verknüpft zwei Werte des Typs MonthFormatVariants. |
## YearFormatVariants
Ganzzahltyp zur Darstellung des Jahresformats im Datum. | Operator | Description | | :------- | :----------------------------------------------- | | `+` | Verknüpft zwei Werte vom Typ YearFormatVariants. |
## XInterval
Typ zur Darstellung eines Bereichs von X-Koordinaten auf einem Bild. | Operator | Description | | :------- | :--------------------------------------------------------------------------------------------------------------------------------------------- | | `+` | Addiert einen Wert des Typs XInterval zu einem Wert des Typs Distanz. Binärer Operator. Gibt einen Wert des Typs Xinterval zurück. | | `+` | Addiert einen Wert des Typs XInterval zu einem Wert des Typs DistInterval. Binärer Operator. Gibt einen Wert des Typs Xinterval zurück. | | `-` | Subtrahiert einen Wert des Typs Distanz von einem Wert des Typs XInterval. Binärer Operator. Gibt einen Wert des Typs Xinterval zurück. | | `-` | Subtrahiert einen Wert des Typs DistInterval von einem Wert des Typs XInterval. Binärer Operator. Gibt einen Wert des Typs Xinterval zurück. | | `-` | Subtrahiert einen Wert des Typs XInterval von einem Wert des Typs XInterval. Binärer Operator. Gibt einen Wert des Typs XInterval zurück. | | `-` | Subtrahiert einen Wert des Typs XCoordinate von einem Wert des Typs XInterval. Binärer Operator. Gibt einen Wert des Typs DistInterval zurück. | | `-` | Subtrahiert einen Wert des Typs XInterval von einem Wert des Typs XCoordinate. Binärer Operator. Gibt einen Wert des Typs DistInterval zurück. | | Method | Description | | :-------------------- | :-------------------------------------------------------------------------------- | | `XCoordinate Start()` | Gibt die X-Koordinate des Intervallanfangs zurück. Schreibgeschützte Eigenschaft. | | `XCoordinate End()` | Gibt die X-Koordinate des Intervallendes zurück. Schreibgeschützte Eigenschaft. |
## YInterval
Typ zur Darstellung eines Bereichs von Y-Koordinaten auf einem Bild. | Operator | Description | | :------- | :---------------------------------------------------------------------------------------------------------------------------------------- | | `+` | Addiert einen Wert vom Typ YInterval zu einem Wert vom Typ Distance. Binärer Operator. Gibt einen Wert vom Typ Yinterval zurück. | | `+` | Addiert einen Wert vom Typ YInterval zu einem Wert vom Typ DistInterval. Binärer Operator. Gibt einen Wert vom Typ Yinterval zurück. | | `-` | Subtrahiert einen Wert vom Typ Distance von einem Wert vom Typ YInterval. Binärer Operator. Gibt einen Wert vom Typ Yinterval zurück. | | `-` | Subtrahiert einen Wert vom Typ DistInterval von einem Wert vom Typ YInterval. Binärer Operator. Gibt einen Wert vom Typ Yinterval zurück. | | `-` | Subtrahiert einen Wert vom Typ YInterval von einem Wert vom Typ YInterval. Binärer Operator. Gibt einen Wert vom Typ DistInterval zurück. | | Method | Description | | :-------------------- | :-------------------------------------------------------------------------------- | | `YCoordinate Start()` | Gibt die Y-Koordinate des Intervallanfangs zurück. Schreibgeschützte Eigenschaft. | | `YCoordinate End()` | Gibt die Y-Koordinate des Intervallendes zurück. Schreibgeschützte Eigenschaft. |
## DistInterval
Typ zur Darstellung des zulässigen Bereichs von Abständen. | Operator | Description | | :------- | :--------------------------------------------------------------------------------------------------------------------------------------- | | `*` | Multipliziert einen Wert vom Typ DistInterval mit einer Zahl vom Typ Int. Binärer Operator. Gibt einen Wert vom Typ DistInterval zurück. | | `/` | Dividiert durch eine Zahl vom Typ Int. Binärer Operator. | | Method | Description | | :----------------- | :--------------------------------------------------------------- | | `Distance Start()` | Gibt die minimale Distanz zurück. Schreibgeschützte Eigenschaft. | | `Distance End()` | Gibt die maximale Distanz zurück. Schreibgeschützte Eigenschaft. |
## Rect
Rechteck auf einem Bild. | Constructor | Description | | :-------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Rect Rect( XCoordinate left, YCoordinate top, XCoordinate right, YCoordinate bottom )` | Erstellt einen Wert des Typs Rect aus Koordinaten auf dem Bild. Die Begrenzungen des Rechtecks werden als Parameter übergeben: left – linke Begrenzung, top – obere Begrenzung, right – rechte Begrenzung, bottom – untere Begrenzung. | | Operator | Description | | :------- | :------------------------------------------------------------------------------------------------------ | | `Or` | Vereinigt zwei Rechtecke. Das Ergebnis ist das kleinste Rechteck, das beide Rechtecke enthält. | | `And` | Schneidet zwei Rechtecke. Das Ergebnis ist das größte Rechteck, das in beiden Rechtecken enthalten ist. | | Method | Description | | :--------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `XCoordinate Left()` | Gibt die linke Begrenzung des Rechtecks zurück. Schreibgeschützte Eigenschaft. | | `YCoordinate top()` | Gibt die obere Begrenzung des Rechtecks zurück. Schreibgeschützte Eigenschaft. | | `XCoordinate Right()` | Gibt die rechte Begrenzung des Rechtecks zurück. Schreibgeschützte Eigenschaft. | | `YCoordinate Bottom()` | Gibt die untere Begrenzung des Rechtecks zurück. Schreibgeschützte Eigenschaft. | | `Distance Width()` | Gibt die Breite des Rechtecks zurück. Schreibgeschützte Eigenschaft. | | `Distance Height()` | Gibt die Höhe des Rechtecks zurück. Schreibgeschützte Eigenschaft. | | `Area Area()` | Gibt die Fläche des Rechtecks zurück. Schreibgeschützte Eigenschaft. | | `Void Left( XCoordinate x )` | Legt die linke Begrenzung des Rechtecks fest. | | `Void top( YCoordinate y )` | Legt die obere Begrenzung des Rechtecks fest. | | `Void Right( XCoordinate x )` | Legt die rechte Begrenzung des Rechtecks fest. | | `Void Bottom( YCoordinate y )` | Legt die untere Begrenzung des Rechtecks fest. | | `XCoordinate XCenter()` | Die X-Koordinate des Mittelpunkts des Rechtecks. | | `YCoordinate YCenter()` | Die Y-Koordinate des Mittelpunkts des Rechtecks. | | `Void Inflate( Distance xDist, Distance yDist )` | Vergrößert das Rechteck um xDist nach links und rechts sowie um yDist nach oben und unten. | | `XCoordinate GetX( Real ratio )` | Berechnet die X-Koordinate, die innerhalb des Rechtecks zwischen den Koordinaten Left und Right liegt, als Left + Width \* ratio. | | `YCoordinate GetY( Real ratio )` | Berechnet die Y-Koordinate, die innerhalb des Rechtecks zwischen den Koordinaten top und Bottom liegt, als Top + Height \* ratio. | | `Rect GetInflated( Distance xDist, Distance yDist )` | Gibt ein „vergrößertes“ Rechteck zurück. Jede Ecke wird um xDist und yDist in die Richtung verschoben, die die Figur vergrößert (die obere linke Ecke also nach oben und nach links usw.). Das Rechteck selbst bleibt unverändert. | | `Logic IsEmpty()` | Prüft, ob das Rechteck einer nicht leeren Region auf dem Bild entspricht, also einer Region, für die Left \< Right und top \< Bottom gilt. |
## FuzzyRect
Fuzzy-Rectangle. Weitere Informationen finden Sie unter [Fuzzy-Rectangle](/de/flexi-capture/fls/language/fuzzy-rect). | Operator | Beschreibung | | :------- | :-------------------------------------------------------------------------------------------------------------------------------------- | | `And` | Bildet die Schnittmenge zweier Fuzzy-Rectangles, d. h. die Schnittmenge der Wertebereiche der Grenzen der angegebenen Fuzzy-Rectangles. | | `Or` | Vereinigt zwei Fuzzy-Rectangles, d. h. die Wertebereiche der Grenzen der angegebenen Fuzzy-Rectangles werden vereinigt. | | Methode | Beschreibung | | :---------------------- | :---------------------------------------------------------------------------- | | `Rect ExternalRect()` | Gibt eine Kopie des äußeren Rectangles zurück. | | `Rect InternalRect()` | Gibt eine Kopie des inneren Rectangles zurück. | | `XInterval Left()` | Die linke Grenze des Fuzzy-Rectangles, horizontaler Bereich. | | `YInterval top()` | Die obere Grenze des Fuzzy-Rectangles, vertikaler Bereich. | | `XInterval Right()` | Die rechte Grenze des Fuzzy-Rectangles, horizontaler Bereich. | | `YInterval Bottom()` | Die untere Grenze des Fuzzy-Rectangles, vertikaler Bereich. | | `XInterval XCenter()` | Die X-Koordinate des Mittelpunkts des Fuzzy-Rectangles, horizontaler Bereich. | | `YInterval YCenter()` | Die Y-Koordinate des Mittelpunkts des Fuzzy-Rectangles, vertikaler Bereich. | | `DistInterval Width()` | Die Breite des Fuzzy-Rectangles, Distanzbereich. | | `DistInterval Height()` | Die Höhe des Fuzzy-Rectangles, Distanzbereich. | | `Logic IsEmpty()` | Prüft, ob das Fuzzy-Rectangle leer ist. |
## RectArray
Array von Rechtecken. | Constructor | Beschreibung | | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------- | | `RectArray RectArray ()` | Erstellt ein leeres Array von Rechtecken. | | `RectArray RectArray( Rect rect )` | Constructor mit dem Parameter Rect. Erstellt ein Array, das aus einem Rechteck besteht, welches dem Rechteck rect entspricht. | | `RectArray RectArray( Region region )` | Constructor mit dem Parameter Region. Erstellt ein Array, das aus den Rechtecken der Region region besteht. | | Methode | Beschreibung | | :---------------------------- | :-------------------------------------------------------------- | | `Int Count()` | Gibt die Anzahl der Array-Elemente zurück. | | `Region Region()` | Zusammenhängende Region aus einem Array von Rechtecken. | | `Rect Rect()` | Rechteck, das ein Array von Rechtecken umschließt. | | `Rect GetAt( Int )` | Gibt das Element am angegebenen index zurück. | | `Rect Rect( Int )` | Entspricht der Methode Rect GetAt( Int ), veraltete Syntax. | | `Void Add( Rect rect )` | Fügt einem Array von Rechtecken das Rechteck rect hinzu. | | `Void Add( RectArray array )` | Fügt einem Array von Rechtecken ein Array von Rechtecken hinzu. |
## Region
Eine Region ist eine Menge von Rechtecken, die so untereinander angeordnet sind, dass die Oberkante des unteren Rechtecks mit der Unterkante des oberen Rechtecks zusammenfällt (sodass sich die Rechtecke nicht überlappen). | Constructor | Description | | :------------------------------------- | :--------------------------------------------------------------------------------------------------------------------- | | `Region Region()` | Erstellt eine leere Region. | | `Region Region( RectArray rectArray )` | Constructor aus einem Wert vom Typ RectArray. Erstellt eine Region, die die Rechtecke aus dem Array rectArray enthält. | | Operator | Description | | :------- | :-------------------------------------------------------------------------------------------------------------------- | | `Or` | Vereinigt zwei Regionen. | | `And` | Bildet die Schnittmenge zweier Regionen oder einer Region und eines Rechtecks. Gibt einen Wert vom Typ Region zurück. | | Method | Description | | :----------------------------------------------- | :---------------------------------------------------------------------------------------------------- | | `XCoordinate Left()` | Gibt die linke Begrenzung der Region zurück. Schreibgeschützte Eigenschaft. | | `YCoordinate top()` | Gibt die obere Begrenzung der Region zurück. Schreibgeschützte Eigenschaft. | | `XCoordinate Right()` | Gibt die rechte Begrenzung der Region zurück. Schreibgeschützte Eigenschaft. | | `YCoordinate Bottom()` | Gibt die untere Begrenzung der Region zurück. Schreibgeschützte Eigenschaft. | | `Distance Width()` | Gibt die Breite der Region zurück. Schreibgeschützte Eigenschaft. | | `Distance Height()` | Gibt die Höhe der Region zurück. Schreibgeschützte Eigenschaft. | | `Area Area()` | Gibt die Fläche der Region zurück. Schreibgeschützte Eigenschaft. | | `Void Inflate( Distance xDist, Distance yDist )` | Erweitert die Region um *xDist* nach rechts und nach links sowie um *yDist* nach oben und nach unten. | | `Rect Rect()` | Gibt eine Kopie des Rechtecks zurück, das die Region umschließt. |
## ImageObjectSet
Typ zur Darstellung der Menge von Bildobjekten, die zur Hypothese gehören. | Methode | Beschreibung | | :------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------- | | `RectArray Rects()` | Gibt eine Kopie des Arrays mit den Rechtecken der zur Hypothese gehörenden Bildobjekte zurück. | | `Region Region()` | Gibt eine Kopie der zusammenhängenden Region zurück, die aus dem Array mit den Rechtecken der zur Hypothese gehörenden Bildobjekte erstellt wurde. |
## TextTypes
Typ zur Darstellung einer Menge von Texttypen. | Operator | Description | | :------- | :--------------------------------------- | | `+` | Verknüpft zwei Werte des Typs TextTypes. |
## BarcodeTypes
Typ zur Darstellung einer Menge von Barcode-Typen. | Operator | Description | | :------- | :----------------------------------------- | | `+` | Verknüpft zwei Werte vom Typ BarcodeTypes. |
## BarcodeOrientations
Typ zur Darstellung einer Menge möglicher Barcode-Orientierungen. | Operator | Description | | :------- | :------------------------------------------------ | | `+` | Verknüpft zwei Werte vom Typ BarcodeOrientations. |
## RecognitionMode
Ganzzahliger Typ zur Darstellung von Pre-Recognition-Modi.
## Direction
Typ zur Angabe der vertikalen oder horizontalen Richtung. Legt die Richtung von Separator- und White Gap-Elementen fest.
## HorSearchAreaBound
Typ zur Darstellung der rechten und linken Grenze des Suchbereichs eines Elements. Eine Variable dieses Typs lässt sich nur über einen Let-Ausdruck erstellen. | Operator | Description | | :------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `-` | Binärer Operator, der einen Wert vom Typ HorSearchAreaBound von einem Wert vom Typ XInterval subtrahiert und umgekehrt. Gibt einen Wert vom Typ Xinterval zurück. | | `>, <` | Binäre Operatoren, die einen Wert vom Typ HorSearchAreaBound mit einem Wert vom Typ XCoordinate vergleichen. Geben einen Wert vom Typ FuzzyRect zurück. |

VertSearchAreaBound

Typ zur Darstellung der oberen und unteren Grenzen des Suchbereichs eines Elements. Eine Variable dieses Typs lässt sich nur über einen Let-Ausdruck erstellen. | Operator | Beschreibung | | :------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `-` | Binärer Operator, der einen Wert vom Typ HorSearchAreaBound von einem Wert vom Typ YInterval subtrahiert und umgekehrt. Gibt einen Wert vom Typ Yinterval zurück. | | `>, <` | Binäre Operatoren, die einen Wert vom Typ VertSearchAreaBound mit einem Wert vom Typ YCoordinate vergleichen. Geben einen Wert vom Typ FuzzyRect zurück. |
## Hypothesis
Typ, der zum Aufrufen einer Hypothese eines Elements beliebigen Typs verwendet wird. Weitere Informationen finden Sie unter [Hypothesen für alle Arten von Elementen](/de/flexi-capture/fls/language/hyp-all).
## HypothesisInstances
Beschreibt Instanzen eines Elements vom Typ wiederholbare Gruppe. Verfügt über dieselben Methoden wie Hypothesen. Weitere Informationen zu den Methoden von Hypothesen finden Sie unter [Hypothesen für alle Elementtypen](/de/flexi-capture/fls/language/hyp-all). | Methode | Beschreibung | | :----------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `YCoordinateArray GetYArray( Real ratio )` | Gibt das Array der Y-Koordinaten der Instanzrechtecke zurück. Die Y-Koordinate wird nach folgender Formel berechnet: Top + Height \* ratio. Null-Instanzen werden ignoriert. |
## YCoordinateArray
Das Array der Y-Koordinaten der Rechtecke. | Konstruktor | Description | | :------------------------------------ | :----------------------------------------------------------------------------------------------- | | `YCoordinateArray YCoordinateArray()` | Konstruktor. Erstellt ein leeres Array von Rechtecken, die durch Y-Koordinaten angegeben werden. | | Methode | Description | | :---------------------------------------- | :-------------------------------------------------------------------------------------- | | `Void Add( YCoordinate )` | Fügt ein Rechteck am Ende des Arrays hinzu. | | `Void Add( YCoordinateArray )` | Fügt ein weiteres Array am Ende des Arrays hinzu. | | `Void InsertAt( Int index, YCoordinate )` | Fügt ein Rechteck an der Position index ein. | | `Void DeleteAll()` | Löscht alle Elemente des Arrays. | | `Void DeleteAt( Int index )` | Löscht das Element an der Position index. | | `YCoordinate GetAt( Int index )` | Gibt das Element mit dem angegebenen index zurück. | | `Int Count()` | Gibt die Anzahl der Elemente im Array zurück. | | `Void ShiftDown( Int index, Distance )` | Verschiebt die Koordinate des angegebenen Elements im Array nach unten (erhöht sie). | | `Void ShiftUp( Int index, Distance )` | Verschiebt die Koordinate des angegebenen Elements im Array nach oben (verringert sie). | | `Void ShiftDown( Distance )` | Verschiebt alle Elemente im Array nach unten (erhöht sie). | | `Void ShiftUp( Distance )` | Verschiebt alle Elemente im Array nach oben (verringert sie). |
## TableBlock
Ein Typ für den Zugriff auf einen Tabellenblock. | Methode | Beschreibung | | :------------------------------------- | :------------------------------------------------------------------------------------------------------------ | | `Int ColumnsCount()` | Gibt die Anzahl der Spalten im Block zurück. | | `String ColumnName( Int columnIndex )` | Der Name der Spalte columnIndex, wobei columnIndex die Nummer der Spalte ist. Die Nummerierung beginnt bei 0. |
## TableBlockColumn
Typ, der zum Aufrufen einer Spalte des Tabellenblocks verwendet wird. Eine Variable dieses Typs kann nur mithilfe eines Let-Ausdrucks erstellt werden. Weitere Informationen finden Sie unter [Hypothesen für Table-Elemente](/de/flexi-capture/fls/hypotheses/hyp-table).
## TableBlockColumnArray
Typ, der zum Aufrufen eines Arrays von Spalten des Tabellenblocks verwendet wird. Eine Variable dieses Typs kann nur mithilfe eines Let-Ausdrucks erstellt werden. Weitere Informationen finden Sie unter [Hypothesen für Table-Elemente](/de/flexi-capture/fls/hypotheses/hyp-table). | Konstruktor | Beschreibung | | :------------------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------- | | `TableBlockColumnArray( TableBlockColumn )` | Erstellt aus einer einzelnen Spalte ein Array von Spalten. Beispiel: `TableBlockColumnArray arr; arr = Blocks.TableBlock.Column1;` | | Methode | Beschreibung | | :----------------------------- | :------------------------------------------------------- | | `Void Add( TableBlockColumn )` | Fügt die ausgewählte Spalte dem Array von Spalten hinzu. | | Operator | Beschreibung | | :------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `<<` | Binärer Operator, der ein Array von Spalten einem anderen Array von Spalten hinzufügt. Beispiel: `TableBlockColumnArray arr; arr = Blocks.TableBlock.Column1; arr << Blocks.TableBlock.Column2 << Blocks.TableBlock.Column3;` |
## TableHypothesis
Typ, der zum Aufrufen einer Hypothese des Table-Elements verwendet wird. Weitere Informationen finden Sie unter [Hypothesen für Table-Elemente](/de/flexi-capture/fls/hypotheses/hyp-table).
## TableHypColumn
Typ, mit dem eine Spalte der Hypothese des Table-Elements aufgerufen wird. Eine Variable dieses Typs kann nur mithilfe eines Let-Ausdrucks erstellt werden. Weitere Informationen finden Sie unter [Hypothesen für Table-Elemente](/de/flexi-capture/fls/hypotheses/hyp-table).
## TableColumnType
Typ zur Beschreibung mehrerer Arten von Spalteninhalten.
## CurrencyPositionTypes
Typ, mit dem die Position des Währungsnamens relativ zum numerischen Wert in einem Currency-Element festgelegt wird. | Operator | Description | | :------- | :--------------------------------------------------------------- | | `+` | Verknüpft Werte vom Typ CurrencyPositionTypes. Binärer Operator. |
## PageInterval
Typ zur Darstellung des Seitenintervalls eines mehrseitigen Documents. | Methode | Beschreibung | | :---------------- | :------------------------------------------------------------------------- | | `Logic IsEmpty()` | Prüft, ob der Bereich eines Rectangle leer ist. Schreibgeschützt. | | `Int Start()` | Gibt die Nummer der ersten Seite eines Bereichs zurück. Schreibgeschützt. | | `Int End()` | Gibt die Nummer der letzten Seite eines Bereichs zurück. Schreibgeschützt. |
## PageArea
Bereich auf einer Seite. Wird von den Methoden PageSearchAreaLocal, PageSearchAreaGlobal, PageAreaLocal und PageAreaGlobal zurückgegeben (diese Funktionen erwarten Seitennummern als Argumente). Kann je nach aufgerufener Funktion entweder in globalen oder in lokalen Koordinaten angegeben werden. | Methode | Beschreibung | | :---------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `XInterval Left()` | Die linke Begrenzung des auf der angegebenen Seite befindlichen Teils der Hypothese, horizontales Intervall. | | `YInterval Top()` | Die obere Begrenzung des auf der angegebenen Seite befindlichen Teils der Hypothese, vertikales Intervall. | | `XInterval Right()` | Die rechte Begrenzung des auf der angegebenen Seite befindlichen Teils der Hypothese, horizontales Intervall. | | `YInterval Bottom()` | Die untere Begrenzung des auf der angegebenen Seite befindlichen Teils der Hypothese, vertikales Intervall. | | `XInterval XCenter()` | Die Abszisse des Mittelpunkts des auf der angegebenen Seite befindlichen Teils der Hypothese, horizontales Intervall. | | `YInterval YCenter()` | Die Ordinate des Mittelpunkts des auf der angegebenen Seite befindlichen Teils der Hypothese, vertikales Intervall. | | `DistInterval Width()` | Die Breite des auf der angegebenen Seite befindlichen Teils der Hypothese. | | `DistInterval Height()` | Die Höhe des auf der angegebenen Seite befindlichen Teils der Hypothese. | | `FuzzyRect FuzzyRect()` | Das Fuzzy Rectangle des auf der angegebenen Seite befindlichen Teils der Hypothese. | | `Rect Rect()` | Das umschließende Rechteck des auf der angegebenen Seite befindlichen Teils der Hypothese. Stimmt mit dem äußeren Rechteck des Fuzzy Rectangle überein. | | `Region Region()` | Die Region des auf der angegebenen Seite befindlichen Teils der Hypothese. | | `Region SimplifiedRegion()` | Die Region des auf der angegebenen Seite befindlichen Teils der Hypothese, vereinfacht für eine bessere Darstellung. | | `ImageObjectSet Set()` | Bildobjekte, die von dem auf der angegebenen Seite befindlichen Teil der Hypothese erfasst werden. | | `ImageObjectSet ExcludeSet()` | Bildobjekte auf dem Teil des Bildes, der durch Exclude-Methoden aus dem Suchbereich des auf der angegebenen Seite befindlichen Teils der Hypothese ausgeschlossen wurde. | | `RectArray Rects()` | Das Array der Rechtecke der Bildobjekte, die von dem auf der angegebenen Seite befindlichen Teil der Hypothese erfasst werden. |
## PageEdge
Der Typ, mit dem die Nearest-Funktion relativ zu einem Seitenrand angegeben wird. Damit können Sie die Hypothese auswählen, die dem oberen, unteren, linken oder rechten Seitenrand am nächsten liegt.
## Seite
Von der Funktion Page( Int PageNumber ) zurückgegebener Typ. | Methode | Beschreibung | | :----------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Distance AverageLineHeight()` | Durchschnittliche Zeilenhöhe auf einer Seite. | | `Distance AverageInterlineInterval()` | Durchschnittlicher Zeilenabstand auf einer Seite. | | `Area ObjectsAreaLocal( Rect localRect, ImageObjectType )` | Die Fläche der Objekte im angegebenen Rechteck auf einer Seite des angegebenen Typs. Für das Rechteck werden lokale Koordinaten verwendet. | | `Area ObjectsIntersectionAreaLocal( Rect localRect, ImageObjectType )` | Die Gesamtfläche der Objekte im angegebenen Rechteck sowie die Fläche der Überschneidung der Objekte mit dem Rechteck auf einer Seite des angegebenen Typs. Für das Rechteck werden lokale Koordinaten verwendet. | | `Area ObjectsAreaGlobal( Rect globalRect, ImageObjectType )` | Die Fläche der Objekte im angegebenen Rechteck auf einer Seite des angegebenen Typs. Für das Rechteck werden globale Koordinaten verwendet. | | `Area ObjectsIntersectionAreaGlobal( Rect globalRect, ImageObjectType )` | Die Gesamtfläche der Objekte im angegebenen Rechteck sowie die Fläche der Überschneidung der Objekte mit dem Rechteck auf einer Seite des angegebenen Typs. Für das Rechteck werden globale Koordinaten verwendet. | | `Rect RectLocal()` | Das Rechteck des gesamten Bildes in lokalen Koordinaten. | | `Rect RectGlobal()` | Das Rechteck des gesamten Bildes in globalen Koordinaten. |
## SearchAreaPageSetType
Der in der Funktion RestrictSearchArea verwendete Typ. Die vordefinierten Konstanten für diesen Typ sind `AnyPage`, `OddPages`, `EvenPages` und `LastPage`.
## IntArray
Array von Ganzzahlen. | Konstruktor | Description | | :------------------------- | :-------------------------------------------------------------------------------------- | | `IntArray IntArray()` | Erstellt ein leeres Array. | | `IntArray IntArray( Int )` | Konstruktor mit dem Parameter Int. Erstellt ein Array, das aus dieser Ganzzahl besteht. | | Methode | Description | | :--------------------------------------- | :------------------------------------------------- | | `Int Count()` | Gibt die Anzahl der Elemente im Array zurück. | | `Int GetAt( Int )` | Gibt das Element mit dem angegebenen Index zurück. | | `Void Add( Int )` | Fügt eine Ganzzahl am Ende des Arrays hinzu. | | `Void Add( IntArray )` | Fügt ein weiteres Array am Ende des Arrays hinzu. | | `Void InsertAt( Int index, Int number )` | Fügt eine Ganzzahl an der Position index ein. | | `Void DeleteAll()` | Löscht alle Elemente des Arrays. | | `Void DeleteAt( Int index )` | Löscht das Element an der Position index. | | Operator | Description | | :------- | :------------------------------------------------------- | | `<<` | Binärer Operator, der eine Ganzzahl zum Array hinzufügt. |
## StringArray
Array von strings. | Konstruktor | Description | | :-------------------------- | :------------------------- | | `StringArray StringArray()` | Erstellt ein leeres Array. | | Methode | Description | | :----------------------------------- | :------------------------------------------------- | | `Int Count()` | Gibt die Anzahl der Elemente im Array zurück. | | `String GetAt( Int index )` | Gibt das Element mit dem angegebenen index zurück. | | `Void Add( String )` | Fügt einen string am Ende des Arrays hinzu. | | `Void Add( StringArray )` | Fügt ein weiteres Array am Ende des Arrays hinzu. | | `Void InsertAt( Int index, String )` | Fügt einen string an der Position index ein. | | `Void DeleteAll()` | Löscht alle Elemente des Arrays. | | `Void DeleteAt( Int index )` | Löscht das Element an der Position index. |
## IntFuzzyInterval
Ein Typ zur Darstellung eines unscharfen Intervalls ganzer Zahlen. Das unscharfe Intervall wird durch vier Werte vom Typ Int dargestellt, von denen jeder größer oder gleich dem vorhergehenden Wert sein muss. | Konstruktor | Beschreibung | | :----------------------------------------------- | :------------------------------------------------------------------------------------- | | `IntFuzzyInterval IntFuzzyInterval( Int value )` | Konstruktor aus einer ganzen Zahl. Initialisiert alle vier Werte mit dem Wert „value“. | | Initialisierung | Beschreibung | | :------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Expression of type {x1, x2, x3, x4}` | Eine Variable vom Typ IntFuzzyInterval kann durch einen Ausdruck der Form `{x1, x2, x3, x4}` initialisiert werden, wobei x1, x2, x3 und x4 Werte vom Typ Int sind. Beispiel: `Int x1 = 5; IntFuzzyInterval intFuzzyInt = {x1, 200, 300, 5000};` | | Operator | Beschreibung | | :------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `+` | Ein binärer Additionsoperator, der einen Wert vom Typ Int zu einem Wert vom Typ IntFuzzyInterval addiert. Gibt einen Wert vom Typ IntFuzzyInterval zurück. | | `+` | Ein binärer Additionsoperator, der einen Wert vom Typ DistInterval zu einem Wert vom Typ IntFuzzyInterval addiert. Gibt einen Wert vom Typ IntFuzzyInterval zurück. | | `-` | Ein binärer Subtraktionsoperator, der einen Wert vom Typ Int von einem Wert vom Typ IntFuzzyInterval subtrahiert. Gibt einen Wert vom Typ IntFuzzyInterval zurück. | | `-` | Ein binärer Subtraktionsoperator, der einen Wert vom Typ IntFuzzyInterval von einem Wert vom Typ Int subtrahiert. Gibt einen Wert vom Typ IntFuzzyInterval zurück. | | `-` | Ein binärer Subtraktionsoperator, der einen Wert vom Typ DistInterval von einem Wert vom Typ IntFuzzyInterval subtrahiert. Gibt einen Wert vom Typ IntFuzzyInterval zurück. | | `-` | Ein binärer Subtraktionsoperator, der einen Wert vom Typ IntFuzzyInterval von einem Wert vom Typ DistInterval subtrahiert. Gibt einen Wert vom Typ IntFuzzyInterval zurück. | | `*` | Ein binärer Multiplikationsoperator, der einen Wert vom Typ IntFuzzyInterval mit einem Wert vom Typ Int multipliziert. Gibt einen Wert vom Typ IntFuzzyInterval zurück. | | `*` | Ein binärer Multiplikationsoperator, der einen Wert vom Typ IntFuzzyInterval mit einem Wert vom Typ DistInterval multipliziert. Gibt einen Wert vom Typ IntFuzzyInterval zurück. | | `/` | Ein binärer Divisionsoperator, der einen Wert vom Typ IntFuzzyInterval durch einen Wert vom Typ Int dividiert. Gibt einen Wert vom Typ IntFuzzyInterval zurück. |
## DistFuzzyInterval
Ein Typ zur Darstellung eines unscharfen ganzzahligen Intervalls von Abständen. Das unscharfe Intervall wird durch vier Werte vom Typ Distance dargestellt, von denen jeder größer oder gleich dem vorherigen Wert sein muss. | Konstruktor | Beschreibung | | :------------------------------------------------------- | :----------------------------------------------------------------------------------------------- | | `DistFuzzyInterval DistFuzzyInterval ( Distance value )` | Konstruktor aus einem Wert vom Typ Distance. Initialisiert alle vier Werte mit dem Wert „value“. | | Initialisierung | Beschreibung | | :------------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Expression of type {d1, d2, d3, d4}` | Eine Variable vom Typ DistFuzzyInterval kann mit einem Ausdruck der Form `{d1, d2, d3, d4}` initialisiert werden, wobei d1, d2, d3 und d4 Werte vom Typ Distance sind. Beispiel: `Distance d1 = 5dt; DistFuzzyInterval distFuzzyInt = {d1, 200dt, 300dt, 5000dt};` | | Operator | Beschreibung | | :------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `+` | Ein binärer Additionsoperator, der einen Wert vom Typ DistFuzzyInterval zu einem Wert vom Typ Distance addiert. Gibt einen Wert vom Typ DistFuzzyInterval zurück. | | `+` | Ein binärer Additionsoperator, der einen Wert vom Typ DistFuzzyInterval zu einem Wert vom Typ DistInterval addiert. Gibt einen Wert vom Typ DistFuzzyInterval zurück. | | `-` | Ein binärer Subtraktionsoperator, der einen Wert vom Typ Distance von einem Wert vom Typ DistFuzzyInterval subtrahiert. Gibt einen Wert vom Typ DistFuzzyInterval zurück. | | `-` | Ein binärer Subtraktionsoperator, der einen Wert vom Typ DistFuzzyInterval von einem Wert vom Typ Distance subtrahiert. Gibt einen Wert vom Typ DistFuzzyInterval zurück. | | `-` | Ein binärer Subtraktionsoperator, der einen Wert vom Typ DistInterval von einem Wert vom Typ DistFuzzyInterval subtrahiert. Gibt einen Wert vom Typ DistFuzzyInterval zurück. | | `-` | Ein binärer Subtraktionsoperator, der einen Wert vom Typ DistFuzzyInterval von einem Wert vom Typ DistInterval subtrahiert. Gibt einen Wert vom Typ DistFuzzyInterval zurück. | | `*` | Ein binärer Multiplikationsoperator, der einen Wert vom Typ DistFuzzyInterval mit einem Wert vom Typ Int multipliziert. Gibt einen Wert vom Typ DistFuzzyInterval zurück. | | `*` | Ein binärer Multiplikationsoperator, der einen Wert vom Typ DistFuzzyInterval mit einem Wert vom Typ DistInterval multipliziert. Gibt einen Wert vom Typ DistFuzzyInterval zurück. | | `/` | Ein binärer Divisionsoperator, der einen Wert vom Typ DistFuzzyInterval durch einen Wert vom Typ Int dividiert. Gibt einen Wert vom Typ DistFuzzyInterval zurück. |
## AreaFuzzyInterval
Ein Typ zur Darstellung eines unscharfen ganzzahligen Intervalls einer Fläche. Das unscharfe Intervall wird durch vier Werte vom Typ Area dargestellt, von denen jeder größer oder gleich dem vorhergehenden Wert sein muss. | Konstruktor | Beschreibung | | :--------------------------------------------------- | :------------------------------------------------------------------------------------------- | | `AreaFuzzyInterval AreaFuzzyInterval ( Area value )` | Konstruktor aus einem Wert vom Typ Area. Initialisiert alle vier Werte mit dem Wert „value“. | | Initialisierung | Beschreibung | | :------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `Expression of type {a1, a2, a3, a4}` | Eine Variable vom Typ AreaFuzzyInterval kann mit einem Ausdruck der Form `{a1, a2, a3, a4}` initialisiert werden, wobei a1, a2, a3 und a4 Werte vom Typ Area sind. Beispiel: `Area a1 = 500dt*dt; AreaFuzzyInterval areaFuzzyInterval = {a1, 2000dt*dt, 3000dt*dt, 5000dt*dt};` | | Operator | Beschreibung | | :------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `+` | Ein binärer Additionsoperator, der einen Wert vom Typ AreaFuzzyInterval und einen Wert vom Typ Area addiert. Gibt einen Wert vom Typ AreaFuzzyInterval zurück. | | `-` | Ein binärer Subtraktionsoperator, der einen Wert vom Typ Area von einem Wert vom Typ AreaFuzzyInterval subtrahiert. Gibt einen Wert vom Typ AreaFuzzyInterval zurück. | | `-` | Ein binärer Subtraktionsoperator, der einen Wert vom Typ AreaFuzzyInterval von einem Wert vom Typ Area subtrahiert. Gibt einen Wert vom Typ AreaFuzzyInterval zurück. | | `*` | Ein binärer Multiplikationsoperator, der einen Wert vom Typ AreaFuzzyInterval mit einem Wert vom Typ Int multipliziert. Gibt einen Wert vom Typ AreaFuzzyInterval zurück. | | `/` | Ein binärer Divisionsoperator, der einen Wert vom Typ AreaFuzzyInterval durch einen Wert vom Typ Int dividiert. Gibt einen Wert vom Typ AreaFuzzyInterval zurück. |
## TextRotations
Ein Typ zur Darstellung einer Menge von Orientierungen des erkannten Textes, in denen nach dem Element gesucht wird. | Operator | Description | | :------- | :------------------------------------- | | `+` | Verknüpft Werte vom Typ TextRotations. |