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

# Hypothèses pour tous les types d’éléments

> Propriétés d’hypothèse communes à tous les éléments FlexiLayout : IsNull, Region, FuzzyRect, limites et méthodes de page, avec un exemple détaillé d’hypothèse nulle.

Une hypothèse pour un élément peut être trouvée ou non. Une hypothèse trouvée est généralement formulée à partir d’un ou plusieurs objets d’image ou de leurs fragments (à l’exception de l’élément **White Gap**, qui peut ne contenir aucun objet d’image).

<div id="hypothesis-regions-and-boundaries">
  ## Regions et limites des hypothèses
</div>

Une hypothèse trouvée pour un élément simple est toujours une Region continue. Les hypothèses des éléments **White Gap**, **Separator** et **Barcode** sont toujours des rectangles uniques.

Si une hypothèse est formulée à partir d’un jeu d’objets d’image détectés, par exemple une hypothèse pour un élément **Paragraph**, la Region de l’hypothèse est construite à partir du tableau de rectangles des objets détectés. La Region créée de cette manière peut être obtenue à l’aide de la méthode `Region` de l’hypothèse.

Lors de l’affichage de la Region de l’hypothèse sur l’image, ou lors de la création d’un bloc à partir de l’hypothèse, les limites de la Region ne suivent pas exactement celles de chaque rectangle. À la place, les limites de la zone de recherche sont lissées pour améliorer la visualisation. Une Region créée de cette manière peut être obtenue à l’aide de la méthode `SimplifiedRegion` de l’hypothèse.

Les méthodes `Region` et `SimplifiedRegion` peuvent être utilisées soit dans le champ **Advanced pre-search relations** de l’onglet **Advanced** (lors de la définition de la zone de recherche de l’élément), soit dans le champ **Region expression** lors de la définition des propriétés du bloc et de l’utilisation des éléments déjà trouvés.

Si une hypothèse n’a pas été trouvée, elle coïncide avec le rectangle flou de sa zone de recherche. Lors de l’affichage d’une hypothèse non trouvée sur l’image, FlexiLayout Studio dessine le rectangle externe du rectangle flou.

Les limites `Left`, `top`, `Right` et `Bottom` de toute hypothèse sont des plages. Pour chaque hypothèse trouvée, la plage se réduit à un point, c’est-à-dire `Left.Start = Left.End`, `top.Start = top.End`, etc. Pour une hypothèse non trouvée, les plages des limites coïncident avec celles de sa zone de recherche.

<div id="hypothesis-access-in-flexilayout-code">
  ## Accès aux hypothèses dans le code FlexiLayout
</div>

L’accès aux hypothèses générées et à leurs propriétés dans le code des boîtes de dialogue correspondantes des blocs et des éléments fournit des outils supplémentaires pour configurer FlexiLayout. Les hypothèses d’élément sont accessibles par le nom des éléments. Pour accéder à une hypothèse de l’élément actuel dans le champ [Advanced post-search relations](/fr/flexi-capture/fls/template/advanced-post-search), vous pouvez utiliser uniquement le nom de la propriété.

Les hypothèses et leurs propriétés sont accessibles en mode lecture seule. Les hypothèses des éléments sont accessibles dans les champs [Advanced pre-search relations](/fr/flexi-capture/fls/template/advanced-pre-search) et **Advanced post-search relations** de l’onglet **Advanced** de la boîte de dialogue **Properties** de l’élément, ainsi que dans le champ [Region expression](/fr/flexi-capture/fls/template/search-constraints) de la boîte de dialogue **Properties** du bloc.

Dans **Advanced pre-search relations**, vous pouvez accéder aux hypothèses générées (et à leurs propriétés) pour tous les éléments situés au-dessus de l’élément actuel dans l’arborescence FlexiLayout. Dans **Advanced post-search relations**, vous pouvez accéder aux hypothèses générées pour les éléments situés au-dessus de l’élément actuel dans l’arborescence FlexiLayout, ainsi qu’à l’hypothèse de l’élément actuel lui-même.

Dans **Region expression**, vous pouvez accéder aux hypothèses (et à leurs propriétés) pour tous les éléments.

<div id="properties-of-hypotheses-for-all-element-types">
  ## Propriétés des hypothèses pour tous les types d’éléments
</div>

Le tableau suivant répertorie les propriétés des hypothèses pour tous les types d’éléments.

