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

# Fonctions permettant de créer un rectangle flou

> Fonctions du langage FlexiLayout qui renvoient un FuzzyRect pour RestrictSearchArea : AreaLeftOf, AreaAbove, ImageBelow et d’autres fonctions utilitaires pour les limites de la zone de recherche.

La fonction `RestrictSearchArea( FuzzyRect fuzzyRect )`, décrite dans [Fonctions qui limitent la zone de recherche](/fr/flexi-capture/fls/language/search-functions), limite la zone de recherche à un rectangle flou quelconque.

<div id="fuzzy-rectangle-functions">
  ## Fonctions de rectangle flou
</div>

Le langage FlexiLayout fournit les fonctions suivantes pour obtenir un rectangle flou.

| Définition                                                               | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `HorSearchAreaBound LeftBound()`                                         | Sert à définir une contrainte sur la limite gauche de la zone de recherche. Les expressions de type `LeftBound() > XCoordinate` renvoient `FuzzyRect`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `VertSearchAreaBound TopBound()`                                         | Sert à définir une contrainte sur la limite supérieure de la zone de recherche. Les expressions de type `TopBound() > YCoordinate` renvoient `FuzzyRect`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `HorSearchAreaBound RightBound()`                                        | Sert à définir une contrainte sur la limite droite de la zone de recherche. Les expressions de type `RightBound() > XCoordinate` renvoient `FuzzyRect`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `VertSearchAreaBound BottomBound()`                                      | Sert à définir une contrainte sur la limite inférieure de la zone de recherche. Les expressions de type `BottomBound() > YCoordinate` renvoient `FuzzyRect`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `FuzzyRect AreaLeftOf( XInterval x, Distance offset = 0 )`               | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan vertical situé à gauche du point `x.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `FuzzyRect AreaLeftOf( FuzzyRect rect, Distance offset = 0 )`            | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan vertical situé à gauche du point `rect.Left.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `FuzzyRect AreaLeftOf( Hypothesis hyp, Distance offset = 0 )`            | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan vertical situé à gauche du point `hyp.Rect.Left.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `FuzzyRect AreaLeftOf( HypothesisInstances hyps, Distance offset = 0 )`  | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan vertical situé à gauche du point `hyps.Rect.Left.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `FuzzyRect AreaRightOf( XInterval x, Distance offset = 0 )`              | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan vertical situé à droite du point `x.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `FuzzyRect AreaRightOf( FuzzyRect rect, Distance offset = 0 )`           | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan vertical situé à droite du point `rect.Right.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `FuzzyRect AreaRightOf( Hypothesis hyp, Distance offset = 0 )`           | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan vertical situé à droite du point `hyp.rect.Right.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `FuzzyRect AreaRightOf( HypothesisInstances hyps, Distance offset = 0 )` | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan vertical situé à droite du point `hyps.Rect.Right.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `FuzzyRect AreaAbove( YInterval y, Distance offset = 0 )`                | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan horizontal situé au-dessus du point `y.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `FuzzyRect AreaAbove( FuzzyRect rect, Distance offset = 0 )`             | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan horizontal situé au-dessus du point `rect.top.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `FuzzyRect AreaAbove( Hypothesis hyp, Distance offset = 0 )`             | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan horizontal situé au-dessus du point `hyp.rect.top.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `FuzzyRect AreaAbove( HypothesisInstances hyps, Distance offset = 0 )`   | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan horizontal situé au-dessus du point `hyps.Rect.top.End - offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `FuzzyRect AreaBelow( YInterval y, Distance offset = 0 )`                | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan horizontal situé en dessous du point `y.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `FuzzyRect AreaBelow( FuzzyRect rect, Distance offset = 0 )`             | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan horizontal situé en dessous du point `rect.Bottom.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `FuzzyRect AreaBelow( Hypothesis hyp, Distance offset = 0 )`             | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan horizontal situé en dessous du point `hyp.rect.Bottom.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `FuzzyRect AreaBelow( HypothesisInstances hyps, Distance offset = 0 )`   | Renvoie un rectangle flou en coordonnées globales, sous la forme d’un demi-plan horizontal situé en dessous du point `hyps.Rect.Bottom.Start + offset`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `FuzzyRect ImageLeftOf( XInterval x, Distance offset = 0 )`              | Renvoie un rectangle flou, qui correspond à l’intersection entre le rectangle de la page et le demi-plan vertical situé à gauche du point `x.End - offset`.<br />**Important !** La fonction ne peut être utilisée que si le nombre minimal et le nombre maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaLeftOf( XInterval x, Distance offset = 0 )`.                    |
| `FuzzyRect ImageLeftOf( FuzzyRect rect, Distance offset = 0 )`           | Renvoie un rectangle flou, qui correspond à l’intersection entre le rectangle de la page et le demi-plan vertical situé à gauche du point `rect.Left.End - offset`.<br />**Important !** La fonction ne peut être utilisée que si le nombre minimal et le nombre maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaLeftOf( FuzzyRect rect, Distance offset = 0 )`.         |
| `FuzzyRect ImageLeftOf( Hypothesis hyp, Distance offset = 0 )`           | Renvoie un rectangle flou, qui correspond à l’intersection entre le rectangle de la page et le demi-plan vertical situé à gauche du point `hyp.Rect.Left.End - offset`.<br />**Important !** La fonction ne peut être utilisée que si le nombre minimal et le nombre maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaLeftOf( Hypothesis hyp, Distance offset = 0 )`.     |
| `FuzzyRect ImageRightOf( XInterval x, Distance offset = 0 )`             | Renvoie un rectangle flou, qui correspond à l’intersection entre le rectangle de la page et le demi-plan vertical situé à droite du point `x.Start + offset`.<br />**Important !** La fonction ne peut être utilisée que si le nombre minimal et le nombre maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaRightOf( XInterval x, Distance offset = 0 )`.                 |
| `FuzzyRect ImageRightOf( FuzzyRect rect, Distance offset = 0 )`          | Renvoie un rectangle flou, qui correspond à l’intersection entre le rectangle de la page et le demi-plan vertical situé à droite du point `rect.Right.Start + offset`.<br />**Important !** La fonction ne peut être utilisée que si le nombre minimal et le nombre maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaRightOf( FuzzyRect rect, Distance offset = 0 )`.     |
| `FuzzyRect ImageRightOf( Hypothesis hyp, Distance offset = 0 )`          | Renvoie un rectangle flou, qui correspond à l’intersection entre le rectangle de la page et le demi-plan vertical situé à droite du point `hyp.rect.Right.Start + offset`.<br />**Important !** La fonction ne peut être utilisée que si le nombre minimal et le nombre maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaRightOf( Hypothesis hyp, Distance offset = 0 )`. |
| `FuzzyRect ImageAbove( YInterval y, Distance offset = 0 )`               | Renvoie un rectangle flou, qui correspond à l’intersection entre le rectangle de la page et le demi-plan horizontal situé au-dessus du point `y.End - offset`.<br />**Important !** La fonction ne peut être utilisée que si le nombre minimal et le nombre maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaAbove( YInterval y, Distance offset = 0 )`.                  |
| `FuzzyRect ImageAbove( FuzzyRect rect, Distance offset = 0 )`            | Renvoie un rectangle flou, qui correspond à l’intersection entre le rectangle de la page et le demi-plan horizontal situé au-dessus du point `rect.top.End - offset`.<br />**Important !** La fonction ne peut être utilisée que si le nombre minimal et le nombre maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaAbove( FuzzyRect rect, Distance offset = 0 )`.        |
| `FuzzyRect ImageAbove( Hypothesis hyp, Distance offset = 0 )`            | Renvoie un rectangle flou, qui correspond à l’intersection entre le rectangle de la page et le demi-plan horizontal situé au-dessus du point `hyp.rect.top.End - offset`.<br />**Important !** La fonction ne peut être utilisée que si le nombre minimal et le nombre maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaAbove( Hypothesis hyp, Distance offset = 0 )`.    |
| `FuzzyRect ImageBelow( YInterval y, Distance offset = 0 )`               | Renvoie un rectangle flou, qui correspond à l’intersection entre le rectangle de la page et le demi-plan horizontal situé en dessous du point `y.Start + offset`.<br />**Important !** La fonction ne peut être utilisée que si le nombre minimal et le nombre maximal de pages du document sont définis sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaBelow( YInterval y, Distance offset = 0 )`.               |
| `FuzzyRect ImageBelow( FuzzyRect rect, Distance offset = 0 )`            | Retourne un rectangle flou correspondant à l’intersection entre le rectangle de la page et le demi-plan horizontal situé sous le point `rect.Bottom.Start + offset`.<br />**Important !** Cette fonction ne peut être utilisée que si le nombre minimal et maximal de pages du document est défini sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaBelow( FuzzyRect rect, Distance offset = 0 )`.                  |
| `FuzzyRect ImageBelow( Hypothesis hyp, Distance offset = 0 )`            | Retourne un rectangle flou correspondant à l’intersection entre le rectangle de la page et le demi-plan horizontal situé sous le point `hyp.rect.Bottom.Start + offset`.<br />**Important !** Cette fonction ne peut être utilisée que si le nombre minimal et maximal de pages du document est défini sur 1, c’est-à-dire si le document détecté ne comporte qu’une seule page. Si vous utilisez cette fonction pour un document multipage, la mise en correspondance d’un FlexiLayout renverra une erreur.<br />Pour un document multipage, utilisez la fonction `FuzzyRect AreaBelow( Hypothesis hyp, Distance offset = 0 )`.              |
