Changeset 19 for trunk/workshop-foss4g/geometries.rst

Timestamp:

23/09/2011 15:36:21 (13 years ago)

Author:

djay

Message:

Ajouter quelques traductions.

File:

• trunk/workshop-foss4g/geometries.rst (modified) (15 diffs)

trunk/workshop-foss4g/geometries.rst

@@ -1 +1 @@
 .. _geometries:
 
-Section 8: Geometries
+Partie 8 : les géometries
 =====================
 
@@ -7 +7 @@
 ------------
 
-In the previous :ref:`section <loading_data>`, we loaded a variety of data.  Before we start playing with our data lets have a look at some simpler examples.  In pgAdmin, once again select the **nyc** database and open the SQL query tool.  Paste this example SQL code into the pgAdmin SQL Editor window (removing any text that may be there by default) and then execute.
+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 encore la base de donnée **nyc** et ouvrez l'outils de requêtage SQL. Copiez cette exemple de code SQL (aprÚs avoir supprimer le contenu présent défaut si nécessaire) puis exécutez-le.
 
 .. code-block:: sql
@@ -26 +26 @@
 .. image:: ./geometries/start01.png
 
-The above example CREATEs a table (**geometries**) then INSERTs five geometries: a point, a line, a polygon, a polygon with a hole, and a collection. Finally, the inserted rows are SELECTed and displayed in the Output pane.
-
-Metadata Tables
----------------
-
-In conformance with the Simple Features for SQL (:term:`SFSQL`) specification, PostGIS provides two tables to track and report on the geometry types available in a given database. 
-
-* The first table, ``spatial_ref_sys``, defines all the spatial reference systems known to the database and will be described in greater detail later.  
-* The second table, ``geometry_columns``, provides a listing of all "features" (defined as an object with geometric attributes), and the basic details of those features.  
+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. Au final, les lignes insérées sont sélectionnées et affichées dans le tableau de sortie.
+
+Les tables de métadonnées
+-------------------------
+
+Dans 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.
+
+* La premiÚre table, ``spatial_ref_sys``, définit tout les systÚme de projection connu de la base de données et sera décrite plus en détals plus tard.  
+* 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. 
 
 .. image:: ./geometries/table01.png
 
-In our introductory example, the :command:`Populate_Geometry_Columns()` function finds all the columns in the database that contain geometry and updates the ``geometry_columns`` table to include references to them.  
-
-Lets have a look at the ``geometry_columns`` table in our database.  Paste this command in the Query Tool as before:
+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.
+
+Regardons maintenant table ``geometry_columns`` de notre base de données. Copiez cette commande dans la fenêtre de requêtage :
+
 
 .. code-block:: sql
@@ -48 +49 @@
 .. image:: ./geometries/start08.png
 
-* ``f_table_catalog``, ``f_table_schema``, and ``f_table_name`` provide the fully qualified name of the feature table containing a given geometry.  Because PostgreSQL doesn't make use of catalogs, ``f_table_catalog`` will tend to be empty.  
-* ``f_geometry_column`` is the name of the column that geometry containing column -- for feature tables with multiple geometry columns, there will be one record for each.  
-* ``coord_dimension`` and ``srid`` define the the dimension of the geometry (2-, 3- or 4-dimensional) and the Spatial Reference system identifier that refers to the ``spatial_ref_sys`` table respectively.  
-* The ``type`` column defines the type of geometry as described below; we've seen Point and Linestring types so far.  
-
-By querying this table, GIS clients and libraries can determine what to expect when retrieving data and can perform any necessary projection, processing or rendering without needing to inspect each geometry.
-
-Representing Real World Objects
--------------------------------
-
-The Simple Features for SQL (:term:`SFSQL`) specification, the original guiding standard for PostGIS development, defines how a real world object is represented.  By taking a continuous shape and digitizing it at a fixed resolution we achieve a passable representation of the object.  SFSQL only handled 2-dimensional representations.  PostGIS has extended that to include 3- and 4-dimensional representations; more recently the SQL-Multimedia Part 3 (:term:`SQL/MM`) specification has officially defined their own representation.  
-
-Our example table contains a mixture of different geometry types. We can collect general information about each object using functions that read the geometry metadata.
-
- * :command:`ST_GeometryType(geometry)` returns the type of the geometry
- * :command:`ST_NDims(geometry)` returns the number of dimensions of the geometry
- * :command:`ST_SRID(geometry)` returns the spatial reference identifier number of the geometry
+* ``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.  
+* ``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.
+* ``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``.  
+* 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.  
+
+En interrogeant cette table, les clients SIG et les libraires peuvent déterminer quoi attendre lors de la récupration des données et peuvent réaliser les opération de reprojection, transformation ou rendu sans avoir a inspecter chaque géométrie.
+
+Réprésenter des objets du mode réel
+-----------------------------------
+
+La 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 obtenu un 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ésenation.
+
+Notre table exemple contient différents types de géométries Nous pouvons récupérer les informations de chaque objets en utilisant les fonctions qui lisent les métadonnées de la géométrie.
+
+ * :command:`ST_GeometryType(geometry)` retourne le type de la géométrie
+ * :command:`ST_NDims(geometry)` retourne le nombre de dimension d'une géométrie
+ * :command:`ST_SRID(geometry)` retourne l'identifiant de référence spatiale de la géométrie
 
 .. code-block:: sql
