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.

Changeset 62 for trunk/workshop-foss4g


Ignore:
Timestamp:
17/03/2012 00:49:40 (13 years ago)
Author:
thomasg
Message:

Fin correction typo et orthographe V2 du document

Location:
trunk/workshop-foss4g
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/workshop-foss4g/about_data.rst

    r45 r62  
    44================================== 
    55 
    6 Les données utilisées dans ces travaux pratiques sont quatre shapefiles de la ville de New York, et une table attributaire des variables socio-démographiques de la ville. Nous les avons charger sous forme de tables PostGIS et nous ajouterons les données  socio-démographiques plus tard. 
     6Les données utilisées dans ces travaux pratiques sont quatre shapefiles de la ville de New York, et une table attributaire des variables socio-démographiques de la ville. Nous les avons chargés sous forme de tables PostGIS et nous ajouterons les données  socio-démographiques plus tard. 
    77 
    88Cette partie fournit le nombre d'enregistrements et les attributs de chacun de nos ensembles de données. Ces valeurs attributaires et les relations sont essentielles pour nos futures analyses. 
    … …  
    1313----------------- 
    1414 
    15 Un bloc ressencé est la plus petite entité géographique pour laquelle un ressencement est raporté. Toutes les couches représentant les niveaux suppérieurs (régions, zones de métro, comtés) peuvent être contruites à partir de ces blocs. Nous avons attaché des données démographiques aux blocs. 
     15Un bloc recensé est la plus petite entité géographique pour laquelle un recensement est rapporté. Toutes les couches représentant les niveaux supérieurs (régions, zones de métro, comtés) peuvent être contruites à partir de ces blocs. Nous avons attaché des données démographiques aux blocs. 
    1616 
    1717Nombre d'enregistrements : 36592 
    1818 
    1919.. list-table:: 
    20    :widths: 20 80  
     20   :widths: 20 80 
    2121 
    2222   * - **blkid** 
    … …  
    2929     - Nombre de personnes se déclarant comme de couleur noire 
    3030   * - **popn_nativ** 
    31      - Nombre de personnes se déclarant comme natif d'amérique du nord 
     31     - Nombre de personnes se déclarant comme natif d'Amérique du nord 
    3232   * - **popn_asian** 
    3333     - Nombre de personnes se déclarant comme asiatique 
    … …  
    4646 
    4747.. figure:: ./screenshots/nyc_census_blocks.png 
    48     
    49    *Pourcentage de la population qui est de couleur noire*  
    5048 
    51 .. note::  
     49   *Pourcentage de la population qui est de couleur noire* 
    5250 
    53     Pour disposer des données d'un recensement dans votre SIG, vous avez besoin de joindre deux informations: Les données socio-démographiques et les limites géographiques des blocs/quartiers. Il existe plusieurs moyen de se les procurer, dans notre cas elles ont été récupérées sur le site Internet du Census Bureau's `American FactFinder <http://factfinder.census.gov>`_.  
    54      
     51.. note:: 
     52 
     53    Pour disposer des données d'un recensement dans votre SIG, vous avez besoin de joindre deux informations: Les données socio-démographiques et les limites géographiques des blocs/quartiers. Il existe plusieurs moyen de se les procurer, dans notre cas, elles ont été récupérées sur le site Internet du Census Bureau's `American FactFinder <http://factfinder.census.gov>`_. 
     54 
    5555nyc_neighborhoods 
    5656----------------- 
    5757 
    58 Les quartiers de New York  
     58Les quartiers de New York 
    5959 
    6060Nombre d'enregistrements: 129 
    6161 
    6262.. list-table:: 
    63    :widths: 20 80  
     63   :widths: 20 80 
    6464 
    6565   * - **name** 
    6666     - Nom du quartier 
    6767   * - **boroname** 
    68      - Name de la section dans New York (Manhattan, The Bronx, Brooklyn, Staten Island, Queens) 
     68     - Nom de la section dans New York (Manhattan, The Bronx, Brooklyn, Staten Island, Queens) 
    6969   * - **the_geom** 
    7070     - Limite polygonale du quartier 
    71     
     71 
    7272.. figure:: ./screenshots/nyc_neighborhoods.png 
    7373 
    74     *Les quartiers de New York*  
     74    *Les quartiers de New York* 
    7575 
    7676nyc_streets 
    … …  
    8282 
    8383.. list-table:: 
    84    :widths: 20 80  
     84   :widths: 20 80 
    8585 
    8686   * - **name** 
    … …  
    9292   * - **the_geom** 
    9393     - Ligne du centre de la rue. 
    94     
     94 
    9595.. figure:: ./screenshots/nyc_streets.png 
    9696 
    9797     *Les rues de New York (les rues principales apparaissent en rouge)* 
    9898 
    99     
     99 
    100100nyc_subway_stations 
    101101------------------- 
    … …  
    132132.. note:: 
    133133 
    134    La donnée ``nyc_census_sociodata`` est une table attributaire. Nous devrons nous connecter aux géométries correspondant à la zone du recenssement avant de conduire toute analyse spatiale . 
    135     
     134   La donnée ``nyc_census_sociodata`` est une table attributaire. Nous devrons nous connecter aux géométries correspondant à la zone du recensement avant de conduire toute analyse spatiale . 
     135 
    136136.. list-table:: 
    137137   :widths: 20 80 
    138138 
    139139   * - **tractid** 
    140      - Un code à 11 chiffre qui identifie chaque secteur de recessement. **tract**. Eg: 36005000100 
     140     - Un code à 11 chiffre qui identifie chaque secteur de recensement. **tract**. Eg: 36005000100 
    141141   * - **transit_total** 
    142142     - Nombre de travailleurs dans le secteur 
    … …  
    146146     - Nombre de travailleurs dans le secteur utilisant un véhicule privé 
    147147   * - **transit_other** 
    148      - Nombre de travailleurs dans le secteur utilisant un autre moyen de transport  
     148     - Nombre de travailleurs dans le secteur utilisant un autre moyen de transport 
    149149   * - **transit_time_mins** 
    150150     - Nombre total de minutes passées dans les transports par l'ensemble des travailleurs du secteur (minutes) 
    … …  
    152152     - Nombre de familles dans le secteur 
    153153   * - **family_income_median** 
    154      - Revenu médiant par famille du secteur (dollars) 
     154     - Revenu médian par famille du secteur (dollars) 
    155155   * - **family_income_aggregate** 
    156156     -  Revenu total de toutes les familles du secteur (dollars) 
    … …  
    164164     - Nombre de personnes ayant un diplÃŽme de lycée 
    165165   * - **edu_graduate_dipl** 
    166      - Nombre de personnes ayant un diplÃŽme de collÚge  
     166     - Nombre de personnes ayant un diplÃŽme de collÚge 
    167167 

  • trunk/workshop-foss4g/equality.rst

    r52 r62  
    77-------- 
    88 
    9 ÃŠtre en mesure de déterminer si deux geométries sont égales peut être compliqué. PostGIS met à votre disposition différentes fonctions permettant de juger de l'égalité à différents niveaux, bien que pour des raison de simplicité nous nuos contenterons ici de la définition fournie plus bas. Pour illustrer ces fonctions, nous utiliseront les polygones suivants. 
     9Être en mesure de déterminer si deux geométries sont égales peut être compliqué. PostGIS met à votre disposition différentes fonctions permettant de juger de l'égalité à différents niveaux, bien que pour des raison de simplicité nous nous contenterons ici de la définition fournie plus bas. Pour illustrer ces fonctions, nous utiliserons les polygones suivants. 
    1010 
    1111.. image:: ./equality/polygon-table.png 
    … …  
    1616 
    1717  CREATE TABLE polygons (name varchar, poly geometry); 
    18    
    19   INSERT INTO polygons VALUES  
     18 
     19  INSERT INTO polygons VALUES 
    2020    ('Polygon 1', 'POLYGON((-1 1.732,1 1.732,2 0,1 -1.732, 
    2121        -1 -1.732,-2 0,-1 1.732))'), 
    … …  
    2727        2 0,1.5 -0.866,1 -1.732,0 -1.732,-1 -1.732,-1.5 -0.866, 
    2828        -2 0,-1.5 0.866,-1 1.732))'), 
    29     ('Polygon 5', 'POLYGON((-2 -1.732,2 -1.732,2 1.732,  
     29    ('Polygon 5', 'POLYGON((-2 -1.732,2 -1.732,2 1.732, 
    3030        -2 1.732,-2 -1.732))'); 
    31          
     31 
    3232   SELECT Populate_Geometry_Columns(); 
    3333 
    … …  
    3535 
    3636Exactement égaux 
    37 ^^^^^^^^^^^^^^^^^^ 
     37^^^^^^^^^^^^^^^^ 
    3838 
    39 L'égalité exacte est déterminée en comparant deux géométries, sommets par sommets, dans l'ordre, pour s'assurer que chacun est à une position identique. Les exemples suivant montrent comment cette méthode peut être limitée dans son éfficacité. 
     39L'égalité exacte est déterminée en comparant deux géométries, sommets par sommets, dans l'ordre, pour s'assurer que chacun est à une position identique. Les exemples suivant montrent comment cette méthode peut être limitée dans son efficacité. 
    4040 
    4141.. code-block:: sql 
    … …  
    4747.. image:: ./equality/start14.png 
    4848 
    49 Dans cette exemple, les polygones sont seulement égaux à eux-même, mais jamais avec un des autres polygones (dans notre exemple les polygones de 1 à 3). Dans le cas des polygones 1, 2 et 3, les sommets sont à des position identiques mais sont définies dans un ordre différent. Le polygone 4 a des sommets en double causant la non-égalité avec le polygone 1. 
     49Dans cette exemple, les polygones sont seulement égaux à eux-même, mais jamais avec un des autres polygones (dans notre exemple les polygones de 1 à 3). Dans le cas des polygones 1, 2 et 3, les sommets sont à des positions identiques mais sont définis dans un ordre différent. Le polygone 4 a des sommets en double causant la non-égalité avec le polygone 1. 
    5050 
    51 Spatiallement égaux 
    52 ^^^^^^^^^^^^^^^ 
     51Spatialement égaux 
     52^^^^^^^^^^^^^^^^^^ 
    5353 
    54 Comme nous l'avons précédemment, l'égalité exacte ne prend pas en compte la nature spatiale des géométries. Il y a une fonction, nommée :command:`ST_Equals`, permettant de tester l'égalité spatiale ou l'équivalent des géométries. 
     54Comme nous l'avons précédemment montré, l'égalité exacte ne prend pas en compte la nature spatiale des géométries. Il y a une fonction, nommée :command:`ST_Equals`, permettant de tester l'égalité spatiale ou l'équivalence des géométries. 
    5555 
    5656.. code-block:: sql 
    5757 
    58   SELECT a.name, b.name, CASE WHEN ST_Equals(a.poly, b.poly)  
     58  SELECT a.name, b.name, CASE WHEN ST_Equals(a.poly, b.poly) 
    5959      THEN 'Spatially Equal' ELSE 'Not Equal' end 
    6060    FROM polygons as a, polygons as b; 
    … …  
    6262.. image:: ./equality/start15.png 
    6363 
    64 Ces résultats sont plus proches de notre compréhension intuitive de l'égalité. Les polygones de 1 à 4 sont cosidérés comme égaux, puisque qu'elles recouvrent la même zone. Notez que ni la direction despolygones n'est considérée, le point de départ pour la définition du polygone, ni le nombre de points. Ce qui importe c'est que la zone géographique représentée est la même. 
     64Ces résultats sont plus proches de notre compréhension intuitive de l'égalité. Les polygones de 1 à 4 sont considérés comme égaux, puisque qu'ils recouvrent la même zone. Notez que ni la direction des polygones n'est considérée, ni le point de départ pour la définition du polygone, ni le nombre de points. Ce qui importe c'est que la zone géographique représentée soit la même. 
    6565 
    6666Égalité des étendues 
    6767^^^^^^^^^^^^^^^^^^^^^ 
    6868 
    69 L'égalité exacte nécessite, dans le pire des cas, de comparer chaqu'un  des sommets d'une géométrie pour déterminé l'égalité. Ceci peut être trÚs lent, et s'avérer innaproprié pour comparer un grand nombre de géométries. Pour permettre de rendre plus rapide ces comparaison, l'opération d'égalité des étendue est fournit :  :command:`=`. Cet opérateur utilise uniquement les étendues (cadre limite rectangulaire), assurant que les géométries occupent le même espace dans un repÚre cartésien en deux dimensions, mais ne représente pas nécessairement le même espace. 
     69L'égalité exacte nécessite, dans le pire des cas, de comparer chacun des sommets d'une géométrie pour déterminer l'égalité. Ceci peut être trÚs lent, et s'avérer innaproprié pour comparer un grand nombre de géométries. Pour permettre de rendre plus rapide ces comparaison, l'opération d'égalité des étendue est fournit :  :command:`=`. Cet opérateur utilise uniquement les étendues (cadre limite rectangulaire), assurant que les géométries occupent le même espace dans un repÚre cartésien en deux dimensions, mais ne représente pas nécessairement le même espace. 
    7070 
    7171.. code-block:: sql 
    7272 
    73   SELECT a.name, b.name, CASE WHEN a.poly = b.poly  
     73  SELECT a.name, b.name, CASE WHEN a.poly = b.poly 
    7474      THEN 'Equal Bounds' ELSE 'Non-equal Bounds' end 
    7575    FROM polygons as a, polygons as b; 
    … …  
    7777.. image:: ./equality/start17.png 
    7878 
    79 Comme vous pouvez le constater, toutes les géométries égales ont aussi une étendue égales. Malheureusement, le polygone 5 est aussi retourné comme étant égal avec ce test, puisqu'il partage la même étendue que les autres géométries. Mais alors, pourquoi est-ce utile ? Bien que cela soit traité en détail plus tard, la réponse courte est que cela permet l'utilisation d'indexation spatiales qui peuvent réduire drastiquement les ensembles de géométries à comparrer en utilisant des filtres utilisant cette égalité d'étendues. 
     79Comme vous pouvez le constater, toutes les géométries égales ont aussi une étendue égale. Malheureusement, le polygone 5 est aussi retourné comme étant égal avec ce test, puisqu'il partage la même étendue que les autres géométries. Mais alors, pourquoi est-ce utile ? Bien que cela soit traité en détail plus tard, la réponse courte est que cela permet l'utilisation d'indexations spatiales qui peuvent réduire drastiquement les ensembles de géométries à comparer en utilisant des filtres utilisant cette égalité d'étendue. 
    8080 

  • trunk/workshop-foss4g/geography.rst

    r53 r62  
    44===================================== 
    55 
    6 Il est trÚs fréquent de manipuler des données à coordonnées "géographiques" ou de "longitude/latitude".  
    7  
    8 Au contraire des coordonnées de type Mercator, UTM ou Stateplane, les coordonnées géographiques ne représentent pas une distance linéaire depuis une origine, tel que dans un plan. Elles décrivent la distance angulaire entre l'équateur et les pÃŽles. Dans les sytÚmes de coordonnées sphériques, un point est spécifié par son rayon (distance à l'origine), son angle de rotation par rapport au méridien plan, et son angle par rapport à l'axe pÃŽlaire.  
     6Il est trÚs fréquent de manipuler des données à coordonnées "géographiques" ou de "longitude/latitude". 
     7 
     8Au contraire des coordonnées de type Mercator, UTM ou Stateplane, les coordonnées géographiques ne représentent pas une distance linéaire depuis une origine, tel que dans un plan. Elles décrivent la distance angulaire entre l'équateur et les pÃŽles. Dans les sytÚmes de coordonnées sphériques, un point est spécifié par son rayon (distance à l'origine), son angle de rotation par rapport au méridien plan, et son angle par rapport à l'axe pÃŽlaire. 
    99 
    1010.. image:: ./geography/cartesian_spherical.jpg 
    1111 
    1212 
    13 Vous pouvez continuer à utiliser des coordonnées géographiques comme des coordonnées cartésiennes approximatives pour vos analyses spatiales. Par contre les mesures de distances, d'aires et de longueur seront éronées. Etant donné que les coordonnées spériques mesurent des angles, l'unité est le dégré. Par exemple, les résultats cartésien approximatifs de tests tels que 'intersects' et 'contains' peuvent s'avérer terriblement faux. Par ailleurs, plus une zone est située prÚs du pÃŽle ou de la ligne de date internationale, plus la distance entre les points est agrandie.   
    14   
     13Vous pouvez continuer à utiliser des coordonnées géographiques comme des coordonnées cartésiennes approximatives pour vos analyses spatiales. Par contre les mesures de distances, d'aires et de longueurs seront erronées. Etant donné que les coordonnées sphériques mesurent des angles, l'unité est le degré. Par exemple, les résultats cartésien approximatifs de tests tels que 'intersects' et 'contains' peuvent s'avérer terriblement faux. Par ailleurs, plus une zone est située prÚs du pÃŽle ou de la ligne de date internationale, plus la distance entre les points est agrandie. 
     14 
    1515 
    1616Voici par exemple les coordonnées des villes de Los Angeles et Paris. 
    … …  
    1818 * Los Angeles: ``POINT(-118.4079 33.9434)`` 
    1919 * Paris: ``POINT(2.3490 48.8533)`` 
    20   
    21 La requête suivante calcule la distance entre Los Angeles et Paris en utilisant le systÚme cartésien standard de PostGIS :command:`ST_Distance(geometry, geometry)`.  Notez que le SRID 4326 déclare un systÚme de références spatiales géographiques. 
     20 
     21La requête suivante calcule la distance entre Los Angeles et Paris en utilisant le systÚme cartésien standard de PostGIS :command:`ST_Distance(geometry, geometry)`.  Notez que le SRID 4326 déclare un systÚme de référence spatiale géographique. 
    2222 
    2323.. code-block:: sql 
    … …  
    3131 
    3232  121.898285970107 
    33    
    34 Aha! 121! Mais, que veut dire cela ?  
    35  
    36 L'unité pour SRID 4326 est le degré. Donc la réponse signifie 121 degrés. Sur une sphÚre, la taille d'un degré "au carré" est assez variable. Elle devient plsu petite au fur et à mesure que l'on s'éloigne de l'équateur. Pensez par exemple aux méridiens sur le globe qui se ressÚrent entre eux au niveau des pÃŽles. Donc une distance de 121 degrés ne veut rien dire ! 
    37  
    38 Pour calculer une distance ayant du sens, nous devons traiter les coordonnées géographiques non pas come des coordonnées cartésiennes approximatives, mais plutÃŽt comme de réelles coordonnées sphériques. Nous devons mesurer les distances entre les points comme de vrais chemins par dessus uen sphÚre, comme une portion d'un grand cercle. 
     33 
     34Aha! 121! Mais, que veut dire cela ? 
     35 
     36L'unité pour SRID 4326 est le degré. Donc la réponse signifie 121 degrés. Sur une sphÚre, la taille d'un degré "au carré" est assez variable. Elle devient plus petite au fur et à mesure que l'on s'éloigne de l'équateur. Pensez par exemple aux méridiens sur le globe qui se resserrent entre eux au niveau des pÃŽles. Donc une distance de 121 degrés ne veut rien dire ! 
     37 
     38Pour calculer une distance ayant du sens, nous devons traiter les coordonnées géographiques non pas comme des coordonnées cartésiennes approximatives, mais plutÃŽt comme de réelles coordonnées sphériques. Nous devons mesurer les distances entre les points comme de vrais chemins par dessus une sphÚre, comme une portion d'un grand cercle. 
    3939 
    4040Depuis sa version 1.5, PostGIS fournit cette fonctionnalité avec le type ``geography``. 
    … …  
    4343 
    4444  Différentes bases de données spatiales développent différentes approches pour manipuler les coordonnées géographiques. 
    45    
    46   * Oracle essaye de mettre à jour la différence de maniÚre transparente en lanacant des calculs lorsuqe le SRID est géographique. 
    47   * SQL Server utilise deux types spatiaux, "STGeometry" pour les coordonnées cartésiens et STGeography" pour les coordonnées géographqiues.  
    48   * Informix Spatial est une pure extension cartésienne d'Informix, alors qu'Informix Geodetic est une pure extension géographique.  
     45 
     46  * Oracle essaye de mettre à jour la différence de maniÚre transparente en lançant des calculs lorsque le SRID est géographique. 
     47  * SQL Server utilise deux types spatiaux, "STGeometry" pour les coordonnées cartésiens et STGeography" pour les coordonnées géographqiues. 
     48  * Informix Spatial est une pure extension cartésienne d'Informix, alors qu'Informix Geodetic est une pure extension géographique. 
    4949  * Comme SQL Server, PostGIS utilise deux types: "geometry" et "geography". 
    50    
    51 En utilisant le type ``geography`` plutot que ``geometry``, essayon sà nouveau de mesurer la distance entre Los Angeles et Paris. Au lieu de la commande :command:`ST_GeometryFromText(text)`, nous utiliserons cette fois :command:`ST_GeographyFromText(text)`. 
     50 
     51En utilisant le type ``geography`` plutot que ``geometry``, essayons sà nouveau de mesurer la distance entre Los Angeles et Paris. Au lieu de la commande :command:`ST_GeometryFromText(text)`, nous utiliserons cette fois :command:`ST_GeographyFromText(text)`. 
    5252 
    5353.. code-block:: sql 
    … …  
    6666Les versions plus anciennes de PostGIS supportaient uniquement des calculs sur sphÚre trÚs basiques comme la fonction :command:`ST_Distance_Spheroid(point, point, measurement)`. Celle-ci est trÚs limitée et ne fonctionne uniquement sur des  points. Elle ne supporte pas non plus l'indexation au niveau des pÃŽles ou de la ligne de date internationale. 
    6767 
    68 Le besoin du support des autres types de géométries se fit ressentir lorsqu'il s'agissait de répondre à des questions du type  "A quelle distance la ligne de vol d'un avion Los Angeles/Paris passe-t-elle de l'Islande?"  
     68Le besoin du support des autres types de géométries se fit ressentir lorsqu'il s'agissait de répondre à des questions du type  "A quelle distance la ligne de vol d'un avion Los Angeles/Paris passe-t-elle de l'Islande?" 
    6969 
    7070.. image:: ./geography/lax_cdg.jpg 
    7171 
    72 Répondre à cette question en travaillant avec un plan cartésien fournit une trÚs mauvaise réponse en effet ! En utilisant la ligne rouge, nou sobtenon sune bien meilleure réponse. Si nous convertissons notre vol LAX-CDG en une ligne et que nous calculons la distance à un point en Islande, nous obtiendrons la réponse exacte, en mÚtres.  
     72Répondre à cette question en travaillant avec un plan cartésien fournit une trÚs mauvaise réponse en effet ! En utilisant la ligne rouge, nous obtenons une bien meilleure réponse. Si nous convertissons notre vol LAX-CDG en une ligne et que nous calculons la distance à un point en Islande, nous obtiendrons la réponse exacte, en mÚtres. 
    7373 
    7474.. code-block:: sql 
    … …  
    7676  SELECT ST_Distance( 
    7777    ST_GeographyFromText('LINESTRING(-118.4079 33.9434, 2.5559 49.0083)'), -- LAX-CDG 
    78     ST_GeographyFromText('POINT(-21.8628 64.1286)')                        -- Iceland   
     78    ST_GeographyFromText('POINT(-21.8628 64.1286)')                        -- Iceland 
    7979  ); 
    8080 
    … …  
    8282 
    8383  531773.757079116 
    84    
    85 Donc le point le plu sproche de l'Islande pendant le vol LAX-CDG est de 532 kilomÚtres.S 
    86  
    87 L'approche cartésienne pour manipuler les coordonnées géographiques pert tout son sens pour les objets situées au dessus de la ligne de date internationale. La route "sphérique" la plus courte entre Los-Angeles et Tokyo traverse l'océan Pacifique. La route "cartésienne" la plus courte traverse quant à elle les océans Atlantique et Indien.   
     84 
     85Donc le point le plus proche de l'Islande pendant le vol LAX-CDG est de 532 kilomÚtres. 
     86 
     87L'approche cartésienne pour manipuler les coordonnées géographiques perd tout son sens pour les objets situés au dessus de la ligne de date internationale. La route "sphérique" la plus courte entre Los-Angeles et Tokyo traverse l'océan Pacifique. La route "cartésienne" la plus courte traverse quant à elle les océans Atlantique et Indien. 
    8888 
    8989.. image:: ./geography/lax_nrt.png 
    … …  
    9494     ST_GeometryFromText('Point(-118.4079 33.9434)'),  -- LAX 
    9595     ST_GeometryFromText('Point(139.733 35.567)'))     -- NRT (Tokyo/Narita) 
    96        AS geometry_distance,  
     96       AS geometry_distance, 
    9797   ST_Distance( 
    9898     ST_GeographyFromText('Point(-118.4079 33.9434)'), -- LAX 
    99      ST_GeographyFromText('Point(139.733 35.567)'))    -- NRT (Tokyo/Narita)  
    100        AS geography_distance;  
    101      
    102 :: 
    103  
    104    geometry_distance | geography_distance  
     99     ST_GeographyFromText('Point(139.733 35.567)'))    -- NRT (Tokyo/Narita) 
     100       AS geography_distance; 
     101 
     102:: 
     103 
     104   geometry_distance | geography_distance 
    105105  -------------------+-------------------- 
    106106    258.146005837336 |   8833954.76996256 
    … …  
    110110---------------------------- 
    111111 
    112 Afin d'importer des données dans une table de type geography, les objets géographiques doivent d'avord être projetées dans le systÚme EPSG:4326 (longitude/latitude), ensuite elles doivent être converties en objets de type géographies. La fonction :command:`ST_Transform(geometry,srid)` convertie les coordonnées en géographies et la fonction :command:`Geography(geometry)` change le type ("cast") de géométrie à géographie. 
     112Afin d'importer des données dans une table de type ``geography``, les objets géographiques doivent d'abord être projetés dans le systÚme EPSG:4326 (longitude/latitude), ensuite ils doivent être convertis en objets de type ``geography``. La fonction :command:`ST_Transform(geometry,srid)` convertit les coordonnées en ``geography`` et la fonction :command:`Geography(geometry)` change le type ("cast") de géométrie à géographie. 
    113113 
    114114.. code-block:: sql 
    115115 
    116116  CREATE TABLE nyc_subway_stations_geog AS 
    117   SELECT  
    118     Geography(ST_Transform(the_geom,4326)) AS geog,  
    119     name,  
     117  SELECT 
     118    Geography(ST_Transform(the_geom,4326)) AS geog, 
     119    name, 
    120120    routes 
    121121  FROM nyc_subway_stations; 
    122     
    123 La construction d'une indexation spatiale sur une table stockant des objets de type géographie est exactement identique à la méthode employée pour les géométries :    
    124  
    125 .. code-block:: sql 
    126  
    127   CREATE INDEX nyc_subway_stations_geog_gix  
     122 
     123La construction d'une indexation spatiale sur une table stockant des objets de type ``geography`` est exactement identique à la méthode employée pour les géométries : 
     124 
     125.. code-block:: sql 
     126 
     127  CREATE INDEX nyc_subway_stations_geog_gix 
    128128  ON nyc_subway_stations_geog USING GIST (geog); 
    129129 
    130 La différence est camouflé : l'indexation des objets de type géographie gére correctement les requêtes qui recouvrent les pÃŽles ou traverses les fuseaux horraires, alors que les géométries ne le supporteront pas. 
    131  
    132 Il n'y a qu'un petit nombre de fonctions disponibles pour le type géographie :   
    133   
     130La différence est camouflée : l'indexation des objets de type ``geography`` gÚre correctement les requêtes qui recouvrent les pÃŽles ou traversent les fuseaux horaires, alors que les géométries ne le supporteront pas. 
     131 
     132Il n'y a qu'un petit nombre de fonctions disponibles pour le type ``geography`` : 
     133 
    134134 * :command:`ST_AsText(geography)` retourne la représentation ``textuelle`` 
    135135 * :command:`ST_GeographyFromText(text)` retourne un objet de type ``geography`` 
    … …  
    149149 * :command:`ST_Buffer(geography, float8)` retourne ``geography`` [#Casting_note]_ 
    150150 * :command:`ST_Intersection(geography, geography)` retourne ``geography`` [#Casting_note]_ 
    151   
    152 Création d'une table stockant des géograhpies 
     151 
     152Création d'une table stockant des géographies 
    153153--------------------------------------------- 
    154   
    155 Le code SQL permettant la création d'une nouvelle table avec une colonne de type géographie ressemble à la création d'une table stockant des géométries. Cependant, les objets de type géographie permettent de spécifier directement le type d'objet géographique à la création de la table. Par exemple : 
     154 
     155Le code SQL permettant la création d'une nouvelle table avec une colonne de type ``geography`` ressemble à la création d'une table stockant des géométries. Cependant, les objets de type ``geography`` permettent de spécifier directement le type d'objet géographique à la création de la table. Par exemple : 
    156156 
    157157.. code-block:: sql 
    … …  
    161161    geog GEOGRAPHY(Point) 
    162162  ); 
    163    
     163 
    164164  INSERT INTO airports VALUES ('LAX', 'POINT(-118.4079 33.9434)'); 
    165165  INSERT INTO airports VALUES ('CDG', 'POINT(2.5559 49.0083)'); 
    166166  INSERT INTO airports VALUES ('REK', 'POINT(-21.8628 64.1286)'); 
    167    
    168 Lors de la définitionn le type ``GEOGRAPHY(Point)`` spécifie que nos airoports sont des points. Les nouveau champs géographie n'est pas référencé dans la table ``geometry_columns``. Le stockage des métadonnées relatives aux données de type géograhpie sont stockées dans une vue appellée ``geography_columns`` qui est maintenue à jour automatiquement sans avoir besoin d'utiliser des fonctions comme ``geography_columns``. 
     167 
     168Lors de la définition le type ``GEOGRAPHY(Point)`` spécifie que nos aéroports sont des points. Le nouveau champ géographie n'est pas référencé dans la table ``geometry_columns``. Le stockage des métadonnées relatives aux données de type ``geography`` s'effectue dans une vue appelée ``geography_columns`` qui est maintenue à jour automatiquement sans avoir besoin d'utiliser des fonctions comme ``geography_columns``. 
    169169 
    170170.. code-block:: sql 
    171171 
    172172  SELECT * FROM geography_columns; 
    173    
    174 :: 
    175  
    176            f_table_name         | f_geography_column | srid |   type    
     173 
     174:: 
     175 
     176           f_table_name         | f_geography_column | srid |   type 
    177177 -------------------------------+--------------------+------+---------- 
    178178  nyc_subway_stations_geography | geog               |    0 | Geometry 
    179179  airports                      | geog               | 4326 | Point 
    180    
     180 
    181181.. note:: 
    182182 
    183   La possibilité de définir les types et le SRID lors de la création de la table (requête ``CREATE``), et la mise à jour automatique des métadonnées ``geometry_columns`` sont des fonctionalités qui seront adaptées pour le type géométrie pour la version 2.0 de PostGIS.   
     183  La possibilité de définir les types et le SRID lors de la création de la table (requête ``CREATE``), et la mise à jour automatique des métadonnées ``geometry_columns`` sont des fonctionalités qui seront adaptées pour le type géométrie pour la version 2.0 de PostGIS. 
    184184 
    185185Conversion de type 
    186186------------------- 
    187187 
    188 Bien que les fonctions de bases qui s'appliquent au type géographie peuvent être utilisées dans un grand nombre de cas d'utilisation, il est parfois nécessaire d'accéder aux autres fonctions qui ne supportent que le type géométrie. Heureusement, il est possible de convertir des objets de type géométries en des objets de types géographies et inversement. 
    189  
    190 La syntaxe habituelle de PostgreSQL pour les conversion de type  consiste à ajouter à la valeur la chaîne suivante ``::typename``. Donc, ``2::text`` convertie la valeur numérique deux en une chaîne de caractÚres '2'. La commande : ``'POINT(0 0)'::geometry`` convertira la représentation textuelle d'un point en une point géométrique. 
    191  
    192 La fonction :command:`ST_X(point)` supporte seulement le type géométrique. Comment lire la coordonée X d'une de nos géographie ? 
     188Bien que les fonctions de base qui s'appliquent au type ``geography`` puissent être utilisées dans un grand nombre de cas d'utilisation, il est parfois nécessaire d'accéder aux autres fonctions qui ne supportent que le type géométrie. Heureusement, il est possible de convertir des objets de type géométrie en des objets de types géographie et inversement. 
     189 
     190La syntaxe habituelle de PostgreSQL pour les conversion de type  consiste à ajouter à la valeur la chaîne suivante ``::typename``. Donc, ``2::text`` convertit la valeur numérique deux en une chaîne de caractÚres '2'. La commande : ``'POINT(0 0)'::geometry`` convertira la représentation textuelle d'un point en une point géométrique. 
     191 
     192La fonction :command:`ST_X(point)` supporte seulement le type géométrique. Comment lire la coordonnée X d'une de nos géographie ? 
    193193 
    194194.. code-block:: sql 
    … …  
    198198:: 
    199199 
    200   code | longitude  
     200  code | longitude 
    201201 ------+----------- 
    202   LAX  | -118.4079  
     202  LAX  | -118.4079 
    203203  CDG  |    2.5559 
    204204  REK  |  -21.8628 
    205205 
    206 En ajoutant la chaîne ``::geometry`` à notre valeur géographique, nous la convertissons en une géographie ayant le SRID : 4326. À partir de maintenant, nous pouvons utiliser autemps de fonctions s'appliquant au géométries que nous le souhaitons. Mais, souvenez-vous - maintenant que nos objets sont des géométries, leur coordonnées seront interprétées comme des coordonnées cartésiennes, non pas sphériques. 
    207   
    208   
     206En ajoutant la chaîne ``::geometry`` à notre valeur géographique, nous la convertissons en une géographie ayant le SRID : 4326. À partir de maintenant, nous pouvons utiliser autant de fonctions s'appliquant aux géométries que nous le souhaitons. Mais, souvenez-vous - maintenant que nos objets sont des géométries, leur coordonnées seront interprétées comme des coordonnées cartésiennes, non pas sphériques. 
     207 
     208 
    209209Pourquoi (ne pas) utiliser les géographies 
    210210------------------------------------------ 
    211211 
    212 Les géographies ont des coordonnées universellement acceptées - chacun peut comprendre que représente la latitue et la longitude, mais peut de personne comprennent ce que les coordonnées UTM signifient. Pourquoi ne pas tout le temps utiliser des géographies ? 
    213  
    214  * PremiÚrement, comme indiqué précédemment, il n'y a que quelques fonctions qui supportent ce type de données. Vous risquer de perdre beaucoup de temps à contourner les problÚmes liés à la non-disponibilité de certaines fonctions. 
    215  * DeuxiÚmement, les calculs sur une sphÚre sont plus consomateurs en ressource que les mêmes calculs dans un systÚme cartésien. Par exemple, la formule de calcul de distance (Pythagore) entraine un seul appÚle à la fonction racine carré (sqrt()). La formule de calcul de distance sphérique (Haversine) utilise deux appÚle à la fonction racine carré, et un appÚle à arctan(), quatre appÚle à sin() et deux à cos(). Les fonctions trigonométriques sont trÚs couteuses, et les calculs sphériques les utilisent massivement. 
    216   
    217 Quel conclusion en tirer ?  
    218  
    219 Si vos données sont géograhpiquement compact (contenu à l'intérieur d'un état, d'un pays ou d'une ville), utilisez le type ``geometry`` avec une projection cartésienne qui est pertinent pour votre localisation. Consultez le site http://spatialreference.org et tapez le nom de votre région pour visualiser la liste des systÚme de projection applicables dans votre cas. 
    220  
    221 Si, d'un autre coté, vous avez besoin de calculer des distances qui est géographiquement éparse (recouvrant la plupart du monde), utiliser le type ``geography``. La compléxité de l'application que vous éviterait en travaillant avec des objets de type ``geography`` dépassera les problÚmes de performances. La conversion de type  en géométrie permettra de dépasser les limites des fonctionnalités proposé pour ce type. 
     212Les géographies ont des coordonnées universellement acceptées - chacun peut comprendre que représente la latitude et la longitude, mais peu de personne comprennent ce que les coordonnées UTM signifient. Pourquoi ne pas tout le temps utiliser des géographies ? 
     213 
     214 * PremiÚrement, comme indiqué précédemment, il n'y a que quelques fonctions qui supportent ce type de données. Vous risquez de perdre beaucoup de temps à contourner les problÚmes liés à la non-disponibilité de certaines fonctions. 
     215 * DeuxiÚmement, les calculs sur une sphÚre sont plus consomateurs en ressource que les mêmes calculs dans un systÚme cartésien. Par exemple, la formule de calcul de distance (Pythagore) entraîne un seul appel à la fonction racine carré (sqrt()). La formule de calcul de distance sphérique (Haversine) utilise deux appels à la fonction racine carré, et un appel à arctan(), quatre appels à sin() et deux à cos(). Les fonctions trigonométriques sont trÚs coûteuses, et les calculs sphériques les utilisent massivement. 
     216 
     217Quel conclusion en tirer ? 
     218 
     219Si vos données sont géographiquement compactes (contenu à l'intérieur d'un état, d'un pays ou d'une ville), utilisez le type ``geometry`` avec une projection cartésienne qui est pertinente pour votre localisation. Consultez le site http://spatialreference.org et tapez le nom de votre région pour visualiser la liste des systÚmes de projection applicables dans votre cas. 
     220 
     221Si, d'un autre coté, vous avez besoin de calculer des distances qui sont géographiquement éparses (recouvrant la plupart du monde), utilisez le type ``geography``. La complexité de l'application évitée en travaillant avec des objets de type ``geography`` dépassera les problÚmes de performances. La conversion de type en géométrie permettra de dépasser les limites des fonctionnalités proposées pour ce type. 
    222222 
    223223Liste des fonctions 
    224224------------------- 
    225225 
    226 `ST_Distance(geometry, geometry) <http://postgis.org/docs/ST_Distance.html>`_: Pour le type géométrie, renvoit la distance cartésienne, pour les géographies la distance sphérique en métres. 
     226`ST_Distance(geometry, geometry) <http://postgis.org/docs/ST_Distance.html>`_: Pour le type géométrie, renvoie la distance cartésienne, pour les géographies la distance sphérique en mÚtres. 
    227227 
    228228`ST_GeographyFromText(text) <http://postgis.org/docs/ST_GeographyFromText.html>`_: Retourne la valeur géographique à partir d'une représentation en WKT ou EWKT. 
    229229 
    230 `ST_Transform(geometry, srid) <http://postgis.org/docs/ST_Transform.html>`_: Retourne une nouvelle géométrie avec ses coordonnées reprojetées dans le systÚme de référence spatial référencé par le SRID fournit. 
     230`ST_Transform(geometry, srid) <http://postgis.org/docs/ST_Transform.html>`_: Retourne une nouvelle géométrie avec ses coordonnées reprojetées dans le systÚme de référence spatial référencé par le SRID fourni. 
    231231 
    232232`ST_X(point) <http://postgis.org/docs/ST_X.html>`_: Retourne la coordonnée X d'un point, ou NULL si non disponible. La valeur passée doit être un point. 
    233233 
    234234 
    235 .. rubric:: Footnotes 
    236  
    237 .. [#Casting_note] Les fonctions buffer et intersection sont actuellement construite sur le principe de conversion de type en géométries, et ne sont pas actuellement capable de gérer des coordonnées sphariques. Il en résulte qu'elles peuvent ne pas parvenir à retourner un résultat correcte pour des objets ayant une grande étendue qui ne peut être représenté correctement avec une représentation planaire. 
    238   
    239    Par exemple, la fonction :command:`ST_Buffer(geography,distance)`  transforme les objets géographiques dans la "meilleure" projection, crée la zone tampon, puis les transforme à nouveau en des géographies. S'il n'y a pas de "meilleure" projection (l'objet est trop vaste), l'opération peut ne pas réussir à retourner une valeur correct ou retourner une one tampon mal formée. 
    240  
     235.. rubric:: Notes de bas de page 
     236 
     237.. [#Casting_note] Les fonctions buffer et intersection sont actuellement construites sur le principe de conversion de type en géométries, et ne sont pas actuellement capable de gérer des coordonnées sphériques. Il en résulte qu'elles peuvent ne pas parvenir à retourner un résultat correcte pour des objets ayant une grande étendue qui ne peut être représenté correctement avec une représentation planaire. 
     238 
     239   Par exemple, la fonction :command:`ST_Buffer(geography,distance)`  transforme les objets géographiques dans la "meilleure" projection, crée la zone tampon, puis les transforme à nouveau en des géographies. S'il n'y a pas de "meilleure" projection (l'objet est trop vaste), l'opération peut ne pas réussir à retourner une valeur correcte ou retourner un tampon mal formé. 
     240 

  • trunk/workshop-foss4g/geometries.rst

    r46 r62  
    22 
    33Partie 8 : Les géometries 
    4 ===================== 
     4========================= 
    55 
    66Introduction 
    77------------ 
    88 
    9 Dans :ref:`une partie précédente<loading_data>` nous avons charger différentes données. Avant de commencer à jouer avec, commençons par regarder quelques exemples simples. Depuis pgAdmin, choisissez de nouveau la base de donnée **nyc** et ouvrez l'outil de requêtage SQL. Copiez cette exemple de code SQL (aprÚs avoir supprimer le contenu présent par défaut si nécessaire) puis exécutez-le. 
     9Dans :ref:`une partie précédente<loading_data>` nous avons chargé différentes données. Avant de commencer à jouer avec, commençons par regarder quelques exemples simples. Depuis pgAdmin, choisissez de nouveau la base de donnée **nyc** et ouvrez l'outil de requêtage SQL. Copiez cette exemple de code SQL (aprÚs avoir supprimé le contenu présent par défaut si nécessaire) puis exécutez-le. 
    1010 
    1111.. code-block:: sql 
    1212 
    1313  CREATE TABLE geometries (name varchar, geom geometry); 
    14    
    15   INSERT INTO geometries VALUES  
     14 
     15  INSERT INTO geometries VALUES 
    1616    ('Point', 'POINT(0 0)'), 
    1717    ('Linestring', 'LINESTRING(0 0, 1 1, 2 1, 2 2)'), 
    … …  
    1919    ('PolygonWithHole', 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1))'), 
    2020    ('Collection', 'GEOMETRYCOLLECTION(POINT(2 0),POLYGON((0 0, 1 0, 1 1, 0 1, 0 0)))'); 
    21      
     21 
    2222  SELECT Populate_Geometry_Columns(); 
    23    
     23 
    2424  SELECT name, ST_AsText(geom) FROM geometries; 
    2525 
    2626.. image:: ./geometries/start01.png 
    2727 
    28 L'exemple ci-dessus créé une table (**geometries**) puis y insert cinq géométries : un point, une ligne, un polygone, un polygone avec un trou, et une collection. Les lignes insérées sont sélectionnées et affichées dans le tableau de sortie. 
     28L'exemple ci-dessus créé une table (**geometries**) puis y insÚre cinq géométries : un point, une ligne, un polygone, un polygone avec un trou, et une collection. Les lignes insérées sont sélectionnées et affichées dans le tableau de sortie. 
    2929 
    3030Les tables de métadonnées 
    … …  
    3333Dans le respect de la spécification Simple Features for SQL (:term:`SFSQL`), PostGIS fournit deux tables pour récupérer et s'informer sur les types de géométries disponibles dans une base de données spécifique. 
    3434 
    35 * La premiÚre table, ``spatial_ref_sys``, définit tout les systÚmes de projection connus de la base de données et sera décrite plus en détails plus tard.   
    36 * La seconde table, ``geometry_columns``, fournit une liste de toutes les "entités" (définit comme un objet avec un attribut géométrique) et les détails de base relatives à ces entités.  
     35* La premiÚre table, ``spatial_ref_sys``, définit tous les systÚmes de projection connus de la base de données et sera décrite plus en détails plus tard. 
     36* La seconde table, ``geometry_columns``, fournit une liste de toutes les "entités" (définit comme un objet avec un attribut géométrique) et les détails de base relatives à ces entités. 
    3737 
    3838.. image:: ./geometries/table01.png 
    3939 
    40 Dans l'exemple founit en introduction, la fonction :command:`Populate_Geometry_Columns()` détecte toute les colonnes de la base de données qui contiennent des géométries et met à jour la table ``geometry_columns`` pour y inclure leurs références. 
     40Dans l'exemple fournit en introduction, la fonction :command:`Populate_Geometry_Columns()` détecte toutes les colonnes de la base de données qui contiennent des géométries et met à jour la table ``geometry_columns`` pour y inclure leurs références. 
    4141 
    4242Regardons maintenant la table ``geometry_columns`` de notre base de données. Copiez cette commande dans la fenêtre de requêtage : 
    … …  
    4949.. image:: ./geometries/start08.png 
    5050 
    51 * ``f_table_catalog``, ``f_table_schema``, et ``f_table_name`` fournissent le nom complet de la table contenant une géométrie donnée. Étant donné que PostgreSQL n'utilise pas de catalogues, ``f_table_catalog`` est toujouts vide.   
     51* ``f_table_catalog``, ``f_table_schema``, et ``f_table_name`` fournissent le nom complet de la table contenant une géométrie donnée. Étant donné que PostgreSQL n'utilise pas de catalogues, ``f_table_catalog`` est toujours vide. 
    5252* ``f_geometry_column`` est le nom de la colonne qui contient la géométrie -- pour les tables ayant plusieurs colonnes géométriques, il y a un enregistrement dans cette table pour chacune. 
    53 * ``coord_dimension`` et ``srid`` définissent respectivement la dimension de la géométrie (en 2-, 3- or 4-dimensions) et le systÚme de références spatiales qui fait référence à la table ``spatial_ref_sys``.   
    54 * La colonne ``type`` définit le type de géométrie comme décrit plus tÃŽt, nous avons déjà vu les points et les lignes.   
     53* ``coord_dimension`` et ``srid`` définissent respectivement la dimension de la géométrie (en 2-, 3- or 4-dimensions) et le systÚme de référence spatiale qui fait référence à la table ``spatial_ref_sys``. 
     54* La colonne ``type`` définit le type de géométrie comme décrit plus tÃŽt, nous avons déjà vu les points et les lignes. 
    5555 
    5656En interrogeant cette table, les clients SIG et les libraires peuvent déterminer quoi attendre lors de la récupération des données et peuvent réaliser les opération de reprojection, transformation ou rendu sans avoir à inspecter chaque géométrie. 
    5757 
    5858Réprésenter des objets du monde réel 
    59 ----------------------------------- 
     59------------------------------------ 
    6060 
    6161La spécification Simple Features for SQL (:term:`SFSQL`), le standard ayant guidé le développement de PostGIS, définit comment les objets du monde réel doivent être représentés. En considérant une forme continue à une seule résolution fixe, nous obtenons une piÚtre représentation des objets. SFSQL considÚre uniquement les représentations en 2 dimensions. PostGIS a étendu cela en ajoutant les représentation en 3 et 4 dimensions. Plus récemment, la spécification SQL-Multimedia Part 3 (:term:`SQL/MM`) a officiellement définit sa propre représentation. 
    … …  
    7474:: 
    7575 
    76        name       |    st_geometrytype    | st_ndims | st_srid  
     76       name       |    st_geometrytype    | st_ndims | st_srid 
    7777 -----------------+-----------------------+----------+--------- 
    7878  Point           | ST_Point              |        2 |      -1 
    … …  
    9090   :align: center 
    9191 
    92 Un **point** représente une localisation unique sur la Terre. Ce point est représenté par une seule coordonnée (incluant soit 2, 3 ou 4 dimensions). Les points sont utilisés pour représenter des objets lorsque le détail exact du contour n'est pas important à une échelle donnée. Par exemple, les villes sur une carte du monde peuvent être décrite sous la forme de points alors qu'une carte régionale utiliserait une représentation polygonale des villes. 
    93  
    94 .. code-block:: sql 
    95  
    96   SELECT ST_AsText(geom)  
     92Un **point** représente une localisation unique sur la Terre. Ce point est représenté par une seule coordonnée (incluant soit 2, 3 ou 4 dimensions). Les points sont utilisés pour représenter des objets lorsque le détail exact du contour n'est pas important à une échelle donnée. Par exemple, les villes sur une carte du monde peuvent être décrites sous la forme de points alors qu'une carte régionale utiliserait une représentation polygonale des villes. 
     93 
     94.. code-block:: sql 
     95 
     96  SELECT ST_AsText(geom) 
    9797    FROM geometries 
    9898    WHERE name = 'Point'; 
    … …  
    105105 
    106106 * :command:`ST_X(geometry)` retourne la composante X 
    107  * :command:`ST_Y(geometry)` retourne la composante Y  
     107 * :command:`ST_Y(geometry)` retourne la composante Y 
    108108 
    109109Donc, nous pouvons lire les coordonnées d'un point de la maniÚre suivante : 
    … …  
    124124 
    125125 
    126 Les lignes  
     126Les lignes 
    127127~~~~~~~~~~~ 
    128128 
    … …  
    130130   :align: center 
    131131 
    132 Une **ligne** est un chemin entre plusieurs points. Elle prend la forme d'un tableau ordonné composé de deux (ou plusieurs) points. Les routes et les riviÚres sont typiquement représentés sous la forme de lignes. Une ligne est dite **fermée** si elle commence et fini en un même point. Elle est dite **simple** si elle ne se coupe pas ou ne se touche pas elle-même (sauf à ses extrémités si elle est fermée). Une ligne peut être à la fois **fermée** et **simple**. 
    133  
    134 Le réseau des rues de New York (``nyc_streets``) a été chargé auparavant. Cet ensemble de données contient les détails comme le nom et le type des rues. Une rue du monde réel pourrait être constituée de plusieurs lignes, chacune représentant une file avec différents attributs. 
     132Une **ligne** est un chemin entre plusieurs points. Elle prend la forme d'un tableau ordonné composé de deux (ou plusieurs) points. Les routes et les riviÚres sont typiquement représentées sous la forme de lignes. Une ligne est dite **fermée** si elle commence et finit en un même point. Elle est dite **simple** si elle ne se coupe pas ou ne se touche pas elle-même (sauf à ses extrémités si elle est fermée). Une ligne peut être à la fois **fermée** et **simple**. 
     133 
     134Le réseau des rues de New York (``nyc_streets``) a été chargé auparavant. Cet ensemble de données contient les détails comme le nom et le type des rues. Une rue du monde réel pourrait être constituée de plusieurs lignes, chacune représentant une segment de routes avec ses différents attributs. 
    135135 
    136136La requête SQL suivante retourne la géométrie associée à une ligne (dans la colonne :command:`ST_AsText`) : 
    … …  
    138138.. code-block:: sql 
    139139 
    140   SELECT ST_AsText(geom)  
     140  SELECT ST_AsText(geom) 
    141141    FROM geometries 
    142142    WHERE name = 'Linestring'; 
    143    
     143 
    144144:: 
    145145 
    … …  
    150150 * :command:`ST_Length(geometry)` retourne la longueur d'une ligne 
    151151 * :command:`ST_StartPoint(geometry)` retourne le premier point d'une ligne 
    152  * :command:`ST_EndPoint(geometry)` retourne le denier point d'une ligne 
     152 * :command:`ST_EndPoint(geometry)` retourne le dernier point d'une ligne 
    153153 * :command:`ST_NPoints(geometry)` retourne le nombre de points dans une ligne 
    154154 
    … …  
    157157.. code-block:: sql 
    158158 
    159   SELECT ST_Length(geom)  
     159  SELECT ST_Length(geom) 
    160160    FROM geometries 
    161161    WHERE name = 'Linestring'; 
    … …  
    172172  :align: center 
    173173 
    174 Un polygone est représenté comme une zone. Le contour externe du polygone est représenté par une ligne simple et fermée. Les trous sont représenté de la même maniÚre. 
    175  
    176 Les polygones sont utilisés pour représenter les objets dont les tailles et la forme sont importants. Les limites de villes, les parcs, les bâtiments ou les cours d'eau sont habituellement représenté par des polygones lorsque l'échelle est suffisament élevée pour voir distinguer leurs zones. Les routes et les riviÚres peuvent parfois être représenté comme des polygones. 
     174Un polygone est représenté comme une zone. Le contour externe du polygone est représenté par une ligne simple et fermée. Les trous sont représentés de la même maniÚre. 
     175 
     176Les polygones sont utilisés pour représenter les objets dont les tailles et la forme sont importants. Les limites de villes, les parcs, les bâtiments ou les cours d'eau sont habituellement représentés par des polygones lorsque l'échelle est suffisament élevée pour pouvoir distinguer leurs zones. Les routes et les riviÚres peuvent parfois être représentées comme des polygones. 
    177177 
    178178La requête SQL suivante retournera la géométrie associée à un polygone (dans la colonne :command:`ST_AsText`). 
    … …  
    180180.. code-block:: sql 
    181181 
    182   SELECT ST_AsText(geom)  
     182  SELECT ST_AsText(geom) 
    183183    FROM geometries 
    184184    WHERE name LIKE 'Polygon%'; 
    … …  
    203203 * :command:`ST_ExteriorRing(geometry)` retourne le contour extérieur 
    204204 * :command:`ST_InteriorRingN(geometry,n)` retourne le contour intérieur numéro n 
    205  * :command:`ST_Perimeter(geometry)` retourne la longueur de tout les contours 
     205 * :command:`ST_Perimeter(geometry)` retourne la longueur de tous les contours 
    206206 
    207207Nous pouvons calculer l'aire de nos polygones en utilisant la fonction area : 
    … …  
    209209.. code-block:: sql 
    210210 
    211   SELECT name, ST_Area(geom)  
     211  SELECT name, ST_Area(geom) 
    212212    FROM geometries 
    213213    WHERE name LIKE 'Polygon%'; 
    … …  
    221221 
    222222Les collections 
    223 ~~~~~~~~~~~~~~~~  
    224  
    225 Il y a quatre types de collections, qui regroupe ensemble plusieurs géométries simples. 
     223~~~~~~~~~~~~~~~~ 
     224 
     225Il y a quatre types de collections, qui regroupent ensemble plusieurs géométries simples. 
    226226 
    227227 * **MultiPoint**, une collection de points 
    … …  
    230230 * **GeometryCollection**, une collection hétérogÚne de n'importe quelle géométrie (dont d'autre collections) 
    231231 
    232 Les collections sont un concept présents dans les logiciels SIG  plus que dans les applications de rendu graphique génériques. Elles sont utiles pour directement modeler les objets du monde réel comme des objet spatiaux. Par exemple, comment modéliser une parcelle qui a été coupée par un chemin ? Comme un **MultiPolygon**, ayant une partie de chaque coté du chemin. 
     232Les collections sont un concept présents dans les logiciels SIG  plus que dans les applications de rendu graphique génériques. Elles sont utiles pour directement modéliser les objets du monde réel comme des objet spatiaux. Par exemple, comment modéliser une parcelle qui a été coupée par un chemin ? Comme un **MultiPolygon**, ayant une partie de chaque coté du chemin. 
    233233 
    234234.. image:: ./screenshots/collection2.png 
    … …  
    238238.. code-block:: sql 
    239239 
    240   SELECT name, ST_AsText(geom)  
     240  SELECT name, ST_AsText(geom) 
    241241    FROM geometries 
    242242    WHERE name = 'Collection'; 
    … …  
    252252 * :command:`ST_NumGeometries(geometry)` retourne le nombre de composantes d'une collection 
    253253 * :command:`ST_GeometryN(geometry,n)` retourne une composante spécifique 
    254  * :command:`ST_Area(geometry)` retourne l'aire totale des composantes de types polygones 
    255  * :command:`ST_Length(geometry)` retourne la longueur totale des composantes de types lignes 
     254 * :command:`ST_Area(geometry)` retourne l'aire totale des composantes de type polygone 
     255 * :command:`ST_Length(geometry)` retourne la longueur totale des composantes de type ligne 
    256256 
    257257Entré / Sortie des géométries 
    … …  
    261261 
    262262 * Format texte bien connu (Well-known text :term:`WKT`) 
    263   
     263 
    264264   * :command:`ST_GeomFromText(text)` retourne une ``geometry`` 
    265265   * :command:`ST_AsText(geometry)` retourne le ``texte`` 
    266266   * :command:`ST_AsEWKT(geometry)` retourne le ``texte`` 
    267     
     267 
    268268 * Format binaire bien connu (Well-known binary :term:`WKB`) 
    269   
     269 
    270270   * :command:`ST_GeomFromWKB(bytea)` retourne ``geometry`` 
    271271   * :command:`ST_AsBinary(geometry)` retourne ``bytea`` 
    272272   * :command:`ST_AsEWKB(geometry)` retourne ``bytea`` 
    273     
     273 
    274274 * Geographic Mark-up Language (:term:`GML`) 
    275   
     275 
    276276   * :command:`ST_GeomFromGML(text)` retourne ``geometry`` 
    277277   * :command:`ST_AsGML(geometry)` retourne ``text`` 
    278     
     278 
    279279 * Keyhole Mark-up Language (:term:`KML`) 
    280   
     280 
    281281   * :command:`ST_GeomFromKML(text)` retourne ``geometry`` 
    282282   * :command:`ST_AsKML(geometry)` retourne ``text`` 
    283     
     283 
    284284 * :term:`GeoJSON` 
    285   
     285 
    286286   * :command:`ST_AsGeoJSON(geometry)` retourne ``text`` 
    287     
     287 
    288288 * Scalable Vector Graphics (:term:`SVG`) 
    289   
     289 
    290290   * :command:`ST_AsSVG(geometry)` retourne ``text`` 
    291   
     291 
    292292La requête SQL suivante montre un exemple de représentation en :term:`WKB` (l'appel à :command:`encode()` est requis pour convertir le format binaire en ASCII pour l'afficher) : 
    293293 
    … …  
    295295 
    296296  SELECT encode( 
    297     ST_AsBinary(ST_GeometryFromText('LINESTRING(0 0 0,1 0 0,1 1 2)')),  
     297    ST_AsBinary(ST_GeometryFromText('LINESTRING(0 0 0,1 0 0,1 1 2)')), 
    298298    'hex'); 
    299299 
    … …  
    302302Dans le reste de ces travaux pratiques, nous utiliserons principalement le format WKT pour que vous puissiez lire et comprendre les géométries que nous voyons. Néanmoins, pour la plupart des traitement actuels, comme la visualisation des données dans une application SIG, le transfert de données à des services web, ou l'exécution distante de traitements, le format WKB est un format de choix. 
    303303 
    304 Puisque le WKT et le WKB sont définit dans la spécification :term:`SFSQL`, elles ne prennent pas en compte les géométries à 3 ou 4 dimensions. C'est pour cette raison que PostGIS définit les formats Extended Well Known Text (EWKT) et Extended Well Known Binary (EWKB). Cela permet de gérer de façon similaire aux formats WKT et WKB les dimensions ajoutées. 
     304Puisque les formats WKT et le WKB sont définis dans la spécification :term:`SFSQL`, ils ne prennent pas en compte les géométries à 3 ou 4 dimensions. C'est pour cette raison que PostGIS définit les formats Extended Well Known Text (EWKT) et Extended Well Known Binary (EWKB). Cela permet de gérer de façon similaire aux formats WKT et WKB les dimensions ajoutées. 
    305305 
    306306Voici un exemple de ligne 3D au format WKT : 
    … …  
    330330------------------- 
    331331 
    332 `Populate_Geometry_Columns <http://postgis.org/docs/Populate_Geometry_Columns.html>`_: s'assure que les colonnes géométriques on les contraintes spatiales appropriées et qu'elles sont présentes dans la table  geometry_columns. 
    333  
    334 `ST_Area <http://postgis.org/docs/ST_Area.html>`_: retourne l'aire de la surface si c'est un polygon ou un multi-polygone. Pour le type "geometry" l'aire est dans l'unité du SRID. Pour les "geography" l'aire est en mÚtres carrés. 
    335  
    336 `ST_AsText <http://postgis.org/docs/ST_AsText.html>`_: retourne la représentation de la geometry/geography au format Well-Known Text (WKT) sans metadonnée correspondant au SRID. 
    337  
    338 `ST_AsBinary <http://postgis.org/docs/ST_AsBinary.html>`_: retourne la représentation de la geometry/geography au format Well-Known Binary (WKB) sans metadonnée correspondant u SRID.  
     332`Populate_Geometry_Columns <http://postgis.org/docs/Populate_Geometry_Columns.html>`_: s'assure que les colonnes géométriques ont les contraintes spatiales appropriées et qu'elles sont présentes dans la table  geometry_columns. 
     333 
     334`ST_Area <http://postgis.org/docs/ST_Area.html>`_: retourne l'aire de la surface si c'est un polygone ou un multi-polygone. Pour le type "geometry" l'aire est dans l'unité du SRID. Pour les "geography" l'aire est en mÚtres carrés. 
     335 
     336`ST_AsText <http://postgis.org/docs/ST_AsText.html>`_: retourne la représentation de la geometry/geography au format Well-Known Text (WKT) sans métadonnée correspondant au SRID. 
     337 
     338`ST_AsBinary <http://postgis.org/docs/ST_AsBinary.html>`_: retourne la représentation de la geometry/geography au format Well-Known Binary (WKB) sans métadonnée correspondant u SRID. 
    339339 
    340340`ST_EndPoint <http://postgis.org/docs/ST_EndPoint.html>`_: retourne le dernier point d'une ligne. 
    341341 
    342 `ST_AsEWKB <http://postgis.org/docs/ST_AsEWKB.html>`_: retourne la représentation de la geometrie au format Well-Known Binary (WKB) avec la métadonnée SRID. 
    343  
    344 `ST_AsEWKT <http://postgis.org/docs/ST_AsEWKT.html>`_: retourne la représentation de la geometrie au format Well-Known Text (WKT) avec la métadonnée SRID. 
     342`ST_AsEWKB <http://postgis.org/docs/ST_AsEWKB.html>`_: retourne la représentation de la géometrie au format Well-Known Binary (WKB) avec la métadonnée SRID. 
     343 
     344`ST_AsEWKT <http://postgis.org/docs/ST_AsEWKT.html>`_: retourne la représentation de la géometrie au format Well-Known Text (WKT) avec la métadonnée SRID. 
    345345 
    346346`ST_AsGeoJSON <http://postgis.org/docs/ST_AsGeoJSON.html>`_: retourne la géométrie au format GeoJSON. 
    … …  
    352352`ST_AsSVG <http://postgis.org/docs/ST_AsSVG.html>`_: retourne la géométrie au format SVG. 
    353353 
    354 `ST_ExteriorRing <http://postgis.org/docs/ST_ExteriorRing.html>`_: retourne une ligne représentant le contour extérieur du polygone. Retourne NULL si la géométrie n'est pas un polygone. Ne fonctionne pas avec les multi-polygone. 
    355  
    356 `ST_GeometryN <http://postgis.org/docs/ST_GeometryN.html>`_: retourne niÚme composante si la géométrie est du type GEOMETRYCOLLECTION, MULTIPOINT, MULTILINESTRING, MULTICURVE ou MULTIPOLYGON. Sinon, retourne NULL. 
     354`ST_ExteriorRing <http://postgis.org/docs/ST_ExteriorRing.html>`_: retourne une ligne représentant le contour extérieur du polygone. Retourne NULL si la géométrie n'est pas un polygone. Ne fonctionne pas avec les multi-polygones. 
     355 
     356`ST_GeometryN <http://postgis.org/docs/ST_GeometryN.html>`_: retourne la niÚme composante si la géométrie est du type GEOMETRYCOLLECTION, MULTIPOINT, MULTILINESTRING, MULTICURVE ou MULTIPOLYGON. Sinon, retourne NULL. 
    357357 
    358358`ST_GeomFromGML <http://postgis.org/docs/ST_GeomFromGML.html>`_: prend en entrée une représentation GML de la géométrie et retourne un object PostGIS de type geometry. 
    … …  
    362362`ST_GeomFromText <http://postgis.org/docs/ST_GeomFromText.html>`_: retourne une valeur de type ST_Geometry à partir d'une représentation au format Well-Known Text (WKT). 
    363363 
    364 `ST_GeomFromWKB <http://postgis.org/docs/ST_GeomFromWKB.html>`_: retourne une valeur de type ST_Geometry à partir d'une représenattion au format Well-Known Binary (WKB). 
     364`ST_GeomFromWKB <http://postgis.org/docs/ST_GeomFromWKB.html>`_: retourne une valeur de type ST_Geometry à partir d'une représentation au format Well-Known Binary (WKB). 
    365365 
    366366`ST_GeometryType <http://postgis.org/docs/ST_GeometryType.html>`_: retourne le type de géométrie de la valeur de type ST_Geometry. 
    … …  
    368368`ST_InteriorRingN <http://postgis.org/docs/ST_InteriorRingN.html>`_: retourne le niÚme contour intérieur d'un polygone. Retourne NULL si la géométrie n'est pas un polygone ou si N est hors des limites. 
    369369 
    370 `ST_Length <http://postgis.org/docs/ST_Length.html>`_: retourne la longueur en 2-dimensions si c'est une ligne ou une multi-lignes. Les objets de type geometry sont dans l'unité du systÚme de références spatiales et les objet de type geography sont en metres (sphéroïde par défaut). 
     370`ST_Length <http://postgis.org/docs/ST_Length.html>`_: retourne la longueur en 2-dimensions si c'est une ligne ou une multi-lignes. Les objets de type geometry sont dans l'unité du systÚme de référence spatiale et les objets de type geography sont en mÚtres (sphéroïde par défaut). 
    371371 
    372372`ST_NDims <http://postgis.org/docs/ST_NDims.html>`_: retourne le nombre de dimensions d'une géométrie. Les valeurs possibles sont : 2,3 ou 4. 
    … …  
    378378`ST_NumGeometries <http://postgis.org/docs/ST_NumGeometries.html>`_: si la géométrie est du type GEOMETRYCOLLECTION (ou MULTI*) retourne le nombre de géométries, sinon retourne NULL. 
    379379 
    380 `ST_Perimeter <http://postgis.org/docs/ST_Perimeter.html>`_: retourne la longueur du contours extérieur d'une valeur de type ST_Surface ou ST_MultiSurface (polygone, multi-polygone). 
     380`ST_Perimeter <http://postgis.org/docs/ST_Perimeter.html>`_: retourne la longueur du contour extérieur d'une valeur de type ST_Surface ou ST_MultiSurface (polygone, multi-polygone). 
    381381 
    382382`ST_SRID <http://postgis.org/docs/ST_SRID.html>`_: retourne l'identifiant du systÚme de référence spatiale définit dans la table spatial_ref_sys d'un objet de type ST_Geometry. 

  • trunk/workshop-foss4g/geometries_exercises.rst

    r47 r62  
    22 
    33Partie 9 : Exercices sur les géométries 
    4 ====================================== 
     4======================================= 
    55 
    66Voici un petit rappel de toutes les fonction que nous avons abordé jusqu'à présent. Elles devraient être utiles pour les exercices ! 
    … …  
    1010 * :command:`ST_GeometryType(geometry)` retourne le type de la géométrie 
    1111 * :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 
     12 * :command:`ST_SRID(geometry)` retourne l'identifiant du systÚme de référence spatiale 
    1313 * :command:`ST_X(point)` retourne la coordonnée X 
    1414 * :command:`ST_Y(point)` retourne la coordonnée Y 
    … …  
    1919 * :command:`ST_Area(geometry)` retourne l'aire d'un polygone 
    2020 * :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 
     21 * :command:`ST_ExteriorRing(polygon)` retourne le contour extérieur (ligne) d'un polygone 
    2222 * :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 
     23 * :command:`ST_Perimeter(geometry)` retourne la longueur de tous les contours 
    2424 * :command:`ST_NumGeometries(multi/geomcollection)` retourne le nombre de composantes dans une collection 
    2525 * :command:`ST_GeometryN(geometry, integer)` retourne la niÚme entité de la collection 
    … …  
    3939Souvenez-vous aussi des tables disponibles: 
    4040 
    41  * ``nyc_census_blocks``  
    42   
     41 * ``nyc_census_blocks`` 
     42 
    4343   * name, popn_total, boroname, the_geom 
    44   
     44 
    4545 * ``nyc_streets`` 
    46   
     46 
    4747   * name, type, the_geom 
    48     
     48 
    4949 * ``nyc_subway_stations`` 
    50   
     50 
    5151   * name, the_geom 
    52   
     52 
    5353 * ``nyc_neighborhoods`` 
    54   
     54 
    5555   * name, boroname, the_geom 
    5656 
    … …  
    5959 
    6060 * **"Quelle est l'aire du quartier 'West Village'?"** 
    61   
     61 
    6262   .. code-block:: sql 
    6363 
    … …  
    6565       FROM nyc_neighborhoods 
    6666       WHERE name = 'West Village'; 
    67         
    68    ::  
     67 
     68   :: 
    6969 
    7070     1044614.53027344 
    … …  
    7272   .. note:: 
    7373 
    74       L'aire est donnée 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 en acres ?"** (Astuce: ``nyc_census_blocks`` et ``nyc_neighborhoods`` on toutes deux le champ ``boroname``.) 
    77   
     74      L'aire est donnée en mÚtres carrés. Pour obtenir l'aire en hectare, divisez par 10000. Pour obtenir l'aire en acres, divisez par 4047. 
     75 
     76 * **"Quelle est l'aire de Manhattan en acres ?"** (Astuce: ``nyc_census_blocks`` et ``nyc_neighborhoods`` ont toutes les deux le champ ``boroname``.) 
     77 
    7878   .. code-block:: sql 
    7979 
    … …  
    8282       WHERE boroname = 'Manhattan'; 
    8383 
    84    ::  
    85     
     84   :: 
     85 
    8686     13965.3201224118 
    8787 
    … …  
    9494       WHERE boroname = 'Manhattan'; 
    9595 
    96    ::  
    97     
     96   :: 
     97 
    9898     14572.1575543757 
    9999 
    100100 
    101101 * **"Combien de blocs de la ville de New York ont des trous ?"** 
    102   
    103    .. code-block:: sql 
    104  
    105      SELECT Count(*)  
     102 
     103   .. code-block:: sql 
     104 
     105     SELECT Count(*) 
    106106       FROM nyc_census_blocks 
    107107       WHERE ST_NRings(the_geom) > 1; 
    108108 
    109    ::  
    110     
    111      66  
    112     
     109   :: 
     110 
     111     66 
     112 
    113113 * **"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.) 
    114    
    115     .. code-block:: sql 
     114 
     115   .. code-block:: sql 
    116116 
    117117     SELECT Sum(ST_Length(the_geom)) / 1000 
    118118       FROM nyc_streets; 
    119119 
    120    ::  
    121     
     120   :: 
     121 
    122122     10418.9047172 
    123123 
    124124 * **"Quelle est la longueur de 'Columbus Cir' (Columbus Circle) ?"** 
    125   
    126      .. code-block:: sql 
    127   
    128       SELECT ST_Length(the_geom) 
    129         FROM nyc_streets 
    130         WHERE name = 'Columbus Cir'; 
    131  
    132      ::  
    133     
    134        308.34199 
     125 
     126   .. code-block:: sql 
     127 
     128     SELECT ST_Length(the_geom) 
     129       FROM nyc_streets 
     130       WHERE name = 'Columbus Cir'; 
     131 
     132   :: 
     133 
     134     308.34199 
    135135 
    136136 * **"Quelle est le contour de 'West Village' au format JSON ?"** 
    137   
     137 
    138138   .. code-block:: sql 
    139139 
    … …  
    143143 
    144144   :: 
    145       
     145 
    146146      {"type":"MultiPolygon","coordinates": 
    147147       [[[[583263.2776595836,4509242.6260239873], 
    … …  
    149149          [583263.2776595836,4509242.6260239873]]]]} 
    150150 
    151 La géométrie de type "MultiPolygon", interressant ! 
    152     
    153        
     151La géométrie de type "MultiPolygon", intéressant ! 
     152 
     153 
    154154 * **"Combien de polygones sont dans le multi-polygone 'West Village' ?"** 
    155   
     155 
    156156   .. code-block:: sql 
    157157 
    … …  
    163163 
    164164      1 
    165         
     165 
    166166   .. note:: 
    167     
     167 
    168168      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 stocker des géométries simples et multiples sans mélanger les types. 
    169         
    170         
     169 
     170 
    171171 * **"Quel est la longueur des rues de la ville de New York, suivant leur type ?"** 
    172   
     172 
    173173   .. code-block:: sql 
    174174 
    … …  
    179179 
    180180   :: 
    181     
    182                             type                       |      length       
     181 
     182                            type                       |      length 
    183183     --------------------------------------------------+------------------ 
    184184      residential                                      | 8629870.33786606 
    … …  
    204204      motorway_link; residential                       |  215.07778911517 
    205205 
    206      
     206 
    207207   .. note:: 
    208208 
    209209      La clause ``ORDER BY length DESC`` ordonne le résultat par la valeur des longueurs dans l'ordre décroissant. Le résultat avec la plus grande valeur se retrouve au début la liste de résultats. 
    210210 
    211   
    212   
    213   
    214          

  • trunk/workshop-foss4g/geometry_returning.rst

    r50 r62  
    44==================================================== 
    55 
    6 Toute les fonctions que nous avons vu jusqu'à présent traitent les géométries "comme elles sont" et retournent:  
    7   
    8 * une analyse des objets (:command:`ST_Length(geometry)`, :command:`ST_Area(geometry)`),  
    9 * une sérialisation des objets (:command:`ST_AsText(geometry)`, :command:`ST_AsGML(geometry)`),  
     6Toute les fonctions que nous avons vu jusqu'à présent traitent les géométries "comme elles sont" et retournent: 
     7 
     8* une analyse des objets (:command:`ST_Length(geometry)`, :command:`ST_Area(geometry)`), 
     9* une sérialisation des objets (:command:`ST_AsText(geometry)`, :command:`ST_AsGML(geometry)`), 
    1010* une partie de l'objet (:command:`ST_RingN(geometry,n)`) ou 
    1111* un résultat vrai/faux (:command:`ST_Contains(geometry,geometry)`, :command:`ST_Intersects(geometry,geometry)`). 
    … …  
    1717------------------------------- 
    1818 
    19 Un besoin commun lors de la création de requêtes spatiales est de remplacer une entité polygonale par un point représentant cette entité. Cela esr utile pour les jointures spatiales (comme indiqué ici : :ref:`polypolyjoins`) car utiliser :command:`ST_Intersects(geometry,geometry)` avec deux polygones impliquera un double comptage : un polygone pour le contour externe intersectera dans les deux senses; le replacer par un point le forcera à être dans un seul sens, pas les deux. 
     19Un besoin commun lors de la création de requêtes spatiales est de remplacer une entité polygonale par un point représentant cette entité. Cela est utile pour les jointures spatiales (comme indiqué ici : :ref:`polypolyjoins`) car utiliser :command:`ST_Intersects(geometry,geometry)` avec deux polygones impliquera un double comptage : un polygone pour le contour externe intersectera dans les deux sens; le remplacer par un point le forcera à être dans un seul sens, pas les deux. 
    2020 
    21  * :command:`ST_Centroid(geometry)` retourne le point qui est approximativement au centre de la masse de la géométrie passé en paramÚtre. C'est un calcul simle et rapide, mais parfois non proftable, car le point retourné peut se trouver à l'extérieur de l'entité elle-même. Si l'entité fournie est convee (imaginez la lettre 'C') le centroïde renvoyé pourrait ne pas être à l'intérieur du polygone. 
    22  * :command:`ST_PointOnSurface(geometry)` retourne un point qui est obligatoirement dans l'entité passée en paramÚtre. Cette fonction coûte plus cher en ressource que le calcul du centroïd. 
    23   
     21 * :command:`ST_Centroid(geometry)` retourne le point qui est approximativement au centre de la masse de la géométrie passée en paramÚtre. C'est un calcul simple et rapide, mais parfois non profitable, car le point retourné peut se trouver à l'extérieur de l'entité elle-même. Si l'entité fournie est convexe (imaginez la lettre 'C') le centroïde renvoyé pourrait ne pas être à l'intérieur du polygone. 
     22 * :command:`ST_PointOnSurface(geometry)` retourne un point qui est obligatoirement dans l'entité passée en paramÚtre. Cette fonction coûte plus cher en ressource que le calcul du centroïde. 
     23 
    2424.. image:: ./geometry_returning/centroid.jpg 
    2525 
    … …  
    2828--------- 
    2929 
    30 L'opération de zone tampon est souvent disponible dans les outils SIG, il est aussi disponible dans PostGIS. La fonction :command:`ST_Buffer(geometry,distance)` prend en paramÚtre une géométrie et une distance et retourne une zone tampon dont le contour est à une distance données de la géométrie d'origine. 
     30L'opération de zone tampon est souvent disponible dans les outils SIG, il est aussi disponible dans PostGIS. La fonction :command:`ST_Buffer(geometry,distance)` prend en paramÚtre une géométrie et une distance et retourne une zone tampon dont le contour est à une distance donnée de la géométrie d'origine. 
    3131 
    3232.. image:: ./geometry_returning/st_buffer.png 
    3333 
    34 Par exemple, si les services des parks américains souhaitaient renforcer la zone du traffique maritime autour de l'île 'Liberty', ils pourraient construire une zone tampon de 500 mÚtres autour de l'île. L'île de 'Liiberty' est représenté par un seul bloque dans notre table ``nyc_census_blocks`, nous pouvons donc facilement réaliser ce calcul.  
     34Par exemple, si les services des parcs américains souhaitaient renforcer la zone du traffic maritime autour de l'île 'Liberty', ils pourraient construire une zone tampon de 500 mÚtres autour de l'île. L'île de 'Liberty' est représentée par un seul bloc dans notre table ``nyc_census_blocks``, nous pouvons donc facilement réaliser ce calcul. 
    3535 
    3636.. code-block:: sql 
    … …  
    3838  -- Création d'une nouvelle table avec une zone tampon de 500 m autour de 'Liberty Island' 
    3939  CREATE TABLE libery_island_zone AS 
    40   SELECT ST_Buffer(the_geom,500) AS the_geom  
    41   FROM nyc_census_blocks  
     40  SELECT ST_Buffer(the_geom,500) AS the_geom 
     41  FROM nyc_census_blocks 
    4242  WHERE blkid = '360610001009000'; 
    4343 
    4444  -- Mise à jour de la table geometry_columns 
    45   SELECT Populate_Geometry_Columns();  
    46    
     45  SELECT Populate_Geometry_Columns(); 
     46 
    4747.. image:: ./geometry_returning/liberty_positive.jpg 
    4848 
    49 La fonction :command:`ST_Buffer` permet aussi d'utiliser des valeur négative pour le paramÚtre distance et construit un polygone inclue dans celui passé en paramÚtre. Pour les points et les lignes vous obtiendrez simplement un résultat vide. 
     49La fonction :command:`ST_Buffer` permet aussi d'utiliser des valeurs négatives pour le paramÚtre distance et construit un polygone inclus dans celui passé en paramÚtre. Pour les points et les lignes vous obtiendrez simplement un résultat vide. 
    5050 
    5151.. image:: ./geometry_returning/liberty_negative.jpg 
    … …  
    5555--------------- 
    5656 
    57 Une autre opération classique présente dans les SIGS - le chevauchement - crée une nouvelle entité en calculant la zone correpondant à l'intersection de deux polygones supperposés. Le résultat à la propriété de permettre de reconstruire les entité de base à l'aide de ce résultat. 
     57Une autre opération classique présente dans les SIG - le chevauchement - crée une nouvelle entité en calculant la zone correspondant à l'intersection de deux polygones superposés. Le résultat à la propriété de permettre de reconstruire les entités de base à l'aide de ce résultat. 
    5858 
    59 La fonction :command:`ST_Intersection(geometry A, geometry B)` retourne la zone géographique (ou une ligne, ou un point) que les deux géométries on en commun. Si les géométries sont disjointes, la fontion retourne une géométrie vide. 
     59La fonction :command:`ST_Intersection(geometry A, geometry B)` retourne la zone géographique (ou une ligne, ou un point) que les deux géométries ont en commun. Si les géométries sont disjointes, la fonction retourne une géométrie vide. 
    6060 
    6161.. code-block:: sql 
    … …  
    6363  -- Quelle est l'aire que ces deux cercles ont en commun ? 
    6464  -- Utilisons la fonction ST_Buffer pour créer ces cercles ! 
    65    
     65 
    6666  SELECT ST_AsText(ST_Intersection( 
    6767    ST_Buffer('POINT(0 0)', 2), 
    … …  
    7676-------- 
    7777 
    78 Dans l'exemple précédent nous intersections des géométries, créant une nouvelle géométrie unique à partir de deux entités. La commade :command:`ST_Union` fait l'inverse, elle prend en paramÚtre des géométries et supprime les parties communes. Il y a deux versions possibles de la fonction  :command:`ST_Union` :  
     78Dans l'exemple précédent, nous intersections des géométries, créant une nouvelle géométrie unique à partir de deux entités. La commande :command:`ST_Union` fait l'inverse, elle prend en paramÚtre des géométries et supprime les parties communes. Il y a deux versions possibles de la fonction  :command:`ST_Union` : 
    7979 
    80  * :command:`ST_Union(geometry, geometry)`: une version avec deux paramÚtres qui prend les géométries et rentourne l'union des deux. Par exemple, nos deux cercles ressemble à ce qui suit si nous utilisons l'opération union plutÃŽt que l'intersection. 
    81   
     80 * :command:`ST_Union(geometry, geometry)`: une version avec deux paramÚtres qui prend les géométries et retourne l'union des deux. Par exemple, nos deux cercles ressemblent à ce qui suit si nous utilisons l'opération union plutÃŽt que l'intersection. 
     81 
    8282   .. code-block:: sql 
    8383 
    84      -- Quelle est l'aire totale des ces deux cercles ? 
     84     -- Quelle est l'aire totale de ces deux cercles ? 
    8585     -- Utilisons ST_Buffer pour créer les cercles ! 
    86   
     86 
    8787     SELECT ST_AsText(ST_Union( 
    8888       ST_Buffer('POINT(0 0)', 2), 
    8989       ST_Buffer('POINT(3 0)', 2) 
    9090     )); 
    91    
     91 
    9292   .. image:: ./geometry_returning/union.jpg 
    93     
    9493 
    95  * :command:`ST_Union([geometry])`: une version agrégée qui prendre un ensemble de géométries et retourne une géométrie contenant l'ensemble des géométries rassemblées. La fonction égrégée ST_Union peut être utilisé grâce au SQL ``GROUP BY`` our créer un ensemble rassemblant des sous-ensembles de géométries basiques. Cela est trÚs puissant, 
    9694 
    97 Par exemple la fonction d'agrégation  :command:`ST_Union`, considÚrons notre table ``nyc_census_blocks``.  
    98 As an example of :command:`ST_Union` aggregation, consider our ``nyc_census_blocks`` table. Census geography is carefully constructed so that larger geographies can be built up from smaller ones. So, we can create a census tracts map by merging the blocks that form each tract (as we do later in :ref:`creatingtractstable`). Or, we can create a county map by merging blocks that fall within each county. 
     95 * :command:`ST_Union([geometry])`: une version agrégée qui prendre un ensemble de géométries et retourne une géométrie contenant l'ensemble des géométries rassemblées. La fonction agrégée ST_Union peut être utilisé grâce au SQL ``GROUP BY`` pour créer un ensemble rassemblant des sous-ensembles de géométries basiques. Cela est trÚs puissant. 
    9996 
    100 To carry out the merge, note that the unique key ``blkid`` actually embeds information about the higher level geographies. Here are the parts of the key for Liberty Island we used earlier: 
     97Comme exemple pour la fonction d'agrégation  :command:`ST_Union`, considérons notre table ``nyc_census_blocks``. 
     98Les géographie du recensement sont construites de maniÚre à ce qu'on puisse créer d'autres géographies à partir des premiÚres. ainsi, nous pouvons créer une carte des secteurs de recensement en fusionnant les blocs que forme chaque secteur (comme nous le ferons aprÚs dans :ref:`la création des tables secteurs<creatingtractstable>`). Ou, nous pouvons créer une carte du comté en fusionnant les blocs qui relÚvent de chaque comté. 
     99 
     100Pour effectuer la fusion, notez que la clé unique ``blkid`` incorpore des informations sur les géographies de niveau supérieur. Voici les parties de la clé pour Liberty Island que nous avons utilisé précédemment. 
    101101 
    102102:: 
    103103 
    104104  360610001009000 = 36 061 00100 9000 
    105    
     105 
    106106  36     = State of New York 
    107107  061    = New York County (Manhattan) 
    … …  
    109109  9      = Census Block Group 
    110110  000    = Census Block 
    111    
    112 So, we can create a county map by merging all geometries that share the same first 5 digits of their ``blkid``. 
     111 
     112Ainsi, nous pouvons créer une carte du comté en fusionnant toutes les géométries qui partagent les 5 premiers chiffres de ``blkid``. 
    113113 
    114114.. code-block:: sql 
    115115 
    116   -- Création d'une table nyc_census_counties en regroupant les bloques 
     116  -- Création d'une table nyc_census_counties en regroupant les blocs 
    117117  CREATE TABLE nyc_census_counties AS 
    118   SELECT  
    119     ST_Union(the_geom) AS the_geom,  
     118  SELECT 
     119    ST_Union(the_geom) AS the_geom, 
    120120    SubStr(blkid,1,5) AS countyid 
    121121  FROM nyc_census_blocks 
    122122  GROUP BY countyid; 
    123    
     123 
    124124  -- Mise à jour de la table geometry_columns 
    125125  SELECT Populate_Geometry_Columns(); 
    126    
     126 
    127127.. image:: ./geometry_returning/union_counties.png 
    128128 
    129 An area test can confirm that our union operation did not lose any geometry. First, we calculate the area of each individual census block, and sum those areas grouping by census county id. 
     129Un test de surface peut confirmer que notre opération d'union n'a pas perdu de géométries. Tout d'abord, nous calculons la surface de chacun des blocs de recensement et faisons la somme de ces surfaces en les groupant par l'identifiant de recensement des comtés. 
    130130 
    131131.. code-block:: sql 
    132132 
    133133  SELECT SubStr(blkid,1,5) AS countyid, Sum(ST_Area(the_geom)) AS area 
    134   FROM nyc_census_blocks  
     134  FROM nyc_census_blocks 
    135135  GROUP BY countyid; 
    136136 
    137137:: 
    138138 
    139   countyid |       area        
     139  countyid |       area 
    140140 ----------+------------------ 
    141141  36005    | 109807439.720947 
    … …  
    145145  36085    | 149806077.958252 
    146146 
    147 Ensuite nous calculons l'aire de chaque zone de nos nouveaux polygones de régions de la table count : 
     147Ensuite nous calculons l'aire de chaque zone de nos nouveaux polygones de région de la table count : 
    148148 
    149149.. code-block:: sql 
    … …  
    154154:: 
    155155 
    156   countyid |       area        
     156  countyid |       area 
    157157 ----------+------------------ 
    158158  36005    | 109807439.720947 
    … …  
    167167------------------- 
    168168 
    169 `ST_AsText(text) <http://postgis.org/docs/ST_AsText.html>`_: retourne la représentation Well-Known Text (WKT) de la geometry/geography sans métadonnée SRID. 
     169`ST_AsText(text) <http://postgis.org/docs/ST_AsText.html>`_: retourne la représentation Well-Known Text (WKT) de la géométrie/géographie sans métadonnée SRID. 
    170170 
    171 `ST_Buffer(geometry, distance) <http://postgis.org/docs/ST_Buffer.html>`_: For geometry: Returns a geometry that represents all points whose distance from this Geometry is less than or equal to distance. Calculations are in the Spatial Reference System of this Geometry. For geography: Uses a planar transform wrapper.  
     171`ST_Buffer(geometry, distance) <http://postgis.org/docs/ST_Buffer.html>`_: Pour les géométries: retourne une géométrie qui représente tous les points dont la distance depuis cette géométrie est inférieure ou égale à la distance utilisée. Les calculs se font dans le systÚme de référence spatial de cette géométrie. Pour les géographies: utilise une fonction de transformation planaire pour effectuer le calcul. 
    172172 
    173 `ST_Intersection(geometry A, geometry B) <http://postgis.org/docs/ST_Intersection.html>`_: Returns a geometry that represents the shared portion of geomA and geomB. The geography implementation does a transform to geometry to do the intersection and then transform back to WGS84. 
     173`ST_Intersection(geometry A, geometry B) <http://postgis.org/docs/ST_Intersection.html>`_: retourne une géométrie qui représente la portion commune des géométries A et B. L'implémentation du type géographie fait une transformation vers une géométrie pour faire l'intersection puis reprojette le résultat en WGS84. 
    174174 
    175 `ST_Union() <http://postgis.org/docs/ST_Union.html>`_: Returns a geometry that represents the point set union of the Geometries. 
     175`ST_Union() <http://postgis.org/docs/ST_Union.html>`_: Renvoie un objet géométrique qui représente l'ensemble d'union des objets géométriques désignés. 
    176176 
    177 `substring(string [from int] [for int]) <http://www.postgresql.org/docs/8.1/static/functions-string.html>`_: PostgreSQL string function to extract substring matching SQL regular expression. 
     177`substring(string [from int] [for int]) <http://www.postgresql.org/docs/8.1/static/functions-string.html>`_: Fonction de chaîne PostgreSQL pour extraire une sous-chaîne de caractÚres. 
    178178 
    179 `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. 
     179`sum(expression) <http://www.postgresql.org/docs/8.2/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE>`_: Fonction d'agrégation PostgreSQL qui retourne la somme des valeurs d'une colonne dans un ensemble d'enregistrements. 
     180 

  • trunk/workshop-foss4g/glossary.rst

    r57 r62  
    22 
    33Annexes B : Glossaire 
    4 ==================== 
     4===================== 
    55 
    66.. glossary:: 
    77 
    88    CRS 
    9         Un "systÚme de références spatiales". La combinaison d'un systÚme de coordonnée géographiques et un systÚme de projection. 
     9        Un "systÚme de référence spatiale". La combinaison d'un systÚme de coordonnéee géographiques et un systÚme de projection. 
    1010 
    1111    GDAL 
    … …  
    1313 
    1414    GeoJSON 
    15         "Javascript Object Notation", un format texte qui est trÚs rapide et qui permet de représenter des objet JavaScript. En spatial, la spécification étendue `GeoJSON <http://geojson.org>`_ est courramment utilisée. 
    16      
     15        "Javascript Object Notation", un format texte qui est trÚs rapide et qui permet de représenter des objets JavaScript. En spatial, la spécification étendue `GeoJSON <http://geojson.org>`_ est couramment utilisée. 
     16 
    1717    SIG 
    18         `SystÚme d'Information Géographique <http://en.wikipedia.org/wiki/Geographic_information_system>`_ capture, stock, analyse, gÚre, et présente les données qui sont reliées à la zone géographique. 
    19      
     18        `SystÚme d'Information Géographique <http://en.wikipedia.org/wiki/Geographic_information_system>`_ capture, stocke, analyse, gÚre, et présente les données qui sont reliées à la zone géographique. 
     19 
    2020    GML 
    2121        `Geography Markup Language <http://www.opengeospatial.org/standards/gml>`_.  Le GML est un format standard XML :term:`OGC` pour représenter les données géographiques. 
    2222 
    2323    JSON 
    24         "Javascript Object Notation", un format text qui est trÚs rapide permettant de stocker les objets JavaScript. Au niveau spatial, la spécification étendu `GeoJSON <http://geojson.org>`_ est courramment utilisé. 
     24        "Javascript Object Notation", un format texte qui est trÚs rapide et permet de stocker des objets JavaScript. Au niveau spatial, la spécification étendue `GeoJSON <http://geojson.org>`_ est couramment utilisé. 
    2525 
    2626    JSTL 
    27         "JavaServer Page Template Library", est une bibliothÚque pour :term:`JSP` qui encapsule plusieurs fonctionalités de bases géré en JSP (requête de bases de données, itération, conditionnel) dans un syntaxe tiÚrce. 
     27        "JavaServer Page Template Library", est une bibliothÚque pour :term:`JSP` qui encapsule plusieurs fonctionnalités de bases gérées en JSP (requête de bases de données, itération, conditionnel) dans un syntaxe tierce. 
    2828 
    2929    JSP 
    … …  
    3131 
    3232    KML 
    33         "Keyhole Markup Language", le format XML utilisé par Google Earth. Google Earth. Il fût à l'origine développé par la société "Keyhole", ce qui expliqe sa présence (maintenant obscure)  dans le nom du format. 
     33        "Keyhole Markup Language", le format XML utilisé par Google Earth. Google Earth. Il fût à l'origine développé par la société "Keyhole", ce qui explique sa présence (maintenant obscure)  dans le nom du format. 
    3434 
    3535    OGC 
    36         Open Geospatial Consortium <http://opengeospatial.org/> (OGC) est une organisation qui développent des spécifications pour les services spatiaux. 
     36        Open Geospatial Consortium `<http://opengeospatial.org/>`_ (OGC) est une organisation qui développe des spécifications pour les services spatiaux. 
    3737 
    3838    OSGeo 
    39          Open Source Geospatial Foundation <http://osgeo.org> (OSGeo) est une association à but non lucratif dédié à la promotion et au support des logiciels cartographiques open source. 
     39         Open Source Geospatial Foundation `<http://osgeo.org>`_ (OSGeo) est une association à but non lucratif dédiée à la promotion et au support des logiciels cartographiques open source. 
    4040 
    4141    SFSQL 
    42         La spécification `Simple Features for SQL <http://www.opengeospatial.org/standards/sfs>`_ (SFSQL) de l':term:`OGC` définit les types et les fonctions qui doivent être disponibles dans une base de données spatiales. 
     42        La spécification `Simple Features for SQL <http://www.opengeospatial.org/standards/sfs>`_ (SFSQL) de l':term:`OGC` définit les types et les fonctions qui doivent être disponibles dans une base de données spatiale. 
    4343 
    4444    SLD 
    45         Les spécifications `Styled Layer Descriptor <http://www.opengeospatial.org/standards/sld>`_ (SLD) de l':term:`OGC` définissent un format permettant de décrire la maniÚre d'afficher des donnéesvectorielles. 
     45        Les spécifications `Styled Layer Descriptor <http://www.opengeospatial.org/standards/sld>`_ (SLD) de l':term:`OGC` définissent un format permettant de décrire la maniÚre d'afficher des données vectorielles. 
    4646 
    4747    SRID 
    48         "Spatial reference ID" est un identifiant unique assigné à un systÚme de coordonnées géographique particulier. La table PostGIS **spatial_ref_sys** contient un loarge collection de valeurs de SRID connus. 
     48        "Spatial reference ID" est un identifiant unique assigné à un systÚme de coordonnées géographiques particulier. La table PostGIS **spatial_ref_sys** contient une large collection de valeurs de SRID connus. 
    4949 
    5050    SQL 
    51         "Structured query language" est un standard permettant de requêter les bases de données relationnelle. Référence http://en.wikipedia.org/wiki/SQL. 
     51        "Structured query language" est un standard permettant de requêter les bases de données relationnelles. Référence http://en.wikipedia.org/wiki/SQL. 
    5252 
    5353    SQL/MM 
    54         `SQL Multimedia <http://www.fer.hr/_download/repository/SQLMM_Spatial-_The_Standard_to_Manage_Spatial_Data_in_Relational_Database_Systems.pdf>`_; includes several sections on extended types, including a substantial section on spatial types. 
     54        `SQL Multimedia <http://www.fer.hr/_download/repository/SQLMM_Spatial-_The_Standard_to_Manage_Spatial_Data_in_Relational_Database_Systems.pdf>`_; spécification contenant différentes sections sur les types étendues. Elle inclue une section substantielle sur les types spatiaux. 
    5555 
    5656    SVG 
    57         "Scalable vector graphics" est une famille de spécifications basé sur le format XML pour décrire des objet graphiques en 2 dimensions, aussi bien statiques que dynamiques (par exemple interactive ou animé). Réference : http://en.wikipedia.org/wiki/Scalable_Vector_Graphics. 
     57        "Scalable vector graphics" est une famille de spécifications basé sur le format XML pour décrire des objet graphiques en 2 dimensions, aussi bien statiques que dynamiques (par exemple interactif ou animé). Réference : http://en.wikipedia.org/wiki/Scalable_Vector_Graphics. 
    5858 
    5959    WFS 
    60         Les spécifications `Web Feature Service <http://www.opengeospatial.org/standards/wfs>`_ (WFS) de l':term:`OGC` définit une interface pour lire et écrire des données géographiques à travers internet. 
     60        La spécification `Web Feature Service <http://www.opengeospatial.org/standards/wfs>`_ (WFS) de l':term:`OGC` définit une interface pour lire et écrire des données géographiques à travers internet. 
    6161 
    6262    WMS 
    63         Les spécifications `Web Map Service <http://www.opengeospatial.org/standards/wms>`_ (WMS) de l':term:`OGC` définit une interface pour requêter une carte à travers internet. 
     63        La spécification `Web Map Service <http://www.opengeospatial.org/standards/wms>`_ (WMS) de l':term:`OGC` définit une interface pour requêter une carte à travers internet. 
    6464 
    6565    WKB 
    66         "Well-known binary". Fait référence à la représentation binaire desgéométries comme décrit dans les spécifications Simple Features for SQL (:term:`SFSQL`). 
    67          
     66        "Well-known binary". Fait référence à la représentation binaire des géométries comme décrit dans les spécifications Simple Features for SQL (:term:`SFSQL`). 
     67 
    6868    WKT 
    6969        "Well-known text". Fait référence à la représentation textuelle de géométries, avec des chaînes commençant par "POINT", "LINESTRING", "POLYGON", etc. Il peut aussi faire référence à la représentation textuelle d'un :term:`CRS`, avec une chaîne commençant par "PROJCS", "GEOGCS", etc.  Les représentations au format Well-known text sont des standards de l':term:`OGC`, mais n'ont pas leur propres documents de spécifications. La premiÚre description du WKT (pour les géométries et pour les CRS) apparaissent dans les spécifications :term:`SFSQL` 1.0. 
    70          
    7170 
    72    

  • trunk/workshop-foss4g/index.rst

    r59 r62  
    1919 
    2020**software/** 
    21   un répertoire contenant tout les logiciels que nous installerons 
     21  un répertoire contenant tous les logiciels que nous installerons 
    2222 
    2323**data/** 

  • trunk/workshop-foss4g/indexing.rst

    r47 r62  
    44================================= 
    55 
    6 Rapellez-vous que l'indexation spatiale est l'une des trois fonctionnalités clés d'une base de données spatiales. Les indexes permettent l'utilisation de grandes quantités de données dans une base. Sans l'indexation, chaque recherche d'entité nécessitera d'accéder séquentiellement à tout les enregistrements de la base de données. L'indexation accélÚres les recherche en organisant les données dans des arbres de recherche qui peuvent être parcouru efficacement pour retrouver une entité particuliÚre. 
     6Rapellez-vous que l'indexation spatiale est l'une des trois fonctionnalités clés d'une base de données spatiales. Les index permettent l'utilisation de grandes quantités de données dans une base. Sans l'indexation, chaque recherche d'entité nécessitera d'accéder séquentiellement à tous les enregistrements de la base de données. L'indexation accélÚre les recherches en organisant les données dans des arbres de recherche qui peuvent être parcourus efficacement pour retrouver une entité particuliÚre. 
    77 
    8 L'indexation spatiale l'un des plus grands atouts de PostGIS. Dans les exemples précédents, nous avons construit nos jointures spatiales en comparant la totalité des tables. Ceci peut parfois s'averrer trÚs coûteux : Réaliser la jointure de deux tables de 10000 enregistrements sans indexation nécessitera de comparer 100000000 valeurs, les comparaisons requises ne seront plus que 20000 avec l'indexation. 
     8L'indexation spatiale l'un des plus grands atouts de PostGIS. Dans les exemples précédents, nous avons construit nos jointures spatiales en comparant la totalité des tables. Ceci peut parfois s'avérer trÚs coûteux : réaliser la jointure de deux tables de 10000 enregistrements sans indexation nécessitera de comparer 100000000 valeurs, les comparaisons requises ne seront plus que 20000 avec l'indexation. 
    99 
    10 Lorsque nous avons chargé la table  ``nyc_census_blocks``, l'outils pgShapeLoader crée automatiquement un indexe spatial appelé ``nyc_census_blocks_the_geom_gist``. 
     10Lorsque nous avons chargé la table  ``nyc_census_blocks``, l'outil pgShapeLoader crée automatiquement un index spatial appelé ``nyc_census_blocks_the_geom_gist``. 
    1111 
    12 Pour démontrer combien il est important d'indexer ses données pour la performance des requêtes, essayons de requêter notre table ``nyc_census_blocks`` **sans** utiliser notre indexe. 
     12Pour démontrer combien il est important d'indexer ses données pour la performance des requêtes, essayons de requêter notre table ``nyc_census_blocks`` **sans** utiliser notre index. 
    1313 
    1414La premiÚre étape consiste à supprimer l'index. 
    … …  
    1717 
    1818  DROP INDEX nyc_census_blocks_the_geom_gist; 
    19    
     19 
    2020.. note:: 
    2121 
    2222   La commande ``DROP INDEX`` supprime un index existant de la base de données. Pour de plus amples informations à ce sujet, consultez la `documentation officielle de PostgreSQL <http://docs.postgresql.fr/9.1/sql-dropindex.html>`_. 
    23     
     23 
    2424Maintenant, regardons le temps d'exécution dans le coin en bas à droite de l'interface de requêtage de pgAdmin, puis lançons la commande suivante. Notre requête recherche les blocs de la rue Broad. 
    2525 
    … …  
    3131  ON ST_Contains(blocks.the_geom, subways.the_geom) 
    3232  WHERE subways.name = 'Broad St'; 
    33    
     33 
    3434:: 
    3535 
    36        blkid       
     36       blkid 
    3737 ----------------- 
    3838  360610007003006 
    39    
    40 La table ``nyc_census_blocks`` est trÚs petite (seulement quelque millier d'enregistrements) donc même sans l'index, la requête prends **55 ms** sur l'ordinateur de test. 
     39 
     40La table ``nyc_census_blocks`` est trÚs petite (seulement quelque milliers d'enregistrements) donc même sans l'index, la requête prends **55 ms** sur l'ordinateur de test. 
    4141 
    4242Maintenant remettons en place l'index et lançons de nouveau la requête. 
    … …  
    4848.. note:: l'utilisation de la clause ``USING GIST`` spécifie à PostgreSQL de créer une structure (GIST) pour cet index. Si vous recevez un message d'erreur ressemblant à ``ERROR: index row requires 11340 bytes, maximum size is 8191`` lors de la création, cela signifie sans doute que vous avez omis la clause ``USING GIST``. 
    4949 
    50 Sur l'rdinateur de test le temps d'exécution se réduit à **9 ms**. Plus votre table est grande, plus la différence de temps d'exécution pour une requête utilisant les indexes augmentera. 
     50Sur l'ordinateur de test le temps d'exécution se réduit à **9 ms**. Plus votre table est grande, plus la différence de temps d'exécution pour une requête utilisant les index augmentera. 
    5151 
    52 Comment les indexes spatiaux fonctionnent 
    53 ----------------------------------------- 
     52Comment les index spatiaux fonctionnent 
     53--------------------------------------- 
    5454 
    55 Les indexes des base de données standards créent des arbres hierarchiques basés sur les valeurs des colonnes à indexer. Les indexes spatiaux sont un peu différents - ils ne sont pas capables d'indexer des entités géométriques elles-même mais indexe leur étendues. 
     55Les index des bases de données standards créent des arbres hiérarchiques basés sur les valeurs des colonnes à indexer. Les index spatiaux sont un peu différents - ils ne sont pas capables d'indexer des entités géométriques elles-même mais ils indexent leur étendues. 
    5656 
    5757.. image:: ./indexing/bbox.png 
    … …  
    5959Dans la figure ci-dessus, le nombre de lignes qui intersectent l'étoile jaune est *unique*, la ligne rouge. Mais l'étendue des entités qui intersectent la boîte jaune sont *deux*, la boîte rouge et la boîte bleue. 
    6060 
    61 La maniÚre dont les bases de données répondent de maniÚre efficace à la question "Quelles lignes intersectent l'étoile jaune ?" correspond premiÚrement à répondre à la question "Quelle étendue intersecte l'étendue jaune" en utilisant les indexes (ce qui est trÚs rapide) puis à calculer le résultat exact de la question "Quelles lignes intersectent l'étoile jaune ?" **seulement en utilisant les entités retourné par le premier test**. 
     61La maniÚre dont les bases de données répondent de maniÚre efficace à la question "Quelles lignes intersectent l'étoile jaune ?" correspond premiÚrement à répondre à la question "Quelle étendue intersecte l'étendue jaune" en utilisant les index (ce qui est trÚs rapide) puis à calculer le résultat exact de la question "Quelles lignes intersectent l'étoile jaune ?" **seulement en utilisant les entités retournées par le premier test**. 
    6262 
    63 Pour de grandes tables, il y a un systÚme en "deux étapes" d'évaluation en utilisant dans un premier temps l'approximation à l'aide d'indexes, puis en réalisant le test exact sur une quantité bien moins importante de données ce qui réduit drastiquement le temps de calcul nécessaire à cette deuxiÚme étape. 
     63Pour de grandes tables, il y a un systÚme en "deux étapes" d'évaluation en utilisant dans un premier temps l'approximation à l'aide d'index, puis en réalisant le test exact sur une quantité bien moins importante de données ce qui réduit drastiquement le temps de calcul nécessaire à cette deuxiÚme étape. 
    6464 
    6565PotGIS et Oracle Spatial partage la même notion d'index structuré sous la forme "d'arbres R" [#RTree]_. Les arbres R classent les données sous forme de rectangles, de sous-rectangles etc. Cette structure d'index gÚre automatiquement la densité et la taille des objets. 
    … …  
    6767.. image:: ./indexing/index-01.png 
    6868 
    69 Requête avec seulement des indexes 
    70 ---------------------------------- 
     69Requête avec seulement des index 
     70-------------------------------- 
    7171 
    72 La plupart des fonctions utilisées par PostGIS (:command:`ST_Contains`, :command:`ST_Intersects`, :command:`ST_DWithin`, etc) prennent en compte les indexes automatiquement. Mais certaines fonctions (comme par exemple : :command:`ST_Relate`) ne les utilisent pas. 
     72La plupart des fonctions utilisées par PostGIS (:command:`ST_Contains`, :command:`ST_Intersects`, :command:`ST_DWithin`, etc) prennent en compte les index automatiquement. Mais certaines fonctions (comme par exemple : :command:`ST_Relate`) ne les utilisent pas. 
    7373 
    74 Pour utiliser une recherche par étendue utilisant les indexes (et pas de filtres), vous pouvez utiliser l'opérateur :command:`&&`. Pour les géométries, l'opérateur :command:`&&` signifie "l'étendue recouvre ou touche" de la même maniÚre que l'opérateur :command:`=` sur des entiers signifie que les valeurs sont égales. 
     74Pour utiliser une recherche par étendue utilisant les index (et pas de filtres), vous pouvez utiliser l'opérateur :command:`&&`. Pour les géométries, l'opérateur :command:`&&` signifie "l'étendue recouvre ou touche" de la même maniÚre que l'opérateur :command:`=` sur des entiers signifie que les valeurs sont égales. 
    7575 
    76 Essayons de comparer une requête avec seulement un indexe pour la population du quartier 'West Village'. En utilisant la commande :command:`&&` notre requête ressemble à cela : 
     76Essayons de comparer une requête avec seulement un index pour la population du quartier 'West Village'. En utilisant la commande :command:`&&` notre requête ressemble à cela : 
    7777 
    7878.. code-block:: sql 
    7979 
    80   SELECT Sum(popn_total)  
     80  SELECT Sum(popn_total) 
    8181  FROM nyc_neighborhoods neighborhoods 
    8282  JOIN nyc_census_blocks blocks 
    8383  ON neighborhoods.the_geom && blocks.the_geom 
    8484  WHERE neighborhoods.name = 'West Village'; 
    85    
     85 
    8686:: 
    8787 
    8888  50325 
    89    
     89 
    9090Maintenant essayons la même requête en utilisant la fonction plus précise :command:`ST_Intersects`. 
    9191 
    9292.. code-block:: sql 
    9393 
    94   SELECT Sum(popn_total)  
     94  SELECT Sum(popn_total) 
    9595  FROM nyc_neighborhoods neighborhoods 
    9696  JOIN nyc_census_blocks blocks 
    9797  ON ST_Intersects(neighborhoods.the_geom, blocks.the_geom) 
    9898  WHERE neighborhoods.name = 'West Village'; 
    99    
     99 
    100100:: 
    101101 
    102102  27141 
    103103 
    104 Un plus faible nombre de résultats ! La premiÚre requête nous renvoit tout les blocs qui intersectent l'étendue du quartier, la seconde nous renvoit seulement les blocs qui intersectent le quartier lui-même. 
     104Un plus faible nombre de résultats ! La premiÚre requête nous renvoie tous les blocs qui intersectent l'étendue du quartier, la seconde nous renvoie seulement les blocs qui intersectent le quartier lui-même. 
    105105 
    106106Analyse 
    107107--------- 
    108108 
    109 Le plannificateur de requête de PostgreSQL choisit intelligemment d'utiliser ou non les indexes pour réaliser une requête. Il n'est pas toujours plus rapide d'utiliser un index pour réaliser une recherche : si la recherche doit renvoyer l'ensemble des enregistrements d'une table, parcourir l'index pour récupérer chaque valeur sera plus lent que de parcourir linéairement l'ensemble de la table. 
     109Le planificateur de requête de PostgreSQL choisit intelligemment d'utiliser ou non les index pour réaliser une requête. Il n'est pas toujours plus rapide d'utiliser un index pour réaliser une recherche : si la recherche doit renvoyer l'ensemble des enregistrements d'une table, parcourir l'index pour récupérer chaque valeur sera plus lent que de parcourir linéairement l'ensemble de la table. 
    110110 
    111 Afin de savoir dans quelle situation il est nécessaire d'utiliser les idexes (lire une petite partie de la table plutÃŽt qu'une grande partie), PostgreSQL conserve des statistiques relatives à la distribution des données dans chaque colonne indexée. Par défaut, PostgreSQL rassemble les statistiques sur une base réguliÚre. Nénamoins, si vous changez dramatiquement le contenu de vos tables dans une période courte, les statisuqes ne seront alors plus à jour. 
     111Afin de savoir dans quelle situation il est nécessaire d'utiliser les index (lire une petite partie de la table plutÃŽt qu'une grande partie), PostgreSQL conserve des statistiques relatives à la distribution des données dans chaque colonne indexée. Par défaut, PostgreSQL rassemble les statistiques sur une base réguliÚre. Néanmoins, si vous changez dramatiquement le contenu de vos tables dans une période courte, les statistiques ne seront alors plus à jour. 
    112112 
    113 Pour vous assurez que les statistiques correspondent bien au contenu de la table actuelle, il est courrant d'utiliser la commande ``ANALYZE`` aprÚs un grand nombre de modifications ou de suppression de vos données. Cela force le systÚme de gestion des statistiques à récupérer l'ensemble des données des colonnes indexées. 
     113Pour vous assurez que les statistiques correspondent bien au contenu de la table actuelle, il est courant d'utiliser la commande ``ANALYZE`` aprÚs un grand nombre de modifications ou de suppression de vos données. Cela force le systÚme de gestion des statistiques à récupérer l'ensemble des données des colonnes indexées. 
    114114 
    115 La commande ``ANALYZE`` demande à PostgreSQL de parcourir la table et de mettre à jour les statistiques utilisées par le plannificateur de requêtes (la plannification des requêtes sera traité utiltérieurement). 
     115La commande ``ANALYZE`` demande à PostgreSQL de parcourir la table et de mettre à jour les statistiques utilisées par le planificateur de requêtes (la planification des requêtes sera traité ultérieurement). 
    116116 
    117117.. code-block:: sql 
    118118 
    119119   ANALYZE nyc_census_blocks; 
    120     
     120 
    121121Néttoyage 
    122122--------- 
    123123 
    124 Il est souvent stressant de constater que la simple création d'un indexe n'est pas suffisant pour que PostgreSQL l'utilise efficacement. Le nettoyage doit être réalisé aprÚs qu'un indexe soit créé ou aprÚs un grand nombre de requêtes UDATE, INSERT ou DELETE est été réalisé sur une table. La commande ``VACUUM`` demande à PostgreSQL de récupérer chaque espace non utilisé dans les pages de la table qui sont laissé en l'état lors des requêtes UPDATE ou DELETE à cause du modÚle d'estapillage multi-versions. 
     124Il est souvent stressant de constater que la simple création d'un index n'est pas suffisant pour que PostgreSQL l'utilise efficacement. Le nettoyage doit être réalisé aprÚs qu'un index soit créé ou aprÚs un grand nombre de requêtes UDATE, INSERT ou DELETE ait été réalisé sur une table. La commande ``VACUUM`` demande à PostgreSQL de récupérer chaque espace non utilisé dans les pages de la table qui sont laissées en l'état lors des requêtes UPDATE ou DELETE à cause du modÚle d'estampillage multi-versions. 
    125125 
    126126Le nettoyage des données est tellement important pour une utilisation efficace du serveur de base de données PostgreSQL qu'il existe maintenant une option "autovacuum". 
    127127 
    128 Activée par défaut, le processus autovacuum nettoie (récupÚre l'espace libre) et analyse (met à jour les statistiques) vos tables suivant un interval donné déterminé par l'activité des bases de données. Bien que cela fonctionne avec les bases de données hautement transactionnelles, il n'est pas supportable de devoir attendre que le processus autovacuum se lance lors de la mise à jour ou la suppression massive de données. Dans ce cas, il faut lancer la commande ``VACUUM`` manuellement. 
     128Activée par défaut, le processus autovacuum nettoie (récupÚre l'espace libre) et analyse (met à jour les statistiques) vos tables suivant un intervalle donné déterminé par l'activité des bases de données. Bien que cela fonctionne avec les bases de données hautement transactionnelles, il n'est pas supportable de devoir attendre que le processus autovacuum se lance lors de la mise à jour ou la suppression massive de données. Dans ce cas, il faut lancer la commande ``VACUUM`` manuellement. 
    129129 
    130 Le nettoyage et l'analyse de la base de données peut être réalisé séparément si nécessaire. Utiliser la commande ``VACUUM`` ne mettra pas à jour les statistiques alors que lancer la commande ``ANALYZE`` ne récupÚrera pas l'espace libre des lignes d'une table. Chacune de ces commandes peut être lancée sur l'intégralité de la base de données, sur une table ou sur une seule colonne. 
     130Le nettoyage et l'analyse de la base de données peuvent être réalisés séparément si nécessaire. Utiliser la commande ``VACUUM`` ne mettra pas à jour les statistiques alors que lancer la commande ``ANALYZE`` ne récupÚrera pas l'espace libre des lignes d'une table. Chacune de ces commandes peut être lancée sur l'intégralité de la base de données, sur une table ou sur une seule colonne. 
    131131 
    132132.. code-block:: sql 
    … …  
    137137------------------- 
    138138 
    139 `geometry_a && geometry_b <http://postgis.org/docs/ST_Geometry_Overlap.html>`_: retourne TRUE si l'étendue de A cheuvauche celle de B. 
     139`geometry_a && geometry_b <http://postgis.org/docs/ST_Geometry_Overlap.html>`_: retourne TRUE si l'étendue de A chevauche celle de B. 
    140140 
    141141`geometry_a = geometry_b <http://postgis.org/docs/ST_Geometry_EQ.html>`_: retourne TRUE si l'étendue de A est la même que celle de B. 
    142142 
    143 `ST_Intersects(geometry_a, geometry_b) <http://postgis.org/docs/ST_Intersects.html>`_: retourne TRUE si l'objet Geometrie/Geography "intersecte spatiallement" - (ont une partie en commun) et FALSE sinon (elles sont dijointes).  
     143`ST_Intersects(geometry_a, geometry_b) <http://postgis.org/docs/ST_Intersects.html>`_: retourne TRUE si la géométrie *a* "intersecte spatialement" la géométrie '*b*- (si elles ont une partie en commun) et FALSE sinon (elles sont disjointes). 
    144144 
    145 .. rubric:: Footnotes 
     145.. rubric:: Notes de bas de page 
    146146 
    147147.. [#RTree] http://postgis.org/support/rtree.pdf 

  • trunk/workshop-foss4g/joins.rst

    r47 r62  
    44=================================== 
    55 
    6 Les jointures spatiales sont la cerise sur le gâteau des base de données spatiales. Elles vous pemettent de combiner les informations de plusieures tables en utilisant une relation spatiale comme clause de jointure. La plupart des "analyses SIG standards" peuvent être exprimées à l'aide de jointure spatiales. 
     6Les jointures spatiales sont la cerise sur le gâteau des base de données spatiales. Elles vous pemettent de combiner les informations de plusieurs tables en utilisant une relation spatiale comme clause de jointure. La plupart des "analyses SIG standards" peuvent être exprimées à l'aide de jointures spatiales. 
    77 
    88Dans la partie précé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 avons utilisé ce résultat dans nos autres requêtes pour répondre aux questions comme "dans quel quartier se situe la station 'Broad St' ?" 
    99 
    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 quartier la contenant :  
    11  
    12 .. code-block:: sql 
    13  
    14   SELECT  
    15     subways.name AS subway_name,  
    16     neighborhoods.name AS neighborhood_name,  
     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 quartier la contenant : 
     11 
     12.. code-block:: sql 
     13 
     14  SELECT 
     15    subways.name AS subway_name, 
     16    neighborhoods.name AS neighborhood_name, 
    1717    neighborhoods.boroname AS borough 
    1818  FROM nyc_neighborhoods AS neighborhoods 
    … …  
    2121  WHERE subways.name = 'Broad St'; 
    2222 
    23 ::  
    24  
    25    subway_name | neighborhood_name  |  borough   
     23:: 
     24 
     25   subway_name | neighborhood_name  |  borough 
    2626  -------------+--------------------+----------- 
    2727   Broad St    | Financial District | Manhattan 
    … …  
    3838.. code-block:: sql 
    3939 
    40   SELECT  
    41     neighborhoods.name AS neighborhood_name,  
     40  SELECT 
     41    neighborhoods.name AS neighborhood_name, 
    4242    Sum(census.popn_total) AS population, 
    4343    Round(100.0 * Sum(census.popn_white) / Sum(census.popn_total),1) AS white_pct, 
    … …  
    5252:: 
    5353 
    54    neighborhood_name  | population | white_pct | black_pct  
     54   neighborhood_name  | population | white_pct | black_pct 
    5555 ---------------------+------------+-----------+----------- 
    5656  Carnegie Hill       |      19909 |      91.6 |       1.5 
    … …  
    8787 
    8888#. La clause ``JOIN`` crée une table virtuelle qui contient les colonnes à la fois des quartiers et des recensements (tables neighborhoods et census). 
    89 #. La clause ``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étique et de formatage (ex: ``GROUP BY``, ``ORDER BY``)) sur le nombres finaux, notre requête calcul les pourcentages. 
    92  
    93 .. note::  
     89#. La clause ``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 population. 
     91#. AprÚs un peu d'arithmétique et de formatage (ex: ``GROUP BY``, ``ORDER BY``)) sur le nombres finaux, notre requête calcule les pourcentages. 
     92 
     93.. note:: 
    9494 
    9595   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. 
    9696 
    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 d'analyser la géographie raciale de New York en utilisant les requêtes de distance. 
     97Nous pouvons aussi utiliser le test de la distance dans notre clef de jointure, pour créer une regroupement de "tous les éléments dans un certain rayon". Essayons d'analyser la géographie raciale de New York en utilisant les requêtes de distance. 
    9898 
    9999PremiÚrement, essayons d'obtenir la répartition raciale de la ville. 
    … …  
    101101.. code-block:: sql 
    102102 
    103   SELECT  
    104     100.0 * Sum(popn_white) / Sum(popn_total) AS white_pct,  
    105     100.0 * Sum(popn_black) / Sum(popn_total) AS black_pct,  
     103  SELECT 
     104    100.0 * Sum(popn_white) / Sum(popn_total) AS white_pct, 
     105    100.0 * Sum(popn_black) / Sum(popn_total) AS black_pct, 
    106106    Sum(popn_total) AS popn_total 
    107107  FROM nyc_census_blocks; 
    108108 
    109 ::  
    110  
    111         white_pct      |      black_pct      | popn_total  
     109:: 
     110 
     111        white_pct      |      black_pct      | popn_total 
    112112  ---------------------+---------------------+------------ 
    113113   44.6586020115685295 | 26.5945063345703034 |    8008278 
    … …  
    123123 
    124124  SELECT DISTINCT routes FROM nyc_subway_stations; 
    125    
    126 ::  
     125 
     126:: 
    127127 
    128128 A,C,G 
    … …  
    137137 
    138138   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. 
    139     
    140 Donc pour trouver le train A, nous allons demander toutes 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. 
    141  
    142 .. code-block:: sql 
    143  
    144    SELECT DISTINCT routes  
    145    FROM nyc_subway_stations AS subways  
     139 
     140Donc pour trouver le train A, nous allons demander toutes 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 champ route. 
     141 
     142.. code-block:: sql 
     143 
     144   SELECT DISTINCT routes 
     145   FROM nyc_subway_stations AS subways 
    146146   WHERE strpos(subways.routes,'A') > 0; 
    147     
     147 
    148148:: 
    149149 
    … …  
    157157  A,B,C,D 
    158158  A,C,E 
    159    
     159 
    160160Essayons de regrouper la répartition raciale dans un rayon de 200 mÚtres de la ligne du train A. 
    161161 
    162162.. code-block:: sql 
    163163 
    164   SELECT  
    165     100.0 * Sum(popn_white) / Sum(popn_total) AS white_pct,  
    166     100.0 * Sum(popn_black) / Sum(popn_total) AS black_pct,  
     164  SELECT 
     165    100.0 * Sum(popn_white) / Sum(popn_total) AS white_pct, 
     166    100.0 * Sum(popn_black) / Sum(popn_total) AS black_pct, 
    167167    Sum(popn_total) AS popn_total 
    168168  FROM nyc_census_blocks AS census 
    … …  
    173173:: 
    174174 
    175         white_pct      |      black_pct      | popn_total  
     175        white_pct      |      black_pct      | popn_total 
    176176  ---------------------+---------------------+------------ 
    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. 
     179La répartition raciale le long de la ligne du train A n'est pas radicalement différente de la répartition générale de la ville de New York. 
    180180 
    181181Jointures avancées 
    182182------------------ 
    183183 
    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étro à la fois. Pour faire ceci, nous créerons une table qui permettra d'énumérer toutes les lignes que nous voulons regrouper. 
     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 trains 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 plusieurs lignes de métro à 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 
    189189 
    190190    CREATE TABLE subway_lines ( route char(1) ); 
    191     INSERT INTO subway_lines (route) VALUES  
     191    INSERT INTO subway_lines (route) VALUES 
    192192      ('A'),('B'),('C'),('D'),('E'),('F'),('G'), 
    193193      ('J'),('L'),('M'),('N'),('Q'),('R'),('S'), 
    … …  
    195195      ('7'); 
    196196 
    197 Maintenant nous pouvons joindre les tables des lignes de métros à notre requête précédente. 
    198  
    199 .. code-block:: sql 
    200  
    201     SELECT  
     197Maintenant nous pouvons joindre les tables des lignes de métro à notre requête précédente. 
     198 
     199.. code-block:: sql 
     200 
     201    SELECT 
    202202      lines.route, 
    203       Round(100.0 * Sum(popn_white) / Sum(popn_total), 1) AS white_pct,  
    204       Round(100.0 * Sum(popn_black) / Sum(popn_total), 1) AS black_pct,  
     203      Round(100.0 * Sum(popn_white) / Sum(popn_total), 1) AS white_pct, 
     204      Round(100.0 * Sum(popn_black) / Sum(popn_total), 1) AS black_pct, 
    205205      Sum(popn_total) AS popn_total 
    206206    FROM nyc_census_blocks AS census 
    … …  
    214214:: 
    215215 
    216      route | white_pct | black_pct | popn_total  
     216     route | white_pct | black_pct | popn_total 
    217217    -------+-----------+-----------+------------ 
    218218     S     |      30.1 |      59.5 |      32730 
    … …  
    239239 
    240240 
    241 Comme précédemment, les jointures créent une table virtuelle de toutes les combinaisons possibles et 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 blocs sont suffisamment proches des lignes de métros inclues dans le calcul. 
     241Comme précédemment, les jointures créent une table virtuelle de toutes les combinaisons possibles et disponibles à l'aide des contraintes de type ``JOIN ON`. Ces lignes sont ensuite utilisées dans le regroupement ``GROUP``. La magie spatiale tient dans l'utilisation de la fonction ``ST_DWithin`` qui s'assure que les blocs sont suffisamment proches des lignes de métros incluses dans le calcul. 
    242242 
    243243Liste de fonctions 
    … …  
    246246`ST_Contains(geometry A, geometry B) <http://postgis.org/docs/ST_Contains.html>`_: retourne TRUE si et seulement si aucun point 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. 
    247247 
    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).  
     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 portion de l'espace) et FALSE sinon (elles sont disjointes). 
    251251 
    252252`round(v numeric, s integer) <http://www.postgresql.org/docs/7.4/interactive/functions-math.html>`_: fonction de PostgreSQL qui arrondit à s décimales. 
    … …  
    256256`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 
    258 .. rubric:: Footnotes 
     258.. rubric:: Notes de bas de page 
    259259 
    260260.. [#PostGIS_Doco] http://postgis.org/documentation/manual-1.5/ 

  • trunk/workshop-foss4g/joins_advanced.rst

    r54 r62  
    44======================================= 
    55 
    6 Dans la partie précédente nous avons vu les fonctions :command:`ST_Centroid(geometry)` et :command:`ST_Union([geometry])` ainsi que quelques exemples simples. Dans cette partie nous réaliseront des choses plus éllaborées. 
     6Dans la partie précédente nous avons vu les fonctions :command:`ST_Centroid(geometry)` et :command:`ST_Union(geometry)` ainsi que quelques exemples simples. Dans cette partie nous réaliserons des choses plus élaborées. 
    77 
    88.. _creatingtractstable: 
    … …  
    1111------------------------------------------------ 
    1212 
    13 Dans le répertoire ``\data\`` des travaux pratiques, il y a un fichier qui contient des données attributaires, mais pas de géométries, ce fichier est nommé ``nyc_census_sociodata.sql``. La table contient des données sociaux-économiques interressantes à propos de New York : revenus financiers, éducation .... Il y a juste un problÚme, les données sont rassemblé en "trace de recensement" et nous n'avons pas de données spatiales associées ! 
     13Dans le répertoire ``\data\`` des travaux pratiques, il y a un fichier qui contient des données attributaires, mais pas de géométries, ce fichier est nommé ``nyc_census_sociodata.sql``. La table contient des données sociaux-économiques intéressantes à propos de New York : revenus financiers, éducation .... Il y a juste un problÚme, les données sont rassemblées en "trace de recensement" et nous n'avons pas de données spatiales associées ! 
    1414 
    1515Dans cette partie nous allons 
    … …  
    1818 * Créer une table spatiale pour les traces de recensement 
    1919 * Joindre les données attributaires à nos données spatiales 
    20  * Réaliser certaines analises sur nos nouvelles données 
    21   
     20 * Réaliser certaines analyses sur nos nouvelles données 
     21 
    2222Chargement du fichier nyc_census_sociodata.sql 
    2323~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    2424 
    2525 #. Ouvrez la fenêtre de requêtage SQL depuis PgAdmin 
    26  #. Selectionnez **File->Open** depuis le menu et naviguez jusqu'au fichier ``nyc_census_sociodata.sql`` 
     26 #. Sélectionnez **File->Open** depuis le menu et naviguez jusqu'au fichier ``nyc_census_sociodata.sql`` 
    2727 #. Cliquez sur le bouton "Run Query" 
    28  #. Si vous cliquez sur le bouton "Refresh" depuis PgAdmin, la liste des table devrait contenir votre nouvelle table ``nyc_census_sociodata`` 
    29   
     28 #. Si vous cliquez sur le bouton "Refresh" depuis PgAdmin, la liste des tables devrait contenir votre nouvelle table ``nyc_census_sociodata`` 
     29 
    3030Création de la table traces de recensement 
    31 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    32   
    33 Comme nous l'avons dans la partie précédente, nous pouvons construire des géométries de niveau suppérieur en utilisant nos blocks de base en utilisant une partie de la clef ``blkid``. Afin de calculer les traces de recensement, nous avons besoin de regrouper les blocks en uitlisant les 11 premiers caractÚres de la colonne ``blkid``.  
    34   
     31~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     32 
     33Comme nous l'avons fait dans la partie précédente, nous pouvons construire des géométries de niveau suppérieur en utilisant nos blocs de base en utilisant une partie de la clef ``blkid``. Afin de calculer les traces de recensement, nous avons besoin de regrouper les blocs en uitlisant les 11 premiers caractÚres de la colonne ``blkid``. 
     34 
    3535  :: 
    3636 
    3737    360610001009000 = 36 061 00100 9000 
    3838 
    39     36     = State of New York  
     39    36     = State of New York 
    4040    061    = New York County (Manhattan) 
    4141    000100 = Census Tract 
    … …  
    4444 
    4545Création de la nouvelle table en utilisant la fonction d'agrégation :command:`ST_Union` : 
    46   
    47 .. code-block:: sql 
    48     
     46 
     47.. code-block:: sql 
     48 
    4949   -- Création de la table 
    5050   CREATE TABLE nyc_census_tract_geoms AS 
    51    SELECT  
    52      ST_Union(the_geom) AS the_geom,  
     51   SELECT 
     52     ST_Union(the_geom) AS the_geom, 
    5353     SubStr(blkid,1,11) AS tractid 
    5454   FROM nyc_census_blocks 
    5555   GROUP BY tractid; 
    56       
     56 
    5757   -- Indexation du champ tractid 
    5858   CREATE INDEX nyc_census_tract_geoms_tractid_idx ON nyc_census_tract_geoms (tractid); 
    59       
     59 
    6060   -- Mise à jour de la table geometry_columns 
    6161   SELECT Populate_Geometry_Columns(); 
    … …  
    6464~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    6565 
    66 L'objectif est ici de regrouper les données spatiales que nous avons créé avec les donées attributaires que nous avions chargé initialement. 
    67    
    68 .. code-block:: sql 
    69    
     66L'objectif est ici de regrouper les données spatiales que nous avons créé avec les données attributaires que nous avions chargé initialement. 
     67 
     68.. code-block:: sql 
     69 
    7070  -- Création de la table 
    7171  CREATE TABLE nyc_census_tracts AS 
    72   SELECT  
     72  SELECT 
    7373    g.the_geom, 
    7474    a.* 
    … …  
    7676  JOIN nyc_census_sociodata a 
    7777  ON g.tractid = a.tractid; 
    78      
     78 
    7979  -- Indexation des géométries 
    8080  CREATE INDEX nyc_census_tract_gidx ON nyc_census_tracts USING GIST (the_geom); 
    81      
     81 
    8282  -- Mise à jour de la table geometry_columns 
    8383  SELECT Populate_Geometry_Columns(); 
    … …  
    8585.. _interestingquestion: 
    8686 
    87 Répondre à une question interressante 
    88 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    89       
    90 Répondre à une question interressante ! "Lister les 10 meilleurs quartiers ordonnées par la proportion de personne ayant acquis un diplome".  
    91    
    92 .. code-block:: sql 
    93    
    94   SELECT  
    95     Round(100.0 * Sum(t.edu_graduate_dipl) / Sum(t.edu_total), 1) AS graduate_pct,  
    96     n.name, n.boroname  
    97   FROM nyc_neighborhoods n  
    98   JOIN nyc_census_tracts t  
    99   ON ST_Intersects(n.the_geom, t.the_geom)  
     87Répondre à une question intéressante 
     88~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     89 
     90Répondre à une question intéressante ! "Lister les 10 meilleurs quartiers ordonnés par la proportion de personnes ayant acquis un diplÃŽme". 
     91 
     92.. code-block:: sql 
     93 
     94  SELECT 
     95    Round(100.0 * Sum(t.edu_graduate_dipl) / Sum(t.edu_total), 1) AS graduate_pct, 
     96    n.name, n.boroname 
     97  FROM nyc_neighborhoods n 
     98  JOIN nyc_census_tracts t 
     99  ON ST_Intersects(n.the_geom, t.the_geom) 
    100100  WHERE t.edu_total > 0 
    101101  GROUP BY n.name, n.boroname 
    … …  
    103103  LIMIT 10; 
    104104 
    105 Nous sommons les statistiques qui nous interressent, nous les divisons ensuite à la fin. Afin d'aviter l'erreur de non-division par zero, nous ne prennons pas en compte les quartiers qui n'ont aucune personne ayant obtenu un diplome. 
    106  
    107 :: 
    108    
    109    graduate_pct |       name        | boroname   
     105Nous sommons les statistiques qui nous intéressent, nous les divisons ensuite à la fin. Afin d'éviter l'erreur de non-division par zéro, nous ne prenons pas en compte les quartiers qui n'ont aucune personne ayant obtenu un diplÃŽme. 
     106 
     107:: 
     108 
     109   graduate_pct |       name        | boroname 
    110110  --------------+-------------------+----------- 
    111111           40.4 | Carnegie Hill     | Manhattan 
    … …  
    119119           29.8 | West Village      | Manhattan 
    120120           29.7 | Central Park      | Manhattan 
    121      
    122    
     121 
     122 
    123123.. _polypolyjoins: 
    124124 
    125125Polygones/Jointures de polygones 
    126 --------------------------------- 
    127  
    128 Dans notre requête interressante (dans :ref:`interestingquestion`) nous avons utilisé la fonction :command:`ST_Intersects(geometry_a, geometry_b)` pour déterminer quelle entité polygonale à inclure dans chaque groupe de quartier. Ce qui nous conduit à la question : que ce passe-t-il si une entité tombe ntre deux quartier ? Il intersectera chacun d'entre eux et ainsi sera inclu dans **chacun** des résultats.  
     126-------------------------------- 
     127 
     128Dans notre requête intéressante (dans :ref:`interestingquestion`) nous avons utilisé la fonction :command:`ST_Intersects(geometry_a, geometry_b)` pour déterminer quelle entité polygonale à inclure dans chaque groupe de quartier. Ce qui nous conduit à la question : que ce passe-t-il si une entité tombe entre deux quartiers ? Il intersectera chacun d'entre eux et ainsi sera inclut dans **chacun** des résultats. 
    129129 
    130130.. image:: ./screenshots/centroid_neighborhood.png 
    … …  
    132132Pour éviter ce cas de double comptage il existe trois méthodes : 
    133133 
    134  * La méthode simple consiste a s'assurer que chaque entité ne se retrouve que dans **un** seul groupe géograhique (en utilisant :command:`ST_Centroid(geometry)`) 
     134 * La méthode simple consiste a s'assurer que chaque entité ne se retrouve que dans **un** seul groupe géographique (en utilisant :command:`ST_Centroid(geometry)`) 
    135135 * La méthode complexe consiste à disviser les parties qui se croisent en utilisant les bordures (en utilisant :command:`ST_Intersection(geometry,geometry)`) 
    136   
     136 
    137137Voici un exemple d'utilisation de la méthode simple pour éviter le double comptage dans notre requête précédente : 
    138138 
    139139.. code-block:: sql 
    140140 
    141   SELECT  
    142     Round(100.0 * Sum(t.edu_graduate_dipl) / Sum(t.edu_total), 1) AS graduate_pct,  
    143     n.name, n.boroname  
    144   FROM nyc_neighborhoods n  
    145   JOIN nyc_census_tracts t  
    146   ON ST_Contains(n.the_geom, ST_Centroid(t.the_geom))  
     141  SELECT 
     142    Round(100.0 * Sum(t.edu_graduate_dipl) / Sum(t.edu_total), 1) AS graduate_pct, 
     143    n.name, n.boroname 
     144  FROM nyc_neighborhoods n 
     145  JOIN nyc_census_tracts t 
     146  ON ST_Contains(n.the_geom, ST_Centroid(t.the_geom)) 
    147147  WHERE t.edu_total > 0 
    148148  GROUP BY n.name, n.boroname 
    149149  ORDER BY graduate_pct DESC 
    150150  LIMIT 10; 
    151    
     151 
    152152Remarquez que la requête prend plus de temps à s'exécuter, puisque la fonction :command:`ST_Centroid` doit être effectuée pour chaque entité. 
    153153 
    154154:: 
    155155 
    156    graduate_pct |       name        | boroname   
     156   graduate_pct |       name        | boroname 
    157157  --------------+-------------------+----------- 
    158158           49.2 | Carnegie Hill     | Manhattan 
    … …  
    166166           30.1 | Downtown          | Brooklyn 
    167167           28.4 | Cobble Hill       | Brooklyn 
    168    
     168 
    169169Éviter le double comptage change le résultat ! 
    170170 
    … …  
    175175---------------------------------------------- 
    176176 
    177 Une requête qu'il est sympat de demander est : "Comment les temps de permutation des gens proches (dans un rayon de 500 metres ) des stations de métros diffÚrent de ceuxqui en vive loin ? " 
    178  
    179 Néanmoins, la question rencontre les même problÚme de double comptage : plusieurs personnes seront dans un rayon de 500 metres de plusieurs stations de métros différentes. Coparons la population de New York : 
     177Une requête qu'il est "sympa" de demander est : "Comment les temps de permutation des gens proches (dans un rayon de 500 mÚtres ) des stations de métro diffÚrent de ceux qui en vivent loin ? " 
     178 
     179Néanmoins, la question rencontre les mêmes problÚmes de double comptage : plusieurs personnes seront dans un rayon de 500 mÚtres de plusieurs stations de métro différentes. Comparons la population de New York : 
    180180 
    181181.. code-block:: sql 
    … …  
    183183  SELECT Sum(popn_total) 
    184184  FROM nyc_census_blocks; 
    185    
     185 
    186186:: 
    187187 
    188188  8008278 
    189    
    190 Avec la population des gens de New York dans un rayon de 500 metres d'une station de métros : 
     189 
     190Avec la population des gens de New York dans un rayon de 500 mÚtres d'une station de métro : 
    191191 
    192192.. code-block:: sql 
    … …  
    196196  JOIN nyc_subway_stations subway 
    197197  ON ST_DWithin(census.the_geom, subway.the_geom, 500); 
    198    
     198 
    199199:: 
    200200 
    201201  10556898 
    202202 
    203 Il y a plus de personnes proches du métro qu'il y a de peronnes ! Clairement, notre requête SQL simple rencontre un gros problÚme de double comptage. Vous pouvez voir le problÚme en regardant l'image des zones tampons créées pour les stations. 
     203Il y a plus de personnes proches du métro qu'il y a de personnes ! Clairement, notre requête SQL simple rencontre un gros problÚme de double comptage. Vous pouvez voir le problÚme en regardant l'image des zones tampons créées pour les stations. 
    204204 
    205205.. image:: ./screenshots/subways_buffered.png 
    206206 
    207 La solution est de s'assurer que nous avons seulement des blocks distincts avant de les les regrouper. Nou spouvons réaliser cela en cassant notre requête en sous-requêtes qui récupÚre les blocks distincts, regroupé ensuite pour retrouner notre réponse : 
     207La solution est de s'assurer que nous avons seulement des blocs distincts avant de les regrouper. Nous pouvons réaliser cela en cassant notre requête en sous-requêtes qui récupÚrent les blocs distincts, les regroupent pour ensuite retourner notre réponse : 
    208208 
    209209.. code-block:: sql 
    … …  
    216216    ON ST_DWithin(census.the_geom, subway.the_geom, 500) 
    217217  ) AS distinct_blocks; 
    218    
     218 
    219219:: 
    220220 
    221221  4953599 
    222222 
    223 C'est mieux ! Donc un peu plus de 50 % de la population de New York vit à proximité (50m environ 5 à 7 minutes de marche) du métro. 
    224  
    225  
    226  
     223C'est mieux ! Donc un peu plus de 50 % de la population de New York vit à proximité (500m, environ 5 à 7 minutes de marche) du métro. 
     224 

  • trunk/workshop-foss4g/joins_exercises.rst

    r47 r62  
    66Voici un petit rappel de certaines des fonctions vues précédemment. Elles seront utiles pour les exercices ! 
    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_Area(geometry)` retourbe l'aire d'un polygone 
    11 * :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  
     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_Area(geometry)` retourne l'aire d'un polygone 
     11* :command:`ST_AsText(geometry)` retourne un texte WKT 
     12* :command:`ST_Contains(geometry A, geometry B)` retourne TRUE si la géométrie A contient la géométrie B 
    1313* :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_GeomFromText(text)` returns ``geometry`` 
    16 * :command:`ST_Intersects(geometry A, geometry B)` returns the true if geometry A intersects geometry B 
    17 * :command:`ST_Length(linestring)` retourne la longueur d'une 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 
     14* :command:`ST_DWithin(geometry A, geometry B, radius)` retourne TRUE si la A est distante d'au plus radius de B 
     15* :command:`ST_GeomFromText(text)` retourne une géométrie 
     16* :command:`ST_Intersects(geometry A, geometry B)` retourne TRUE si la géométrie A intersecte la géométrie B 
     17* :command:`ST_Length(linestring)` retourne la longueur d'une ligne 
     18* :command:`ST_Touches(geometry A, geometry B)` retourne TRUE si le contour extérieur de A touche B 
     19* :command:`ST_Within(geometry A, geometry B)` retourne TRUE si A est hors de B 
    2020 
    21 Souvenez-vous aussi des tables à votre disposition :  
     21Souvenez-vous aussi des tables à votre disposition : 
    2222 
    23  * ``nyc_census_blocks``  
    24   
     23 * ``nyc_census_blocks`` 
     24 
    2525   * name, popn_total, boroname, the_geom 
    26   
     26 
    2727 * ``nyc_streets`` 
    28   
     28 
    2929   * name, type, the_geom 
    30     
     30 
    3131 * ``nyc_subway_stations`` 
    32   
     32 
    3333   * name, routes, the_geom 
    34   
     34 
    3535 * ``nyc_neighborhoods`` 
    36   
     36 
    3737   * name, boroname, the_geom 
    3838 
    … …  
    4040--------- 
    4141 
    42  * **"Quelle station de métros se situe dans le quartier 'Little Italy' ? Quelle est l'itinéraire de métro à emprunter ?"** 
    43   
     42 * **"Quelle station de métro se situe dans le quartier 'Little Italy' ? Quelle est l'itinéraire de métro à emprunter ?"** 
     43 
    4444   .. code-block:: sql 
    45   
    46      SELECT s.name, s.routes  
     45 
     46     SELECT s.name, s.routes 
    4747     FROM nyc_subway_stations AS s 
    48      JOIN nyc_neighborhoods AS n  
    49      ON ST_Contains(n.the_geom, s.the_geom)   
     48     JOIN nyc_neighborhoods AS n 
     49     ON ST_Contains(n.the_geom, s.the_geom) 
    5050     WHERE n.name = 'Little Italy'; 
    5151 
    52    ::  
    53    
    54        name    | routes  
     52   :: 
     53 
     54       name    | routes 
    5555    -----------+-------- 
    5656     Spring St | 6 
    57       
     57 
    5858 * **"Quels sont les quartiers desservis pas le train numéro 6 ?"** (Astuce: la colonne ``routes`` de la table ``nyc_subway_stations`` dispose des valeurs suivantes: 'B,D,6,V' et 'C,6') 
    59   
     59 
    6060   .. code-block:: sql 
    61    
    62     SELECT DISTINCT n.name, n.boroname  
     61 
     62    SELECT DISTINCT n.name, n.boroname 
    6363    FROM nyc_subway_stations AS s 
    64     JOIN nyc_neighborhoods AS n  
    65     ON ST_Contains(n.the_geom, s.the_geom)   
     64    JOIN nyc_neighborhoods AS n 
     65    ON ST_Contains(n.the_geom, s.the_geom) 
    6666    WHERE strpos(s.routes,'6') > 0; 
    67      
     67 
    6868   :: 
    69    
    70             name        | boroname   
     69 
     70            name        | boroname 
    7171    --------------------+----------- 
    7272     Midtown            | Manhattan 
    … …  
    8787 
    8888   .. note:: 
    89    
    90      Nous avons utilisé le mot clef ``DISTINCT`` pour supprimer les répétitions dans notre ensemble de résultats où il y avait plus d'une seule station de métro dans le quartier.  
    91          
     89 
     90     Nous avons utilisé le mot clef ``DISTINCT`` pour supprimer les répétitions dans notre ensemble de résultats où il y avait plus d'une seule station de métro dans le quartier. 
     91 
    9292 * **"AprÚs le 11 septembre, le quartier de 'Battery Park' était interdit d'accÚs pendant plusieurs jours. Combien de personnes ont dû être évacuées ?"** 
    93   
     93 
    9494   .. code-block:: sql 
    95   
     95 
    9696     SELECT Sum(popn_total) 
    9797     FROM nyc_neighborhoods AS n 
    98      JOIN nyc_census_blocks AS c  
    99      ON ST_Intersects(n.the_geom, c.the_geom)   
     98     JOIN nyc_census_blocks AS c 
     99     ON ST_Intersects(n.the_geom, c.the_geom) 
    100100     WHERE n.name = 'Battery Park'; 
    101     
    102    ::  
     101 
     102   :: 
    103103 
    104104     9928 
    105      
     105 
    106106 * **"Quelle est la densité de population (personne / km^2) des quartiers de 'Upper West Side' et de 'Upper East Side' ?"** (Astuce: il y a 1000000 m^2 dans un km^2.) 
    107   
     107 
    108108   .. code-block:: sql 
    109     
    110      SELECT  
    111        n.name,  
     109 
     110     SELECT 
     111       n.name, 
    112112       Sum(c.popn_total) / (ST_Area(n.the_geom) / 1000000.0) AS popn_per_sqkm 
    113113     FROM nyc_census_blocks AS c 
    … …  
    117117     OR n.name = 'Upper East Side' 
    118118     GROUP BY n.name, n.the_geom; 
    119       
     119 
    120120   :: 
    121     
    122            name       |  popn_per_sqkm    
     121 
     122           name       |  popn_per_sqkm 
    123123     -----------------+------------------ 
    124124      Upper East Side | 47943.3590089405 
    125125      Upper West Side | 39729.5779474286 
    126126 
    127       

  • trunk/workshop-foss4g/postgis-functions.rst

    r57 r62  
    55 
    66Constructeurs 
    7 ------------ 
     7------------- 
    88 
    9 :command:`ST_MakePoint(Longitude, Latitude)`  
    10   Retourne un nouveau point. Note : ordre des coordonées (longitude puis latitude). 
     9:command:`ST_MakePoint(Longitude, Latitude)` 
     10  Retourne un nouveau point. Note : ordre des coordonnées (longitude puis latitude). 
    1111 
    1212:command:`ST_GeomFromText(WellKnownText, srid)` 
    … …  
    1717 
    1818:command:`ST_Expand(geometry, Radius)` 
    19   Retourne une nouvelle géométrie qui est une extension de l'étendue de la géométrie passé en argument. Cette fonction est utile pour créer des envelopes pour des recherches utilisants les indexations. 
     19  Retourne une nouvelle géométrie qui est une extension de l'étendue de la géométrie passée en argument. Cette fonction est utile pour créer des enveloppes pour des recherches utilisant les indexations. 
    2020 
    21 Srotie 
     21Sorties 
    2222------- 
    2323 
    … …  
    3131  Retourne une géométrie au format "standard" `GeoJSON <http://geojson.org>`_. 
    3232 
    33 Measures 
    34 ------------ 
     33Mesures 
     34------- 
    3535 
    3636:command:`ST_Area(geometry)` 
    37   Retourne l'aire d'une géométrie dans l'unité du systÚme de références spatiales. 
     37  Retourne l'aire d'une géométrie dans l'unité du systÚme de référence spatiale. 
    3838 
    3939:command:`ST_Length(geometry)` 
    40   Retourne la longueur de la géométrie dans l'unité du systÚme de références spatiales. 
     40  Retourne la longueur de la géométrie dans l'unité du systÚme de référence spatiale. 
    4141 
    4242:command:`ST_Perimeter(geometry)` 
    43   Retourne le périmétre de la géométrie dans l'unité du systÚme de références spatiales. 
     43  Retourne le périmÚtre de la géométrie dans l'unité du systÚme de référence spatiale. 
    4444 
    4545:command:`ST_NumPoints(linestring)` 
    … …  
    4949  Retourne le nombre de contours dans un polygone. 
    5050 
    51 :command:`ST_NumGeometries(geometry)`  
    52   Retourne le nombre de géométries dans une collections de géométries. 
     51:command:`ST_NumGeometries(geometry)` 
     52  Retourne le nombre de géométries dans une collection de géométries. 
    5353 
    5454Relations 
    55 ------------- 
     55--------- 
    5656 
    5757:command:`ST_Distance(geometry, geometry)` 
    58   Retourne la distance entre deux géométries dans l'unité du  systÚme de références spatiales. 
     58  Retourne la distance entre deux géométries dans l'unité du  systÚme de référence spatiale. 
    5959 
    60 :command:`ST_DWithin(geometry, geometry, radius)`  
    61   Retourne vrai si les géométries sont distant d'un rayon de l'autre, sinon faux. 
     60:command:`ST_DWithin(geometry, geometry, radius)` 
     61  Retourne TRUE si les géométries sont distantes d'un rayon de l'autre, sinon FALSE. 
    6262 
    6363:command:`ST_Intersects(geometry, geometry)` 
    64   Retourne vrai si les géométries sont disjointes, sinon faux. 
     64  Retourne TRUE si les géométries sont disjointes, sinon FALSE. 
    6565 
    6666:command:`ST_Contains(geometry, geometry)` 
    67   Retourne vrai si la premiÚre géométrie est totalement contenu dans la seconde, sinon faux. 
     67  Retourne TRUE si la premiÚre géométrie est totalement contenue dans la seconde, sinon FALSE. 
    6868 
    6969:command:`ST_Crosses(geometry, geometry)` 
    70   Retourne vrai si une ligne ou les contours d'un polygone croisent une ligne ou un contour de polygone, sinon faux. 
     70  Retourne TRUE si une ligne ou les contours d'un polygone croisent une ligne ou un contour de polygone, sinon FALSE. 
     71 

  • trunk/workshop-foss4g/projection.rst

    r47 r62  
    44=================================== 
    55 
    6 La Terre n'est pas plate et il n'y a pas de moyen simple de la poser à plat sur une carte en papier (ou l'écran d'un ordinateur). 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. 
     6La Terre n'est pas plate et il n'y a pas de moyen simple de la poser à plat sur une carte en papier (ou l'écran d'un ordinateur). Certaines projections préservent les aires, donc tous 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 Nous avons déjà recontrer des projections, lorsque nous avons charger les données de la ville de Ney York .Rappelez-vous qu'elles utilisaient le SRID 26918. Parfois, vous aurez malgré tout besoin de transformer et de reprojeter vos données d'un systÚme de projection à un 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)`. 
     8Nous avons déjà rencontré des projections, lorsque nous avons chargé les données de la ville de Ney York .Rappelez-vous qu'elles utilisaient le SRID 26918. Parfois, vous aurez malgré tout besoin de transformer et de reprojeter vos données d'un systÚme de projection à un autre, en utilisant la fonction  :command:`ST_Transform(geometry, srid)`. Pour manipuler les identifiants de systÚme de référence spatiale à partir d'une géométrie, PostGIS fournit les fonctions :command:`ST_SRID(geometry)` et :command:`ST_SetSRID(geometry, srid)`. 
    99 
    1010Nous pouvons vérifier le SRID de nos données avec la commande :command:`ST_SRID` : 
    … …  
    1313 
    1414  SELECT ST_SRID(the_geom) FROM nyc_streets LIMIT 1; 
    15    
     15 
    1616:: 
    1717 
    1818  26918 
    19    
    20 Et quelle est la définition du "26918" ? Comme nous l'avons vu lors de la partie ":ref:`chargement des données`", la définition se trouve dans la table ``spatial_ref_sys``. En fait, **deux** définitions sont présentes. La définition au format :term:`WKT` dans la colonne ``srtext`` 
     19 
     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 format :term:`WKT` dans la colonne ``srtext`` 
    2121 
    2222.. code-block:: sql 
    2323 
    2424   SELECT * FROM spatial_ref_sys WHERE srid = 26918; 
    25     
     25 
    2626En 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 : 
    2727 
    … …  
    2929 
    3030  SELECT proj4text FROM spatial_ref_sys WHERE srid = 26918; 
    31    
     31 
    3232:: 
    3333 
    34   +proj=utm +zone=18 +ellps=GRS80 +datum=NAD83 +units=m +no_defs  
    35    
     34  +proj=utm +zone=18 +ellps=GRS80 +datum=NAD83 +units=m +no_defs 
     35 
    3636En 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 autres, alors que la colonne ``proj4text`` est principalement utilisée par PostGIS en interne. 
    3737 
    … …  
    5454  ERROR:  Operation on two geometries with different SRIDs 
    5555  CONTEXT:  SQL function "st_equals" statement 1 
    56    
     56 
    5757 
    5858.. note:: 
    5959 
    60    Faites attention de pas utiliser la transformation à la volée à l'aide de :command:`ST_Transform` trop 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 application externe. 
     60   Faites attention de pas utiliser la transformation à la volée à l'aide de :command:`ST_Transform` trop souvent. Les index spatiaux sont construits en utilisant le SRID inclus dans les géométries. Si la comparaison est faite avec un SRID différent, les index 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 application externe. 
    6161 
    6262 
    … …  
    6464----------------------- 
    6565 
    66 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 le mÚtre comme unité de mesure. 
     66Si vous retournez à la définition au format proj4 du SRID 26918, vous pouvez voir que notre projection actuelle est de type UTM zone 18 (Universal Transvers Mercator), avec le mÚtre comme unité de mesure. 
    6767 
    6868:: 
    6969 
    70    +proj=utm +zone=18 +ellps=GRS80 +datum=NAD83 +units=m +no_defs  
     70   +proj=utm +zone=18 +ellps=GRS80 +datum=NAD83 +units=m +no_defs 
    7171 
    7272Essayons de convertir certaines données de notre systÚme de projection dans un systÚme de coordonnées géographiques connu comme "longitude/latitude". 
    7373 
    74 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é cela, 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 ? 
     74Pour 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é cela, nous devons ensuite trouver le SRID dans lequel nous souhaitons re-projeter. En d'autre terme, quel est le SRID des coordonnées géographiques ? 
    7575 
    76 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. 
     76Le 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 http://spatialreference.org. 
    7777 
    7878  http://spatialreference.org/ref/epsg/4326/ 
    79    
     79 
    8080Vous pouvez aussi récupérer les définitions dans la table  ``spatial_ref_sys`` : 
    8181 
    … …  
    8383 
    8484  SELECT srtext FROM spatial_ref_sys WHERE srid = 4326; 
    85    
     85 
    8686:: 
    8787 
    … …  
    9898.. code-block:: sql 
    9999 
    100   SELECT ST_AsText(ST_Transform(the_geom,4326))  
    101   FROM nyc_subway_stations  
     100  SELECT ST_AsText(ST_Transform(the_geom,4326)) 
     101  FROM nyc_subway_stations 
    102102  WHERE name = 'Broad St'; 
    103    
     103 
    104104:: 
    105105 
    106106  POINT(-74.0106714688735 40.7071048155841) 
    107107 
    108 Si vous chargez les données ou créez une nouvelle géométrie sans spécifier de 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. 
     108Si vous chargez les données ou créez une nouvelle géométrie sans spécifier de SRID, la valeur du SRID prendra alors la valeur -1. Rappelez-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. 
    109109 
    110 Pour visualiser la table d'assignation des SRID, interroger la table ``geometry_columns`` de la base de données. 
     110Pour visualiser la table d'assignation des SRID, interrogez la table ``geometry_columns`` de la base de données. 
    111111 
    112112.. code-block:: sql 
    113113 
    114   SELECT f_table_name AS name, srid  
     114  SELECT f_table_name AS name, srid 
    115115  FROM geometry_columns; 
    116    
     116 
    117117:: 
    118118 
    119           name         | srid   
     119          name         | srid 
    120120  ---------------------+------- 
    121121   nyc_census_blocks   | 26918 
    … …  
    125125   geometries          |    -1 
    126126 
    127    
    128 Néanmoins, si vous connaissez 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. 
     127 
     128Néanmoins, si vous connaissez 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 transformer dans d'autres systÚmes de projections. 
    129129 
    130130.. code-block:: sql 
    … …  
    144144`ST_SetSRID(geometry, srid) <http://postgis.org/docs/ST_SetSRID.html>`_: affecte une valeur au SRID d'une géométrie. 
    145145 
    146 `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`ST_SRID(geometry) <http://postgis.org/docs/ST_SRID.html>`_: retourne l'identifiant du systÚme de référence spatiale d'un objet ST_Geometry comme défini dans la table spatial_ref_sys. 
    147147 
    148 `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. 
     148`ST_Transform(geometry, srid) <http://postgis.org/docs/ST_Transform.html>`_: retourne une nouvelle géométrie aprÚs avoir re-projeté  les données dans le systÚme correspondant au SRID passé en paramÚtre. 
     149 

  • trunk/workshop-foss4g/projection_exercises.rst

    r47 r62  
    55 
    66Voici un rappel de certaines fonctions que nous avons vu. Elles seront utiles pour les exercices ! 
    7       
     7 
    88* :command:`sum(expression)` agrégation qui retourne la somme d'un ensemble de valeurs 
    99* :command:`ST_Length(linestring)` retourne la longueur d'une ligne 
    1010* :command:`ST_SRID(geometry, srid)` retourne le SRID d'une géométrie 
    11 * :command:`ST_Transform(geometry, srid)` reprojette des géométries dans un autre systÚme de références spatiales 
     11* :command:`ST_Transform(geometry, srid)` reprojette des géométries dans un autre systÚme de référence spatiale 
    1212* :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``) 
     13* :command:`ST_AsText(geometry)` retourne un WKT (``texte``) 
     14* :command:`ST_AsGML(geometry)` retourne un GML (``texte``) 
    1515 
    16 Rappelez-vous les resssources en ligne : 
     16Rappelez-vous les ressources en ligne : 
    1717 
    1818* http://spatialreference.org 
    … …  
    2121Et les tables disponibles : 
    2222 
    23  * ``nyc_census_blocks``  
    24   
     23 * ``nyc_census_blocks`` 
     24 
    2525   * name, popn_total, boroname, the_geom 
    26   
     26 
    2727 * ``nyc_streets`` 
    28   
     28 
    2929   * name, type, the_geom 
    30     
     30 
    3131 * ``nyc_subway_stations`` 
    32   
     32 
    3333   * name, the_geom 
    34   
     34 
    3535 * ``nyc_neighborhoods`` 
    36   
     36 
    3737   * name, boroname, the_geom 
    3838 
    … …  
    4141 
    4242 * **"Quelle est la longueur des rue de New York, mesurée en UTM 18 ?"** 
    43   
     43 
    4444   .. code-block:: sql 
    4545 
    … …  
    4747       FROM nyc_streets; 
    4848 
    49    ::  
    50     
     49   :: 
     50 
    5151     10418904.7172 
    52        
    53  * **"Quelle est la définition du SRID 2831 ?"**    
    54      
     52 
     53 * **"Quelle est la définition du SRID 2831 ?"** 
     54 
    5555   .. code-block:: sql 
    5656 
    … …  
    6262 :: 
    6363 
    64   PROJCS["NAD83(HARN) / New York Long Island",  
    65   GEOGCS["NAD83(HARN)",  
    66     DATUM["NAD83 (High Accuracy Regional Network)",  
    67       SPHEROID["GRS 1980", 6378137.0, 298.257222101, AUTHORITY["EPSG","7019"]],  
    68       TOWGS84[-0.991, 1.9072, 0.5129, 0.0257899075194932, -0.009650098960270402, -0.011659943232342112, 0.0],  
    69       AUTHORITY["EPSG","6152"]],  
    70     PRIMEM["Greenwich", 0.0, AUTHORITY["EPSG","8901"]],  
    71     UNIT["degree", 0.017453292519943295],  
    72     AXIS["Geodetic longitude", EAST],  
    73     AXIS["Geodetic latitude", NORTH],  
    74     AUTHORITY["EPSG","4152"]],  
    75   PROJECTION["Lambert Conic Conformal (2SP)", AUTHORITY["EPSG","9802"]],  
    76   PARAMETER["central_meridian", -74.0],  
    77   PARAMETER["latitude_of_origin", 40.166666666666664],  
    78   PARAMETER["standard_parallel_1", 41.03333333333333],  
    79   PARAMETER["false_easting", 300000.0],  
    80   PARAMETER["false_northing", 0.0],  
    81   PARAMETER["scale_factor", 1.0],  
    82   PARAMETER["standard_parallel_2", 40.666666666666664],  
    83   UNIT["m", 1.0],  
    84   AXIS["Easting", EAST],  
    85   AXIS["Northing", NORTH],  
     64  PROJCS["NAD83(HARN) / New York Long Island", 
     65  GEOGCS["NAD83(HARN)", 
     66    DATUM["NAD83 (High Accuracy Regional Network)", 
     67      SPHEROID["GRS 1980", 6378137.0, 298.257222101, AUTHORITY["EPSG","7019"]], 
     68      TOWGS84[-0.991, 1.9072, 0.5129, 0.0257899075194932, -0.009650098960270402, -0.011659943232342112, 0.0], 
     69      AUTHORITY["EPSG","6152"]], 
     70    PRIMEM["Greenwich", 0.0, AUTHORITY["EPSG","8901"]], 
     71    UNIT["degree", 0.017453292519943295], 
     72    AXIS["Geodetic longitude", EAST], 
     73    AXIS["Geodetic latitude", NORTH], 
     74    AUTHORITY["EPSG","4152"]], 
     75  PROJECTION["Lambert Conic Conformal (2SP)", AUTHORITY["EPSG","9802"]], 
     76  PARAMETER["central_meridian", -74.0], 
     77  PARAMETER["latitude_of_origin", 40.166666666666664], 
     78  PARAMETER["standard_parallel_1", 41.03333333333333], 
     79  PARAMETER["false_easting", 300000.0], 
     80  PARAMETER["false_northing", 0.0], 
     81  PARAMETER["scale_factor", 1.0], 
     82  PARAMETER["standard_parallel_2", 40.666666666666664], 
     83  UNIT["m", 1.0], 
     84  AXIS["Easting", EAST], 
     85  AXIS["Northing", NORTH], 
    8686  AUTHORITY["EPSG","2831"]] 
    87    
    8887 
    89  * **"Quelle est la longueur des rue de New York, mesuré en utilisant le SRID 2831 ?"** 
    90   
     88 
     89 * **"Quelle est la longueur des rues de New York, mesurée en utilisant le SRID 2831 ?"** 
     90 
    9191   .. code-block:: sql 
    9292 
    … …  
    9494       FROM nyc_streets; 
    9595 
    96    ::  
    97     
     96   :: 
     97 
    9898     10421993.706374 
    99       
     99 
    100100   .. note:: 
    101     
    102      La différence entre les mesure en UTM 18 et en 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, ce qui est proche de la valeur dans l'autre systÚme de projection (Stateplane Long Island). Ce dernier 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 beaucoup plus large. 
    103       
     101 
     102     La différence entre les mesure en UTM 18 et en 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 routes est 10421999, ce qui est proche de la valeur dans l'autre systÚme de projection (Stateplane Long Island). Ce dernier 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 raisonnable pour une zone régionale beaucoup plus large. 
     103 
    104104 * **"Quelle est la représentation KML du point de la station de métris 'Broad St' ?"** 
    105   
     105 
    106106   .. code-block:: sql 
    107     
    108      SELECT ST_AsKML(the_geom)  
     107 
     108     SELECT ST_AsKML(the_geom) 
    109109     FROM nyc_subway_stations 
    110110     WHERE name = 'Broad St'; 
    111       
    112    ::  
    113     
     111 
     112   :: 
     113 
    114114     <Point><coordinates>-74.010671468873468,40.707104815584088</coordinates></Point> 
    115       
     115 
    116116Hé ! les coordonnées sont géographiques bien que nous n'ayons pas fait appel à la fonction  :command:`ST_Transform`, mais pourquoi ? Parce que le standard KML spécifie que toutes les coordonnées *doivent* être géographiques (en fait, dans le systÚme EPSG:4326), donc la fonction :command:`ST_AsKML` réalise la transformation automatiquement. 
     117 

  • trunk/workshop-foss4g/simple_sql.rst

    r45 r62  
    44=============================== 
    55 
    6 :term:`SQL`, pour "Structured Query Language", définit la maniÚre d'importer et d'interroger des données dans une base. Vous avez déjà rédigé du SQL lorsque nous avons créer notre premiÚre base de données.  Rappel: 
     6:term:`SQL`, pour "Structured Query Language", définit la maniÚre d'importer et d'interroger des données dans une base. Vous avez déjà rédigé du SQL lorsque nous avons créé notre premiÚre base de données. 
     7 
     8Rappel: 
    79 
    810.. code-block:: sql 
    … …  
    1012   SELECT postgis_full_version(); 
    1113 
    12 Maintenant que nous avons charger des données dans notre base, essayons d'utiliser SQL pour les interroger. Par exemple, 
     14Maintenant que nous avons chargé des données dans notre base, essayons d'utiliser SQL pour les interroger. Par exemple, 
    1315 
    14   "Quel sont les noms des quartiers de la ville de New York ?" 
    15    
     16  "Quels sont les noms des quartiers de la ville de New York ?" 
     17 
    1618Ouvrez une fenêtre SQL depuis pgAdmin en cliquant sur le bouton SQL 
    1719 
    … …  
    2325 
    2426  SELECT name FROM nyc_neighborhoods; 
    25    
     27 
    2628et cliquez sur le bouton **Execute Query** (le triangle vert). 
    27    
    28 .. image:: ./screenshots/pgadmin_08.png   
     29 
     30.. image:: ./screenshots/pgadmin_08.png 
    2931 
    3032La requête s'exécutera pendant quelques (mili)secondes et retournera 129 résultats. 
    3133 
    32 .. image:: ./screenshots/pgadmin_09.png   
     34.. image:: ./screenshots/pgadmin_09.png 
    3335 
    34 Mais que c'est-il exactement passé ici ? Pour le comprendre, commençons par présenter les quatre types de requêtes du SQL : 
     36Mais que s'est-il exactement passé ici ? Pour le comprendre, commençons par présenter les quatre types de requêtes du SQL : 
    3537 
    3638 * ``SELECT``, retourne des lignes en réponse à une requête 
    … …  
    3840 * ``UPDATE``, modifie des lignes existantes d'une table 
    3941 * ``DELETE``, supprime des lignes d'une table 
    40   
    41 Nous travaillerons principalement avec des requêtes de type ``SELECT``afin d'interroger les tables en utilisant des fonctions spatiales. 
     42 
     43Nous travaillerons principalement avec des requêtes de type ``SELECT`` afin d'interroger les tables en utilisant des fonctions spatiales. 
    4244 
    4345Requête de type SELECT 
    … …  
    4749 
    4850  SELECT colonnes FROM données WHERE conditions; 
    49    
     51 
    5052.. note:: 
    5153 
    52     Pour une description exhaustive des paramÚtres possible d'une requête ``SELECT``, consultez la `documentaton de PostgresSQL  <http://www.postgresql.org/docs/8.1/interactive/sql-select.html>`_. 
    53      
     54    Pour une description exhaustive des paramÚtres possible d'une requête ``SELECT``, consultez la `documentation de PostgresSQL  <http://www.postgresql.org/docs/8.1/interactive/sql-select.html>`_. 
    5455 
    55 Les ``colonnes`` sont soit des noms de colonnes, soit des fonctions utilisant les valeurs des colonnes. Les ``données`` sont soit une table seule, soit plusieures tables reliées ensemble en réalisant une jointure sur une clef ou une autre condition. Les ``conditions`` représentent le filtre qui restreint le nombre de lignes à retourner. 
     56 
     57Les ``colonnes`` sont soit des noms de colonnes, soit des fonctions utilisant les valeurs des colonnes. Les ``données`` sont soit une table seule, soit plusieurs tables reliées ensemble en réalisant une jointure sur une clef ou une autre condition. Les ``conditions`` représentent le filtre qui restreint le nombre de lignes à retourner. 
    5658 
    5759  "Quel sont les noms des quartiers de Brooklyn ?" 
    5860 
    59 Nous retournons à notre table ``nyc_neighborhoods`` avec le filtre en main. La table contient tout les quartiers de New York et nous voulons uniquement ceux de Brooklyn. 
     61Nous retournons à notre table ``nyc_neighborhoods`` avec le filtre en main. La table contient tous les quartiers de New York et nous voulons uniquement ceux de Brooklyn. 
    6062 
    6163.. code-block:: sql 
    6264 
    63   SELECT name  
    64     FROM nyc_neighborhoods  
     65  SELECT name 
     66    FROM nyc_neighborhoods 
    6567    WHERE boroname = 'Brooklyn'; 
    6668 
    67 La requête prendra à nouveau quelque (mili)secondes et retournera les 23 éléments résultants. 
     69La requête prendra à nouveau quelque (milli)secondes et retournera les 23 éléments résultants. 
    6870 
    69 Parfois nous aurons besoin d'appliquer des fonctions sur le résultats d'une de nos requêtes. Par exemple, 
     71Parfois, nous aurons besoin d'appliquer des fonctions sur le résultat d'une de nos requêtes. Par exemple, 
    7072 
    7173  "Quel est le nombre de lettres dans les noms des quartiers de Brooklyn ?" 
    72    
     74 
    7375Heureusement PostgreSQL fournit une fonction calculant la longueur d'une chaîne de caractÚres : :command:`char_length(string)`. 
    7476 
    7577.. code-block:: sql 
    7678 
    77   SELECT char_length(name)  
    78     FROM nyc_neighborhoods  
     79  SELECT char_length(name) 
     80    FROM nyc_neighborhoods 
    7981    WHERE boroname = 'Brooklyn'; 
    8082 
    81 Bien souvent nous sommes moins interressés par une ligne particuliÚre mais plus par un calcul statistique sur l'ensemble résultant. Donc, connaitre la longueur des noms de quartiers est moins interressant que de calculer la moyenne des ces longueurs. Les fonctions qui renvoit un résultat unique en utilisant un ensemble de valeurs sont appelée des "fonctions d'aggrégations". 
     83Bien souvent, nous sommes moins interessés par une ligne particuliÚre que par un calcul statistique sur l'ensemble résultant. Donc, connaître la longueur des noms de quartiers est moins intéressant que de calculer la moyenne de ces longueurs. Les fonctions qui renvoient un résultat unique en utilisant un ensemble de valeurs sont appelées des "fonctions d'aggrégations". 
    8284 
    83 PostgreSQL fournit un ensemble de fonctions d'aggrégations, parmis lesquelles :command:`avg()` pour calculer la moyenne, and :command:`stddev()` pour l'écart type. 
     85PostgreSQL fournit un ensemble de fonctions d'aggrégations, parmi lesquelles :command:`avg()` pour calculer la moyenne, and :command:`stddev()` pour l'écart type. 
    8486 
    85   "Quel est le nombre moyen et l'écart type du nombre de lettre dans le noms des quartier de Brooklyn ?" 
    86    
     87  "Quel est le nombre moyen et l'écart type du nombre de lettres dans le nom des quartier de Brooklyn ?" 
     88 
    8789.. code-block:: sql 
    8890 
    89   SELECT avg(char_length(name)), stddev(char_length(name))  
    90     FROM nyc_neighborhoods  
     91  SELECT avg(char_length(name)), stddev(char_length(name)) 
     92    FROM nyc_neighborhoods 
    9193    WHERE boroname = 'Brooklyn'; 
    92    
     94 
    9395:: 
    9496 
    95            avg         |       stddev        
     97           avg         |       stddev 
    9698  ---------------------+-------------------- 
    9799   11.7391304347826087 | 3.9105613559407395 
    98100 
    99 Les fonctions d'agrégation dans notre dernier exemple sont appliquées à chaque ligne de l'ensemble des résultats. Comment faire si nous voulons rassembler des données ? Pour cela nous utilisons la clause ``GROUP BY``. Les fonctions d'agrégation ont souvent besoin d'une clause ``GROUP BY`` pour regrouper les éléments en utilisant une ou plusieures colonnes. 
     101Les fonctions d'agrégation dans notre dernier exemple sont appliquées à chaque ligne de l'ensemble des résultats. Comment faire si nous voulons rassembler des données ? Pour cela, nous utilisons la clause ``GROUP BY``. Les fonctions d'agrégation ont souvent besoin d'une clause ``GROUP BY`` pour regrouper les éléments en utilisant une ou plusieurs colonnes. 
    100102 
    101   "Quel est la moyenne des les noms de quartier de New York, renvoyer par quartiers ?" 
     103  "Quel est la moyenne du nombre de caractÚres des noms de quartiers et l'écart-type du nombre de caractÚres des noms de quartiers, renvoyé par section de New York ?" 
    102104 
    103105.. code-block:: sql 
    104106 
    105   SELECT boroname, avg(char_length(name)), stddev(char_length(name))  
    106     FROM nyc_neighborhoods  
     107  SELECT boroname, avg(char_length(name)), stddev(char_length(name)) 
     108    FROM nyc_neighborhoods 
    107109    GROUP BY boroname; 
    108   
    109110 
    110 Nous ajoutons la colonne ``boroname`` dans le résultat afin de pouvoir déterminer quelle valeur statistique s'applique à quel quartier. Dans une requête agrégée, vous pouvez seulement retourner les colonnes qui sont (a) membre de la clause de regroupement ou (b) des fonctions d'agrégation. 
    111    
     111 
     112Nous ajoutons la colonne ``boroname`` dans le résultat afin de pouvoir déterminer quelle valeur statistique s'applique à quelle section. Dans une requête agrégée, vous pouvez seulement retourner les colonnes qui sont (a) membre de la clause de regroupement ou (b) des fonctions d'agrégation. 
     113 
    112114:: 
    113115 
    114      boroname    |         avg         |       stddev        
     116     boroname    |         avg         |       stddev 
    115117  ---------------+---------------------+-------------------- 
    116118   Brooklyn      | 11.7391304347826087 | 3.9105613559407395 
    … …  
    119121   Queens        | 11.6666666666666667 | 5.0057438272815975 
    120122   Staten Island | 12.2916666666666667 | 5.2043390480959474 
    121    
     123 
    122124Liste de fonctions 
    123125------------------ 
    … …  
    125127`avg(expression) <http://www.postgresql.org/docs/current/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE>`_: fonction d'agrégation de PostgreSQL  qui retourne la valeur moyenne d'une colonne. 
    126128 
    127 `char_length(string) <http://www.postgresql.org/docs/current/static/functions-string.html>`_: fonction s'applicant aux chaînes de caractÚre de PostgreSQL qui retourne le nombre de lettres dans une chaîne. 
     129`char_length(string) <http://www.postgresql.org/docs/current/static/functions-string.html>`_: fonction s'appliquant aux chaînes de caractÚre de PostgreSQL qui retourne le nombre de lettres dans une chaîne. 
    128130 
    129131`stddev(expression) <http://www.postgresql.org/docs/current/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-STATISTICS-TABLE>`_: fonction d'aggrégation de PostgreSQL qui retourne l'écart type d'un ensemble de valeurs. 
    130    
    131    
     132 

  • trunk/workshop-foss4g/simple_sql_exercises.rst

    r46 r62  
    44=================================== 
    55 
    6 En utilisant la table ``nyc_census_blocks``, répondez au questions suivantes (et n'allez pas directement aux réponses ! ).  
     6En utilisant la table ``nyc_census_blocks``, répondez au questions suivantes (et n'allez pas directement aux réponses ! ). 
    77 
    8 Vous trouverez ci-dessous des informations utiles pour commencer. Référez-vous à la partie :ref:`À propos des nos données` pour la définition de notre table ``nyc_census_blocks``. 
     8Vous trouverez ci-dessous des informations utiles pour commencer. Référez-vous à la partie :ref:`A propos des nos données<about_data>` pour la définition de notre table ``nyc_census_blocks``. 
    99 
    1010.. list-table:: 
    … …  
    3838Ici se trouvent certaines des fonctions d'aggrégation qui vous seront utiles pour répondre aux questions : 
    3939 
    40  * avg() - la moyenne des vlauers dans un ensemble d'enregistrements 
    41  * sum() - la somme des valeurs d'un ensembe d'enregistrements 
    42  * count() - le nombre d'élément contenu dans un ensembe d'enregistrements. 
     40 * avg() - la moyenne des valeurs dans un ensemble d'enregistrements 
     41 * sum() - la somme des valeurs d'un ensemble d'enregistrements 
     42 * count() - le nombre d'éléments contenus dans un ensemble d'enregistrements. 
    4343 
    4444Maintenant les questions : 
    4545 
    4646 * **"Quelle est la population de la ville de New York ?"** 
    47   
     47 
    4848   .. code-block:: sql 
    49     
     49 
    5050     SELECT Sum(popn_total) AS population 
    5151       FROM nyc_census_blocks; 
    52       
    53    ::  
    54     
    55      8008278  
    56     
    57    .. note::  
    58     
    59        Qu'est-ce que ce ``AS`` dans la requête ? vous pouvez donner un nom à une table ou a des colonnes en utilisant un alias. Les alias permettent de rendre les requêtes plus simple à écrire et à lire. Donc au lieu que notre colonne résultat soit nommée ``sum`` nous utilisons le  **AS** pour la renommer en ``population``.  
    60         
     52 
     53   :: 
     54 
     55     8008278 
     56 
     57   .. note:: 
     58 
     59       Qu'est-ce que ce ``AS`` dans la requête ? vous pouvez donner un nom à une table ou à des colonnes en utilisant un alias. Les alias permettent de rendre les requêtes plus simple à écrire et à lire. Donc au lieu que notre colonne résultat soit nommée ``sum`` nous utilisons le  **AS** pour la renommer en ``population``. 
     60 
    6161 * **"Quelle est la population du Bronx ?"** 
    6262 
    6363   .. code-block:: sql 
    64   
     64 
    6565     SELECT Sum(popn_total) AS population 
    6666       FROM nyc_census_blocks 
    6767       WHERE boroname = 'The Bronx'; 
    68       
    69    ::  
    70     
    71      1332650  
    72     
    73  * **"Quelle est en moyenne le nombre de personne vivant dans chaque appartement de la ville de New York ?"** 
    74   
     68 
     69   :: 
     70 
     71     1332650 
     72 
     73 * **"Quelle est en moyenne le nombre de personnes vivant dans chaque appartement de la ville de New York ?"** 
     74 
    7575   .. code-block:: sql 
    7676 
    … …  
    7878       FROM nyc_census_blocks; 
    7979 
    80    ::  
    81     
    82      2.6503540522400804  
    83     
     80   :: 
     81 
     82     2.6503540522400804 
     83 
    8484 * **"Pour chaque quartier, quel est le pourcentage de population blanche ?"** 
    8585 
    8686   .. code-block:: sql 
    8787 
    88      SELECT  
    89          boroname,  
     88     SELECT 
     89         boroname, 
    9090         100 * Sum(popn_white)/Sum(popn_total) AS white_pct 
    9191       FROM nyc_census_blocks 
    9292       GROUP BY boroname; 
    9393 
    94    ::  
    95     
    96         boroname    |      white_pct       
     94   :: 
     95 
     96        boroname    |      white_pct 
    9797     ---------------+--------------------- 
    9898      Brooklyn      | 41.2005552206888663 
    … …  
    101101      Queens        | 44.0806610271290794 
    102102      Staten Island | 77.5968611401579346 
    103   
     103 
    104104Liste des fonctions 
    105105------------------- 
    106106 
    107 `avg(expression) <http://www.postgresql.org/docs/8.2/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE>`_: fonction d'aggrégation de PostgreSQL qui renvoit la moyenne d'un esemble de nombres. 
     107`avg(expression) <http://www.postgresql.org/docs/8.2/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE>`_: fonction d'aggrégation de PostgreSQL qui renvoie la moyenne d'un ensemble de nombres. 
    108108 
    109 `count(expression) <http://www.postgresql.org/docs/8.2/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE>`_: une fonction d'aggrégation de PostgreSQL qui retourne le nombre d'éléments dans un esemble. 
     109`count(expression) <http://www.postgresql.org/docs/8.2/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE>`_: une fonction d'aggrégation de PostgreSQL qui retourne le nombre d'éléments dans un ensemble. 
    110110 
    111111`sum(expression) <http://www.postgresql.org/docs/8.2/static/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE>`_: une fonction d'aggrégation de PostgreSQL qui retourne la somme des valeurs numériques d'un ensemble. 
     112 

  • trunk/workshop-foss4g/spatial_relationships.rst

    r47 r62  
    22 
    33Partie 10 : Les relations spatiales 
    4 ================================= 
     4=================================== 
    55 
    66Jusqu'à présent, nous avons utilisé uniquement des fonctions qui permettent de mesurer (:command:`ST_Area`, :command:`ST_Length`), de sérialiser (:command:`ST_GeomFromText`) ou désérialiser (:command:`ST_AsGML`) des géométries. Ces fonctions sont toutes utilisées sur une géométrie à la fois. 
    … …  
    88Les base de données spatiales sont puissantes car elle ne se contentent pas de stocker les géométries, elle peuvent aussi vérifier les *relations entre les géométries*. 
    99 
    10 Pour les questions comme "Quel est le plus proche garage à vélo prêt du parc ?" ou "Ou est l'intersection du métro avec telle rue ?", nous devrons comparer les géométries représentant les garage à vélo, les rues et les lignes de métro. 
     10Pour les questions comme "Quel est le plus proche garage à vélo prÚs du parc ?" ou "Ou est l'intersection du métro avec telle rue ?", nous devrons comparer les géométries représentant les garages à vélo, les rues et les lignes de métro. 
    1111 
    12 Le standard de l'OGC définit l'ensemble de fonctions suivant pour comparer les géométries. 
     12Le standard de l'OGC définit l'ensemble de fonctions suivantes pour comparer les géométries. 
    1313 
    1414ST_Equals 
    1515--------- 
    16   
    17 :command:`ST_Equals(geometry A, geometry B)` teste l'égalité spatiale de deux géométries.  
     16 
     17:command:`ST_Equals(geometry A, geometry B)` teste l'égalité spatiale de deux géométries. 
    1818 
    1919.. figure:: ./spatial_relationships/st_equals.png 
    … …  
    2727 
    2828  SELECT name, the_geom, ST_AsText(the_geom) 
    29   FROM nyc_subway_stations  
    30   WHERE name = 'Broad St';              
     29  FROM nyc_subway_stations 
     30  WHERE name = 'Broad St'; 
    3131 
    3232:: 
    … …  
    3535  ----------+----------------------------------------------------+----------------------- 
    3636   Broad St | 0101000020266900000EEBD4CF27CF2141BC17D69516315141 | POINT(583571 4506714) 
    37   
     37 
    3838Maintenant, copiez / collez la valeur affichée pour tester la fonction :command:`ST_Equals`: 
    3939 
    4040.. code-block:: sql 
    4141 
    42   SELECT name  
    43   FROM nyc_subway_stations  
     42  SELECT name 
     43  FROM nyc_subway_stations 
    4444  WHERE ST_Equals(the_geom, '0101000020266900000EEBD4CF27CF2141BC17D69516315141'); 
    4545 
    … …  
    6161   :align: center 
    6262 
    63 :command:`ST_Intersects(geometry A, geometry B)` retourne t (TRUE) si l'intersection ne renvoit 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)` retourne t (TRUE) si l'intersection ne renvoie 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 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. 
     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 efficace de tester si deux géométries ne s'intersectent pas que de tester si elles sont disjointes du fait que le test d'intersection peut être spatialement indexé alors que le test disjoint ne le peut pas. 
    6969 
    70 .. figure:: ./spatial_relationships/st_crosses.png   
     70.. figure:: ./spatial_relationships/st_crosses.png 
    7171   :align: center 
    7272 
    … …  
    7878: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. 
    7979 
    80 Essayons de prendre la station de métro de Broad Street et de déterminer sont voisinage en utilisant la fonction :command:`ST_Intersects` : 
     80Essayons de prendre la station de métro de Broad Street et de déterminer son voisinage en utilisant la fonction :command:`ST_Intersects` : 
    8181 
    8282.. code-block:: sql 
    8383 
    84   SELECT name, boroname  
     84  SELECT name, boroname 
    8585  FROM nyc_neighborhoods 
    8686  WHERE ST_Intersects(the_geom, '0101000020266900000EEBD4CF27CF2141BC17D69516315141'); 
    … …  
    8888:: 
    8989 
    90           name        | boroname   
     90          name        | boroname 
    9191  --------------------+----------- 
    9292   Financial District | Manhattan 
    … …  
    102102   :align: center 
    103103 
    104 :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érieurs de l'une intersecte le contour extérieur de l'autre. 
     104:command:`ST_Touches(geometry A, geometry B)` retourne TRUE soit si les contours des géométries s'intersectent ou si l'un des contours intérieurs de l'une intersecte le contour extérieur de l'autre. 
    105105 
    106106ST_Within et ST_Contains 
    107107------------------------- 
    108108 
    109 :command:`ST_Within` et :command:`ST_Contains` test si une géométrie est totalement incluse dans l'autre.  
     109:command:`ST_Within` et :command:`ST_Contains` teste si une géométrie est totalement incluse dans l'autre. 
    110110 
    111111.. figure:: ./spatial_relationships/st_within.png 
    112112   :align: center 
    113      
    114 :command:`ST_Within(geometry A , geometry B)` retourne TRUE si la premiÚre géométrie est complÚtement contenue dans l'autre. ST_Within test l'exact opposé au résultat de ST_Contains.   
     113 
     114:command:`ST_Within(geometry A , geometry B)` retourne TRUE si la premiÚre géométrie est complÚtement contenue dans l'autre. ST_Within teste l'exact opposé au résultat de ST_Contains. 
    115115 
    116116:command:`ST_Contains(geometry A, geometry B)` retourne TRUE si la seconde géométrie est complÚtement contenue dans la premiÚre géométrie. 
    … …  
    120120-------------------------- 
    121121 
    122 Une question fréquente dans le domaine du SIG est "trouver tout les éléments qui se trouvent à une distance X de cet autre élément". 
     122Une question fréquente dans le domaine du SIG est "trouver tous les éléments qui se trouvent à une distance X de cet autre élément". 
    123123 
    124124La fonction :command:`ST_Distance(geometry A, geometry B)` calcule la *plus courte* distance entre deux géométries. Cela est pratique pour récupérer la distance entre les objets. 
    … …  
    134134  3 
    135135 
    136 Pour tester si deux objets sont à la même distance d'un autre, la fonction :command:`ST_DWithin` fournit un test tirant profit des indexes. Cela est trÚs utile pour répondre a une question telle que: "Combien d'arbre se situent 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. 
     136Pour tester si deux objets sont à la même distance d'un autre, la fonction :command:`ST_DWithin` fournit un test tirant profit des index. Cela est trÚs utile pour répondre a une question telle que: "Combien d'arbres se situent 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. 
    137137 
    138138  .. figure:: ./spatial_relationships/st_dwithin.png 
    139139     :align: center 
    140      
     140 
    141141En utilisant de nouveau notre station de métro Broad Street, nous pouvons trouver les rues voisines (à 10 mÚtres de) de la station : 
    142142 
    143143.. code-block:: sql 
    144144 
    145   SELECT name  
    146   FROM nyc_streets  
     145  SELECT name 
     146  FROM nyc_streets 
    147147  WHERE ST_DWithin( 
    148           the_geom,  
    149           '0101000020266900000EEBD4CF27CF2141BC17D69516315141',  
     148          the_geom, 
     149          '0101000020266900000EEBD4CF27CF2141BC17D69516315141', 
    150150          10 
    151151        ); 
    152152 
    153 ::  
     153:: 
    154154 
    155        name      
     155       name 
    156156  -------------- 
    157157     Wall St 
    … …  
    159159     Nassau St 
    160160 
    161 Nous pouvons vérifier la réponse sur une carte. La station Broad St est actuellement à l'intersection des rues Wall, Broad et Nassau.  
     161Nous pouvons vérifier la réponse sur une carte. La station Broad St est actuellement à l'intersection des rues Wall, Broad et Nassau. 
    162162 
    163163.. image:: ./spatial_relationships/broad_st.jpg 
    … …  
    170170`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. 
    171171 
    172 `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>`_ : retourne TRUE si les géométries ne s'intersectent pas - elles n'ont aucun point en commun. 
    173173 
    174 `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>`_ : retourne la distance cartésienne en 2 dimensions minimum entre deux géométries dans l'unité de la projection. 
    175175 
    176 `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>`_ : retourne TRUE si les géométries sont distante (radius) l'une de l'autre. 
    177177 
    178 `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>`_ : retourne TRUE si les géométries fournies représentent la même géométrie. L'ordre des entités n'est pas pris en compte. 
    179179 
    180 `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>`_ : 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). 
    181181 
    182182`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 contenues l'une dans l'autre. 
    … …  
    186186`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 
    187187 
    188  
    189  

  • trunk/workshop-foss4g/spatial_relationships_exercises.rst

    r47 r62  
    11.. _spatial_relationships_exercises: 
    22 
    3 Partie 11 : Exercises sur les relations spatiales 
    4 =========================================== 
     3Partie 11 : Exercices sur les relations spatiales 
     4================================================= 
    55 
    66Voici 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)` 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 
     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 TRUE si la géométrie A contient la géométrie B 
     11* :command:`ST_Crosses(geometry A, geometry B)` retourne TRUE si la géométrie A croise la géométrie B 
     12* :command:`ST_Disjoint(geometry A , geometry B)` retourne TRUE si les géométries ne s'intersectent pas 
    1313* :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 
     14* :command:`ST_DWithin(geometry A, geometry B, radius)` retourne TRUE si la A est distante d'au plus radius de B 
     15* :command:`ST_Equals(geometry A, geometry B)` retourne TRUE si A est la même géométrie que B 
     16* :command:`ST_Intersects(geometry A, geometry B)` retourne TRUE si A intersecte B 
     17* :command:`ST_Overlaps(geometry A, geometry B)` retourne TRUE si A et B on un espace en commun, mais ne sont pas complÚtement incluses l'un dans l'autre. 
     18* :command:`ST_Touches(geometry A, geometry B)` retourne TRUE si le contour extérieur de A touche B 
     19* :command:`ST_Within(geometry A, geometry B)` retourne TRUE si A est hors de B 
    2020 
    2121Souvenez-vous les tables à votre disposition : 
    2222 
    23  * ``nyc_census_blocks``  
    24   
     23 * ``nyc_census_blocks`` 
     24 
    2525   * name, popn_total, boroname, the_geom 
    26   
     26 
    2727 * ``nyc_streets`` 
    28   
     28 
    2929   * name, type, the_geom 
    30     
     30 
    3131 * ``nyc_subway_stations`` 
    32   
     32 
    3333   * name, the_geom 
    34   
     34 
    3535 * ``nyc_neighborhoods`` 
    36   
     36 
    3737   * name, boroname, the_geom 
    3838 
    … …  
    4040--------- 
    4141 
    42  * **"Quel est la valeur géométrique de la rue nommée  'Atlantic Commons' ?"** 
    43   
     42 * **"Quelle est la valeur géométrique de la rue nommée  'Atlantic Commons' ?"** 
     43 
    4444   .. code-block:: sql 
    4545 
    … …  
    4949 
    5050   :: 
    51     
     51 
    5252     01050000202669000001000000010200000002000000093235673BE82141F319CD89A22E514170E30E0ADFE82141CB2D3EFFA52E5141 
    53       
    54  * **"Quel sont les quartiers et villes qui sont dans Atlantic Commons ?"** 
    55       
     53 
     54 * **"Quels sont les quartiers et villes qui sont dans Atlantic Commons ?"** 
     55 
    5656   .. code-block:: sql 
    5757 
    58      SELECT name, boroname  
    59      FROM nyc_neighborhoods  
     58     SELECT name, boroname 
     59     FROM nyc_neighborhoods 
    6060     WHERE ST_Intersects( 
    6161       the_geom, 
    … …  
    6464 
    6565   :: 
    66       
    67           name    | boroname  
     66 
     67          name    | boroname 
    6868      ------------+---------- 
    6969       Fort Green | Brooklyn 
    70       
    7170 
    72  * **"Quelles rues touchent Atlantic Commons ?"**  
    73   
     71 
     72 * **"Quelles rues touchent Atlantic Commons ?"** 
     73 
    7474   .. code-block:: sql 
    7575 
    76      SELECT name  
    77      FROM nyc_streets  
     76     SELECT name 
     77     FROM nyc_streets 
    7878     WHERE ST_Touches( 
    79        the_geom,  
     79       the_geom, 
    8080       '01050000202669000001000000010200000002000000093235673BE82141F319CD89A22E514170E30E0ADFE82141CB2D3EFFA52E5141' 
    8181     ); 
    82      
     82 
    8383   :: 
    84    
    85           name       
     84 
     85          name 
    8686     --------------- 
    8787      S Oxford St 
    … …  
    8989 
    9090   .. image:: ./spatial_relationships/atlantic_commons.jpg 
    91    
    9291 
    93  * **"Approximativement combien de personnes vivent dans (ou dans une zone de 50 metres autour d') Atlantic Commons ?"** 
    94   
     92 
     93 * **"Approximativement combien de personnes vivent dans (ou dans une zone de 50 mÚtres autour d') Atlantic Commons ?"** 
     94 
    9595   .. code-block:: sql 
    9696 
    … …  
    102102        50 
    103103        ); 
    104          
    105    ::  
    106     
    107      1186  
    108     
     104 
     105   :: 
     106 
     107     1186 
     108 

  • trunk/workshop-foss4g/tuning.rst

    r50 r62  
    44================================================= 
    55 
    6 PostgreSQL est une base de données trÚs versatile, capable de tourner dans des environnements ayant des ressources trÚs limités et partageant ces ressources avec un grand nombre d'autres applications. Afin d'assurer qu'il tournera convenablement dans ces environnements, la configuration par défaut est trÚs peu consomatrice de ressource mais terriblement innadapaté pour des bases de données hautes-performances en production. Ajoutez à cela le fait que les base de données spatiales ont différent type d'utilisation, et que les données sont généralement plus grandes que les autres types de données, vous en arriverez à la conclusion que les parÚtres par défaut ne sont pas approprié pour notre utilisasion. 
     6PostgreSQL est une base de données trÚs versatile, capable de tourner dans des environnements ayant des ressources trÚs limitées et partageant ces ressources avec un grand nombre d'autres applications. Afin d'assurer qu'elle tournera convenablement dans ces environnements, la configuration par défaut est trÚs peu consommatrice de ressources mais terriblement inadaptée pour des bases de données hautes-performances en production. Ajoutez à cela le fait que les bases de données spatiales ont différents types d'utilisation, et que les données sont généralement plus grandes que les autres types de données, vous en arriverez à la conclusion que les paramÚtres par défaut ne sont pas appropriés pour notre utilisation. 
    77 
    8 Tout ces paramÚtres de configuration peuvent être édités dans le fichier de configuration de la base de données : :file:`C:\\Documents and Settings\\%USER\\.opengeo\\pgdata\\%USER`.  Le contenu du fichier est du texte et il peut donc être ouvert avec l'outils d'édition de fichiers de votre choix (Notepad par exemple). Les modifications apportées à ce fichier ne seront effectives que lors du redémarrage du serveur. 
     8Tous ces paramÚtres de configuration peuvent être édités dans le fichier de configuration de la base de données : :file:`C:\\Documents and Settings\\%USER\\.opengeo\\pgdata\\%USER`.  Le contenu du fichier est du texte et il peut donc être ouvert avec l'outil d'édition de fichiers de votre choix (Notepad par exemple). Les modifications apportées à ce fichier ne seront effectives que lors du redémarrage du serveur. 
    99 
    1010.. image:: ./tuning/conf01.png 
    1111 
    12 Une façon simple d'éditer ce fichier de configuration est d'utiliser l'outils nommé : "Backend Configuration Editor".  Depuis pgAdmin, allez dans *File > Open postgresql.conf...*. Il vous sera demandé le chemin du fichier, naviguez dans votre arborescence jusqu'au fichier :file:`C:\\Documents and Settings\\%USER\\.opengeo\\pgdata\\%USER`. 
     12Une façon simple d'éditer ce fichier de configuration est d'utiliser l'outil nommé : "Backend Configuration Editor".  Depuis pgAdmin, allez dans *File > Open postgresql.conf...*. Il vous sera demandé le chemin du fichier, naviguez dans votre arborescence jusqu'au fichier :file:`C:\\Documents and Settings\\%USER\\.opengeo\\pgdata\\%USER`. 
    1313 
    1414.. image:: ./tuning/conf02.png 
    … …  
    1616.. image:: ./tuning/conf03.png 
    1717 
    18 Cette partie décrit certains des paramÚtres de configuration qui doivent être modifiés pour la mise ne place d'une base de données spatiale en production. Pour chaque partie, trouvez le bon paramÚtres dans la liste et double cliquez dessus pour l'éditer. Changez le champs *Value* par la valeur que nous recommendons, assurez-vous que le champs est bien activé pui cliquez sur **OK**. 
     18Cette partie décrit certains des paramÚtres de configuration qui doivent être modifiés pour la mise ne place d'une base de données spatiale en production. Pour chaque partie, trouvez le bon paramÚtre dans la liste et double cliquez dessus pour l'éditer. Changez le champ *Value* par la valeur que nous recommandons, assurez-vous que le champ est bien activé puis cliquez sur **OK**. 
    1919 
    20 .. note:: Ces valeurs sont seulement celles que nous recommendons, chaque environnement differera et tester les différents paramétrages est toujours nécessaire pour s'assurer d'utiliser la configuration optimale. Mais dans cette partie nous vous fournissons un bon point de départ. 
     20.. note:: Ces valeurs sont seulement celles que nous recommandons, chaque environnement diffÚrera et tester les différents paramétrages est toujours nécessaire pour s'assurer d'utiliser la configuration optimale. Mais dans cette partie nous vous fournissons un bon point de départ. 
    2121 
    2222shared_buffers 
    2323-------------- 
    2424 
    25 Alloue la quantité de mémoire que le serveur de bases de données utilise pour ses segments de mémoires partagées. Cela est partagé par tout les processus serveur, comme sont nom l'indique. La valeur par défaut est affligeante et inadaptée pour une base de données en production. 
     25Alloue la quantité de mémoire que le serveur de bases de données utilise pour ses segments de mémoires partagées. Cela est partagé par tous les processus serveur, comme son nom l'indique. La valeur par défaut est affligeante et inadaptée pour une base de données en production. 
    2626 
    2727  *Valeur par défaut* : typiquement 32MB 
    … …  
    3434-------- 
    3535 
    36 Définit la quantité de mémoire que les opération interne d'ordonnancement et les tables de hachages peuvent consommer avec le serveur passe à des fichiers sur le disque. Cette valeur définit la mémoire disponible pour chaque opération complexe, les requêtes complexes peuvent avoir plusieurs ordres ou opération de hachage tournant en parallÚle, et chaque client s connecté peut exécuter une requête.  
     36Définit la quantité de mémoire que les opération internes d'ordonnancement et les tables de hachages peuvent consommer avec le serveur sur le disque. Cette valeur définit la mémoire disponible pour chaque opération complexe, les requêtes complexes peuvent avoir plusieurs ordres ou opération de hachage tournant en parallÚle, et chaque client connecté peut exécuter une requête. 
    3737 
    38 Vous devez donc considérer combient de connexions et quel complexité est attendu dans les requêtes avant d'augmenter cette valeur. Le bénéfice acquis par l'augmentation de cette valeur est que la plupart des opération de classification,dont les clause ORDER BY et DISTINCT, les jointures, les agrégation basé sur les hachages et l'exécution de requête imbriquées, pourront être réalisé sans avoir à passer par un stockage sur disque. 
     38Vous devez donc considérer combien de connexions et quelle complexité est attendue dans les requêtes avant d'augmenter cette valeur. Le bénéfice acquis par l'augmentation de cette valeur est que la plupart des opération de classification, dont les clause ORDER BY et DISTINCT, les jointures, les agrégation basées sur les hachages et l'exécution de requête imbriquées, pourront être réalisées sans avoir à passer par un stockage sur disque. 
    3939 
    4040  *Valeur par défaut* : 1MB 
    … …  
    4747-------------------- 
    4848 
    49 Définit la quantité de mémoire utilisé pour les opération de maintenances, dont le néttoyage (VACUUM), les indexes et la création de clef étrangÚres. Comme ces opération sont courremment utilisées, la valeur par défaut devrait être acceptable. Ce paramÚtre peut être augmenté dynamiquement à l'exécution depuis une connexion au serveur avant l'exécution d'un grand nombre d'appels à :command:`CREATE INDEX` ou :command:`VACUUM` comme le montre la commande suivante. 
     49Définit la quantité de mémoire utilisée pour les opération de maintenance, dont le nettoyage (VACUUM), les index et la création de clefs étrangÚres. Comme ces opération sont couramment utilisées, la valeur par défaut devrait être acceptable. Ce paramÚtre peut être augmenté dynamiquement à l'exécution depuis une connexion au serveur avant l'exécution d'un grand nombre d'appels à :command:`CREATE INDEX` ou :command:`VACUUM` comme le montre la commande suivante. 
    5050 
    5151  .. code-block:: sql 
    … …  
    5757  *Valeur par défaut* : 16MB 
    5858 
    59   *Valeur recommendée* : 128MB 
     59  *Valeur recommandée* : 128MB 
    6060 
    6161.. image:: ./tuning/conf06.png 
    … …  
    6464----------- 
    6565 
    66 Définit la quantité de mémoire utilisé pour l'écriture des données dans le journal respectant la rÚgle du défaire (WAL). Elle indique que les informations pour annuler les effets d'une opération sur un objet doivent être écrites dans le journal en mémoire stable avant que l'objet modifié ne migre sur le disque. Cette rÚgle permet d'assurer l'intégrité des données lors d'une reprise aprÚs défaillance. En effet,il suffiré de lire le journal pour retrouver l'état de la base lors de sont arrêt brutal.  
     66Définit la quantité de mémoire utilisée pour l'écriture des données dans le journal respectant la rÚgle du defer (WAL). Elle indique que les informations pour annuler les effets d'une opération sur un objet doivent être écrites dans le journal en mémoire stable avant que l'objet modifié ne migre sur le disque. Cette rÚgle permet d'assurer l'intégrité des données lors d'une reprise aprÚs défaillance. En effet, il suffira de lire le journal pour retrouver l'état de la base lors de son arrêt brutal. 
    6767 
    68 La taille de ce tampon nécessite simplement d'être suffisament grand pour stoquer les données WAL pour une seule transaction. Alors que la valeur par défaut est généralement siffisante, les données spatiales tendent à être plus large. Il est donc recommendé d'augmenter la taille spécifiée dans ce paramÚtre. 
     68La taille de ce tampon nécessite simplement d'être suffisament grand pour stocker les données WAL pour une seule transaction. Alors que la valeur par défaut est généralement suffisante, les données spatiales tendent à être plus larges. Il est donc recommandé d'augmenter la taille spécifiée dans ce paramÚtre. 
    6969 
    7070  *Valeur par défaut* : 64kB 
    7171 
    72   *Valeur recommendée* : 1MB 
     72  *Valeur recommandée* : 1MB 
    7373 
    7474.. image:: ./tuning/conf07.png 
    … …  
    7777------------------- 
    7878 
    79 Cette valeur définit le nombre maximum de segements des journaux (typiquement 16MB) qui doit être remplit entre chaque point de reprises WAL. Un point de reprise WAL est une partie d'une séquence de transactions pour lequel on garanti que les fichiers de données ont été mis à jour avec toutes les requêtes précédent ce point. À ce moment-là toutes les pages sont punaisées sur le disque et les point de reprises sont écrit dans le fichier de journal. Cela permet au precessus de reprise aprÚs défaillance de trouver les dernierspoints de reprises et applique toute les lignes suivantes pour récupérer l'état des données avant la défaillance. 
     79Cette valeur définit le nombre maximum de segments des journaux (typiquement 16MB) qui doit être remplit entre chaque point de reprise WAL. Un point de reprise WAL est une partie d'une séquence de transactions pour lequel on garantit que les fichiers de données ont été mis à jour avec toutes les requêtes précédant ce point. À ce moment-là toutes les pages sont punaisées sur le disque et les points de reprise sont écrits dans le fichier de journal. Cela permet au processus de reprise aprÚs défaillance de trouver les derniers points de reprise et applique toute les lignes suivantes pour récupérer l'état des données avant la défaillance. 
    8080 
    81 Ã‰tant donnée que les point de reprises nécessitent un punaisage de toutes le pages ayant été modifiée sur le disque, cela va créer une charge d'entrées/sorties significative. Le même arguement que précédemment s'applique ici, les données spatiales sont assez grandes pour contrebalancer l'optimisation de données non spatiales. Augmenter cette valeur limitera le nombre de points de reprise, mais impliquera un plus redémarrage en cas de défaillance. 
     81Étant donné que les points de reprise nécessitent un punaisage de toutes le pages ayant été modifiées sur le disque, cela va créer une charge d'entrées/sorties significative. Le même argument que précédemment s'applique ici, les données spatiales sont assez grandes pour contrebalancer l'optimisation de données non spatiales. Augmenter cette valeur limitera le nombre de points de reprise, mais impliquera un redémarrage plus lent en cas de défaillance. 
    8282 
    8383  *Valeur par défaut* : 3 
    8484 
    85   *Valauer recommendée* : 6 
     85  *Valeur recommandée* : 6 
    8686 
    8787.. image:: ./tuning/conf08.png 
    … …  
    9090---------------- 
    9191 
    92 Cette valeur sans unité représente le coût d'accÚs alléatoire au page du disque. Cete valeur est relative au autres paramÚtres de coût notemment l'accÚs séquentiel au pages, et le coût des opération processeur. Bien qu'il n'y ai pas de valeur magique ici, la valeur par défaut est généralement trop faible. Cette valeur peut être affectée dynamiquement par session en utilisant la commande ``SET random_page_cost TO 2.0``. 
     92Cette valeur sans unité représente le coût d'accÚs aléatoire à une page du disque. Cette valeur est relative aux autres paramÚtres de coût notamment l'accÚs séquentiel aux pages, et le coût des opérations processeur. Bien qu'il n'y ait pas de valeur magique ici, la valeur par défaut est généralement trop faible. Cette valeur peut être affectée dynamiquement par session en utilisant la commande ``SET random_page_cost TO 2.0``. 
    9393 
    9494  *Valeur par défaut* : 4.0 
    … …  
    9797 
    9898.. image:: ./tuning/conf09.png 
    99     
     99 
    100100seq_page_cost 
    101101------------- 
    102102 
    103 C'est une paramÚtre qui controle le coût des accÚs séquentiel au pages. Il n'est généralement pas nécessaire de modifier cette valeur maus la différence entre cette valeur et la valeurs ``random_page_cost`` affecte drastiquement le choix fait par le plannificateur de requêtes. Cette valeur peut aussi être affectée depuis une session. 
     103C'est une paramÚtre qui contrÃŽle le coût des accÚs séquentiels aux pages. Il n'est généralement pas nécessaire de modifier cette valeur mais la différence entre cette valeur et la valeur ``random_page_cost`` affecte drastiquement le choix fait par le planificateur de requêtes. Cette valeur peut aussi être affectée depuis une session. 
    104104 
    105105  *Valeur par défaut* : 1.0 
    … …  
    112112-------------------------- 
    113113 
    114 AprÚs avoir réalisé ces changements mentioné dans cette partie sauvez-les puis rechargez la configuration. 
     114AprÚs avoir réalisé les changements mentionnés dans cette partie sauvez-les puis rechargez la configuration. 
    115115 
    116  * Ceci se fait en cliquant avec le bouton droit sur le nom du serveur (``PostgreSQL 8.4 on localhost:54321``) depuis pgAdmin, selectionnez *Disconnect*.  
    117  * Cliquez sur le bouton *Shutdown* depuis le Dashboard OpenGeo, puis cliquez sur *Start*.  
     116 * Ceci se fait en cliquant avec le bouton droit sur le nom du serveur (``PostgreSQL 8.4 on localhost:54321``) depuis pgAdmin, selectionnez *Disconnect*. 
     117 * Cliquez sur le bouton *Shutdown* depuis le Dashboard OpenGeo, puis cliquez sur *Start*. 
    118118 * Pour finir reconnectez-vous au serveur depuis pgAdmin (cliquez avec le bouton droit sur le serveur puis sélectionnez *Connect*). 
    119   
    120   
    121   
     119 

  • trunk/workshop-foss4g/validity.rst

    r50 r62  
    44==================== 
    55 
    6 Dans 90% des cas la réponse à la 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 ? 
     6Dans 90% des cas la réponse à la question "pourquoi mes requêtes me renvoient 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 
    88Qu'est-ce que la validité ? 
    … …  
    1313Certaines des rÚgles de validation des polygones semble évidentes, et d'autre semblent arbitraires (et le sont vraiment). 
    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. 
     15 * Les contours des polygones doivent être fermés. 
     16 * Les contours qui définissent des trous doivent être inclus dans la zone définie par le contour extérieur. 
    1717 * Les contours ne doivent pas s'intersecter (ils ne doivent ni se croiser ni se toucher). 
    1818 * Les contours ne doivent pas toucher les autres contours, sauf en un point unique. 
    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. 
     20Les deux derniÚres rÚgles font partie de la catégorie arbitraire. Il y a d'autres moyens de définir des polygones qui sont consistants mais les rÚgles ci-dessus sont celles utilisées dans le standard :term:`OGC` :term:`SFSQL` que respecte PostGIS. 
    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". 
     22La raison pour laquelle ces rÚgles sont importantes est que les algorithmes de calcul dépendent de cette structuration consistante des arguments. Il est possible de construire des algorithmes qui n'utilisent pas cette structuration, mais ces fonctions tendent à être trÚs lentes, étant donné que la premiÚre étape consiste à "analyser et construire  des structures à l'intérieur des données". 
    2323 
    2424Voici un exemple de pourquoi cette structuration est importante. Ce polygone n'est pas valide : 
    … …  
    2727 
    2828  POLYGON((0 0, 0 1, 2 1, 2 2, 1 2, 1 0, 0 0)); 
    29    
     29 
    3030Vous pouvez comprendre ce qui n'est pas valide en regardant cette figure : 
    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. 
     34Le contour externe est exactement en forme en 8 avec une intersection au milieu. Notez que la fonction de rendu graphique est tout de même capable d'en afficher l'intérieur, donc visuellement cela ressemble bien à une "aire" : deux unités carré, donc une aire couplant ces deux unités. 
    3535 
    3636Essayons maintenant de voir ce que pense la base de données de notre polygone : 
    … …  
    3939 
    4040  SELECT ST_Area(ST_GeometryFromText('POLYGON((0 0, 0 1, 1 1, 2 1, 2 2, 1 2, 1 1, 1 0, 0 0))')); 
    41    
     41 
    4242:: 
    4343 
    44     st_area  
     44    st_area 
    4545   --------- 
    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) dans un sens de la ligne du contour (peu importe quelle sens, juste *un* sens). 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 annulent la précédente (l'une vaut 1 et l'autre -1) donc le résultat est une "aire de zéro". 
     48Que ce passe-t-il ici ? L'algorithme qui calcule l'aire suppose que les contours ne s'intersectent pas. Un contour normal devra toujours avoir une aire qui est bornée (l'intérieur) dans un sens de la ligne du contour (peu importe quelle sens, juste *un* sens). 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 aires qui sont calculées pour chaque lobe annulent la précédente (l'une vaut 1 et l'autre -1) donc le résultat est une "aire de zéro". 
    4949 
    5050 
    … …  
    5252-------------------- 
    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 : 
     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ée avec notre polygone précédent, nous obtenons rapidement la réponse : 
    5555 
    5656.. code-block:: sql 
    … …  
    5858  SELECT ST_IsValid(ST_GeometryFromText('POLYGON((0 0, 0 1, 1 1, 2 1, 2 2, 1 2, 1 1, 1 0, 0 0))')); 
    5959 
    60 ::  
     60:: 
    6161 
    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é : 
     64Maintenant nous savons que l'entité est non-valide mais nous ne savons pas pourquoi. Nous pouvons utiliser la fonction :command:`ST_IsValidReason(geometry)` pour trouver la cause de non validité : 
    6565 
    6666.. code-block:: sql 
    … …  
    7474Vous remarquerez qu'en plus de la raison (intersection) la localisation de la non validité (coordonnée (1 1)) est aussi renvoyée. 
    7575 
    76 Nous pouvons aussi utiiliser la fonction :command:`ST_IsValid(geometry)` pour tester nos tables :  
     76Nous pouvons aussi utiiliser la fonction :command:`ST_IsValid(geometry)` pour tester nos tables : 
    7777 
    7878.. code-block:: sql 
    7979 
    80   -- Trouver tout les polygones non valides et leur problÚme  
     80  -- Trouver tous les polygones non valides et leur problÚme 
    8181  SELECT name, boroname, ST_IsValidReason(the_geom) 
    8282  FROM nyc_neighborhoods 
    … …  
    8585:: 
    8686 
    87            name           |   boroname    |                     st_isvalidreason                       
     87           name           |   boroname    |                     st_isvalidreason 
    8888 -------------------------+---------------+----------------------------------------------------------- 
    8989  Howard Beach            | Queens        | Self-intersection[597264.083368305 4499924.54228856] 
    … …  
    9797--------------------- 
    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. 
     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 outil extérieur. 
    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. 
     101Voici un exemple de requête SQL qui déplace 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   -- Table à part des géométries non-valide 
     105  -- Table à part des géométries non-valides 
    106106  CREATE TABLE nyc_neighborhoods_invalid AS 
    107107  SELECT * FROM nyc_neighborhoods 
    108108  WHERE NOT ST_IsValid(the_geom); 
    109    
     109 
    110110  -- Suppression de la table principale 
    111111  DELETE FROM nyc_neighborhoods 
    112112  WHERE NOT ST_IsValid(the_geom); 
    113    
    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**. 
    115113 
    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`. 
     114Un bon outil pour réparer visuellement 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**. 
    117115 
    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. 
     116Maintenant, la bonne nouvelle : un grand nombre de non-validités **peut être résolu dans la base de données** en utilisant la fonction : :command:`ST_Buffer`. 
     117 
     118Le coup du Buffer tire avantage de la maniÚre dont les buffers sont construits : 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 
    120120Par 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 
    122 ::  
     122:: 
    123123 
    124124  POLYGON((0 0, 2 0, 1 1, 2 2, 3 1, 2 0, 4 0, 4 4, 0 4, 0 0)) 
    125    
     125 
    126126.. image:: ./validity/banana.png 
    127127 
    … …  
    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. 
    146    
     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 modÚle ESRI considÚre que les contours qui 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. 
     146 

  • trunk/workshop-foss4g/welcome.rst

    r60 r62  
    4646Par exemple: 
    4747 
    48    :command:`ST_Touches(geometry A, geometry B)` retourne vrai si un des contours de géométrie intersecte l'autre contour de géométrie 
     48   :command:`ST_Touches(geometry A, geometry B)` retourne vrai si un des contours de géométrie touche l'autre contour de géométrie 
    4949 
    5050Fichiers, Tables et nom de colonne 
Note: See TracChangeset for help on using the changeset viewer.