> ## 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.
# Funciones globales
> Funciones globales en FlexiLayout language: funciones auxiliares matemáticas y de cadena, consultas a bases de datos como ExecuteSQL, funciones de validación y llamadas a RecognizeText.
FlexiLayout language proporciona funciones globales para operaciones matemáticas y de comparación, cálculos de coordenadas e intervalos, procesamiento de cadenas, conversión y validación, acceso a bases de datos y archivos, manejo de páginas y documentos, y prerreconocimiento.
No utilice variables como argumentos de funciones globales que interactúan con archivos externos o bases de datos.
## Funciones matemáticas y de comparación
| Definición | Descripción |
| ------------------------------------------ | ---------------------------------------------------------------- |
| `Area Max( Area a1, Area a2 )` | Devuelve el valor máximo entre `a1` y `a2`. |
| `Area Min( Area a1, Area a2 )` | Devuelve el valor mínimo entre `a1` y `a2`. |
| `Distance abs( Distance )` | Devuelve el valor absoluto de una distancia. |
| `Distance Min( Distance d1, Distance d2 )` | Devuelve el valor mínimo entre `d1` y `d2`. |
| `Distance Max( Distance d1, Distance d2 )` | Devuelve el valor máximo entre `d1` y `d2`. |
| `Int abs( Int )` | Devuelve el valor absoluto de un número. |
| `Int Ceil( Real )` | Devuelve el entero más pequeño que no es menor que el argumento. |
| `Int Floor( Real )` | Devuelve el entero más grande que no es mayor que el argumento. |
| `Int Max( Int n1, Int n2 )` | Devuelve el valor máximo entre `n1` y `n2`. |
| `Int Min( Int n1, Int n2 )` | Devuelve el valor mínimo entre `n1` y `n2`. |
| `Int Round( Real )` | Devuelve el entero más cercano al valor del argumento. |
| `Real Min( Real d1, Real d2 )` | Devuelve el valor mínimo entre `d1` y `d2`. |
| `Real Max( Real d1, Real d2 )` | Devuelve el valor máximo entre `d1` y `d2`. |
## Funciones de coordenadas e intervalos
| Definición | Descripción |
| ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Area ObjectsArea( Rect, ImageObjectType )` | El área de los objetos del tipo especificado dentro del rectángulo indicado. Usa coordenadas globales. |
| `Area ObjectsIntersectionArea( Rect, ImageObjectType )` | El área de los objetos del tipo especificado dentro del rectángulo indicado y el área de intersección de los objetos del tipo especificado que se extienden más allá del rectángulo indicado. Usa coordenadas globales. |
| `Logic IsOnSameLine( Hypothesis, Hypothesis )` | Comprueba si las hipótesis se superponen verticalmente. |
| `Region FormRegion( RectArray included, RectArray excluded )` | Crea una región que incluye el array de rectángulos `included` y excluye el array de rectángulos `excluded`. |
| `XCoordinate Min( XCoordinate x1, XCoordinate x2 )` | Devuelve el valor mínimo entre `x1` y `x2`. |
| `XCoordinate Max( XCoordinate x1, XCoordinate x2 )` | Devuelve el valor máximo entre `x1` y `x2`. |
| `XCoordinate MiddleBetween( XCoordinate x1, XCoordinate x2 )` | Devuelve la coordenada X calculada como `( x1 + x2 ) / 2`. |
| `XCoordinate Between( XCoordinate x1, XCoordinate x2, Real ratio )` | Devuelve la coordenada X calculada como `x1 + ( x2 - x1 ) * ratio`. |
| `YCoordinate Min( YCoordinate y1, YCoordinate y2 )` | Devuelve el valor mínimo entre `y1` y `y2`. |
| `YCoordinate Max( YCoordinate y1, YCoordinate y2 )` | Devuelve el valor máximo entre `y1` y `y2`. |
| `YCoordinate MiddleBetween( YCoordinate y1, YCoordinate y2 )` | Devuelve YInterval calculado como `( y1 + y2 ) / 2`. |
| `YCoordinate Between( YCoordinate y1, YCoordinate y2, Real ratio )` | Devuelve YInterval calculado como `y1 + ( y2 - y1 ) * ratio`. |
| `XInterval MiddleBetween( XInterval x1, XInterval x2 )` | Devuelve XInterval calculado como `( x1 + x2 ) / 2`. |
| `XInterval Between( XInterval x1, XInterval x2, Real ratio )` | Devuelve XInterval calculado como `x1 + ( x2 - x1 ) * ratio`. |
| `YInterval MiddleBetween( YInterval y1, YInterval y2 )` | Devuelve YInterval calculado como `( y1 + y2 ) / 2`. |
| `YInterval Between( YInterval y1, YInterval y2, Real ratio )` | Devuelve YInterval calculado como `y1 + ( y2 - y1 ) * ratio`. |
## Funciones de cadena
| Definición | Descripción |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `String Chr( Int )` | Devuelve una cadena a partir del código Unicode especificado del carácter (el código debe escribirse en el sistema decimal). |
| `String LCase( String )` | Devuelve una cadena obtenida de la cadena especificada convirtiendo todos sus caracteres a minúsculas. |
| `String RealToStrVariants( Real value, String fractionalPartSeparators, Int maxDigitsCountInFractionalPart = 2 )` | Crea representaciones en cadena, separadas por una barra vertical (`\|`), para el número real especificado `value`, los separadores decimales `fractionalPartSeparators` y el número máximo de dígitos en la parte fraccionaria. Por ejemplo, para los argumentos `19`, `".,"`, `2`, el resultado es `"19\|19.0\|19.00\|19,0\|19,00"`. |
| `String Str( Int )`
`String Str( Logic )`
`String Str( Real )`
`String Str( XInterval )`
`String Str( YInterval )`
`String Str( DistInterval )`
`String Str( FuzzyRect )`
`String Str( Hypothesis )`
`String Str( RectArray )`
`String Str( Region )`
`String Str( Area )`
`String Str( Quality )`
`String Str( Distance )`
`String Str( PageInterval )` | Representación en cadena de un tipo de datos. |
| `String RemoveSpaces( String )` | Devuelve una cadena obtenida de la cadena especificada eliminando todos los espacios. |
| `String UCase( String )` | Devuelve una cadena obtenida de la cadena especificada convirtiendo todos sus caracteres a mayúsculas. |
## Funciones de conversión y validación
| Definición | Descripción |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Int LogicToInt( Lógica value )` | Devuelve `1` si `value` es `true` y `0` si `value` es `false`. |
| `Int StrToInt( String inputString, Lógica isStrictMode = false )` | Devuelve el resultado de convertir el valor de cadena `inputString` en un entero. Se omiten los espacios. El parámetro `isStrictMode` (`false` de forma predeterminada) define si la cadena puede incluir caracteres distintos de dígitos y espacios. Si `isStrictMode = false` y la cadena contiene un carácter que no es un dígito ni un espacio, se omiten todos los caracteres posteriores. Compruebe que la cadena se pueda convertir antes de invocar esta función. Para ello, use la función `IsInt`. |
| `Int StrToIntFuzzy( String, Logic isStrictMode = false )` | Devuelve el resultado de convertir el valor de la cadena `inputString` en un entero, teniendo en cuenta los posibles errores de reconocimiento en la cadena (consulte la descripción de la función `IsIntFuzzy`). Los espacios se ignoran durante la conversión. El parámetro `isStrictMode` (establecido en `false` de forma predeterminada) determina si la cadena puede contener caracteres distintos de dígitos, caracteres que se parezcan a dígitos o espacios. Si `isStrictMode = false` y se encuentra un carácter que no sea un dígito, se ignorarán todos los caracteres que le sigan. Antes de iniciar la conversión, llame a la función `IsIntFuzzy` para comprobar si la cadena puede convertirse de forma segura. |
| `Lógica IsInt( String inputString, Lógica isStrictMode = false )` | Comprueba que la cadena `inputString` puede convertirse de forma segura en un entero. El parámetro `isStrictMode` (`false` de forma predeterminada) define si la cadena puede incluir caracteres distintos de dígitos y espacios. |
| `Lógica IsIntFuzzy( Cadena inputString, Lógica isStrictMode = false )` | Comprueba si la cadena `inputString` puede convertirse de forma segura en un entero, teniendo en cuenta posibles errores de reconocimiento en la cadena. Este tipo de conversión convierte en enteros no solo los dígitos (es decir, los caracteres `0123456789`), sino también los caracteres que se parecen a dígitos (por ejemplo, `oOBsl`). El parámetro `isStrictMode` (que está establecido en `false` de forma predeterminada) determina si la cadena puede contener caracteres distintos de los dígitos, los caracteres que se parecen a dígitos o los espacios. |
| `Logic IsReal( String numberString, String separators = ".,", Logic isStrictMode = false )` | Comprueba que la cadena `inputString` pueda convertirse en un número real. La lista de separadores decimales permitidos se establece con el argumento `separators`. De forma predeterminada, se permiten el punto, la coma y el separador definido por el usuario (configurado en la configuración regional del sistema operativo; consulte `RegionalDecimalPoint`). El parámetro `isStrictMode` (`false` de forma predeterminada) define si la cadena puede incluir caracteres distintos de dígitos, espacios y separadores. |
| `Lógica IsRealFuzzy( Cadena, Cadena separators = defaultDecimalSeparators, Lógica isStrictMode = false )` | Comprueba si la cadena `inputString` puede convertirse de forma segura en un número real, teniendo en cuenta los posibles errores de reconocimiento en la cadena (consulte la descripción de la función `IsIntFuzzy`). La lista de separadores decimales permitidos se especifica con el argumento `separators`. De forma predeterminada, se permiten los siguientes separadores: el punto, la coma y el separador especificado en la configuración regional del sistema operativo del usuario (consulte `RegionalDecimalPoint`). El parámetro `isStrictMode` (establecido en `false` de forma predeterminada) determina si la cadena puede contener caracteres distintos de dígitos, caracteres que parecen dígitos, espacios o separadores. |
| `Quality ValidateByDB( String word, String connectionString, String selectString, Int maxErrors, Real maxErrorsPart, Logic ignoreSpaces, Int maxRecordsCount = 1000 )` | Comprueba la palabra especificada comparándola con una base de datos. Para obtener más información, consulte [Bases de datos y archivos de texto en FlexiLayout language](/es/flexi-capture/fls/language/bd-textfiles). El argumento `connectionString` establece la cadena de conexión a la base de datos. El argumento `selectString` establece una consulta SQL que comienza con el comando `SELECT`. El argumento `maxErrors` establece el número máximo absoluto de errores en la palabra, y `maxErrorsPart` establece el número máximo relativo de errores en la palabra. El argumento `ignoreSpaces` determina si deben tenerse en cuenta los espacios al comparar. Para acelerar la búsqueda, solo se usan las primeras `maxRecordsCount` variantes (la configuración predeterminada es 1000). Devuelve la calidad del emparejamiento entre la palabra especificada y la mejor coincidencia de la base de datos. Esta función puede usarse en el campo **Relaciones avanzadas de posbúsqueda** para el emparejamiento difuso del valor de cadena de una hipótesis devuelta por el método `Value` con las variantes especificadas. |
| `Quality ValidateByFile( String word, String fileName, Int maxErrors, Real maxErrorsPart, Logic ignoreSpaces, Int maxRecordsCount = 1000 )` | Comprueba la palabra especificada comparándola con las variantes del archivo `fileName`, que contiene una lista de posibles variantes de frases. Para obtener más información, consulte [Bases de datos y archivos de texto en el FlexiLayout language](/es/flexi-capture/fls/language/bd-textfiles). El argumento `maxErrors` establece el número máximo absoluto de errores en la palabra, y `maxErrorsPart` establece el número máximo relativo de errores en la palabra. El argumento `ignoreSpaces` determina si deben tenerse en cuenta los espacios al comparar. Devuelve la calidad de la coincidencia entre la palabra especificada y la mejor coincidencia del archivo de texto. Para acelerar la búsqueda, solo se usan las primeras `maxRecordsCount` variantes (la configuración predeterminada es 1000). Esta función puede utilizarse en el campo **Relaciones avanzadas de posbúsqueda** para el emparejamiento difuso del valor de cadena de una hipótesis devuelta por el método `Value` con las variantes especificadas. |
| `Quality ValidateByText( String word, String variants, Int maxErrors, Real maxErrorsPart, Logic ignoreSpaces )` | Comprueba la palabra especificada comparándola con las variantes indicadas. El argumento `maxErrors` establece el número máximo absoluto de errores en la palabra, y `maxErrorsPart` establece el número máximo relativo de errores en la palabra. El argumento `ignoreSpaces` determina si deben tenerse en cuenta los espacios al comparar. Devuelve la calidad del emparejamiento entre la palabra especificada y la mejor coincidencia entre las variantes indicadas en el argumento `variants`. Esta función puede usarse en el campo **Relaciones avanzadas de posbúsqueda** para el emparejamiento difuso del valor de cadena de una hipótesis devuelta por el método `Value` con las variantes especificadas. |
| `Real StrToReal( String numberString, String separators = ".,", Logic isStrictMode = false )` | Devuelve el resultado de convertir la cadena `inputString` en un número real. Se omiten los espacios. El parámetro `isStrictMode` (`false` de forma predeterminada) define si la cadena puede incluir caracteres distintos de dígitos, espacios y separadores. Si `isStrictMode = false` y la cadena contiene un segundo separador decimal o un carácter que no es un dígito ni un espacio, se omiten todos los caracteres siguientes. Compruebe que la cadena se pueda convertir antes de invocar esta función. Para ello, use la función `IsReal`. |
| `Real StrToRealFuzzy( String, String separators = defaultDecimalSeparators, Logic isStrictMode = false )` | Devuelve el resultado de convertir el valor de la cadena `inputString` en un número real, teniendo en cuenta los posibles errores de reconocimiento en la cadena (consulte la descripción de la función `IsIntFuzzy`). Los espacios se ignoran durante la conversión. El parámetro `isStrictMode` (establecido en `false` de forma predeterminada) determina si la cadena puede contener caracteres distintos de dígitos, caracteres que se parecen a dígitos, espacios o separadores. Si `isStrictMode = false` y se encuentra un segundo separador decimal o un carácter distinto de un dígito, se ignorarán todos los caracteres posteriores. Antes de iniciar la conversión, llame a la función `IsRealFuzzy` para comprobar si la cadena puede convertirse de forma segura. |
Ejemplo de `StrToInt`:
```text theme={null}
Int integralValue;
String valueFromDocument = SearchElements.StaticText.Value();
Logic canBeConverted = IsInt(valueFromDocument, true);
if(canBeConverted) then integralValue = StrToInt(valueFromDocument, true);
```
Ejemplo de `ValidateByDB`:
```text theme={null}
if not IsNull then ValidateByDB(Value(), "Provider=Microsoft.Jet.OLEDB.4.0; Data Source=D:\\FCS\\Companies.mdb", "SELECT Name FROM Companies", 1, 0.3, true, 500);
```
Ejemplo de `ValidateByFile`:
```text theme={null}
if not IsNull then ValidateByTextFile(Value(), "Companies.txt", 1, 0.3, true, 500);
```
Ejemplo de `ValidateByText`:
```text theme={null}
if not IsNull then ValidateByText (Value(), "ABBYY|Flexi Capture", 1, 0.3, true);
```
Ejemplo de `StrToReal`:
```text theme={null}
Real realValue;
String valueFromDocument = SearchElements.StaticText.Value();
Logic canBeConverted = IsReal(valueFromDocument, ".");
if(canBeConverted) then realValue = StrToReal(valueFromDocument, ".");
```
## Funciones de base de datos y archivos
| Definición | Descripción |
| --------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Int RecordCount( String connectionString, String selectString )` | Devuelve el número de registros devueltos por la solicitud. Consulte el ejemplo de la función `Record` en esta sección. |
| `Logic ExecuteSQL( String connectionString, String queryString )` | Ejecuta la consulta SQL del usuario `queryString`. El argumento `connectionString` establece la connection string de la base de datos. |
| `Logic TestDBConnection( String connectionString )` | Prueba la conexión a la base de datos. El argumento `connectionString` contiene la connection string. |
| `Logic TestDBSelect( String connectionString, String selectString )` | Comprueba si se puede acceder a la base de datos y si la consulta SQL es correcta (si existen la tabla y el campo especificados). El argumento `connectionString` contiene la connection string. El argumento `selectString` contiene la consulta SQL, que comienza con el comando `SELECT`. |
| `Logic TestFileAccess( String fileName )` | Comprueba si se puede acceder al archivo de texto. |
| `Logic WriteToFile( String filename, String text )` | Agrega la cadena `text` al archivo `filename`. Si no existe un archivo con ese nombre, se creará uno nuevo. |
| `StringArray ReadFromXML( String filename, String xPathQuery )` | Lee un array de cadenas del archivo XML `filename`. Las cadenas se obtienen evaluando la consulta XPath `xPathQuery` proporcionada. |
| `StringArray Record( String connectionString, String selectString, Int index )` | Recupera los datos de un registro específico. Si una celda tiene el valor `NULL`, se devuelve una cadena vacía. |
| `String ReadSingleStringFromXML( String filename, String xPathQuery )` | Lee una cadena del archivo XML `filename`. La cadena se obtiene evaluando la consulta XPath `xPathQuery` proporcionada. |
| `Void PrepareRecordset( String connectionString, String selectString, Int maxRecordsCount = 1000 )` | Prepara la solicitud para un acceso rápido. Consulte el ejemplo de la función `Record` en esta sección. |
Ejemplo de `ExecuteSQL`:
```text theme={null}
ExecuteSQL("Provider=Microsoft.Jet.OLEDB.4.0; Data Source=D:\\FCS\\Companies.mdb", "UPDATE Companies SET total=0");
```
Ejemplo de `WriteToFile`:
```text theme={null}
WriteToFile("D:\\FCS\\logFile.txt", SearchElements.Tag.Value());
```
Ejemplo de `Record`:
```text theme={null}
String connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=D:\\1.mdb;";
String selectString = "SELECT SearchText, LeftPos, TopPos, RightPos, BottomPos from SearchPositions WHERE ElementName = 'DocID'";
PrepareRecordset(connectionString, selectString);
Int recordCount = RecordCount(connectionString, selectString);
String searchString;
RectArray searchArea = RectArray();
for recordIndex from 0 to recordCount - 1 {
StringArray recordArray = Record(connectionString, selectString, recordIndex);
if recordIndex == 0 then {
searchString = recordArray.GetAt(0);
} else {
searchString = searchString + "|" + recordArray.GetAt(0);
}
searchArea.Add(Rect(StrToInt(recordArray.GetAt(1)) * dt, StrToInt(recordArray.GetAt(2)) * dt,StrToInt(recordArray.GetAt(3)) * dt, StrToInt(recordArray.GetAt(4)) * dt));
}
SearchText: searchString;
RSA: searchArea;
```
En este ejemplo, de la tabla **SearchPositions** se extraen una cadena de búsqueda, **SearchText**, y las coordenadas de los rectángulos del área de búsqueda, **LeftPos**, **TopPos**, **RightPos** y **BottomPos**. El valor del campo **SearchText** se combina en una cadena de búsqueda mediante el operador `|`. Las coordenadas **LeftPos**, **TopPos**, **RightPos** y **BottomPos** de los campos de la tabla se usan para generar las coordenadas en puntos de los rectángulos. Las coordenadas generadas se agregan al área de búsqueda del elemento **DocID**.
## Funciones de página y documento
| Definición | Descripción |
| -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Distance AverageLineHeight()` | La altura media de las líneas de texto de la página. Esta función solo puede utilizarse si el número máximo y mínimo de páginas del documento se establece en 1; es decir, si el documento detectado tiene una sola página. Si utiliza esta función con un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error. En el caso de un documento multipágina, use el método correspondiente del tipo `Page`: `Page( N ).AverageLineHeight`. |
| `Distance AverageInterLineInterval()` | La distancia media entre las líneas de texto de la página. Esta función solo puede utilizarse si el número máximo y mínimo de páginas del documento se establece en 1; es decir, si el documento detectado tiene una sola página. Si utiliza esta función con un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error. En el caso de un documento multipágina, use el método correspondiente del tipo `Page`: `Page( N ).AverageInterLineInterval`. |
| `Int PagesCount()` | Devuelve el número de páginas del documento. |
| `Page Page( Int PageNumber )` | Devuelve el tipo que describe la página especificada. |
| `Rect DocumentRect()` | Devuelve el rectángulo del documento completo (en coordenadas globales). |
| `Rect PageRect()` | El rectángulo de la imagen completa. Esta función solo puede utilizarse si el número máximo y mínimo de páginas del documento se establece en 1; es decir, si el documento detectado tiene una sola página. Si utiliza esta función con un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error. En el caso de un documento multipágina, esta función solo puede utilizarse en la sección **Pre-search relations**. Para obtener más información, consulte [Funciones que limitan el área de búsqueda](/es/flexi-capture/fls/language/search-functions). |
| `Void SetPagesCount( Int pagesCount )` | Establece el número de páginas del documento. Se utiliza en las secciones **Pre-search** o **Post-search advanced code**. Esta función debe invocarse desde los elementos Header o Footer, o desde sus subelementos. La función se aplica a documentos que no tienen indicador de fin de documento (el pie de página no existe o es opcional). |
Ejemplo de `SetPagesCount`:
Si el elemento especificado fue emparejado, el documento termina en la página siguiente:
```text theme={null}
if IsFound then SetPagesCount(PagesCount + 1);
```
El número de páginas del documento puede verse en el campo **PageNum**:
```text theme={null}
if PageNum.IsFound and IsInt(PageNum.Value) then SetPagesCount: StrToInt(PageNum.Value);
```
## Funciones de prerreconocimiento
Las siguientes funciones invocan el prerreconocimiento durante el emparejamiento de FlexiLayout. Las líneas de texto que intersectan un área de prerreconocimiento determinada se reconocen en su totalidad (incluidas las partes de las líneas que quedan fuera de los límites del área).
| Definición | Descripción |
| ------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Void RecognizeText()` | Reconoce texto en el rectángulo relativo especificado en la propiedad **Pre-recognition area** de la configuración del proyecto. Todas las páginas del documento se incluyen en el reconocimiento. |
| `Void RecognizeText( IntArray pages )` | Reconoce texto en el rectángulo relativo especificado en la propiedad **Pre-recognition area** de la configuración del proyecto. Solo se incluyen en el reconocimiento las páginas especificadas por el argumento `pages`. |
| `Void RecognizeText( SearchAreaPageSetType pageSetType )` | Reconoce texto en el rectángulo relativo especificado en la propiedad **Pre-recognition area** de la configuración del proyecto. Solo se incluyen en el reconocimiento las páginas especificadas por el argumento `pageSetType`. |
| `Void RecognizeText( Rect rect )` | Reconoce texto en el rectángulo `rect`. |
| `Void RecognizeText( Rect rect, IntArray pages )` | Reconoce texto en el rectángulo `rect`. Solo se incluyen en el reconocimiento las páginas especificadas por el argumento `pages`. |
| `Void RecognizeText( Rect rect, SearchAreaPageSetType pageSetType )` | Reconoce texto en el rectángulo `rect`. Solo se incluyen en el reconocimiento las páginas especificadas por el argumento `pageSetType`. |
| `Void RecognizeText( RectArray rectArray )` | Reconoce texto en el array de rectángulos `rectArray`. |
| `Void RecognizeText( RectArray rectArray, IntArray pages )` | Reconoce texto en el array de rectángulos `rectArray`. Solo se incluyen en el reconocimiento las páginas especificadas por el argumento `pages`. |
| `Void RecognizeText( RectArray rectArray, SearchAreaPageSetType pageSetType )` | Reconoce texto en el array de rectángulos `rectArray`. Solo se incluyen en el reconocimiento las páginas especificadas por el argumento `pageSetType`. |
| `Void RecognizeText( Region region )` | Reconoce texto en la región `region`. |
| `Void RecognizeText( Region region, IntArray pages )` | Reconoce texto en la región `region`. Solo se incluyen en el reconocimiento las páginas especificadas por el argumento `pages`. |
| `Void RecognizeText( Region region, SearchAreaPageSetType pageSetType )` | Reconoce texto en la región `region`. Solo se incluyen en el reconocimiento las páginas especificadas por el argumento `pageSetType`. |
| `RectArray RecognizedRects()` | Una función de depuración que permite imprimir un array de rectángulos prerreconocidos. |