Bienvenue sur PostGIS.fr

Bienvenue sur PostGIS.fr , le site de la communauté des utilisateurs francophones de PostGIS.

PostGIS ajoute le support d'objets géographique à la base de données PostgreSQL. En effet, PostGIS "spatialise" le serverur PostgreSQL, ce qui permet de l'utiliser comme une base de données SIG.

Maintenu à jour, en fonction de nos disponibilités et des diverses sorties des outils que nous testons, nous vous proposons l'ensemble de nos travaux publiés en langue française.


Ignore:
Timestamp:
26/09/2011 11:22:36 (13 years ago)
Author:
djay
Message:

Traduction partie 20

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/workshop-foss4g/validity.rst

    r1 r29  
    11.. _validity: 
    22 
    3 Section 20: Validity 
     3Partie 20 : Validité 
    44==================== 
    55 
    6 In 90% of the cases the answer to the question, "why is my query giving me a 'TopologyException' error" is "one or more of the inputs are invalid".  Which begs the question: what does it mean to be invalid, and why should we care? 
     6Dans 90% des cas la réponse à question "pourquoi mes requêtes me renvoit un message d'erreur du type 'TopologyException' error"" est : "un ou plusieurs des arguments passés sont invalides". Ce qui nous conduit à nous demander : que signifie invalide et pourquoi est-ce important ? 
    77 
    8 What is Validity 
    9 ---------------- 
     8Qu'est-ce que la validité 
     9------------------------- 
    1010 
    11 Validity is most important for polygons, which define bounded areas and require a good deal of structure. Lines are very simple and cannot be invalid, nor can points. 
     11La validité est surtout importante pour les polygones, qui définissent des aires et requiÚrent une bonne structuration. Les lignes sont vraiment simples et ne peuvent pas être invalides ainsi que les points. 
    1212 
    13 Some of the rules of polygon validity feel obvious, and others feel arbitrary (and in fact, are arbitrary). 
     13Certaines des rÚgles de validation des polygones semble évidentes, et d'autre semblent arbitraires (et le sont vraiment). 
    1414 
    15  * Polygon rings must close. 
    16  * Rings that define holes should be inside rings that define exterior boundaries. 
    17  * Rings may not self-intersect (they may neither touch nor cross one another). 
    18  * Rings may not touch other rings, except at a point. 
     15 * Les contours des Polygon doivent être fermés. 
     16 * Les contours qui définissent des trous doivent être inclus dans la zone définit par le coutour extérieur. 
     17 * Les contours ne doivent pas s'intersecter (ils ne doivent ni se croiser ni se toucher). 
     18 * Les contours ne doivent pas toucher les autres contours, sauf en un point unique. 
    1919 
    20 The last two rules are in the arbitrary category. There are other ways to define polygons that are equally self-consistent but the rules above are the ones used by the :term:`OGC` :term:`SFSQL` standard that PostGIS conforms to. 
     20Les deux derniÚres rÚgles font partie de la catégorie arbitraires. Il y a d'autre moyen de définir des poygones qui sont consistent mais les rÚgles ci-dessus sont celles utilisées dans le standard :term:`OGC` :term:`SFSQL` que respecte PostGIS. 
    2121 
    22 The reason the rules are important is because algorithms for geometry calculations depend on consistent structure in the inputs. It is possible to build algorithms that have no structural assumptions, but those routines tend to be very slow, because the first step in any structure-free routine is to *analyze the inputs and build structure into them*. 
     22La raison pour laquelle ces rÚgles sont importants est que les algorythmes de calcul dépendent de cette structuration consistante des arguments. Il est possible de construire des algorythmes qui n'utilise pas cette structuration, mais ces fonctions tendents à être trÚs lentes, étant donné que la premiÚre étape consistera à "analyser et construire  des strcuture à l'intérieur des données". 
    2323 
    24 Here's an example of why structure matters. This polygon is invalid: 
     24Voici un exemple de pourquoi cette structuration est importante. Ce polygon n'est pas valide : 
    2525 
    2626:: 
     
    2828  POLYGON((0 0, 0 1, 2 1, 2 2, 1 2, 1 0, 0 0)); 
    2929   
    30 You can see the invalidity a little more clearly in this diagram: 
     30Vous pouvez comprendre ce qui n'est pas valide en regardant cette figure : 
    3131 
    3232.. image:: ./validity/figure_eight.png 
    3333 
    34 The outer ring is actually a figure-eight, with a self-intersection in the middle. Note that the graphic routines successfully render the polygon fill, so that visually it is appears to be an "area": two one-unit squares, so a total area of two units of area. 
     34Le contour externe est exactement en forme en 8 avec une intersection au milieux. Notez que la fonction de rendu graphique est tout de même capable d'en afficher l'intérieur, don visuellement cela ressemble bien à une "aire" : deux unités quarré, donc une aire couplant ces deux unités. 
    3535 
    36 Let's see what the database thinks the area of our polygon is: 
     36Essayons maintenant de voir ce que pense la base de données de notre polygone : 
    3737 
    3838.. code-block:: sql 
     
    4646          0 
    4747 
    48 What's going on here? The algorithm that calculates area assumes that rings to not self-intersect. A well-behaved ring will always have the area that is bounded (the interior) on one side of the bounding line (it doesn't matter which side, just that it is on *one* side). However, in our (poorly behaved) figure-eight, the bounded area is to the right of the line for one lobe and to the left for the other. This causes the areas calculated for each lobe to cancel out (one comes out as 1, the other as -1) hence the "zero area" result. 
     48Que ce passe-t-il ici ? L'algorythme qui calcule l'aire suppose que les contours ne s'intersectent pas. Un contours normal devra toujours avoir une aire qui est bornée (l'intérieur) sur une partie de la ligne du contour (peu importe quelle partie, juste *une* parte). Néanmoins, dans notre figure en 8, le contour externe est à droite de la ligne pour un lobe et à gauche pour l'autre. Cela entraine que les aire qui sont calculées pour chaque lobe annule la précédente (l'une vaut 1 et l'autre -1) donc le résultat est une "aire de zéro". 
    4949 
    5050 
    51 Detecting Validity 
    52 ------------------ 
     51Détecté la validité 
     52------------------- 
    5353 
    54 In the previous example we had one polygon that we **knew** was invalid. How do we detect invalidity in a table with millions of geometries? With the :command:`ST_IsValid(geometry)` function. Used against our figure-eight, we get a quick answer: 
     54Dans l'exemple précédent nous avions un polygone que nous **savions** non-valide. Comment déterminer les géométries non valides dans une tables d'un million d'enregistrements ? Avec la fonction :command:`ST_IsValid(geometry)`. Utilisé avec notre polygone précédent, nous abtenons rapidement la réponse : 
    5555 
    5656.. code-block:: sql 
     
    6262  f 
    6363 
    64 Now we know that the feature is invalid, but we don't know why. We can use the :command:`ST_IsValidReason(geometry)` function to find out the source of the invalidity: 
     64Maintenant nous savons que l'entité est non-valide mais nous ne savons pas pourquoi. Nous pouvons utilier la fonction :command:`ST_IsValidReason(geometry)` pour trtouver la cause de non validité : 
    6565 
    6666.. code-block:: sql 
     
    7272  Self-intersection[1 1] 
    7373 
    74 Note that in addition to the reason (self-intersection) the location of the invalidity (coordinate (1 1)) is also returned. 
     74Vous remarquerez qu'en plus de la raison (intersection) la localisation de la non validité (coordonnée (1 1)) est aussi renvoyée. 
    7575 
    76 We can use the :command:`ST_IsValid(geometry)` function to test our tables too: 
     76Nous pouvons aussi utiiliser la fonction :command:`ST_IsValid(geometry)` pour tester nos tables :  
    7777 
    7878.. code-block:: sql 
    7979 
    80   -- Find all the invalid polygons and what their problem is 
     80  -- Trouver tout les polygones non valides et leur problÚme  
    8181  SELECT name, boroname, ST_IsValidReason(the_geom) 
    8282  FROM nyc_neighborhoods 
     
    9494 
    9595 
    96 Repairing Invalidity 
    97 -------------------- 
     96Réparer les invalides 
     97--------------------- 
    9898 
    99 First the bad news: there is no guaranteed way to fix invalid geometries. The worst case scenario is identifying them with the :command:`ST_IsValid(geometry)` function, moving them to a side table, exporting that table, and repairing them externally. 
     99Commençons par la mauvaise nouvelle : il n'y a aucune garantie de pouvoir corriger une géométrie non valide. Dans le pire des scénarios, vous pouvez utiliser la fonction  :command:`ST_IsValid(geometry)` pour identifier les entités non valides, les déplacer dans une autre table, exporter cette table et les réparer à l'aide d'un outils extérieur. 
    100100 
    101 Here's an example of SQL to move invalid geometries out of the main table into a side table suitable for dumping to an external cleaning process. 
     101Voici un exemple de requête SQL qui déplacent les géométries non valides hors de la table principale dans une table à part pour les exporter vers un programme de réparation. 
    102102 
    103103.. code-block:: sql 
    104104 
    105   -- Side table of invalids 
     105  -- Table à part des géométries non-valide 
    106106  CREATE TABLE nyc_neighborhoods_invalid AS 
    107107  SELECT * FROM nyc_neighborhoods 
    108108  WHERE NOT ST_IsValid(the_geom); 
    109109   
    110   -- Remove them from the main table 
     110  -- Suppression de la table principale 
    111111  DELETE FROM nyc_neighborhoods 
    112112  WHERE NOT ST_IsValid(the_geom); 
    113113   
    114 A good tool for visually repairing invalid geometry is OpenJump (http://openjump.org) which includes a validation routine under **Tools->QA->Validate Selected Layers**. 
     114Un bon outils pour réparer visuellemen des géométries non valide est OpenJump (http://openjump.org) qui contient un outils de validation depuis le menu **Tools->QA->Validate Selected Layers**. 
    115115 
    116 Now the good news: a large proportion of invalidities **can be fixed inside the database** using the :command:`ST_Buffer` function. 
     116Maintenant, la bonne nouvelle : un grand nombre de non-validités **peuvent être résolues dans la base de données** en utilisant la fonction : :command:`ST_Buffer`. 
    117117 
    118 The buffer trick takes advantage of the way buffers are built: a buffered geometry is a brand new geometry, constructed by offsetting lines from the original geometry. If you offset the original lines by **nothing** (zero) then the new geometry will be structurally identical to the original one, but because it is built using the :term:`OGC` topology rules, it will be valid. 
     118Le coup du Buffer tire avantafe de la maniÚre dont les buffers sont construit : une géométrie bufferisée est une nouvelle géométrie, construite en déplaçant les lignes de la géométrie d'origine. Si vous déplacez les lignes originales par *rien* (zero) alors la nouvelle géométrie aura une structure identique à l'originale, mais puisqu'elle utilise les rÚgles topologiques de l':term:`OGC, elle sera valide. 
    119119 
    120 For example, here's a classic invalidity -- the "banana polygon" -- a single ring that encloses an area but bends around to touch itself, leaving a "hole" which is not actually a hole. 
     120Par exemple, voici un cas classique de non-validité - le "polygone de la banane" - un seul contour que crée une zone mais se touche, laissant un "trou" qui n'en est pas un. 
    121121 
    122122::  
     
    126126.. image:: ./validity/banana.png 
    127127 
    128 Running the zero-offset buffer on the polygon returns a valid :term:`OGC` polygon, consisting of an outer and inner ring that touch at one point. 
     128En créant un buffer de zero sur le polygone retourne un polygone :term:`OGC` valide, le contour externe et un contour interne qui touche l'autre en un seul point. 
    129129 
    130130.. code-block:: sql 
     
    143143.. note:: 
    144144 
    145   The "banana polygon" (or "inverted shell") is a case where the :term:`OGC` topology model for valid geometry and the model used internally by ESRI differ. The ESRI model considers rings that touch to be invalid, and prefers the banana form for this kind of shape. The OGC model is the reverse.  
     145  Le "polygone banane" (ou "coquillage inversé") est un cas où le modÚle topologique de l':term:`OGC` et de ESRI diffÚrent. Le model ESRI considÚre que les contours que se touchent sont non valides et préfÚre la forme de banane pour ce cas de figure. Le modÚle de l'OGC est l'inverse. 
    146146   
Note: See TracChangeset for help on using the changeset viewer.