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 / [30:20]


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

Legend:

Unmodified
Added
Removed

  • /trunk/workshop-foss4g/projection.rst

    r30 r20  
    11.. _projection: 
    22 
    3 Partie 15 : Projections des données 
    4 =================================== 
     3Section 15: Projecting Data 
     4=========================== 
    55 
    6 La 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. 
     6The 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. 
    77 
    8 Nous 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)`. 
     8We'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. 
    99 
    10 Nous pouvons vérifier le SRID de nos données avec la commande :command:`ST_SRID` : 
     10We can confirm the SRID of our data with the :command:`ST_SRID` command: 
    1111 
    1212.. code-block:: sql 
    … …  
    1818  26918 
    1919   
    20 Et 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  
     20And 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 
    2122.. code-block:: sql 
    2223 
    2324   SELECT * FROM spatial_ref_sys WHERE srid = 26918; 
    2425    
    25 En 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 : 
     26In 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: 
    2627 
    2728.. code-block:: sql 
    … …  
    3334  +proj=utm +zone=18 +ellps=GRS80 +datum=NAD83 +units=m +no_defs  
    3435   
    35 En 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. 
     36In 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. 
    3637 
    37 Comparaison de données 
    38 ---------------------- 
     38Comparing Data 
     39-------------- 
    3940 
    40 Combiné, 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. 
     41Taken 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. 
    4142 
    42 Si vous utilisé des géométries avec différents SRID vous obtiendrez une erreur du genre : 
     43If you feed in geometries with differing SRIDs you will just get an error: 
    4344 
    4445.. code-block:: sql 
    … …  
    5758.. note:: 
    5859 
    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. 
     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. 
    6061 
    6162 
    62 Transformer les données 
    63 ----------------------- 
     63Transforming Data 
     64----------------- 
    6465 
    65 Si 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. 
     66If 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. 
    6667 
    6768:: 
    … …  
    6970   +proj=utm +zone=18 +ellps=GRS80 +datum=NAD83 +units=m +no_defs  
    7071 
    71 Essayons 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". 
     72Let's convert some data from our working projection to geographic coordinates -- also known as "longitude/latitude".  
    7273 
    73 Pour 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 ? 
     74To 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? 
    7475 
    75 Le 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. 
     76The 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: 
    7677 
    7778  http://spatialreference.org/ref/epsg/4326/ 
    7879   
    79 Vous pouvez aussi récupérer les définitions dans la table  ``spatial_ref_sys`` : 
     80You can also pull the definitions from the ``spatial_ref_sys`` table: 
    8081 
    8182.. code-block:: sql 
    … …  
    9394    AUTHORITY["EPSG","4326"]] 
    9495 
    95 Essayons de convertir les cordonnées de la station 'Broad St' : 
     96Let's convert the coordinates of the 'Broad St' subway station into geographics: 
    9697 
    9798.. code-block:: sql 
    … …  
    105106  POINT(-74.0106714688735 40.7071048155841) 
    106107 
    107 Si 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. 
     108If 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. 
    108109 
    109 Pour visualiser la table d'assignation des SRID, interroger la table ``geometry_columns`` de la base de données. 
     110To view a table's SRID assignment, query the database's ``geometry_columns`` table. 
    110111 
    111112.. code-block:: sql 
    … …  
    125126 
    126127   
    127 Neanmoins, 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. 
     128However, 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. 
    128129 
    129130.. code-block:: sql 
    … …  
    136137   FROM geometries; 
    137138 
    138 Liste des fonctions 
    139 ------------------- 
     139Function 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. 
    140142 
    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. 
     143`ST_SetSRID(geometry, srid) <http://postgis.org/docs/ST_SetSRID.html>`_: Sets the SRID on a geometry to a particular integer value. 
    142144 
    143 `ST_SetSRID(geometry, srid) <http://postgis.org/docs/ST_SetSRID.html>`_: affecte une valeur au SRID d'une géométrie. 
     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. 
    144146 
    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. 
     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. 

  • /trunk/workshop-foss4g/validity.rst

    r30 r20  
    11.. _validity: 
    22 
    3 Partie 20 : Validité 
     3Section 20: Validity 
    44==================== 
    55 
    6 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 ? 
     6In 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? 
    77 
    8 Qu'est-ce que la validité 
    9 ------------------------- 
     8What is Validity 
     9---------------- 
    1010 
    11 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. 
     11Validity 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. 
    1212 
    13 Certaines des rÚgles de validation des polygones semble évidentes, et d'autre semblent arbitraires (et le sont vraiment). 
     13Some of the rules of polygon validity feel obvious, and others feel arbitrary (and in fact, are arbitrary). 
    1414 
    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. 
     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. 
    1919 
    20 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. 
     20The 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. 
    2121 
    22 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". 
     22The 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*. 
    2323 
    24 Voici un exemple de pourquoi cette structuration est importante. Ce polygon n'est pas valide : 
     24Here's an example of why structure matters. This polygon is invalid: 
    2525 
    2626:: 
    … …  
    2828  POLYGON((0 0, 0 1, 2 1, 2 2, 1 2, 1 0, 0 0)); 
    2929   
    30 Vous pouvez comprendre ce qui n'est pas valide en regardant cette figure : 
     30You can see the invalidity a little more clearly in this diagram: 
    3131 
    3232.. image:: ./validity/figure_eight.png 
    3333 
    34 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. 
     34The 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. 
    3535 
    36 Essayons maintenant de voir ce que pense la base de données de notre polygone : 
     36Let's see what the database thinks the area of our polygon is: 
    3737 
    3838.. code-block:: sql 
    … …  
    4646          0 
    4747 
    48 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". 
     48What'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. 
    4949 
    5050 
    51 Détecté la validité 
    52 ------------------- 
     51Detecting Validity 
     52------------------ 
    5353 
    54 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 : 
     54In 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: 
    5555 
    5656.. code-block:: sql 
    … …  
    6262  f 
    6363 
    64 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é : 
     64Now 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: 
    6565 
    6666.. code-block:: sql 
    … …  
    7272  Self-intersection[1 1] 
    7373 
    74 Vous remarquerez qu'en plus de la raison (intersection) la localisation de la non validité (coordonnée (1 1)) est aussi renvoyée. 
     74Note that in addition to the reason (self-intersection) the location of the invalidity (coordinate (1 1)) is also returned. 
    7575 
    76 Nous pouvons aussi utiiliser la fonction :command:`ST_IsValid(geometry)` pour tester nos tables :  
     76We can use the :command:`ST_IsValid(geometry)` function to test our tables too: 
    7777 
    7878.. code-block:: sql 
    7979 
    80   -- Trouver tout les polygones non valides et leur problÚme  
     80  -- Find all the invalid polygons and what their problem is 
    8181  SELECT name, boroname, ST_IsValidReason(the_geom) 
    8282  FROM nyc_neighborhoods 
    … …  
    9494 
    9595 
    96 Réparer les invalides 
    97 --------------------- 
     96Repairing Invalidity 
     97-------------------- 
    9898 
    99 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. 
     99First 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. 
    100100 
    101 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. 
     101Here'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. 
    102102 
    103103.. code-block:: sql 
    104104 
    105   -- Table à part des géométries non-valide 
     105  -- Side table of invalids 
    106106  CREATE TABLE nyc_neighborhoods_invalid AS 
    107107  SELECT * FROM nyc_neighborhoods 
    108108  WHERE NOT ST_IsValid(the_geom); 
    109109   
    110   -- Suppression de la table principale 
     110  -- Remove them from the main table 
    111111  DELETE FROM nyc_neighborhoods 
    112112  WHERE NOT ST_IsValid(the_geom); 
    113113   
    114 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**. 
     114A good tool for visually repairing invalid geometry is OpenJump (http://openjump.org) which includes a validation routine under **Tools->QA->Validate Selected Layers**. 
    115115 
    116 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`. 
     116Now the good news: a large proportion of invalidities **can be fixed inside the database** using the :command:`ST_Buffer` function. 
    117117 
    118 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. 
     118The 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. 
    119119 
    120 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. 
     120For 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. 
    121121 
    122122::  
    … …  
    126126.. image:: ./validity/banana.png 
    127127 
    128 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. 
     128Running 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. 
    129129 
    130130.. code-block:: sql 
    … …  
    143143.. note:: 
    144144 
    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. 
     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.  
    146146   

  • /trunk/workshop-foss4g/projection_exercises.rst

    r30 r20  
    11.. _projection_exercises: 
    22 
    3 Partie 16 : Exercices de projection 
    4 =================================== 
     3Section 16: Projection Exercises 
     4================================ 
    55 
    6 Voici 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``) 
     6Here's a reminder of some of the functions we have seen.  Hint: they should be useful for the exercises! 
    157 
    16 Rappelez-vous les resssources en ligne : 
     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 
     16Remember the online resources that are available to you: 
    1717 
    1818* http://spatialreference.org 
    1919* http://prj2epsg.org 
    2020 
    21 Et les tables qui sont disponibles : 
     21Also remember the tables we have available: 
    2222 
    2323 * ``nyc_census_blocks``  
    … …  
    3737   * name, boroname, the_geom 
    3838 
    39 Exercices 
     39Exercises 
    4040--------- 
    4141 
    42  * **"Quelle est la longueur des rue de New York, mesurée en UTM 18 ?"** 
     42 * **"What is the length of all streets in New York, as measured in UTM 18?"** 
    4343  
    4444   .. code-block:: sql 
    … …  
    5151     10418904.7172 
    5252       
    53  * **"Quelle est la définition du SRID 2831 ?"**    
     53 * **"What is the WKT definition of SRID 2831?"**    
    5454     
    5555   .. code-block:: sql 
    … …  
    5858     WHERE SRID = 2831; 
    5959 
    60 Ou, via `prj2epsg <http://prj2epsg.org/epsg/2831>`_ 
     60Or, via `prj2epsg <http://prj2epsg.org/epsg/2831>`_ 
    6161 
    6262 :: 
    … …  
    8787   
    8888 
    89  * **"Quelle est la longueur des rue de New York, mesuré en utilisant le SRID 2831 ?"** 
     89 * **"What is the length of all streets in New York, as measured in SRID 2831?"** 
    9090  
    9191   .. code-block:: sql 
    … …  
    100100   .. note:: 
    101101    
    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. 
     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. 
    103103      
    104  * **"Quelle est la représentation KML du point de la station de métris 'Broad St' ?"** 
     104 * **"What is the KML representation of the point at 'Broad St' subway station?"** 
    105105  
    106106   .. code-block:: sql 
    … …  
    114114     <Point><coordinates>-74.010671468873468,40.707104815584088</coordinates></Point> 
    115115      
    116 Hé ! 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. 
     116Hey! 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. 

  • /trunk/workshop-foss4g/spatial_relationships.rst

    r30 r20  
    11.. _spatial_relationships: 
    22 
    3 Partie 10 : relations spatiales 
     3Section 10: Spatial Relationships 
    44================================= 
    55 
    6 Jusqu'à 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. 
     6So 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. 
    77 
    8 Les 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*. 
     8Spatial databases are powerful because they not only store geometry, they also have the ability to compare *relationships between geometries*.  
    99 
    10 Pour 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. 
     10Questions 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. 
    1111 
    12 Le standard de l'OGC définit l'ensemble suivant de fonctions pour comparer les géométries. 
     12The OGC standard defines the following set of methods to compare geometries. 
    1313 
    1414ST_Equals 
    1515--------- 
    1616  
    17 :command:`ST_Equals(geometry A, geometry B)` test l'égalité spatiale de deux géométries.  
     17:command:`ST_Equals(geometry A, geometry B)` tests the spatial equality of two geometries.  
    1818 
    1919.. figure:: ./spatial_relationships/st_equals.png 
    2020   :align: center 
    2121 
    22 ST_Equals retourne TRUE si les deux géométries sont du même type, ont des coordonnées x.y identiques. 
     22ST_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. 
    2323 
    24 PremiÚ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'. 
     24First, let's retrieve a representation of a point from our ``nyc_subway_stations`` table. We'll take just the entry for 'Broad St'. 
    2525 
    2626.. code-block:: sql 
    … …  
    3636   Broad St | 0101000020266900000EEBD4CF27CF2141BC17D69516315141 | POINT(583571 4506714) 
    3737  
    38 Maintenant, copiez / collez la valeur afficher pour tester la fonction :command:`ST_Equals`: 
     38Then, plug the geometry representation back into an :command:`ST_Equals` test: 
    3939 
    4040.. code-block:: sql 
    … …  
    5050.. note:: 
    5151 
    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. 
     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. 
    5353 
    5454 
    55 ST_Intersects, ST_Disjoint, ST_Crosses et ST_Overlaps 
     55ST_Intersects, ST_Disjoint, ST_Crosses and ST_Overlaps 
    5656------------------------------------------------------ 
    5757 
    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. 
     58:command:`ST_Intersects`, :command:`ST_Crosses`, and :command:`ST_Overlaps` test whether the interiors of the geometries intersect.  
    5959 
    6060.. figure:: ./spatial_relationships/st_intersects.png 
    6161   :align: center 
    6262 
    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. 
     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. 
    6464 
    6565.. figure:: ./spatial_relationships/st_disjoint.png 
    6666   :align: center 
    6767 
    68 L'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. 
     68The 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. 
    6969 
    7070.. figure:: ./spatial_relationships/st_crosses.png   
    7171   :align: center 
    72  
    73 Pour 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  
    7472 
    7573For 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. 
    … …  
    7876   :align: center 
    7977 
    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. 
     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. 
    8179 
    82 Essayons de prendre la station de métro de Broad Street et de déterminer sont voisinage en utilisant la fonction :command:`ST_Intersects` : 
     80Let's take our Broad Street subway station and determine its neighborhood using the :command:`ST_Intersects` function: 
    8381 
    8482.. code-block:: sql 
    … …  
    9997---------- 
    10098 
    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 
     99:command:`ST_Touches` tests whether two geometries touch at their boundaries, but do not intersect in their interiors  
    102100 
    103101.. figure:: ./spatial_relationships/st_touches.png 
    104102   :align: center 
    105103 
    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. 
     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. 
    107105 
    108 ST_Within et ST_Contains 
     106ST_Within and ST_Contains 
    109107------------------------- 
    110108 
    111 :command:`ST_Within` et :command:`ST_Contains` test si une géométrie est totalement incluse dans l'autre.  
     109:command:`ST_Within` and :command:`ST_Contains` test whether one geometry is fully within the other.  
    112110 
    113111.. figure:: ./spatial_relationships/st_within.png 
    114112   :align: center 
    115113     
    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.   
     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.   
    117115 
    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. 
     116:command:`ST_Contains(geometry A, geometry B)` returns TRUE if the second geometry is completely contained by the first geometry.  
    119117 
    120118 
    121 ST_Distance et ST_DWithin 
     119ST_Distance and ST_DWithin 
    122120-------------------------- 
    123121 
    124 Une 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". 
     122An extremely common GIS question is "find all the stuff within distance X of this other stuff".  
    125123 
    126 La 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. 
     124The :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. 
    127125 
    128126.. code-block:: sql 
    … …  
    136134  3 
    137135 
    138 Pour 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. 
     136For 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. 
    139137 
    140138  .. figure:: ./spatial_relationships/st_dwithin.png 
    141139     :align: center 
    142140     
    143 En utilisant de nouveau notre station de métros Broad Street, nous pouvons trouver les rues voisines (à 10 mÚtres de) de la station : 
     141Using our Broad Street subway station again, we can find the streets nearby (within 10 meters of) the subway stop: 
    144142 
    145143.. code-block:: sql 
    … …  
    161159     Nassau St 
    162160 
    163 Nous pouvons vérifier la réponse sur une carte. La station Broad St est actuellement à l'intersection des rues Wall, Broad et Nassau.  
     161And we can verify the answer on a map. The Broad St station is actually at the intersection of Wall, Broad and Nassau Streets. 
    164162 
    165163.. image:: ./spatial_relationships/broad_st.jpg 
    166164 
    167 Liste des fonctions 
    168 ------------------- 
     165Function List 
     166------------- 
    169167 
    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. 
     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. 
    171169 
    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. 
     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. 
    173171 
    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. 
     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. 
    175173 
    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.  
     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.  
    177175 
    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.  
     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.  
    179177 
    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. 
     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. 
    181179 
    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).  
     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).  
    183181 
    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. 
     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. 
    185183 
    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. 
     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. 
    187185 
    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 
     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 
    189187 
    190188 

  • /trunk/workshop-foss4g/spatial_relationships_exercises.rst

    r30 r20  
    11.. _spatial_relationships_exercises: 
    22 
    3 Partie 11 : exercises sur les relations spatiales 
     3Section 11: Spatial Relationships Exercises 
    44=========================================== 
    55 
    6 Voici un rappel des fonctions que nous avons vu dans les parties précédentes. Elles seront utiles pour les exercices ! 
     6Here's a reminder of the functions we saw in the last section. They should be useful for the exercises! 
    77 
    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 
     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 
    2020 
    21 Souvenez-vous les tables à notre disposition : 
     21Also remember the tables we have available: 
    2222 
    2323 * ``nyc_census_blocks``  
    … …  
    3737   * name, boroname, the_geom 
    3838 
    39 Exercices 
     39Exercises 
    4040--------- 
    4141 
    42  * **"Quel est la valeur géométrique de la rue nommée  'Atlantic Commons' ?"** 
     42 * **"What is the geometry value for the street named 'Atlantic Commons'?"** 
    4343  
    4444   .. code-block:: sql 
    … …  
    5252     01050000202669000001000000010200000002000000093235673BE82141F319CD89A22E514170E30E0ADFE82141CB2D3EFFA52E5141 
    5353      
    54  * **"Quel sont les quartiers et villes sont dans Atlantic Commons ?"** 
     54 * **"What neighborhood and borough is Atlantic Commons in?"** 
    5555      
    5656   .. code-block:: sql 
    … …  
    7070      
    7171 
    72  * **"Quelles rues touchent Atlantic Commons ?"**  
     72 * **"What streets does Atlantic Commons touch?"**  
    7373  
    7474   .. code-block:: sql 
    … …  
    9191   
    9292 
    93  * **"Approximativement combien de personnes vivent dans (ou à un dans une zone de 50 meters autour) Atlantic Commons ?"** 
     93 * **"Approximately how many people live on (within 50 meters of) Atlantic Commons?"** 
    9494  
    9595   .. code-block:: sql 

  • /trunk/workshop-foss4g/geometries_exercises.rst

    r30 r20  
    11.. _geometries_exercises: 
    22 
    3 Partie 9 : exercices sur les géométries 
    4 ====================================== 
    5  
    6 Voici 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  
    39 Souvenez-vous aussi des tables qui sont disponibles: 
     3Section 9: Geometry Exercises 
     4============================= 
     5 
     6Here'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 
     39Also remember the tables we have available: 
    4040 
    4141 * ``nyc_census_blocks``  
    … …  
    7272   .. note:: 
    7373 
    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``.) 
     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.) 
    7777  
    7878   .. code-block:: sql 
    … …  
    9999 
    100100 
    101  * **"Combien de bloques de la ville de New York ont des trous ?"** 
     101 * **"How many census blocks in New York City have a hole in them?"** 
    102102  
    103103   .. code-block:: sql 
    … …  
    111111     66  
    112112    
    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.) 
     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.) 
    114114   
    115115    .. code-block:: sql 
    … …  
    122122     10418.9047172 
    123123 
    124  * **"Quelle est la longueur de 'Columbus Cir' (Columbus Circle) ?** 
     124 * **"How long is 'Columbus Cir' (Columbus Circle)?** 
    125125  
    126126     .. code-block:: sql 
    … …  
    134134       308.34199 
    135135 
    136  * **"Quelle est le contour de 'West Village' au format JSON ?"** 
     136 * **"What is the JSON representation of the boundary of the 'West Village'?"** 
    137137  
    138138   .. code-block:: sql 
    … …  
    149149          [583263.2776595836,4509242.6260239873]]]]} 
    150150 
    151 La géométrie de type "MultiPolygon", interressant ! 
     151The geometry type is "MultiPolygon", interesting! 
    152152    
    153153       
    154  * **"Combien de polygones sont dans le multi-polygone 'West Village' ?"** 
     154 * **"How many polygons are in the 'West Village' multipolygon?"** 
    155155  
    156156   .. code-block:: sql 
    … …  
    166166   .. note:: 
    167167    
    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 ?"** 
     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?"** 
    172172  
    173173   .. code-block:: sql 
    … …  
    207207   .. note:: 
    208208 
    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. 
     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. 
    210210 
    211211  

  • /trunk/workshop-foss4g/joins.rst

    r30 r20  
    11.. _joins: 
    22 
    3 Partie 12 : les jointures spatiales 
    4 =================================== 
    5  
    6 Les 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  
    8 Dans 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  
    10 En 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 :  
     3Section 12: Spatial Joins 
     4========================= 
     5 
     6Spatial 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 
     8In 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 
     10Using a spatial join, we can answer the question in one step, retrieving information about the subway station and the neighborhood that contains it: 
    1111 
    1212.. code-block:: sql 
    … …  
    2727   Broad St    | Financial District | Manhattan 
    2828 
    29 Nous 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  
    31 Jointure et regroupement 
    32 ------------------------ 
    33  
    34 La combinaison de ``JOIN`` avec ``GROUP BY`` fournit le type d'analyse qui est courramment utilisé dans les systÚmes SIG. 
    35  
    36 Par 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. 
     29We 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 
     31Join and Summarize 
     32------------------ 
     33 
     34The combination of a ``JOIN`` with a ``GROUP BY`` provides the kind of analysis that is usually done in a GIS system. 
     35 
     36For 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. 
    3737 
    3838.. code-block:: sql 
    … …  
    8484 
    8585 
    86 Que 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. 
     86What'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. 
    9292 
    9393.. note::  
    9494 
    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  
    97 Nous 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  
    99 PremiÚrement, essayons d'obtenir la répartition raciale de la ville. 
     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 
     97We 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 
     99First, let's get the baseline racial make-up of the city. 
    100100 
    101101.. code-block:: sql 
    … …  
    114114 
    115115 
    116 Donc, 8M de personnes de New York, environ 44% sont "blancs" et "26% sont "noirs". 
    117  
    118 Duke 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  
    120 PremiÚ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. 
     116So, of the 8M people in New York, about 44% are "white" and 26% are "black".  
     117 
     118Duke 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 
     120First, 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. 
    121121 
    122122.. code-block:: sql 
    … …  
    136136.. note:: 
    137137 
    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. 
     138   The ``DISTINCT`` keyword eliminates duplicate rows from the result.  Without the ``DISTINCT`` keyword, the query above identifies 491 results instead of 73. 
    139139    
    140 Donc 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. 
     140So 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. 
    141141 
    142142.. code-block:: sql 
    … …  
    158158  A,C,E 
    159159   
    160 Essayons de regrouper la répartition racialedans un rayon de 200 mÚtres de la ligne du train A. 
     160Let's summarize the racial make-up of within 200 meters of the A-train line. 
    161161 
    162162.. code-block:: sql 
    … …  
    177177   42.0805466940877366 | 23.0936148851067964 |     185259 
    178178 
    179 La 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  
    181 Jointres avancées 
    182 ----------------- 
    183  
    184 Dans 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  
    186 Pour 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. 
     179So the racial make-up along the A-train isn't radically different from the make-up of New York City as a whole.  
     180 
     181Advanced Join 
     182------------- 
     183 
     184In 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 
     186To 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. 
    187187 
    188188.. code-block:: sql 
    … …  
    195195      ('7'); 
    196196 
    197 Maintenant nous pouvons joindre les tables des lignes de métros à notre requête précédente. 
     197Now we can join the table of subway lines onto our original query. 
    198198 
    199199.. code-block:: sql 
    … …  
    239239 
    240240 
    241 Comme 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  
    243 Liste 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. 
     241As 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 
     243Function 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. 
    257257 
    258258.. rubric:: Footnotes 

  • /trunk/workshop-foss4g/joins_exercises.rst

    r30 r20  
    11.. _joins_exercises: 
    22 
    3 Partie 13 : exercice jointures spatial 
    4 ======================================= 
     3Section 13: Spatial Joins Exercises 
     4=================================== 
    55 
    6 Voici un petit rappel de certaines des fonctions vues précédemment. Astuce: elles pourraient être utiles pour les exercices ! 
     6Here's a reminder of some of the functions we have seen.  Hint: they should be useful for the exercises! 
    77 
    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 
     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 
    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)` 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 
     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 
    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)` 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  
    21 Souvenez-vous des tables à notre disposition :  
     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  
     21Also remember the tables we have available: 
    2222 
    2323 * ``nyc_census_blocks``  
    … …  
    3737   * name, boroname, the_geom 
    3838 
    39 Exercices 
     39Exercises 
    4040--------- 
    4141 
    42  * **"Quelle station de métros se situe dans le quartier 'Little Italy' ? Quelle est l'itinéraire de métros à emprunter ?"** 
     42 * **"What subway station is in 'Little Italy'? What subway route is it on?"** 
    4343  
    4444   .. code-block:: sql 
    … …  
    5656     Spring St | 6 
    5757      
    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') 
     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') 
    5959  
    6060   .. code-block:: sql 
    … …  
    8888   .. note:: 
    8989   
    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 ?"** 
     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?"** 
    9293  
    9394   .. code-block:: sql 
    … …  
    103104     9928 
    104105     
    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.) 
     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.) 
    106107  
    107108   .. code-block:: sql 
Note: See TracChangeset for help on using the changeset viewer.