Changes in trunk/workshop-foss4g/validity.rst [1:29]

File:

• trunk/workshop-foss4g/validity.rst (modified) (8 diffs)

trunk/workshop-foss4g/validity.rst

@@ -1 +1 @@
 .. _validity:
 
-Section 20: Validity
+Partie 20 : Validité
 ====================
 
-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?
+Dans 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 ?
 
-What is Validity
-----------------
+Qu'est-ce que la validité
+-------------------------
 
-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.
+La 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.
 
-Some of the rules of polygon validity feel obvious, and others feel arbitrary (and in fact, are arbitrary).
+Certaines des rÚgles de validation des polygones semble évidentes, et d'autre semblent arbitraires (et le sont vraiment).
 
- * Polygon rings must close.
- * Rings that define holes should be inside rings that define exterior boundaries.
- * Rings may not self-intersect (they may neither touch nor cross one another).
- * Rings may not touch other rings, except at a point.
+ * Les contours des Polygon doivent être fermés.
+ * Les contours qui définissent des trous doivent être inclus dans la zone définit par le coutour extérieur.
+ * Les contours ne doivent pas s'intersecter (ils ne doivent ni se croiser ni se toucher).
+ * Les contours ne doivent pas toucher les autres contours, sauf en un point unique.
 
-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.
+Les 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.
 
-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*.
+La 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".
 
-Here's an example of why structure matters. This polygon is invalid:
+Voici un exemple de pourquoi cette structuration est importante. Ce polygon n'est pas valide :
 
 ::
@@ -28 +28 @@
   POLYGON((0 0, 0 1, 2 1, 2 2, 1 2, 1 0, 0 0));
   
-You can see the invalidity a little more clearly in this diagram:
+Vous pouvez comprendre ce qui n'est pas valide en regardant cette figure :
 
 .. image:: ./validity/figure_eight.png
 
-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.
+Le 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.
 
-Let's see what the database thinks the area of our polygon is:
+Essayons maintenant de voir ce que pense la base de données de notre polygone :
 
 .. code-block:: sql
@@ -46 +46 @@
           0
 
-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.
+Que 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".
 
 
-Detecting Validity
-------------------
+Détecté la validité
+-------------------
 
-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:
+Dans 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 :
 
 .. code-block:: sql
@@ -62 +62 @@
   f
 
-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:
+Maintenant 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é :
 
 .. code-block:: sql
@@ -72 +72 @@
   Self-intersection[1 1]
 
-Note that in addition to the reason (self-intersection) the location of the invalidity (coordinate (1 1)) is also returned.
+Vous remarquerez qu'en plus de la raison (intersection) la localisation de la non validité (coordonnée (1 1)) est aussi renvoyée.
 
-We can use the :command:`ST_IsValid(geometry)` function to test our tables too:
+Nous pouvons aussi utiiliser la fonction :command:`ST_IsValid(geometry)` pour tester nos tables : 
 
 .. code-block:: sql
 
-  -- Find all the invalid polygons and what their problem is
+  -- Trouver tout les polygones non valides et leur problÚme 
   SELECT name, boroname, ST_IsValidReason(the_geom)
   FROM nyc_neighborhoods
@@ -94 +94 @@
 
 
-Repairing Invalidity
---------------------
+Réparer les invalides
+---------------------
 
-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.
+Commenç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.
 
-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.
+Voici 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.
 
 .. code-block:: sql
 
-  -- Side table of invalids
+  -- Table à part des géométries non-valide
   CREATE TABLE nyc_neighborhoods_invalid AS
   SELECT * FROM nyc_neighborhoods
   WHERE NOT ST_IsValid(the_geom);
   
-  -- Remove them from the main table
+  -- Suppression de la table principale
   DELETE FROM nyc_neighborhoods
   WHERE NOT ST_IsValid(the_geom);
   
-A good tool for visually repairing invalid geometry is OpenJump (http://openjump.org) which includes a validation routine under **Tools->QA->Validate Selected Layers**.
+Un 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**.
 
-Now the good news: a large proportion of invalidities **can be fixed inside the database** using the :command:`ST_Buffer` function.
+Maintenant, 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`.
 
-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.
+Le 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.
 
-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.
+Par 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.
 
 :: 
@@ -126 +126 @@
 .. image:: ./validity/banana.png
 
-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.
+En 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.
 
 .. code-block:: sql
@@ -143 +143 @@
 .. note::
 
-  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. 
+  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.