Index: trunk/workshop-foss4g/validity.rst
===================================================================
--- trunk/workshop-foss4g/validity.rst	(revision 1)
+++ trunk/workshop-foss4g/validity.rst	(revision 29)
@@ -1,26 +1,26 @@
 .. _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,11 +28,11 @@
   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,11 +46,11 @@
           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,5 +62,5 @@
   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,11 +72,11 @@
   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,29 +94,29 @@
 
 
-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,5 +126,5 @@
 .. 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,4 +143,4 @@
 .. 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.
   