@@ -83 +84 @@
 
 
-Points
-~~~~~~
+Les points
+~~~~~~~~~~~
 
 .. image:: ./introduction/points.png
    :align: center
 
-A spatial **point** represents a single location on the Earth.  This point is represented by a single coordinate (including either 2-, 3- or 4-dimensions).  Points are used to represent objects when the exact details, such as shape and size, are not important at the target scale.  For example, cities on a map of the world can be described as points, while a map of a single state might represent cities as polygons.  
+Un **point** spatiale 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étails exact du contour n'est pas important à une échelle donnée. Par exemple, les villes sur une carte du monde pourraient être décrite sous la forme de points alors qu'une carte régionale utiliserait une représentation polygonale des villes.
 
 .. code-block:: sql
@@ -101 +102 @@
   POINT(0 0)
 
-Some of the specific spatial functions for working with points are:
-
- * :command:`ST_X(geometry)` returns the X ordinate
- * :command:`ST_Y(geometry)` returns the Y ordinate
-
-So, we can read the ordinates from a point like this:
+Ceraints des fonctions spécifiques pour travailler avec les points sont :
+
+ * :command:`ST_X(geometry)` retourne la composante X
+ * :command:`ST_Y(geometry)` retourne la composante Y 
+
+Donc, nous pouvons lire les coordonnées d'un point de la maniÚre suivante :
 
 .. code-block:: sql
@@ -114 +115 @@
     WHERE name = 'Point';
 
-The New York City subway stations (``nyc_subway_stations``) table is a data set represented as points. The following SQL query will return the geometry associated with one point (in the :command:`ST_AsText` column).
+La table des stations de métros de la ville de New York  (``nyc_subway_stations``) est un ensemble de données représenté sous la forme de points. La requête SQL suivante reverra la géométrie associée à un point (dans la colonne :command:`ST_AsText`).
 
 .. code-block:: sql
@@ -123 +124 @@
 
 
-Linestrings
+Les lignes 
 ~~~~~~~~~~~
 
@@ -129 +130 @@
    :align: center
 
-A **linestring** is a path between locations.  It takes the form of an ordered series of two or more points.  Roads and rivers are typically represented as linestrings.  A linestring is said to be **closed** if it starts and ends on the same point.  It is said to be **simple** if it does not cross or touch itself (except at its endpoints if it is closed).  A linestring can be both **closed** and **simple**.
-
-The street network for New York (``nyc_streets``) was loaded earlier in the workshop.  This dataset contains details such as name, and type.  A single real world street may consist of many linestrings, each representing a segment of road with different attributes.
-
-The following SQL query will return the geometry associated with one linestring (in the :command:`ST_AsText` column).
+Une **ligne** est un chemin entre plusieurs points. Elle prend la forme d'un tableay ordonné de deux (ou plus) points. Les routes et les riviÚres sont tipyquement représenté sous la forme de lignes. Une ligne est dire **fermée** si elle commence et se fini en un même point. Elle est dite **simple** si elle ne se coupe pas ni se touche elle-même (sauf à ses extrémités si elle est fermée). Une ligne peut être à la fois **fermée** et **simple**.
+
+Le réseau des rues de New York (``nyc_streets``) a été chargé plus tÎt. Cet ensemble de données contient les détails comme le nom et le type. Une rue du monde réelle pourrait être constituée de plusieurs lignes, chacune représentant une file de la avec différents attributs.
+
+La requête SQL suivante retourne la géométrie associée à une ligne (dans la colonne :command:`ST_AsText`) :
 
 .. code-block:: sql
