> ## 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 que crean un rectángulo difuso

> Funciones de FlexiLayout language que devuelven un FuzzyRect para RestrictSearchArea: AreaLeftOf, AreaAbove, ImageBelow y otros auxiliares para los límites del área de búsqueda.

La función `RestrictSearchArea( FuzzyRect fuzzyRect )`, descrita en [Funciones que limitan el área de búsqueda](/es/flexi-capture/fls/language/search-functions), limita el área de búsqueda a cualquier rectángulo difuso.

<div id="fuzzy-rectangle-functions">
  ## Funciones de rectángulo difuso
</div>

FlexiLayout language proporciona las siguientes funciones para obtener un rectángulo difuso.

| Definición                                                               | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `HorSearchAreaBound LeftBound()`                                         | Se utiliza para establecer una restricción en el límite izquierdo del área de búsqueda. Las expresiones del tipo `LeftBound() > XCoordinate` devuelven `FuzzyRect`.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `VertSearchAreaBound TopBound()`                                         | Se utiliza para establecer una restricción en el límite superior del área de búsqueda. Las expresiones del tipo `TopBound() > YCoordinate` devuelven `FuzzyRect`.                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `HorSearchAreaBound RightBound()`                                        | Se utiliza para establecer una restricción en el límite derecho del área de búsqueda. Las expresiones del tipo `RightBound() > XCoordinate` devuelven `FuzzyRect`.                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `VertSearchAreaBound BottomBound()`                                      | Se utiliza para establecer una restricción en el límite inferior del área de búsqueda. Las expresiones del tipo `BottomBound() > YCoordinate` devuelven `FuzzyRect`.                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `FuzzyRect AreaLeftOf( XInterval x, Distance offset = 0 )`               | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano vertical situado a la izquierda del punto `x.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `FuzzyRect AreaLeftOf( FuzzyRect rect, Distance offset = 0 )`            | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano vertical situado a la izquierda del punto `rect.Left.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `FuzzyRect AreaLeftOf( Hypothesis hyp, Distance offset = 0 )`            | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano vertical situado a la izquierda del punto `hyp.Rect.Left.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `FuzzyRect AreaLeftOf( HypothesisInstances hyps, Distance offset = 0 )`  | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano vertical situado a la izquierda del punto `hyps.Rect.Left.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `FuzzyRect AreaRightOf( XInterval x, Distance offset = 0 )`              | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano vertical situado a la derecha del punto `x.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `FuzzyRect AreaRightOf( FuzzyRect rect, Distance offset = 0 )`           | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano vertical situado a la derecha del punto `rect.Right.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `FuzzyRect AreaRightOf( Hypothesis hyp, Distance offset = 0 )`           | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano vertical situado a la derecha del punto `hyp.rect.Right.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `FuzzyRect AreaRightOf( HypothesisInstances hyps, Distance offset = 0 )` | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano vertical situado a la derecha del punto `hyps.Rect.Right.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `FuzzyRect AreaAbove( YInterval y, Distance offset = 0 )`                | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano horizontal situado encima del punto `y.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `FuzzyRect AreaAbove( FuzzyRect rect, Distance offset = 0 )`             | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano horizontal situado encima del punto `rect.top.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `FuzzyRect AreaAbove( Hypothesis hyp, Distance offset = 0 )`             | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano horizontal situado encima del punto `hyp.rect.top.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `FuzzyRect AreaAbove( HypothesisInstances hyps, Distance offset = 0 )`   | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano horizontal situado encima del punto `hyps.Rect.top.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `FuzzyRect AreaBelow( YInterval y, Distance offset = 0 )`                | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano horizontal situado debajo del punto `y.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `FuzzyRect AreaBelow( FuzzyRect rect, Distance offset = 0 )`             | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano horizontal situado debajo del punto `rect.Bottom.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `FuzzyRect AreaBelow( Hypothesis hyp, Distance offset = 0 )`             | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano horizontal situado debajo del punto `hyp.rect.Bottom.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `FuzzyRect AreaBelow( HypothesisInstances hyps, Distance offset = 0 )`   | Devuelve un rectángulo difuso en coordenadas globales; es decir, un semiplano horizontal situado debajo del punto `hyps.Rect.Bottom.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `FuzzyRect ImageLeftOf( XInterval x, Distance offset = 0 )`              | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano vertical situado a la izquierda del punto `x.End - offset`.<br />**¡Importante!** La función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaLeftOf( XInterval x, Distance offset = 0 )`.                   |
| `FuzzyRect ImageLeftOf( FuzzyRect rect, Distance offset = 0 )`           | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano vertical situado a la izquierda del punto `rect.Left.End - offset`.<br />**¡Importante!** La función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaLeftOf( FuzzyRect rect, Distance offset = 0 )`.        |
| `FuzzyRect ImageLeftOf( Hypothesis hyp, Distance offset = 0 )`           | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano vertical situado a la izquierda del punto `hyp.Rect.Left.End - offset`.<br />**¡Importante!** La función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaLeftOf( Hypothesis hyp, Distance offset = 0 )`.    |
| `FuzzyRect ImageRightOf( XInterval x, Distance offset = 0 )`             | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano vertical situado a la derecha del punto `x.Start + offset`.<br />**¡Importante!** La función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaRightOf( XInterval x, Distance offset = 0 )`.                  |
| `FuzzyRect ImageRightOf( FuzzyRect rect, Distance offset = 0 )`          | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano vertical situado a la derecha del punto `rect.Right.Start + offset`.<br />**¡Importante!** La función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaRightOf( FuzzyRect rect, Distance offset = 0 )`.      |
| `FuzzyRect ImageRightOf( Hypothesis hyp, Distance offset = 0 )`          | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano vertical situado a la derecha del punto `hyp.rect.Right.Start + offset`.<br />**¡Importante!** La función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaRightOf( Hypothesis hyp, Distance offset = 0 )`.  |
| `FuzzyRect ImageAbove( YInterval y, Distance offset = 0 )`               | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano horizontal situado encima del punto `y.End - offset`.<br />**¡Importante!** La función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaAbove( YInterval y, Distance offset = 0 )`.                          |
| `FuzzyRect ImageAbove( FuzzyRect rect, Distance offset = 0 )`            | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano horizontal situado encima del punto `rect.top.End - offset`.<br />**¡Importante!** La función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaAbove( FuzzyRect rect, Distance offset = 0 )`.                |
| `FuzzyRect ImageAbove( Hypothesis hyp, Distance offset = 0 )`            | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano horizontal situado encima del punto `hyp.rect.top.End - offset`.<br />**¡Importante!** La función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaAbove( Hypothesis hyp, Distance offset = 0 )`.            |
| `FuzzyRect ImageBelow( YInterval y, Distance offset = 0 )`               | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano horizontal situado debajo del punto `y.Start + offset`.<br />**¡Importante!** La función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaBelow( YInterval y, Distance offset = 0 )`.                        |
| `FuzzyRect ImageBelow( FuzzyRect rect, Distance offset = 0 )`            | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano horizontal situado por debajo del punto `rect.Bottom.Start + offset`.<br />**¡Importante!** Esta función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaBelow( FuzzyRect rect, Distance offset = 0 )`.     |
| `FuzzyRect ImageBelow( Hypothesis hyp, Distance offset = 0 )`            | Devuelve un rectángulo difuso, que corresponde a la intersección entre el rectángulo de la página y el semiplano horizontal situado por debajo del punto `hyp.rect.Bottom.Start + offset`.<br />**¡Importante!** Esta función solo puede utilizarse si el número máximo y mínimo de páginas del documento está establecido en 1; es decir, el documento detectado solo tiene una página. Si utiliza esta función para un documento multipágina, el emparejamiento de un FlexiLayout devolverá un error.<br />Para un documento multipágina, utilice la función `FuzzyRect AreaBelow( Hypothesis hyp, Distance offset = 0 )`. |