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 51


Ignore:
Timestamp:
02/10/2011 15:55:56 (8 years ago)
Author:
djay
Message:

Traduction de la partie géographie

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/workshop-foss4g/geography.rst

    r49 r51  
    107107 
    108108 
    109 Utiliser 'Geography' 
    110 ------------------- 
    111  
    112 In order to load geometry data into a geography table, the geometry first needs to be projected into EPSG:4326 (longitude/latitude), then it needs to be changed into geography.  The :command:`ST_Transform(geometry,srid)` function converts coordinates to geographics and the :command:`Geography(geometry)` function "casts" them from geometry to geography. 
     109Utiliser le type 'Geography' 
     110---------------------------- 
     111 
     112Afin 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. 
    113113 
    114114.. code-block:: sql 
     
    121121  FROM nyc_subway_stations; 
    122122    
    123 Building a spatial index on a geography table is exactly the same as for geometry: 
     123La 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 :    
    124124 
    125125.. code-block:: sql 
     
    128128  ON nyc_subway_stations_geog USING GIST (geog); 
    129129 
    130 The difference is under the covers: the geography index will correctly handle queries that cover the poles or the international date-line, while the geometry one will not. 
    131  
    132 There are only a small number of native functions for the geography type: 
    133   
    134  * :command:`ST_AsText(geography)` returns ``text`` 
    135  * :command:`ST_GeographyFromText(text)` returns ``geography`` 
    136  * :command:`ST_AsBinary(geography)` returns ``bytea`` 
    137  * :command:`ST_GeogFromWKB(bytea)` returns ``geography`` 
    138  * :command:`ST_AsSVG(geography)` returns ``text`` 
    139  * :command:`ST_AsGML(geography)` returns ``text`` 
    140  * :command:`ST_AsKML(geography)` returns ``text`` 
    141  * :command:`ST_AsGeoJson(geography)` returns ``text`` 
    142  * :command:`ST_Distance(geography, geography)` returns ``double`` 
    143  * :command:`ST_DWithin(geography, geography, float8)` returns ``boolean`` 
    144  * :command:`ST_Area(geography)` returns ``double`` 
    145  * :command:`ST_Length(geography)` returns ``double`` 
    146  * :command:`ST_Covers(geography, geography)` returns ``boolean`` 
    147  * :command:`ST_CoveredBy(geography, geography)` returns ``boolean`` 
    148  * :command:`ST_Intersects(geography, geography)` returns ``boolean`` 
    149  * :command:`ST_Buffer(geography, float8)` returns ``geography`` [#Casting_note]_ 
    150  * :command:`ST_Intersection(geography, geography)` returns ``geography`` [#Casting_note]_ 
    151   
    152 Creating a Geography Table 
    153 -------------------------- 
    154   
    155 The SQL for creating a new table with a geography column is much like that for creating a geometry table. However, geography includes the ability to specify the object type directly at the time of table creation. For example: 
     130La 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 
     132Il n'y a qu'un petit nombre de fonctions disponibles pour le type géographie :   
     133  
     134 * :command:`ST_AsText(geography)` retourne la représentation ``textuelle`` 
     135 * :command:`ST_GeographyFromText(text)` retourne un objet de type ``geography`` 
     136 * :command:`ST_AsBinary(geography)` retourne la représentation binaire ``bytea`` 
     137 * :command:`ST_GeogFromWKB(bytea)` retourne un objet de type ``geography`` 
     138 * :command:`ST_AsSVG(geography)` retourne ``text`` 
     139 * :command:`ST_AsGML(geography)` retourne ``text`` 
     140 * :command:`ST_AsKML(geography)` retourne ``text`` 
     141 * :command:`ST_AsGeoJson(geography)` retourne ``text`` 
     142 * :command:`ST_Distance(geography, geography)` retourne ``double`` 
     143 * :command:`ST_DWithin(geography, geography, float8)` retourne ``boolean`` 
     144 * :command:`ST_Area(geography)` retourne ``double`` 
     145 * :command:`ST_Length(geography)` retourne ``double`` 
     146 * :command:`ST_Covers(geography, geography)` retourne ``boolean`` 
     147 * :command:`ST_CoveredBy(geography, geography)` retourne ``boolean`` 
     148 * :command:`ST_Intersects(geography, geography)` retourne ``boolean`` 
     149 * :command:`ST_Buffer(geography, float8)` retourne ``geography`` [#Casting_note]_ 
     150 * :command:`ST_Intersection(geography, geography)` retourne ``geography`` [#Casting_note]_ 
     151  
     152Création d'une table stockant des géograhpies 
     153--------------------------------------------- 
     154  
     155Le 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 : 
    156156 
    157157.. code-block:: sql 
     
    166166  INSERT INTO airports VALUES ('REK', 'POINT(-21.8628 64.1286)'); 
    167167   
    168 In the table definition, the ``GEOGRAPHY(Point)`` specifies our airport data type as points. The new geography fields don't get registered in the ``geometry_columns``. Instead, they are registered in a new view called ``geography_columns`` that is automatically kept up to date without need for an :command:`AddGeom...` like functions. 
     168Lors 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``. 
    169169 
    170170.. code-block:: sql 
     
    181181.. note:: 
    182182 
    183   The ability to define geometry types and SRIDs inside the table ``CREATE`` statement, and the automatic update of the ``geometry_columns`` metadata are features that have been prototyped with ``geography`` and will be added to the ``geometry`` type for PostGIS 2.0. 
    184    
    185  
    186 Casting to Geometry 
     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.   
     184 
     185Conversion de type 
    187186------------------- 
    188187 
    189 While the basic functions for geography types can handle many use cases, there are times when you might need access to other functions only supported by the geometry type. Fortunately, you can convert objects back and forth from geography to geometry. 
    190  
    191 The PostgreSQL syntax convention for casting is to append ``::typename`` to the end of the value you wish to cast. So, ``2::text`` with convert a numeric two to a text string '2'. And ``'POINT(0 0)'::geometry`` will convert the text representation of point into a geometry point. 
    192  
    193 The :command:`ST_X(point)` function only supports the geometry type. How can we read the X coordinate from our geographies? 
     188Bien 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 
     190La 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 
     192La fonction :command:`ST_X(point)` supporte seulement le type géométrique. Comment lire la coordonée X d'une de nos géographie ? 
    194193 
    195194.. code-block:: sql 
     
    205204  REK  |  -21.8628 
    206205 
    207 By appending ``::geometry`` to our geography value, we convert the object to a geometry with an SRID of 4326. From there we can use as many geometry functions as strike our fancy. But, remember -- now that our object is a geometry, the coordinates will be interpretted as cartesian coordinates, not spherical ones. 
    208   
    209   
    210 Why (Not) Use Geography 
    211 ----------------------- 
    212  
    213 Geographics are universally accepted coordinates -- everyone understands what latitude/longitude mean, but very few people understand what UTM coordinates mean. Why not use geography all the time? 
    214  
    215  * First, as noted earlier, there are far fewer functions available (right now) that directly support the geography type. You may spend a lot of time working around geography type limitations. 
    216  * Second, the calculations on a sphere are computationally far more expensive than cartesian calculations. For example, the cartesian formula for distance (Pythagoras) involves one call to sqrt(). The spherical formula for distance (Haversine) involves two sqrt() calls, an arctan() call, four sin() calls and two cos() calls. Trigonometric functions are very costly, and spherical calculations involve a lot of them. 
    217   
    218 The conclusion?  
    219  
    220 If your data is geographically compact (contained within a state, county or city), use the ``geometry`` type with a cartesian projection that makes sense with your data. See the http://spatialreference.org site and type in the name of your region for a selection of possible reference systems. 
    221  
    222 If, on the other hand, you need to measure distance with a dataset that is geographically dispersed (covering much of the world), use the ``geography`` type. The application complexity you save by working in ``geography`` will offset any performance issues. And, casting to ``geometry`` can offset most functionality limitations. 
     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 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  
     209Pourquoi (ne pas) utiliser les géographies 
     210------------------------------------------ 
     211 
     212Les 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  
     217Quel conclusion en tirer ?  
     218 
     219Si 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 
     221Si, 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. 
    223222 
    224223Liste des fonctions 
    225224------------------- 
    226225 
    227 `ST_Distance(geometry, geometry) <http://postgis.org/docs/ST_Distance.html>`_: For geometry type Returns the 2-dimensional cartesian minimum distance (based on spatial ref) between two geometries in projected units. For geography type defaults to return spheroidal minimum distance between two geographies in meters. 
    228  
    229 `ST_GeographyFromText(text) <http://postgis.org/docs/ST_GeographyFromText.html>`_: Returns a specified geography value from Well-Known Text representation or extended (WKT). 
    230  
    231 `ST_Transform(geometry, srid) <http://postgis.org/docs/ST_Transform.html>`_: Returns a new geometry with its coordinates transformed to the SRID referenced by the integer parameter. 
    232  
    233 `ST_X(point) <http://postgis.org/docs/ST_X.html>`_: Returns the X coordinate of the point, or NULL if not available. Input must be a point. 
     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. 
     227 
     228`ST_GeographyFromText(text) <http://postgis.org/docs/ST_GeographyFromText.html>`_: Retourne la valeur géographique à partir d'une représentation en WKT ou EWKT. 
     229 
     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. 
     231 
     232`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. 
    234233 
    235234 
    236235.. rubric:: Footnotes 
    237236 
    238 .. [#Casting_note] The buffer and intersection functions are actually wrappers on top of a cast to geometry, and are not carried out natively in spherical coordinates. As a result, they may fail to return correct results for objects with very large extents that cannot be cleanly converted to a planar representation. 
    239   
    240    For example, the :command:`ST_Buffer(geography,distance)` function transforms the geography object into a "best" projection, buffers it, and then transforms it back to geographics. If there is no "best" projection (the object is too large), the operation can fail or return a malformed buffer. 
    241  
     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 
Note: See TracChangeset for help on using the changeset viewer.