@@ -145 +146 @@
   LINESTRING(0 0, 1 1, 2 1, 2 2)
 
-Some of the specific spatial functions for working with linestrings are:
-
- * :command:`ST_Length(geometry)` returns the length of the linestring
- * :command:`ST_StartPoint(geometry)` returns the first coordinate as a point
- * :command:`ST_EndPoint(geometry)` returns the last coordinate as a point
- * :command:`ST_NPoints(geometry)` returns the number of coordinates in the linestring
-
-So, the length of our linestring is:
+Les fonctions spatiales permettant de travailler avec les lignes sont les suivantes :
+
+ * :command:`ST_Length(geometry)` retourne la longueur d'une ligne
+ * :command:`ST_StartPoint(geometry)` retourne le premier point d'une ligne
+ * :command:`ST_EndPoint(geometry)` retourne le denier point d'une ligne
+ * :command:`ST_NPoints(geometry)` retourne le nombre de points dans une ligne
+
+Donc, la longueur de notre ligne est :
 
 .. code-block:: sql
@@ -165 +166 @@
 
 
-Polygons
-~~~~~~~~
+Les polygones
+~~~~~~~~~~~~~~
 
 .. image:: ./introduction/polygons.png
   :align: center
 
-A polygon is a representation of an area.  The outer boundary of the polygon is represented by a ring.  This ring is a linestring that is both closed and simple as defined above.  Holes within the polygon are also represented by rings.
-
-Polygons are used to represent objects whose size and shape are important.  City limits, parks, building footprints or bodies of water are all commonly represented as polygons when the scale is sufficiently high to see their area.  Roads and rivers can sometimes be represented as polygons.
-
-The following SQL query will return the geometry associated with one linestring (in the :command:`ST_AsText` column).
+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.
+
+Les polygones sont utiliser pour représenter les objets dont les tailles et la forme sont importants. Les limites de villes, les parks, les batiments 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.
+
+La requête SQL suivante retournera la géométrie associée à un polygon (dans la colonne :command:`ST_AsText`).
 
 .. code-block:: sql
@@ -185 +186 @@
 .. note::
 
-  Rather than using an ``=`` sign in our ``WHERE`` clause, we are using the ``LIKE`` operator to carry out a string matching operation. You may be used to the ``*`` symbol as a "glob" for pattern matching, but in SQL the ``%`` symbol is used, along with the ``LIKE`` operator to tell the system to do globbing.
+  PlutÎt que d'utiliser le signe ``=`` dans notre clause ``WHERE``, nous avons utilisé l'opérateur ``LIKE`` pour pouvoir définir notre comparaison. Vous auriez sans doute voulu utiliser le symbole ``*`` pour exprimer "n'importe quelle valeur" mais en SQL vous devez utiliser : ``%`` et l'opérateur ``LIKE`` pour informer le systÚme que cette comparaison doit être possible.
 
 ::
@@ -192 +193 @@
  POLYGON((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1))
 
-The first polygon has only one ring. The second one has an interior "hole". Most graphics systems include the concept of a "polygon", but GIS systems are relatively unique in allowing polygons to explicitly have holes.
+Le premier polygon a seulement une ligne. Le second a un "trou". La plupart des systÚmes de rendu graphique supportent le concept de "polygone", mais les systÚme SIG sont les seuls a accepter que les polygones puisse contenir des trous.
 
 .. image:: ./screenshots/polygons.png
 