| Propriété                                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Logic IsNull()`                            | Indique s’il s’agit d’une hypothèse nulle (si l’élément n’a pas été détecté, la propriété `IsNull` de l’hypothèse vaut `True`).                                                                                                                                                                                                                                                                                                   |
| `Logic IsFound()`                           | Indique si l’hypothèse n’est pas nulle (si l’élément n’a pas été détecté, la propriété `IsFound` de l’hypothèse vaut `False`). Équivalent à `not IsNull`.                                                                                                                                                                                                                                                                         |
| `XInterval Left()`                          | La limite gauche de l’hypothèse, plage horizontale en coordonnées globales.                                                                                                                                                                                                                                                                                                                                                       |
| `YInterval top()`                           | La limite supérieure de l’hypothèse, plage verticale en coordonnées globales.                                                                                                                                                                                                                                                                                                                                                     |
| `XInterval Right()`                         | La limite droite de l’hypothèse, plage horizontale en coordonnées globales.                                                                                                                                                                                                                                                                                                                                                       |
| `YInterval Bottom()`                        | La limite inférieure de l’hypothèse, plage verticale en coordonnées globales.                                                                                                                                                                                                                                                                                                                                                     |
| `XInterval XCenter()`                       | La coordonnée X du centre de l’hypothèse, plage horizontale en coordonnées globales.                                                                                                                                                                                                                                                                                                                                              |
| `YInterval YCenter()`                       | La coordonnée Y du centre de l’hypothèse, plage verticale en coordonnées globales.                                                                                                                                                                                                                                                                                                                                                |
| `DistInterval Width()`                      | La largeur de l’hypothèse en coordonnées globales, plage de distances.                                                                                                                                                                                                                                                                                                                                                            |
| `DistInterval Height()`                     | La hauteur de l’hypothèse en coordonnées globales, plage de distances.                                                                                                                                                                                                                                                                                                                                                            |
| `FuzzyRect FuzzyRect()`                     | Rectangle flou de l’hypothèse en coordonnées globales.                                                                                                                                                                                                                                                                                                                                                                            |
| `Rect Rect()`                               | Le rectangle circonscrit à l’hypothèse en coordonnées globales. Il coïncide avec le rectangle externe du rectangle flou.                                                                                                                                                                                                                                                                                                          |
| `Region Region()`                           | La Region de l’hypothèse en coordonnées globales. La méthode n’est pas prise en charge pour les éléments **Group**.                                                                                                                                                                                                                                                                                                               |
| `Region SimplifiedRegion()`                 | La Region de l’hypothèse en coordonnées globales, simplifiée pour une meilleure représentation visuelle. La méthode n’est pas prise en charge pour les éléments **Group**.                                                                                                                                                                                                                                                        |
| `ImageObjectSet Set()`                      | Les objets d’image qui font partie de l’hypothèse.                                                                                                                                                                                                                                                                                                                                                                                |
| `ImageObjectSet ExcludeSet()`               | Les objets d’image qui se trouvent dans la Region exclue de la zone de recherche par des méthodes de type `Exclude`.                                                                                                                                                                                                                                                                                                              |
| `RectArray Rects()`                         | Le tableau des rectangles inclus dans l’hypothèse. Pour la plupart des éléments, il coïncide avec le tableau des rectangles englobant les objets détectés. Pour les éléments **White Gap** et **Region**, aucun objet n’est disponible.                                                                                                                                                                                           |
| `Int HypothesesCount()`                     | Le nombre d’hypothèses pouvant être formulées pour l’élément dans la zone de recherche.<br /><br />**Important !** La fonction ne peut être utilisée que si les nombres maximal et minimal 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 renvoie une erreur. |
| `PageInterval Pages()`                      | La plage de pages dans laquelle l’hypothèse doit être trouvée.                                                                                                                                                                                                                                                                                                                                                                    |
| `PageArea PageAreaGlobal( Int PageNumber )` | Retourne la partie de l’hypothèse située sur la page donnée en coordonnées globales.                                                                                                                                                                                                                                                                                                                                              |
| `PageArea PageAreaLocal( Int PageNumber )`  | Retourne la partie de l’hypothèse située sur la page donnée dans les coordonnées locales de la page.                                                                                                                                                                                                                                                                                                                              |

<div id="example-check-for-a-null-hypothesis-before-accessing-properties">
  ## Exemple : vérifier l’absence d’hypothèse nulle avant d’accéder aux propriétés
</div>

Avant d’accéder aux propriétés d’une hypothèse pour un élément simple ou **Group**, assurez-vous que l’hypothèse concernée n’est pas une hypothèse nulle (appelez sa propriété `IsNull`). L’accès à une propriété d’une hypothèse nulle (qui correspond à un élément non détecté) provoque une erreur.

Prenons un exemple qui utilise le projet de l’Exemple 1, disponible sur le CD-ROM du programme.

Supposons qu’un identifiant figure sur votre document sous la forme d’un Barcode et que vous souhaitiez que votre FlexiLayout associe uniquement les documents dont la valeur du Barcode est `1556897142240`.

Dans la section **Advanced post-search relations** de l’élément qui décrit les propriétés et les contraintes de recherche du Barcode (l’élément `IdentityNumber` dans l’Exemple 1), écrivez le code suivant :

```text theme={null}
if value != "1556897142240" then Quality: 0;
```

Cliquez sur **Apply** ou **Check**. Le compilateur ne détecte aucune erreur de syntaxe. Le code semble donc correct. Toutefois, si vous essayez d’appliquer le FlexiLayout à une page quelconque de Sample 1, le message d’erreur suivant s’affiche : `Error in element “MainGroup.IdentityNumber”, Advanced relations section: Attempt to access undefined hypothesis MainGroup.IdentityNumber`.

La cause de cette erreur est la suivante. FlexiLayout Studio trouve une hypothèse pour l’élément Barcode. Il compare ensuite la valeur du Barcode à la valeur spécifiée dans le code. Si les valeurs sont différentes, le code `Quality: 0;` ramène la valeur de l’hypothèse à 0.

Une hypothèse nulle est alors générée pour cet élément, et FlexiLayout Studio vérifie également pour celle-ci la condition `value != "1556897142240"`. Or, comme il n’est pas permis d’accéder à la valeur d’une hypothèse nulle (puisqu’elle ne possède pas cette propriété), FlexiLayout Studio affiche le message d’erreur « ...undefined hypothesis... ».

Ajustez donc le code comme suit :

```text theme={null}
if not IsNull then {
if value != "1556897142240" then Quality: 0;
}
```

Le code ci-dessus fonctionne uniquement pour un élément obligatoire.

Pour un élément facultatif, adaptez le code comme suit :

```text theme={null}
if not IsNull then {
if value != "1556897142240" then Quality: 0;
}
else {Quality: 0;}
```

Sinon, seule la qualité de l’hypothèse réelle est réinitialisée à 0. Cela entraîne FlexiLayout Studio à générer une hypothèse nulle, pour laquelle la condition `if not IsNull` n’est pas exécutée.

Par conséquent, la qualité de l’hypothèse finale (nulle) reste identique à celle spécifiée dans les propriétés de l’élément (0.97 si la valeur par défaut a été conservée), et FlexiLayout Studio continue la mise en correspondance du FlexiLayout, même sans l’élément concerné.

Si vous ajoutez `else {Quality: 0;}` au code, l’instruction est exécutée pour toutes les hypothèses (y compris l’hypothèse nulle) et la mise en correspondance du FlexiLayout s’arrête, car toute la chaîne d’hypothèses est également réinitialisée à 0 au niveau de cet élément.

<div id="region-and-simplifiedregion-methods-compared">
  ## Comparaison des méthodes Region() et SimplifiedRegion()
</div>

Les méthodes `Region Region()` et `Region SimplifiedRegion()` renvoient toutes deux la Region d’un élément, mais la méthode `Region Region()` renvoie la Region exacte :

<Frame>
  <img src="https://mintcdn.com/abbyy/lqYknuOmCa79141v/images/flexi-capture/fls/Region.gif?s=e46c1e1919cef7f966fcb472c25b1a2b" alt="Capture d’écran de la Region exacte de l’hypothèse renvoyée par la méthode Region() dans ABBYY FlexiLayout Studio, qui suit les limites des objets détectés." width="190" height="159" data-path="images/flexi-capture/fls/Region.gif" />
</Frame>

La méthode `Region SimplifiedRegion()` renvoie le rectangle créé à partir des coordonnées des limites :

<Frame>
  <img src="https://mintcdn.com/abbyy/lqYknuOmCa79141v/images/flexi-capture/fls/Simplified_Region.gif?s=5f6838ff02b0d119264bc09c42536cb7" alt="Capture d’écran de la Region rectangulaire simplifiée de l’hypothèse renvoyée par la méthode SimplifiedRegion() dans ABBYY FlexiLayout Studio, créée à partir des coordonnées des limites." width="181" height="154" data-path="images/flexi-capture/fls/Simplified_Region.gif" />
</Frame>
