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.

Changes in / [20:30]


Ignore:
Location:
/trunk/workshop-foss4g
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • /trunk/workshop-foss4g/projection.rst

    r20 r30  
    11.. _projection: 
    22 
    3 Section 15: Projecting Data 
    4 =========================== 
     3Partie 15 : Projections des données 
     4=================================== 
    55 
    6 The earth is not flat, and there is no simple way of putting it down on a flat paper map (or computer screen), so people have come up with all sorts of ingenious solutions, each with pros and cons. Some projections preserve area, so all objects have a relative size to each other; other projections preserve angles (conformal) like the Mercator projection; some projections try to find a good intermediate mix with only little distortion on several parameters. Common to all projections is that they transform the (spherical) world onto a flat cartesian coordinate system, and which projection to choose depends on how you will be using the data. 
     6La Terre n'est pas plâte et il n'y a pas de moyen simple de la poser à plat sur une carte en papier (ou l'écran d'un ordinateur), donc les gens en sont  arriver à fournir des solutions ingénieuses, chacunes avec des bons et des mauvais cotés. Certaines projections préservent les aires, donc tout les objets ont des tailles relatives aux autres, d'autre projections conservent les angles (conformes) comme la projection Mercator, certaines projections tentent de minimiser la distorsion des différents paramÚtres. Le point commun entre toutes les projections est qu'elles transforment le monde (sphérique) en un systÚme plat de coordonnées cartésiennes, et le choix de la projection dépend de ce que vous souhaitez faire avec vos données. 
    77 
    8 We've already encountered projections when we :ref:`loaded our nyc data <loading_data>`.  (Recall that pesky SRID 26918).  Sometimes, however, you need to transform and re-project between spatial reference systems. PostGIS includes built-in support for changing the projection of data, using the :command:`ST_Transform(geometry, srid)` function. For managing the spatial reference identifiers on geometries, PostGIS provides the :command:`ST_SRID(geometry)` and :command:`ST_SetSRID(geometry, srid)` functions. 
     8Nous avonsdéjà recontrer des projections, lorsque nous avons charger les données` de la ville de Ney York <loading_data>`.Rappelez-vous qu'elles utilisaient le SRID 26918. Parfois, malgrÚs tout, vous aurez besoin de transformer et de reprojeter vos données d'un systÚme de projection à l'autre, en utilisant la fonction  :command:`ST_Transform(geometry, srid)`. Pour manipuler les identifiant de systÚmes de références spatiales à partir d'une géométrie, PostGIS fournit les fonctions :command:`ST_SRID(geometry)` et :command:`ST_SetSRID(geometry, srid)`. 
    99 
    10 We can confirm the SRID of our data with the :command:`ST_SRID` command: 
     10Nous pouvons vérifier le SRID de nos données avec la commande :command:`ST_SRID` : 
    1111 
    1212.. code-block:: sql 
    … …  
    1818  26918 
    1919   
    20 And what is definition of "26918"? As we saw in ":ref:`loading data section <loading_data>`", the definition is contained in the ``spatial_ref_sys`` table. In fact, **two** definitions are there. The "well-known text" (:term:`WKT`) definition is in the ``srtext`` column, and there is a second definition in "proj.4" format in the ``proj4text`` column. 
    21  
     20Et quelle est la définition du "26918" ? Comme nous l'avons vu lors de la partie ":ref:`chargement des données  <loading_data>`", la définition se trouve dans la table ``spatial_ref_sys``. En fait, **deux** définitions sont présentes. La définition au fromat :term:`WKT` dans la colonne ``srtext`` et il y a aussu une seconde définition correspondant au  
    2221.. code-block:: sql 
    2322 
    2423   SELECT * FROM spatial_ref_sys WHERE srid = 26918; 
    2524    
    26 In fact, for the internal PostGIS re-projection calculations, it is the contents of the ``proj4text`` column that are used. For our 26918 projection, here is the proj.4 text: 
     25En fait, pour les calculs internes de re-projection, c'est le contenu de la colonne ``proj4text`` qui est utilisé. Pour notre projection 26918, voici la définition au format proj.4 : 
    2726 
    2827.. code-block:: sql 
    … …  
    3433  +proj=utm +zone=18 +ellps=GRS80 +datum=NAD83 +units=m +no_defs  
    3534   
    36 In practice, both the ``srtext`` and the ``proj4text`` columns are important: the ``srtext`` column is used by external programs like `GeoServer <http://geoserver.org>`_, `uDig <udig.refractions.net>`_, and `FME <http://www.safe.com/>`_  and others; the ``proj4text`` column is used internally. 
     35En pratique, à les deux colonnes ``srtext`` et ``proj4text`` sont importantes : la colonne ``srtext`` est utilisée par les applications externes comme `GeoServer <http://geoserver.org>`_, uDig <udig.refractions.net>`_, `FME <http://www.safe.com/>`_  et les autres alors que la colonne ``proj4text`` est principalement utilisée en interne. 
    3736 
    38 Comparing Data 
    39 -------------- 
     37Comparaison de données 
     38---------------------- 
    4039 
    41 Taken together, a coordinate and an SRID define a location on the globe. Without an SRID, a coordinate is just an abstract notion. A “Cartesian” coordinate plane is defined as a “flat” coordinate system placed on the surface of Earth. Because PostGIS functions work on such a plane, comparison operations require that both geometries be represented in the same SRID. 
     40Combiné, une coordonnée et un SRID définissent une position sur le globe. Sans le SRID, une coordonnée est juste une notion abstraite. Un systÚme de coordonnées "cartésiennes" est définit comme un systÚme de coordonnées "plat" sur la surface de la Terre. Puisque les fonctions de PostGIS utilisent cette surface plane, les opérations de comparaison nécessitent que l'ensemble des objets géométriques soient représenté dans le même systÚme, ayant le même SRID. 
    4241 
    43 If you feed in geometries with differing SRIDs you will just get an error: 
     42Si vous utilisé des géométries avec différents SRID vous obtiendrez une erreur du genre : 
    4443 
    4544.. code-block:: sql 
    … …  
    5857.. note:: 
    5958 
    60    Be careful of getting too happy with using :command:`ST_Transform` for on-the-fly conversion. Spatial indexes are built using SRID of the stored geometries.  If comparison are done in a different SRID, spatial indexes are (often) not used. It is best practice to choose **one SRID** for all the tables in your database. Only use the transformation function when you are reading or writing data to external applications. 
     59   Faites attention de pas utiliser la transformation à la volée à l'aide de :command:`ST_Transform` trpop souvent. Les indexes spatiaux sont construits en utilisant le SRID inclu dans les géométries. Si la comparaison est faite avec un SRID différent, les indexes spatiaux ne seront pas (la plupart du temps) utilisés. Il est reconnu qu'il vaut mieux choisir **un SRID** pour toutes les tables de votre base de données. N'utilisez la fonction de tranformation que lorsque vous lisez ou écrivez les données depuis une applications externe. 
    6160 
    6261 
    63 Transforming Data 
    64 ----------------- 
     62Transformer les données 
     63----------------------- 
    6564 
    66 If we return to our proj4 definition for SRID 26918, we can see that our working projection is UTM (Universal Transverse Mercator) of zone 18, with meters as the unit of measurement. 
     65Si vous retournez à la définition au format proj4 du SRID 26918, vous pouvez voir que notre projectioin actuelle est de type UTM zone 18 (Universal Transvers Mercator), avec comme unité de mesure le mÚtre. 
    6766 
    6867:: 
    … …  
    7069   +proj=utm +zone=18 +ellps=GRS80 +datum=NAD83 +units=m +no_defs  
    7170 
    72 Let's convert some data from our working projection to geographic coordinates -- also known as "longitude/latitude".  
     71Essayons de convertir certaines données de notre systÚme de projection dans un systÚme de coordonnées géographiques, aussi connu comme "longitude/latitude". 
    7372 
    74 To convert data from one SRID to another, you must first verify that your geometry has a valid SRID. Since we have already confirmed a valid SRID, we next need the SRID of the projection to transform into. In other words, what is the SRID of geographic coordinates? 
     73Pour convertir les données d'un SRID à l'autre, nous devons dans un premier temps vérifier que nos géométries ont un SRID valide. une fois que nous avons vérifié ceci, nous devons ensuite trouver le SRID dans le lequel nous souhaitons re-projeter. En d'autre terme, quel est le SRID des coordonnées géographiques ? 
    7574 
    76 The most common SRID for geographic coordinates is 4326, which corresponds to "longitude/latitude on the WGS84 spheroid". You can see the definition at the spatialreference.org site: 
     75Le SRID le plus connu pour les coordonnées géographiques est le 4326, qui correspond au couple "longitude/latitude sur la sphéroïde WGS84". Vous pouvez voir sa définition sur le site spatialreference.org. 
    7776 
    7877  http://spatialreference.org/ref/epsg/4326/ 
    7978   
    80 You can also pull the definitions from the ``spatial_ref_sys`` table: 
     79Vous pouvez aussi récupérer les définitions dans la table  ``spatial_ref_sys`` : 
    8180 
    8281.. code-block:: sql 
    … …  
    9493    AUTHORITY["EPSG","4326"]] 
    9594 
    96 Let's convert the coordinates of the 'Broad St' subway station into geographics: 
     95Essayons de convertir les cordonnées de la station 'Broad St' : 
    9796 
    9897.. code-block:: sql 
    … …  
    106105  POINT(-74.0106714688735 40.7071048155841) 
    107106 
    108 If you load data or create a new geometry without specifying an SRID, the SRID value will be -1.  Recall in :ref:`geometries`, that when we created our ``geoemetries`` table we didn't specify an SRID. If we query our database, we should expect all the ``nyc_`` tables to have an SRID of 26918, while  the ``geometries`` table defaulted to an SRID of -1. 
     107Si vous chargez les données ou crééez une nouvelle géométrie sans spécifier un SRID, la valeur du SRID prendra alors la valeur -1. Rapellez-vous que dans les :ref:`geometries`, lorsque nous avons créé nos tables géométriques nous n'avions pas spécifié un SRID. Si nous interrogeons la base, nous devons nous attendre à ce que toutes les tables préfixées par ``nyc_`` aient le SRID 26918, alors que la table ``geometries`` aura la valeur -1 par défaut. 
    109108 
    110 To view a table's SRID assignment, query the database's ``geometry_columns`` table. 
     109Pour visualiser la table d'assignation des SRID, interroger la table ``geometry_columns`` de la base de données. 
    111110 
    112111.. code-block:: sql 
    … …  
    126125 
    127126   
    128 However, if you know what the SRID of the coordinates is supposed to be, you can set it post-facto, using :command:`ST_SetSRID` on the geometry. Then you will be able to transform the geometry into other systems. 
     127Neanmoins, si vous connaissez quel est le SRID de vos données, vous pouvez l'affecter par la suite, en utilisant la fonction :command:`ST_SetSRID` sur les géométries. Ensuite vous pourrez les tranformer dans d'autres systÚmes de projections. 
    129128 
    130129.. code-block:: sql 
    … …  
    137136   FROM geometries; 
    138137 
    139 Function List 
    140 ------------- 
    141 `ST_AsText <http://postgis.org/docs/ST_AsText.html>`_: Returns the Well-Known Text (WKT) representation of the geometry/geography without SRID metadata. 
     138Liste des fonctions 
     139------------------- 
    142140 
    143 `ST_SetSRID(geometry, srid) <http://postgis.org/docs/ST_SetSRID.html>`_: Sets the SRID on a geometry to a particular integer value. 
     141`ST_AsText <http://postgis.org/docs/ST_AsText.html>`_: retourne la représentation au format Well-Known Text (WKT) sans la métadonnée SRID. 
    144142 
    145 `ST_SRID(geometry) <http://postgis.org/docs/ST_SRID.html>`_: Returns the spatial reference identifier for the ST_Geometry as defined in spatial_ref_sys table. 
     143`ST_SetSRID(geometry, srid) <http://postgis.org/docs/ST_SetSRID.html>`_: affecte une valeur au SRID d'une géométrie. 
    146144 
    147 `ST_Transform(geometry, srid) <http://postgis.org/docs/ST_Transform.html>`_: Returns a new geometry with its coordinates transformed to the SRID referenced by the integer parameter. 
     145`ST_SRID(geometry) <http://postgis.org/docs/ST_SRID.html>`_: retourne l'indentifiant du systÚme de références spatialesd'un objet ST_Geometry comme définit dans la table spatial_ref_sys. 
     146 
     147`ST_Transform(geometry, srid) <http://postgis.org/docs/ST_Transform.html>`_: retourne une nouvelle géométrie aprÚs avoi re-projeté  les données dans le systÚme correspondant au SRID passé en paramÚtre. 

  • /trunk/workshop-foss4g/validity.rst

    r20 r30  
    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   

  • /trunk/workshop-foss4g/projection_exercises.rst

    r20 r30  
    11.. _projection_exercises: 
    22 
    3 Section 16: Projection Exercises 
    4 ================================ 
     3Partie 16 : Exercices de projection 
     4=================================== 
    55 
    6 Here's a reminder of some of the functions we have seen.  Hint: they should be useful for the exercises! 
     6Voici un  rappel de certaines fonctions que nous avons vu. Astuce : elles devraient être utiles pour les exercices ! 
     7      
     8* :command:`sum(expression)` agrégation qui retourn la somme d'un esemble de valeurs 
     9* :command:`ST_Length(linestring)` retourne la longueur d'une ligne 
     10* :command:`ST_SRID(geometry, srid)` retourne le SRID d'une géométrie 
     11* :command:`ST_Transform(geometry, srid)` re-projette des géométries dans un autre systÚme de références spatiales 
     12* :command:`ST_GeomFromText(text)` retourne un objet ``geometry`` 
     13* :command:`ST_AsText(geometry)` retourne le WKT (``text``) 
     14* :command:`ST_AsGML(geometry)` retourne le GML (``text``) 
    715 
    8 * :command:`sum(expression)` aggregate to return a sum for a set of records 
    9 * :command:`ST_Length(linestring)` returns the length of the linestring 
    10 * :command:`ST_SRID(geometry, srid)` returns the SRID of the geometry 
    11 * :command:`ST_Transform(geometry, srid)` converts geometries into different spatial reference systems 
    12 * :command:`ST_GeomFromText(text)` returns ``geometry`` 
    13 * :command:`ST_AsText(geometry)` returns WKT ``text`` 
    14 * :command:`ST_AsGML(geometry)` returns GML ``text`` 
    15  
    16 Remember the online resources that are available to you: 
     16Rappelez-vous les resssources en ligne : 
    1717 
    1818* http://spatialreference.org 
    1919* http://prj2epsg.org 
    2020 
    21 Also remember the tables we have available: 
     21Et les tables qui sont disponibles : 
    2222 
    2323 * ``nyc_census_blocks``  
    … …  
    3737   * name, boroname, the_geom 
    3838 
    39 Exercises 
     39Exercices 
    4040--------- 
    4141 
    42  * **"What is the length of all streets in New York, as measured in UTM 18?"** 
     42 * **"Quelle est la longueur des rue de New York, mesurée en UTM 18 ?"** 
    4343  
    4444   .. code-block:: sql 
    … …  
    5151     10418904.7172 
    5252       
    53  * **"What is the WKT definition of SRID 2831?"**    
     53 * **"Quelle est la définition du SRID 2831 ?"**    
    5454     
    5555   .. code-block:: sql 
    … …  
    5858     WHERE SRID = 2831; 
    5959 
    60 Or, via `prj2epsg <http://prj2epsg.org/epsg/2831>`_ 
     60Ou, via `prj2epsg <http://prj2epsg.org/epsg/2831>`_ 
    6161 
    6262 :: 
    … …  
    8787   
    8888 
    89  * **"What is the length of all streets in New York, as measured in SRID 2831?"** 
     89 * **"Quelle est la longueur des rue de New York, mesuré en utilisant le SRID 2831 ?"** 
    9090  
    9191   .. code-block:: sql 
    … …  
    100100   .. note:: 
    101101    
    102      The difference between the UTM 18 and the Stateplane Long Island measurements is (10421993 - 10418904)/10418904, or 0.02%. Calculated on the spheroid using :ref:`geography` the total street length is 10421999, which is closer to the Stateplane value. This is not surprising, since the Stateplane Long Island projection is precisely calibrated for a very small area (New York City) while UTM 18 has to provide reasonable results for a large regional area. 
     102     La différence entre les mesure en UTM 18 et en the Stateplane Long Island est de (10421993 - 10418904)/10418904, soit 0.02%. Calculé sur la sphéroïde en utilissant en :ref:`geography` le total des longueurs des route est 10421999, qui est proche de la valeur dans l'autre systÚme de projection (Stateplane Long Island) est précisément calibré pour une petite zone géographique (la ville de New York) alors que le systÚme UTM 18 doit fournir un résultat raisonable pour une zone régionale plus large. 
    103103      
    104  * **"What is the KML representation of the point at 'Broad St' subway station?"** 
     104 * **"Quelle est la représentation KML du point de la station de métris 'Broad St' ?"** 
    105105  
    106106   .. code-block:: sql 
    … …  
    114114     <Point><coordinates>-74.010671468873468,40.707104815584088</coordinates></Point> 
    115115      
    116 Hey! The coordinates are in geographics even though we didn't call :command:`ST_Transform`, why? Because the KML standard dictates that all coordinates *must* be in geographics (ESPG:4326, in fact) so the :command:`ST_AsKML` function does the transformation automatically. 
     116Hé ! les coordonnées sont géographiques bien que nous n'ayons pas fait appÚle à la fonction  :command:`ST_Transform`, pourquoi ? Parce que le standard KML spécifit que toutes les coordonnées *doivent* être en géographiques (en fait, dans le systÚme EPSG:4326), donc la fonction :command:`ST_AsKML` réalise la transformation automatiquement. 

  • /trunk/workshop-foss4g/spatial_relationships.rst

    r20 r30  
    11.. _spatial_relationships: 
    22 
    3 Section 10: Spatial Relationships 
     3Partie 10 : relations spatiales 
    44================================= 
    55 
    6 So far we have only used spatial functions that measure (:command:`ST_Area`, :command:`ST_Length`), serialize (:command:`ST_GeomFromText`) or deserialize (:command:`ST_AsGML`) geometries. What these functions have in common is that they only work on one geometry at a time. 
     6Jusqu'à maintenant nous n'avons utilisé que des fonctions qui permettent de mesurer (:command:`ST_Area`, :command:`ST_Length`), de serialiser (:command:`ST_GeomFromText`) ou désérialiser (:command:`ST_AsGML`) des géométries. Ces fonctions ont en commun de fonctionner uniquement sur une géométrie à la fois. 
    77 
    8 Spatial databases are powerful because they not only store geometry, they also have the ability to compare *relationships between geometries*.  
     8Les base de données spatiales sont puissantes car elle ne font pas que stoquer les géométries, elle ont aussi la faculté de vérifier les *relations entre les géométries*. 
    99 
    10 Questions like “Which are the closet bike racks to a park?” or “Where are the intersections of subway lines and streets?” can only be answered by comparing geometries representing the bike racks, streets, and subway lines. 
     10Pour les questions comme "Quel est le plus proche garage à vélo prêt du park ?" ou "Ou est l'intersection du métros avec telle rue ?" nous devrons comparer les géométries représentant les garage à vélo, les rues et les lignes de métros. 
    1111 
    12 The OGC standard defines the following set of methods to compare geometries. 
     12Le standard de l'OGC définit l'ensemble suivant de fonctions pour comparer les géométries. 
    1313 
    1414ST_Equals 
    1515--------- 
    1616  
    17 :command:`ST_Equals(geometry A, geometry B)` tests the spatial equality of two geometries.  
     17:command:`ST_Equals(geometry A, geometry B)` test l'égalité spatiale de deux géométries.  
    1818 
    1919.. figure:: ./spatial_relationships/st_equals.png 
    2020   :align: center 
    2121 
    22 ST_Equals returns TRUE if two geometries of the same type have identical x,y coordinate values, i.e. if the secondary shape is equal (identical) to the primary shape object. 
     22ST_Equals retourne TRUE si les deux géométries sont du même type, ont des coordonnées x.y identiques. 
    2323 
    24 First, let's retrieve a representation of a point from our ``nyc_subway_stations`` table. We'll take just the entry for 'Broad St'. 
     24PremiÚrement, essayons de récupérer la représentation d'un point de notre table ``nyc_subway_stations``. Nous ne prendrons que l'entrée : 'Broad St'. 
    2525 
    2626.. code-block:: sql 
    … …  
    3636   Broad St | 0101000020266900000EEBD4CF27CF2141BC17D69516315141 | POINT(583571 4506714) 
    3737  
    38 Then, plug the geometry representation back into an :command:`ST_Equals` test: 
     38Maintenant, copiez / collez la valeur afficher pour tester la fonction :command:`ST_Equals`: 
    3939 
    4040.. code-block:: sql 
    … …  
    5050.. note:: 
    5151 
    52   The representation of the point was not very human readable (``0101000020266900000EEBD4CF27CF2141BC17D69516315141``) but it was an exact representation of the coordinate values. For a test like equality, using the exact coordinates in necessary. 
     52  La représentation du point n'est pas vraiment compréhensible (``0101000020266900000EEBD4CF27CF2141BC17D69516315141``) mais c'est exactement la représentation des coordonnées. Pour tester l'égalité, utiliser ce format est nécessaire. 
    5353 
    5454 
    55 ST_Intersects, ST_Disjoint, ST_Crosses and ST_Overlaps 
     55ST_Intersects, ST_Disjoint, ST_Crosses et ST_Overlaps 
    5656------------------------------------------------------ 
    5757 
    58 :command:`ST_Intersects`, :command:`ST_Crosses`, and :command:`ST_Overlaps` test whether the interiors of the geometries intersect.  
     58:command:`ST_Intersects`, :command:`ST_Crosses`, et :command:`ST_Overlaps` test si l'intérieur des géométries s'intersect, se croise ou se chevauche. 
    5959 
    6060.. figure:: ./spatial_relationships/st_intersects.png 
    6161   :align: center 
    6262 
    63 :command:`ST_Intersects(geometry A, geometry B)` returns t (TRUE) if the intersection does not result in an empty set. Intersects returns the exact opposite result of disjoint. 
     63:command:`ST_Intersects(geometry A, geometry B)` retourne t (TRUE) si l'intersection ne rénvoit pas un ensemble vide de résultats. Intersects retourne le résultat exactement inverse de la fonction disjoint. 
    6464 
    6565.. figure:: ./spatial_relationships/st_disjoint.png 
    6666   :align: center 
    6767 
    68 The opposite of ST_Intersects is :command:`ST_Disjoint(geometry A , geometry B)`. If two geometries are disjoint, they do not intersect, and vice-versa. In fact, it is often more efficient to test "not intersects" than to test "disjoint" because the intersects tests can be spatially indexed, while the disjoint test cannot. 
     68L'opposé de ST_Intersects est :command:`ST_Disjoint(geometry A , geometry B)`. Si deux géométries sont disjointes, elle ne s'intersectent pas et vice-versa. En fait, il est souvent plus éfficace de tester si deux géométries ne s'intersectent pas que de tester si elles sont dijointes du fait que le test d'intersection peut être spatialement indexé alors que le test disjoint ne le peut pas. 
    6969 
    7070.. figure:: ./spatial_relationships/st_crosses.png   
    7171   :align: center 
     72 
     73Pour les comparaisons de couples de types multipoint/polygon, multipoint/linestring, linestring/linestring, linestring/polygon, et linestring/multipolygon, :command:`ST_Crosses(geometry A, geometry B)` retourne t (TRUE) si les résultats de l'intersection  
    7274 
    7375For multipoint/polygon, multipoint/linestring, linestring/linestring, linestring/polygon, and linestring/multipolygon comparisons, :command:`ST_Crosses(geometry A, geometry B)` returns t (TRUE) if the intersection results in a geometry whose dimension is one less than the maximum dimension of the two source geometries and the intersection set is interior to both source geometries. 
    … …  
    7678   :align: center 
    7779 
    78 :command:`ST_Overlaps(geometry A, geometry B)` compares two geometries of the same dimension and returns TRUE if their intersection set results in a geometry different from both but of the same dimension. 
     80:command:`ST_Overlaps(geometry A, geometry B)` compare deux géométries de même dimension et retourne TRUE si leur intersection est une géométrie différente des deux fournies mais de même dimension. 
    7981 
    80 Let's take our Broad Street subway station and determine its neighborhood using the :command:`ST_Intersects` function: 
     82Essayons de prendre la station de métro de Broad Street et de déterminer sont voisinage en utilisant la fonction :command:`ST_Intersects` : 
    8183 
    8284.. code-block:: sql 
    … …  
    9799---------- 
    98100 
    99 :command:`ST_Touches` tests whether two geometries touch at their boundaries, but do not intersect in their interiors  
     101:command:`ST_Touches` test si deux géométries se touchent en leur contour extérieur, mais leur contours intérieur ne s'intersectent pas 
    100102 
    101103.. figure:: ./spatial_relationships/st_touches.png 
    102104   :align: center 
    103105 
    104 :command:`ST_Touches(geometry A, geometry B)` returns TRUE if either of the geometries' boundaries intersect or if only one of the geometry's interiors intersects the other's boundary. 
     106:command:`ST_Touches(geometry A, geometry B)` retourn TRUE soit si les contours des géométries s'intersectent ou si l'un des contours intérieur de l'une intersecte le contour extérieur de l'autre. 
    105107 
    106 ST_Within and ST_Contains 
     108ST_Within et ST_Contains 
    107109------------------------- 
    108110 
    109 :command:`ST_Within` and :command:`ST_Contains` test whether one geometry is fully within the other.  
     111:command:`ST_Within` et :command:`ST_Contains` test si une géométrie est totalement incluse dans l'autre.  
    110112 
    111113.. figure:: ./spatial_relationships/st_within.png 
    112114   :align: center 
    113115     
    114 :command:`ST_Within(geometry A , geometry B)` returns TRUE if the first geometry is completely within the second geometry. ST_Within tests for the exact opposite result of ST_Contains.   
     116:command:`ST_Within(geometry A , geometry B)` retourne TRUE si la premiÚre géométries est complÚtement contenue dans l'autre. ST_Within test l'exact opposé au résultat de ST_Contains.   
    115117 
    116 :command:`ST_Contains(geometry A, geometry B)` returns TRUE if the second geometry is completely contained by the first geometry.  
     118:command:`ST_Contains(geometry A, geometry B)` retourne TRUE si la seconde géométries est complÚtement contenue dans la premiÚre géométrie. 
    117119 
    118120 
    119 ST_Distance and ST_DWithin 
     121ST_Distance et ST_DWithin 
    120122-------------------------- 
    121123 
    122 An extremely common GIS question is "find all the stuff within distance X of this other stuff".  
     124Une question qui arrive fréquemment dans le domaine du SIG est "trouver tout les trucs qui se trouve à une distance X de cet autre truc". 
    123125 
    124 The :command:`ST_Distance(geometry A, geometry B)` calculates the *shortest* distance between two geometries and returns it as a float. This is useful for actually reporting back the distance between objects. 
     126La fonction :command:`ST_Distance(geometry A, geometry B)` calcule la *plus courte* distance entre deux géoémétries. Cela est pratique pour récupérer la distance entre les objets. 
    125127 
    126128.. code-block:: sql 
    … …  
    134136  3 
    135137 
    136 For testing whether two objects are within a distance of one another, the :command:`ST_DWithin` function provides an index-accelerated true/false test. This is useful for questions like "how many trees are within a 500 meter buffer of the road?". You don't have to calculate an actual buffer, you just have to test the distance relationship. 
     138Pour tester si deux obets sont à la même distance d'un autre, la fonction :command:`ST_DWithin` fournit une test tirant proffit des indexes. Cela est trÚs utile pour répondre au questions du genre : "Combien d'arbre se situe dans un buffer de 500 mÚtres autour de cette route ?". Vous n'avez pas à calculer le buffer, vous avez simplement besoin de tester la distance entre les géométries. 
    137139 
    138140  .. figure:: ./spatial_relationships/st_dwithin.png 
    139141     :align: center 
    140142     
    141 Using our Broad Street subway station again, we can find the streets nearby (within 10 meters of) the subway stop: 
     143En utilisant de nouveau notre station de métros Broad Street, nous pouvons trouver les rues voisines (à 10 mÚtres de) de la station : 
    142144 
    143145.. code-block:: sql 
    … …  
    159161     Nassau St 
    160162 
    161 And we can verify the answer on a map. The Broad St station is actually at the intersection of Wall, Broad and Nassau Streets. 
     163Nous pouvons vérifier la réponse sur une carte. La station Broad St est actuellement à l'intersection des rues Wall, Broad et Nassau.  
    162164 
    163165.. image:: ./spatial_relationships/broad_st.jpg 
    164166 
    165 Function List 
    166 ------------- 
     167Liste des fonctions 
     168------------------- 
    167169 
    168 `ST_Contains(geometry A, geometry B) <http://postgis.org/docs/ST_Contains.html>`_: Returns true if and only if no points of B lie in the exterior of A, and at least one point of the interior of B lies in the interior of A. 
     170`ST_Contains(geometry A, geometry B) <http://postgis.org/docs/ST_Contains.html>`_ : retourne TRUE si aucun des points de B n'est à l'extérieur de A, et au moins un point de l'intérieur de B est à l'intérieur de A. 
    169171 
    170 `ST_Crosses(geometry A, geometry B)  <http://postgis.org/docs/ST_Crosses.html>`_: Returns TRUE if the supplied geometries have some, but not all, interior points in common. 
     172`ST_Crosses(geometry A, geometry B)  <http://postgis.org/docs/ST_Crosses.html>`_ : retourne TRUE si la géométrie A a certains, mais pas la totalité de, ses points à l'intérieur de B. 
    171173 
    172 `ST_Disjoint(geometry A , geometry B) <http://postgis.org/docs/ST_Disjoint.html>`_: Returns TRUE if the Geometries do not "spatially intersect" - if they do not share any space together. 
     174`ST_Disjoint(geometry A , geometry B) <http://postgis.org/docs/ST_Disjoint.html>`_ : retourne TRUE si les gémétries nes s'intersectent pas - elles n'ont aucun point en commun. 
    173175 
    174 `ST_Distance(geometry A, geometry B)  <http://postgis.org/docs/ST_Distance.html>`_: Returns the 2-dimensional cartesian minimum distance (based on spatial ref) between two geometries in projected units.  
     176`ST_Distance(geometry A, geometry B)  <http://postgis.org/docs/ST_Distance.html>`_ : retourne la distance cartésienne en 2 dimensions minimum entre deux géométries dans l'unité de la projection.  
    175177 
    176 `ST_DWithin(geometry A, geometry B, radius) <http://postgis.org/docs/ST_DWithin.html>`_: Returns true if the geometries are within the specified distance (radius) of one another.  
     178`ST_DWithin(geometry A, geometry B, radius) <http://postgis.org/docs/ST_DWithin.html>`_ : retourne TRUE si les géométries sont distante (radius) l'une de l'autre.  
    177179 
    178 `ST_Equals(geometry A, geometry B) <http://postgis.org/docs/ST_Equals.html>`_: Returns true if the given geometries represent the same geometry. Directionality is ignored. 
     180`ST_Equals(geometry A, geometry B) <http://postgis.org/docs/ST_Equals.html>`_ : retourn TRUE si les géométries fournis représentent la même géométrie. L'ordre des entités n'est pas prit en compte. 
    179181 
    180 `ST_Intersects(geometry A, geometry B) <http://postgis.org/docs/ST_Intersects.html>`_: Returns TRUE if the Geometries/Geography "spatially intersect" - (share any portion of space) and FALSE if they don't (they are Disjoint).  
     182`ST_Intersects(geometry A, geometry B) <http://postgis.org/docs/ST_Intersects.html>`_ : retourne TRUE si les géométries s'intersectent - (ont un espace en commun) et FALSE si elles n'en ont pas (elles sont disjointes).  
    181183 
    182 `ST_Overlaps(geometry A, geometry B) <http://postgis.org/docs/ST_Overlaps.html>`_: Returns TRUE if the Geometries share space, are of the same dimension, but are not completely contained by each other. 
     184`ST_Overlaps(geometry A, geometry B) <http://postgis.org/docs/ST_Overlaps.html>`_ : retourne TRUE si les géométries ont un espace en commun, sont de la même dimension, mais ne sont pas complÚtement contenu l'une dans l'autre. 
    183185 
    184 `ST_Touches(geometry A, geometry B)  <http://postgis.org/docs/ST_Touches.html>`_: Returns TRUE if the geometries have at least one point in common, but their interiors do not intersect. 
     186`ST_Touches(geometry A, geometry B)  <http://postgis.org/docs/ST_Touches.html>`_ : retourne TRUE si les géométries ont au moins un point en commun, mais leur intérieurs ne s'intersectent pas. 
    185187 
    186 `ST_Within(geometry A , geometry B) <http://postgis.org/docs/ST_Within.html>`_: Returns true if the geometry A is completely inside geometry B 
     188`ST_Within(geometry A , geometry B) <http://postgis.org/docs/ST_Within.html>`_ : retourne TRUE si la géométrie A est complÚtement à l'intérieur de B 
    187189 
    188190 

  • /trunk/workshop-foss4g/spatial_relationships_exercises.rst

    r20 r30  
    11.. _spatial_relationships_exercises: 
    22 
    3 Section 11: Spatial Relationships Exercises 
     3Partie 11 : exercises sur les relations spatiales 
    44=========================================== 
    55 
    6 Here's a reminder of the functions we saw in the last section. They should be useful for the exercises! 
     6Voici un rappel des fonctions que nous avons vu dans les parties précédentes. Elles seront utiles pour les exercices ! 
    77 
    8 * :command:`sum(expression)` aggregate to return a sum for a set of records 
    9 * :command:`count(expression)` aggregate to return the size of a set of records 
    10 * :command:`ST_Contains(geometry A, geometry B)` returns true if geometry A contains geometry B  
    11 * :command:`ST_Crosses(geometry A, geometry B)` returns true if geometry A crosses geometry B 
    12 * :command:`ST_Disjoint(geometry A , geometry B)` returns true if the geometries do not "spatially intersect"  
    13 * :command:`ST_Distance(geometry A, geometry B)` returns the minimum distance between geometry A and geometry B 
    14 * :command:`ST_DWithin(geometry A, geometry B, radius)` returns true if geometry A is radius distance or less from geometry B 
    15 * :command:`ST_Equals(geometry A, geometry B)` returns true if geometry A is the same as geometry B 
    16 * :command:`ST_Intersects(geometry A, geometry B)` returns true if geometry A intersects geometry B 
    17 * :command:`ST_Overlaps(geometry A, geometry B)` returns true if geometry A and geometry B share space, but are not completely contained by each other. 
    18 * :command:`ST_Touches(geometry A, geometry B)` returns true if the boundary of geometry A touches geometry B 
    19 * :command:`ST_Within(geometry A, geometry B)` returns true if geometry A is within geometry B 
     8 * :command:`sum(expression)` agrégation retournant la somme d'un ensemble 
     9 * :command:`count(expression)` agrégation retournant le nombre d'éléments d'un ensemble 
     10* :command:`ST_Contains(geometry A, geometry B)` retourne vrai si la géométrie A contient la géométrie B  
     11* :command:`ST_Crosses(geometry A, geometry B)` retourne vrai si la géométrie A croise la géométrie B 
     12* :command:`ST_Disjoint(geometry A , geometry B)` retourne vrai si les géométrie ne s'intersectent pas 
     13* :command:`ST_Distance(geometry A, geometry B)` retourne la distance minimum entre deux géométries 
     14* :command:`ST_DWithin(geometry A, geometry B, radius)` retourne vrai si la A est distante d'au plus radius de B 
     15* :command:`ST_Equals(geometry A, geometry B)` retourne vrai si A est la même géométrie que B 
     16* :command:`ST_Intersects(geometry A, geometry B)` retourne vrai si A intersecte B 
     17* :command:`ST_Overlaps(geometry A, geometry B)` retourne vrai si A et B on un espace en commun, mais ne sont pas complétement inclus l'un dans l'autre. 
     18* :command:`ST_Touches(geometry A, geometry B)` retourne vrai si le contour extérieur de A touche B 
     19* :command:`ST_Within(geometry A, geometry B)` retourne vrai si A est hors de B 
    2020 
    21 Also remember the tables we have available: 
     21Souvenez-vous les tables à notre disposition : 
    2222 
    2323 * ``nyc_census_blocks``  
    … …  
    3737   * name, boroname, the_geom 
    3838 
    39 Exercises 
     39Exercices 
    4040--------- 
    4141 
    42  * **"What is the geometry value for the street named 'Atlantic Commons'?"** 
     42 * **"Quel est la valeur géométrique de la rue nommée  'Atlantic Commons' ?"** 
    4343  
    4444   .. code-block:: sql 
    … …  
    5252     01050000202669000001000000010200000002000000093235673BE82141F319CD89A22E514170E30E0ADFE82141CB2D3EFFA52E5141 
    5353      
    54  * **"What neighborhood and borough is Atlantic Commons in?"** 
     54 * **"Quel sont les quartiers et villes sont dans Atlantic Commons ?"** 
    5555      
    5656   .. code-block:: sql 
    … …  
    7070      
    7171 
    72  * **"What streets does Atlantic Commons touch?"**  
     72 * **"Quelles rues touchent Atlantic Commons ?"**  
    7373  
    7474   .. code-block:: sql 
    … …  
    9191   
    9292 
    93  * **"Approximately how many people live on (within 50 meters of) Atlantic Commons?"** 
     93 * **"Approximativement combien de personnes vivent dans (ou à un dans une zone de 50 meters autour) Atlantic Commons ?"** 
    9494  
    9595   .. code-block:: sql 

  • /trunk/workshop-foss4g/geometries_exercises.rst

    r20 r30  
    11.. _geometries_exercises: 
    22 
    3 Section 9: Geometry Exercises 
    4 ============================= 
    5  
    6 Here's a reminder of all the functions we have seen so far. They should be useful for the exercises! 
    7  
    8  * :command:`sum(expression)` aggregate to return a sum for a set of records 
    9  * :command:`count(expression)` aggregate to return the size of a set of records 
    10  * :command:`ST_GeometryType(geometry)` returns the type of the geometry 
    11  * :command:`ST_NDims(geometry)` returns the number of dimensions of the geometry 
    12  * :command:`ST_SRID(geometry)` returns the spatial reference identifier number of the geometry 
    13  * :command:`ST_X(point)` returns the X ordinate 
    14  * :command:`ST_Y(point)` returns the Y ordinate 
    15  * :command:`ST_Length(linestring)` returns the length of the linestring 
    16  * :command:`ST_StartPoint(geometry)` returns the first coordinate as a point 
    17  * :command:`ST_EndPoint(geometry)` returns the last coordinate as a point 
    18  * :command:`ST_NPoints(geometry)` returns the number of coordinates in the linestring 
    19  * :command:`ST_Area(geometry)` returns the area of the polygons 
    20  * :command:`ST_NRings(geometry)` returns the number of rings (usually 1, more if there are holes) 
    21  * :command:`ST_ExteriorRing(polygon)` returns the outer ring as a linestring 
    22  * :command:`ST_InteriorRingN(polygon, integer)` returns a specified interior ring as a linestring 
    23  * :command:`ST_Perimeter(geometry)` returns the length of all the rings 
    24  * :command:`ST_NumGeometries(multi/geomcollection)` returns the number of parts in the collection 
    25  * :command:`ST_GeometryN(geometry, integer)` returns the specified part of the collection 
    26  * :command:`ST_GeomFromText(text)` returns ``geometry`` 
    27  * :command:`ST_AsText(geometry)` returns WKT ``text`` 
    28  * :command:`ST_AsEWKT(geometry)` returns EWKT ``text`` 
    29  * :command:`ST_GeomFromWKB(bytea)` returns ``geometry`` 
    30  * :command:`ST_AsBinary(geometry)` returns WKB ``bytea`` 
    31  * :command:`ST_AsEWKB(geometry)` returns EWKB ``bytea`` 
    32  * :command:`ST_GeomFromGML(text)` returns ``geometry`` 
    33  * :command:`ST_AsGML(geometry)` returns GML ``text`` 
    34  * :command:`ST_GeomFromKML(text)` returns ``geometry`` 
    35  * :command:`ST_AsKML(geometry)` returns KML ``text`` 
    36  * :command:`ST_AsGeoJSON(geometry)` returns JSON ``text`` 
    37  * :command:`ST_AsSVG(geometry)` returns SVG ``text`` 
    38  
    39 Also remember the tables we have available: 
     3Partie 9 : exercices sur les géométries 
     4====================================== 
     5 
     6Voici un petit rappel de toute les fonction que nous avons jusqu'à présent. Elles devraient être utiles pour les exercices ! 
     7 
     8 * :command:`sum(expression)` agrégation retournant la somme d'un ensemble 
     9 * :command:`count(expression)` agrégation retournant le nombre d'éléments d'un ensemble 
     10 * :command:`ST_GeometryType(geometry)` retourne le type de la géométrie 
     11 * :command:`ST_NDims(geometry)` retourne le  nombre de dimensions 
     12 * :command:`ST_SRID(geometry)` retourne l'identifiant du systÚme de références spatiales 
     13 * :command:`ST_X(point)` retourne la coordonnée X 
     14 * :command:`ST_Y(point)` retourne la coordonnée Y 
     15 * :command:`ST_Length(linestring)` retourne la longueur d'une ligne 
     16 * :command:`ST_StartPoint(geometry)` retourne le premier point d'une ligne 
     17 * :command:`ST_EndPoint(geometry)` retourne le dernier point d'une ligne 
     18 * :command:`ST_NPoints(geometry)` retourne le nombre point d'une ligne 
     19 * :command:`ST_Area(geometry)` retourne l'aire d'un polygone 
     20 * :command:`ST_NRings(geometry)` retourne le nombre de contours (1 ou plus si il y a des trous) 
     21 * :command:`ST_ExteriorRing(polygon)` retourne le contour exterieur (ligne) d'un polygon 
     22 * :command:`ST_InteriorRingN(polygon, integer)` retourne le contour intérieur (ligne) d'un polygone 
     23 * :command:`ST_Perimeter(geometry)` retourne la longueur de tout les contours 
     24 * :command:`ST_NumGeometries(multi/geomcollection)` retourne le nombre de composantes dans une collection 
     25 * :command:`ST_GeometryN(geometry, integer)` retourne la niÚme entité de la collection 
     26 * :command:`ST_GeomFromText(text)` retourne ``geometry`` 
     27 * :command:`ST_AsText(geometry)` retourne WKT ``text`` 
     28 * :command:`ST_AsEWKT(geometry)` retourne EWKT ``text`` 
     29 * :command:`ST_GeomFromWKB(bytea)` retourne ``geometry`` 
     30 * :command:`ST_AsBinary(geometry)` retourne WKB ``bytea`` 
     31 * :command:`ST_AsEWKB(geometry)` retourne EWKB ``bytea`` 
     32 * :command:`ST_GeomFromGML(text)` retourne ``geometry`` 
     33 * :command:`ST_AsGML(geometry)` retourne GML ``text`` 
     34 * :command:`ST_GeomFromKML(text)` retourne ``geometry`` 
     35 * :command:`ST_AsKML(geometry)` retourne KML ``text`` 
     36 * :command:`ST_AsGeoJSON(geometry)` retourne JSON ``text`` 
     37 * :command:`ST_AsSVG(geometry)` retourne SVG ``text`` 
     38 
     39Souvenez-vous aussi des tables qui sont disponibles: 
    4040 
    4141 * ``nyc_census_blocks``  
    … …  
    7272   .. note:: 
    7373 
    74       The area is given in square meters. To get an area in hectares, divide by 10000. To get an area in acres, divide by 4047. 
    75  
    76  * **"What is the area of Manhattan in acres?"** (Hint: both ``nyc_census_blocks`` and ``nyc_neighborhoods`` have a ``boroname`` in them.) 
     74      L'aire est données en metres carrés. Pour obtenir l'aire en hectare, divisez par 10000. Pour obrenir l'aire en acres, divisez par 4047. 
     75 
     76 * **"Quelle est l'aire de Manhattan in acres ?"** (Astuce: ``nyc_census_blocks`` et ``nyc_neighborhoods`` on toutes deux le champ ``boroname``.) 
    7777  
    7878   .. code-block:: sql 
    … …  
    9999 
    100100 
    101  * **"How many census blocks in New York City have a hole in them?"** 
     101 * **"Combien de bloques de la ville de New York ont des trous ?"** 
    102102  
    103103   .. code-block:: sql 
    … …  
    111111     66  
    112112    
    113  * **"What is the total length of streets (in kilometers) in New York City?"** (Hint: The units of measurement of the spatial data are meters, there are 1000 meters in a kilometer.) 
     113 * **"Quel est la longueur totale des rues (en kilomÚtres) dans la ville de New York ?"** (Astuce: l'unité de mesure des données spatiales est le mÚtre, il y a 1000 mÚtres dans un kilomÚtre.) 
    114114   
    115115    .. code-block:: sql 
    … …  
    122122     10418.9047172 
    123123 
    124  * **"How long is 'Columbus Cir' (Columbus Circle)?** 
     124 * **"Quelle est la longueur de 'Columbus Cir' (Columbus Circle) ?** 
    125125  
    126126     .. code-block:: sql 
    … …  
    134134       308.34199 
    135135 
    136  * **"What is the JSON representation of the boundary of the 'West Village'?"** 
     136 * **"Quelle est le contour de 'West Village' au format JSON ?"** 
    137137  
    138138   .. code-block:: sql 
    … …  
    149149          [583263.2776595836,4509242.6260239873]]]]} 
    150150 
    151 The geometry type is "MultiPolygon", interesting! 
     151La géométrie de type "MultiPolygon", interressant ! 
    152152    
    153153       
    154  * **"How many polygons are in the 'West Village' multipolygon?"** 
     154 * **"Combien de polygones sont dans le multi-polygone 'West Village' ?"** 
    155155  
    156156   .. code-block:: sql 
    … …  
    166166   .. note:: 
    167167    
    168       It is not uncommon to find single-element MultiPolygons in spatial tables. Using MultiPolygons allows a table with only one geometry type to store both single- and multi-geometries without using mixed types. 
    169         
    170         
    171  * **"What is the length of streets in New York City, summarized by type?"** 
     168      Il n'est pas rare de trouver des éléments de type multi-polygone ne contenant qu'un seul polygone dans des tables. L'utilisation du type multi-polygone permet d'utiliser une seule table pour y stoquer des géométries simples et multiples sans mélanger les types. 
     169        
     170        
     171 * **"Quel est la longueur des rues de la ville de New York, suivant leur type ?"** 
    172172  
    173173   .. code-block:: sql 
    … …  
    207207   .. note:: 
    208208 
    209       The ``ORDER BY length DESC`` clause sorts the result by length in descending order. The result is that most prevalent types are first in the list. 
     209      La clause ``ORDER BY length DESC`` ordonne le résultats par la valeurs des longueur dans l'ordre décroissant. Le résultat avec la plus grande valeur se retrouve au début la liste de résultats. 
    210210 
    211211  

  • /trunk/workshop-foss4g/joins.rst

    r20 r30  
    11.. _joins: 
    22 
    3 Section 12: Spatial Joins 
    4 ========================= 
    5  
    6 Spatial joins are the bread-and-butter of spatial databases.  They allow you to combine information from different tables by using spatial relationships as the join key.  Much of what we think of as "standard GIS analysis" can be expressed as spatial joins. 
    7  
    8 In the previous section, we explored spatial relationships using a two-step process: first we extracted a subway station point for 'Broad St'; then, we used that point to ask further questions such as "what neighborhood is the 'Broad St' station in?" 
    9  
    10 Using a spatial join, we can answer the question in one step, retrieving information about the subway station and the neighborhood that contains it: 
     3Partie 12 : les jointures spatiales 
     4=================================== 
     5 
     6Les jointures saptiales est la cerise sur le gâteau des base de données spatiales. Elles vous pemettent de conbiner les informations de plusieures tables en utilisant une relation spatiale comme clause de jointure. Les plupart des "analyses SIG standards" peuvent être exprimées à l'aide de jointure spatiales. 
     7 
     8Dans la partie prcédente, nous avons utilisé les relations spatiales en utilisant deux étapes dans nos requêtes : nous avons dans un premier temps extrait la station de métro "Broad St" puis nous avon utilisé ce résultat dans nos autres requêtes pour répondre aux questions comme "dans quel quartier se situ la station 'Broad St' ?" 
     9 
     10En utilisant les jointures spatiales, nous pouvons répondre aux questions en une seule étape, récupérant les informations relatives à la station de métro et le quartie la contenant :  
    1111 
    1212.. code-block:: sql 
    … …  
    2727   Broad St    | Financial District | Manhattan 
    2828 
    29 We could have joined every subway station to its containing neighborhood, but in this case we wanted information about just one.  Any function that provides a true/false relationship between two tables can be used to drive a spatial join, but the most commonly used ones are: :command:`ST_Intersects`, :command:`ST_Contains`, and :command:`ST_DWithin`. 
    30  
    31 Join and Summarize 
    32 ------------------ 
    33  
    34 The combination of a ``JOIN`` with a ``GROUP BY`` provides the kind of analysis that is usually done in a GIS system. 
    35  
    36 For example: **"What is the population and racial make-up of the neighborhoods of Manhattan?"** Here we have a question that combines information from about population from the census with the boundaries of neighborhoods, with a restriction to just one borough of Manhattan. 
     29Nous avons pu regrouper chaque station de métros avec le quartier duquel elle fait partie, mais dans ce cas nous n'en voulions qu'une. Chaque fonctionn qui envoit un résultat du type vrai/faux peut être utilisée pour joindre spatialement deux tables, mais la plupart du temps on utilise : :command:`ST_Intersects`, :command:`ST_Contains`, et :command:`ST_DWithin`. 
     30 
     31Jointure et regroupement 
     32------------------------ 
     33 
     34La combinaison de ``JOIN`` avec ``GROUP BY`` fournit le type d'analyse qui est courramment utilisé dans les systÚmes SIG. 
     35 
     36Par exemple : **Quelle est la population et la répartition raciale du quartier de Manhattan ?** Ici nous avons une question qui combine les informations relatives à la population recenssée et les contours des quartier, or nous ne voulons qu'un seul quartier, celui de Manhattan. 
    3737 
    3838.. code-block:: sql 
    … …  
    8484 
    8585 
    86 What's going on here? Notionally (the actual evaluation order is optimized under the covers by the database) this is what happens: 
    87  
    88 #. The ``JOIN`` clause creates a virtual table that includes columns from both the neighborhoods and census tables.  
    89 #. The ``WHERE`` clause filters our virtual table to just rows in Manhattan.  
    90 #. The remaining rows are grouped by the neighborhood name and fed through the aggregation function to :command:`Sum()` the population values. 
    91 #. After a little arithmetic and formatting (e.g., ``GROUP BY``, ``ORDER BY``) on the final numbers, our query spits out the percentages. 
     86Que ce passe-t-il ici ?  Voici ce qui se passe (l'ordre d'évaluation est optimisé par la base de données) : 
     87 
     88#. La clause ``JOIN`` crée une table cirtuelle qui contient les colonnes à la fois des quartier et des recensements (tables neighborhoods et census). 
     89#. La claue ``WHERE`` filtre la table virtuelle pour ne conserver que la ligne correspondant à Manhattan.  
     90#. Les lignes restantes sont regroupées par le nom du quartier et sont utilisées par la fonction d'agrégation : :command:`Sum()` pour réaliser la somme des valeurs de la populations. 
     91#. AprÚs un peu d'arythmétiques et de formatage (ex: ``GROUP BY``, ``ORDER BY``)) ssur le nombres finaux, notre requête calcul les porcentages. 
    9292 
    9393.. note::  
    9494 
    95    The ``JOIN`` clause combines two ``FROM`` items.  By default, we are using an ``INNER JOIN``, but there are four other types of joins. For further information see the `join_type <http://www.postgresql.org/docs/8.1/interactive/sql-select.html>`_ definition in the PostgreSQL documentation. 
    96  
    97 We can also use distance tests as a join key, to create summarized "all items within a radius" queries. Let's explore the racial geography of New York using distance queries. 
    98  
    99 First, let's get the baseline racial make-up of the city. 
     95   La clause ``JOIN`` combine deux parties ``FROM``.  Par défaut, nous utilisons un jointure du type :``INNER JOIN``, mais il existe quatres autres types de jointures. Pour de plus amples informations à ce sujet, consultez la partie `type_jointure <http://docs.postgresql.fr/9.1/sql-select.html>`_ de la page de la documentation officielle de PostgreSQL. 
     96 
     97Nous pouvons aussi utiliser le test de la distance dans notre clef de jointure, pour créer une regroupement de "tout les éléments dans un certain rayon". Essayons de regarder la géographie raciale de New York en utilisant les requêtes de distance. 
     98 
     99PremiÚrement, essayons d'obtenir la répartition raciale de la ville. 
    100100 
    101101.. code-block:: sql 
    … …  
    114114 
    115115 
    116 So, of the 8M people in New York, about 44% are "white" and 26% are "black".  
    117  
    118 Duke Ellington once sang that "You / must take the A-train / To / go to Sugar Hill way up in Harlem." As we saw earlier, Harlem has far and away the highest African-American population in Manhattan (80.5%). Is the same true of Duke's A-train? 
    119  
    120 First, note that the contents of the ``nyc_subway_stations`` table ``routes`` field is what we are interested in to find the A-train. The values in there are a little complex. 
     116Donc, 8M de personnes de New York, environ 44% sont "blancs" et "26% sont "noirs". 
     117 
     118Duke Ellington chantait que "You / must take the A-train / To / go to Sugar Hill way up in Harlem." Comme nous l'avons vu précédemment, Harlem est de trÚs loin le quartier ou se trouve la plus grande concentration d'africains-américains de Manhattan (80.5%). Est-il toujours vrai qu'il faut prendre le train A dont Duke parlait dans sa chanson ? 
     119 
     120PremiÚrement, le contenu du champ ``routes`` de la table ``nyc_subway_stations`` va nous servir à récupérer le train A. Les valeurs de ce champs sont un peu complexes. 
    121121 
    122122.. code-block:: sql 
    … …  
    136136.. note:: 
    137137 
    138    The ``DISTINCT`` keyword eliminates duplicate rows from the result.  Without the ``DISTINCT`` keyword, the query above identifies 491 results instead of 73. 
     138   Le mot clef ``DISTINCT`` permet d'éliminer les répétitions de lignes de notre résultat. Dans ce mot clef, notre requête renverrait 491 résultats au lieu de 73. 
    139139    
    140 So to find the A-train, we will want any row in ``routes`` that has an 'A' in it. We can do this a number of ways, but today we will use the fact that :command:`strpos(routes,'A')` will return a non-zero number if 'A' is in the routes field. 
     140Donc pour trouver le train A, nous allons demander toute les lignes ayant pour ``routes`` la valeur 'A'. Nous pouvons faire cela de différentes maniÚres, mais nous utiliserons aujourd'hui le fait que la fonction :command:`strpos(routes,'A')` retourne un entier différent de 0 si la lettre 'A' se trouve dans la valeur du champs route. 
    141141 
    142142.. code-block:: sql 
    … …  
    158158  A,C,E 
    159159   
    160 Let's summarize the racial make-up of within 200 meters of the A-train line. 
     160Essayons de regrouper la répartition racialedans un rayon de 200 mÚtres de la ligne du train A. 
    161161 
    162162.. code-block:: sql 
    … …  
    177177   42.0805466940877366 | 23.0936148851067964 |     185259 
    178178 
    179 So the racial make-up along the A-train isn't radically different from the make-up of New York City as a whole.  
    180  
    181 Advanced Join 
    182 ------------- 
    183  
    184 In the last section we saw that the A-train didn't serve a population that differed much from the racial make-up of the rest of the city. Are there any trains that have a non-average racial make-up? 
    185  
    186 To answer that question, we'll add another join to our query, so that we can simultaneously calculate the make-up of many subway lines at once. To do that, we'll need to create a new table that enumerates all the lines we want to summarize. 
     179La répartition raciale le long de la ligne du train A n'est pas radicallement différente de la répartition générale de la ville de New York. 
     180 
     181Jointres avancées 
     182----------------- 
     183 
     184Dans la derniÚre partie nous avons vu que le train A n'est pas utilisé par des populations si éloignées de la répartition totale du reste de la ville. Y-a-t-il des train qui passent par des parties de la ville qui ne sont pas dans la moyenne de la répartition raciale ? 
     185 
     186Pour répondre à cette question, nous ajouterons une nouvelle jointure à notre requête, de telle maniÚre que nous puissions calculer simultanément la répartition raciale de plusieures lignes de métros à la fois. Pour faire ceci, nous créerons une table qui permettra d'énumérer toutes les lignes que nous voulons regrouper. 
    187187 
    188188.. code-block:: sql 
    … …  
    195195      ('7'); 
    196196 
    197 Now we can join the table of subway lines onto our original query. 
     197Maintenant nous pouvons joindre les tables des lignes de métros à notre requête précédente. 
    198198 
    199199.. code-block:: sql 
    … …  
    239239 
    240240 
    241 As before, the joins create a virtual table of all the possible combinations available within the constraints of the ``JOIN ON`` restrictions, and those rows are then fed into a ``GROUP`` summary. The spatial magic is in the ``ST_DWithin`` function, that ensures only census blocks close to the appropriate subway stations are included in the calculation. 
    242  
    243 Function List 
    244 ------------- 
    245  
    246 `ST_Contains(geometry A, geometry B) <http://postgis.org/docs/ST_Contains.html>`_: Returns true if and only if no points of B lie in the exterior of A, and at least one point of the interior of B lies in the interior of A. 
    247  
    248 `ST_DWithin(geometry A, geometry B, radius) <http://postgis.org/docs/ST_DWithin.html>`_: Returns true if the geometries are within the specified distance of one another.  
    249  
    250 `ST_Intersects(geometry A, geometry B) <http://postgis.org/docs/ST_Intersects.html>`_: Returns TRUE if the Geometries/Geography "spatially intersect" - (share any portion of space) and FALSE if they don't (they are Disjoint).  
    251  
    252 `round(v numeric, s integer) <http://www.postgresql.org/docs/7.4/interactive/functions-math.html>`_: PostgreSQL math function that rounds to s decimal places 
    253  
    254 `strpos(string, substring) <http://www.postgresql.org/docs/current/static/functions-string.html>`_: PostgreSQL string function that returns an integer location of a specified substring. 
    255  
    256 `sum(expression) <http://www.postgresql.org/docs/8.2/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE>`_: PostgreSQL aggregate function that returns the sum of records in a set of records. 
     241Comme précédemment, les jointure créent une table virtuelle de toutes les combinaisons possible disponibles à l'aide des contraintes de type ``JOIN ON`, ces lignes sont ensuite utilisées dans le regroupement ``GROUP``. La magie spatiale tiend dans l'utilisation de la fonction ``ST_DWithin`` qui s'assure que les bloques sont suffisamment proches des lignes de métros inclues dans le calcul. 
     242 
     243Liste de fonctions 
     244------------------ 
     245 
     246`ST_Contains(geometry A, geometry B) <http://postgis.org/docs/ST_Contains.html>`_: retourne TRUE si et seulement si aucun points de B est à l'extérieur de A, et si au moins un point à l'intérieur de B  est à l'intérieur de A. 
     247 
     248`ST_DWithin(geometry A, geometry B, radius) <http://postgis.org/docs/ST_DWithin.html>`_: retourne TRUE si les géométries sont distantes du rayon donné.  
     249 
     250`ST_Intersects(geometry A, geometry B) <http://postgis.org/docs/ST_Intersects.html>`_: retourne TRUE si les géométries/géographies "s'intersectent spatialement" (partage une portiond de l'espace) et FALSE sinon (elles sont dijointes).  
     251 
     252`round(v numeric, s integer) <http://www.postgresql.org/docs/7.4/interactive/functions-math.html>`_: fonction de PostgreSQL qui arrondit à s décimales. 
     253 
     254`strpos(chaîne, sous-chaîne) <http://www.postgresql.org/docs/current/static/functions-string.html>`_: fonction de chaîne de caractÚres de PostgreSQL qui retourne la position de la sous-chaine. 
     255 
     256`sum(expression) <http://www.postgresql.org/docs/8.2/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE>`_: fonction d'agrégation de PostgreSQL qui retourne la somme d'un ensemble de valeurs. 
    257257 
    258258.. rubric:: Footnotes 

  • /trunk/workshop-foss4g/joins_exercises.rst

    r20 r30  
    11.. _joins_exercises: 
    22 
    3 Section 13: Spatial Joins Exercises 
    4 =================================== 
     3Partie 13 : exercice jointures spatial 
     4======================================= 
    55 
    6 Here's a reminder of some of the functions we have seen.  Hint: they should be useful for the exercises! 
     6Voici un petit rappel de certaines des fonctions vues précédemment. Astuce: elles pourraient être utiles pour les exercices ! 
    77 
    8 * :command:`sum(expression)`: aggregate to return a sum for a set of records 
    9 * :command:`count(expression)`: aggregate to return the size of a set of records 
     8 * :command:`sum(expression)` agrégation retournant la somme d'un ensemble 
     9 * :command:`count(expression)` agrégation retournant le nombre d'éléments d'un ensemble 
    1010* :command:`ST_Area(geometry)` returns the area of the polygons 
    1111* :command:`ST_AsText(geometry)` returns WKT ``text`` 
    12 * :command:`ST_Contains(geometry A, geometry B)` returns the true if geometry A contains geometry B  
    13 * :command:`ST_Distance(geometry A, geometry B)` returns the minimum distance between geometry A and geometry B 
    14 * :command:`ST_DWithin(geometry A, geometry B, radius)` returns the true if geometry A is radius distance or less from geometry B 
     12* :command:`ST_Contains(geometry A, geometry B)` retourne vrai si la géométrie A contient la géométrie B  
     13* :command:`ST_Distance(geometry A, geometry B)` retourne la distance minimum entre deux géométries 
     14* :command:`ST_DWithin(geometry A, geometry B, radius)` retourne vrai si la A est distante d'au plus radius de B 
    1515* :command:`ST_GeomFromText(text)` returns ``geometry`` 
    1616* :command:`ST_Intersects(geometry A, geometry B)` returns the true if geometry A intersects geometry B 
    1717* :command:`ST_Length(linestring)` returns the length of the linestring 
    18 * :command:`ST_Touches(geometry A, geometry B)` returns the true if the boundary of geometry A touches geometry B 
    19 * :command:`ST_Within(geometry A, geometry B)` returns the true if geometry A is within geometry B 
    20   
    21 Also remember the tables we have available: 
     18* :command:`ST_Touches(geometry A, geometry B)` retourne vrai si le contour extérieur de A touche B 
     19* :command:`ST_Within(geometry A, geometry B)` retourne vrai si A est hors de B 
     20 
     21Souvenez-vous des tables à notre disposition :  
    2222 
    2323 * ``nyc_census_blocks``  
    … …  
    3737   * name, boroname, the_geom 
    3838 
    39 Exercises 
     39Exercices 
    4040--------- 
    4141 
    42  * **"What subway station is in 'Little Italy'? What subway route is it on?"** 
     42 * **"Quelle station de métros se situe dans le quartier 'Little Italy' ? Quelle est l'itinéraire de métros à emprunter ?"** 
    4343  
    4444   .. code-block:: sql 
    … …  
    5656     Spring St | 6 
    5757      
    58  * **"What are all the neighborhoods served by the 6-train?"** (Hint: The ``routes`` column in the ``nyc_subway_stations`` table has values like 'B,D,6,V' and 'C,6') 
     58 * **"Quels sont les quartiers desservis pas le train numéro 6 ?"** (Astuce: la colonnes ``routes`` de la table ``nyc_subway_stations`` on les valeurs suivante 'B,D,6,V' et 'C,6') 
    5959  
    6060   .. code-block:: sql 
    … …  
    8888   .. note:: 
    8989   
    90      We used the ``DISTINCT`` keyword to remove duplicate values from our result set where there were more than one subway station in a neighborhood. 
    91      
    92  * **"After 9/11, the 'Battery Park' neighborhood was off limits for several days. How many people had to be evacuated?"** 
     90     Nous avons utilisé le mot clef ``DISTINCT`` pour supprimer les répétitions dans notre ensemble derésultats où il y avait plus d'une seule station de métros dans le quartier.     
     91 * **"AprÚs le 11 septembre, le quartier de 'Battery Park' était interdit d'accÚs pendant plusieurs jours. Combien de personnes ont dût être évacués ?"** 
    9392  
    9493   .. code-block:: sql 
    … …  
    104103     9928 
    105104     
    106  * **"What are the population density (people / km^2) of the 'Upper West Side' and 'Upper East Side'?"** (Hint: There are 1000000 m^2 in one km^2.) 
     105 * **"Quelle est la densité de population (personne / km^2) des quartier de 'Upper West Side' et de 'Upper East Side' ?"** (Astuce: il y a 1000000 m^2 dans un km^2.) 
    107106  
    108107   .. code-block:: sql 
Note: See TracChangeset for help on using the changeset viewer.