-Some of the specific spatial functions for working with polygons are:
-
- * :command:`ST_Area(geometry)` returns the area of the polygons
- * :command:`ST_NRings(geometry)` returns the number of rings (usually 1, more of there are holes)
- * :command:`ST_ExteriorRing(geometry)` returns the outer ring as a linestring
- * :command:`ST_InteriorRingN(geometry,n)` returns a specified interior ring as a linestring
- * :command:`ST_Perimeter(geometry)` returns the length of all the rings
-
-We can calculate the area of our polygons using the area function:
+Certaines des fonctions spatiales spécifique de traitement des polygones sont :
+
+ * :command:`ST_Area(geometry)` retourne l'aire de polygones
+ * :command:`ST_NRings(geometry)` retourne le nombre de contour (habituellement 1, plus lorsqu'il y a des trous)
+ * :command:`ST_ExteriorRing(geometry)` rentourne le contour extérieur
+ * :command:`ST_InteriorRingN(geometry,n)` retourne le contour intérieur numéro n
+ * :command:`ST_Perimeter(geometry)` retourne la longueur de tout les contours
+
+Nous pouvons calculer l'aire de nos polygones en utilisant la fonction area :
 
 .. code-block:: sql
@@ -217 +218 @@
   PolygonWithHole    99
 
-Note that the polygon with a hole has an area that is the area of the outer shell (a 10x10 square) minus the area of the hole (a 1x1 square).
-
-Collections
-~~~~~~~~~~~
-
-There are four collection types, which group multiple simple geometries into sets.  
-
- * **MultiPoint**, a collection of points
- * **MultiLineString**, a collection of linestrings
- * **MultiPolygon**, a collection of polygons
- * **GeometryCollection**, a heterogeneous collection of any geometry (including other collections)
-
-Collections are another concept that shows up in GIS software more than in generic graphics software. They are useful for directly modeling real world objects as spatial objects. For example, how to model a lot that is split by a right-of-way? As a **MultiPolygon**, with a part on either side of the right-of-way.
+Remarquez que le polygone contenant un trou a une aire égale à l'aire du contour externe (un carré de 10 sur 10) moins l'aire du trou (un carré de 1 sur 1).
+
+Les collections
+~~~~~~~~~~~~~~~~ 
+
+Il y a quatre types de collections, qui regroupe ensembles plusieurs géométries simples.
+
+ * **MultiPoint**, une collection de points
+ * **MultiLineString**, une collection de lignes
+ * **MultiPolygon**, une collection de polygones
+ * **GeometryCollection**, une collections hétérogÚne de n'importe quelle géométrie (dont d'autre collections)
+
+Les collections sont un concept présents dans les logiciels SIG  plus que dans les application de rendu graphique générique. Elles sont utiles pour directement modeler  les objets du monde réel comme des objet spatiaux. Par exemple, comment modéliser une parcelle qui é coupée par un chemin ? Comme un **MultiPolygon**, ayant une partie de chaque coté du chemin.
 
 .. image:: ./screenshots/collection2.png
 
-Our example collection contains a polygon and a point:
+Notre collection exemple contient un polygon et un point :
 
 .. code-block:: sql
@@ -247 +248 @@
 .. image:: ./screenshots/collection.png
 
-Some of the specific spatial functions for working with collections are:
-
- * :command:`ST_NumGeometries(geometry)` returns the number of parts in the collection
- * :command:`ST_GeometryN(geometry,n)` returns the specified part
- * :command:`ST_Area(geometry)` returns the total area of all polygonal parts
- * :command:`ST_Length(geometry)` returns the total length of all linear parts
-
-
-
-Geometry Input and Output
--------------------------
+Certaines des fonctions spatiales spécifiques à la manipulation des collections sont :
+
+ * :command:`ST_NumGeometries(geometry)` retourne le nombre de composantes d'une collection
+ * :command:`ST_GeometryN(geometry,n)` retourne une composante spécifique
+ * :command:`ST_Area(geometry)` retourne l'aire totale des composantes de types polygones
+ * :command:`ST_Length(geometry)` retourne la longueur totale des composantes de types lignes
+
+
+
+Entré / Sortie des géométries
+-----------------------------
 
 Within the database, geometries are stored on disk in a format only used by the PostGIS program. In order for external programs to insert and retrieve useful geometries, they need to be converted into a format that other applications can understand. Fortunately, PostGIS supports emitting and consuming geometries in a large number of formats: