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.

source: trunk/workshop-foss4g/geometries.rst @ 47

Revision 46, 20.1 KB checked in by nbozon, 13 years ago (diff)

Some more typos corrected -

RevLine 
[1]1.. _geometries:
2
[37]3Partie 8 : Les géometries
[1]4=====================
5
6Introduction
7------------
8
[37]9Dans :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.
[1]10
11.. code-block:: sql
12
13  CREATE TABLE geometries (name varchar, geom geometry);
14 
15  INSERT INTO geometries VALUES
16    ('Point', 'POINT(0 0)'),
17    ('Linestring', 'LINESTRING(0 0, 1 1, 2 1, 2 2)'),
18    ('Polygon', 'POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))'),
19    ('PolygonWithHole', 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1))'),
20    ('Collection', 'GEOMETRYCOLLECTION(POINT(2 0),POLYGON((0 0, 1 0, 1 1, 0 1, 0 0)))');
21   
22  SELECT Populate_Geometry_Columns();
23 
24  SELECT name, ST_AsText(geom) FROM geometries;
25
26.. image:: ./geometries/start01.png
27
[46]28L'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.
[1]29
[19]30Les tables de métadonnées
31-------------------------
[1]32
[19]33Dans 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.
[1]34
[46]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. 
[19]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.
[1]37
38.. image:: ./geometries/table01.png
39
[19]40Dans 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.
[1]41
[46]42Regardons maintenant la table ``geometry_columns`` de notre base de données. Copiez cette commande dans la fenêtre de requêtage :
[1]43
[19]44
[1]45.. code-block:: sql
46
47  SELECT * FROM geometry_columns;
48
49.. image:: ./geometries/start08.png
50
[19]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. 
52* ``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. 
[1]55
[37]56En 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.
[1]57
[37]58Réprésenter des objets du monde réel
[19]59-----------------------------------
[1]60
[37]61La 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.
[1]62
[37]63Notre table exemple contient différents types de géométries. Nous pouvons récupérer les informations de chaque objet en utilisant les fonctions qui lisent les métadonnées de la géométrie.
[1]64
[19]65 * :command:`ST_GeometryType(geometry)` retourne le type de la géométrie
[46]66 * :command:`ST_NDims(geometry)` retourne le nombre de dimensions d'une géométrie
[19]67 * :command:`ST_SRID(geometry)` retourne l'identifiant de référence spatiale de la géométrie
[1]68
69.. code-block:: sql
70
71  SELECT name, ST_GeometryType(geom), ST_NDims(geom), ST_SRID(geom)
72    FROM geometries;
73
74::
75
76       name       |    st_geometrytype    | st_ndims | st_srid
77 -----------------+-----------------------+----------+---------
78  Point           | ST_Point              |        2 |      -1
79  Polygon         | ST_Polygon            |        2 |      -1
80  PolygonWithHole | ST_Polygon            |        2 |      -1
81  Collection      | ST_GeometryCollection |        2 |      -1
82  Linestring      | ST_LineString         |        2 |      -1
83
84
85
[19]86Les points
87~~~~~~~~~~~
[1]88
89.. image:: ./introduction/points.png
90   :align: center
91
[46]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écrite sous la forme de points alors qu'une carte régionale utiliserait une représentation polygonale des villes.
[1]93
94.. code-block:: sql
95
96  SELECT ST_AsText(geom)
97    FROM geometries
98    WHERE name = 'Point';
99
100::
101
102  POINT(0 0)
103
[46]104Certaines des fonctions spécifiques pour travailler avec les points sont :
[1]105
[19]106 * :command:`ST_X(geometry)` retourne la composante X
107 * :command:`ST_Y(geometry)` retourne la composante Y
[1]108
[19]109Donc, nous pouvons lire les coordonnées d'un point de la maniÚre suivante :
[1]110
111.. code-block:: sql
112
113  SELECT ST_X(geom), ST_Y(geom)
114    FROM geometries
115    WHERE name = 'Point';
116
[46]117La table des stations de métro 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 renverra la géométrie associée à un point (dans la colonne :command:`ST_AsText`).
[1]118
119.. code-block:: sql
120
121  SELECT name, ST_AsText(the_geom)
122    FROM nyc_subway_stations
123    LIMIT 1;
124
125
[19]126Les lignes
[1]127~~~~~~~~~~~
128
129.. image:: ./introduction/lines.png
130   :align: center
131
[46]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é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**.
[1]133
[46]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 file avec différents attributs.
[1]135
[19]136La requête SQL suivante retourne la géométrie associée à une ligne (dans la colonne :command:`ST_AsText`) :
[1]137
138.. code-block:: sql
139
140  SELECT ST_AsText(geom)
141    FROM geometries
142    WHERE name = 'Linestring';
143 
144::
145
146  LINESTRING(0 0, 1 1, 2 1, 2 2)
147
[19]148Les fonctions spatiales permettant de travailler avec les lignes sont les suivantes :
[1]149
[19]150 * :command:`ST_Length(geometry)` retourne la longueur d'une ligne
151 * :command:`ST_StartPoint(geometry)` retourne le premier point d'une ligne
152 * :command:`ST_EndPoint(geometry)` retourne le denier point d'une ligne
153 * :command:`ST_NPoints(geometry)` retourne le nombre de points dans une ligne
[1]154
[19]155Donc, la longueur de notre ligne est :
[1]156
157.. code-block:: sql
158
159  SELECT ST_Length(geom)
160    FROM geometries
161    WHERE name = 'Linestring';
162
163::
164
165  3.41421356237309
166
167
[19]168Les polygones
169~~~~~~~~~~~~~~
[1]170
171.. image:: ./introduction/polygons.png
172  :align: center
173
[19]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é de la même maniÚre.
[1]175
[37]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é 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.
[1]177
[37]178La requête SQL suivante retournera la géométrie associée à un polygone (dans la colonne :command:`ST_AsText`).
[1]179
180.. code-block:: sql
181
182  SELECT ST_AsText(geom)
183    FROM geometries
184    WHERE name LIKE 'Polygon%';
185
186.. note::
187
[19]188  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.
[1]189
190::
191
192 POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))
193 POLYGON((0 0, 10 0, 10 10, 0 10, 0 0),(1 1, 1 2, 2 2, 2 1, 1 1))
194
[46]195Le premier polygone 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Úmes SIG sont les seuls à accepter que les polygones puissent contenir des trous.
[1]196
197.. image:: ./screenshots/polygons.png
198
[37]199Certaines des fonctions spatiales spécifiques de traitement des polygones sont :
[1]200
[46]201 * :command:`ST_Area(geometry)` retourne l'aire d'un polygone
[37]202 * :command:`ST_NRings(geometry)` retourne le nombre de contours (habituellement 1, plus lorsqu'il y a des trous)
203 * :command:`ST_ExteriorRing(geometry)` retourne le contour extérieur
[19]204 * :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
[1]206
[19]207Nous pouvons calculer l'aire de nos polygones en utilisant la fonction area :
[1]208
209.. code-block:: sql
210
211  SELECT name, ST_Area(geom)
212    FROM geometries
213    WHERE name LIKE 'Polygon%';
214
215::
216
217  Polygon            1
218  PolygonWithHole    99
219
[19]220Remarquez 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).
[1]221
[19]222Les collections
223~~~~~~~~~~~~~~~~
[1]224
[46]225Il y a quatre types de collections, qui regroupe ensemble plusieurs géométries simples.
[1]226
[19]227 * **MultiPoint**, une collection de points
228 * **MultiLineString**, une collection de lignes
229 * **MultiPolygon**, une collection de polygones
[37]230 * **GeometryCollection**, une collection hétérogÚne de n'importe quelle géométrie (dont d'autre collections)
[1]231
[37]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 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.
[1]233
234.. image:: ./screenshots/collection2.png
235
[46]236Notre collection exemple contient un polygone et un point :
[1]237
238.. code-block:: sql
239
240  SELECT name, ST_AsText(geom)
241    FROM geometries
242    WHERE name = 'Collection';
243
244::
245
246  GEOMETRYCOLLECTION(POINT(2 0),POLYGON((0 0, 1 0, 1 1, 0 1, 0 0)))
247
248.. image:: ./screenshots/collection.png
249
[19]250Certaines des fonctions spatiales spécifiques à la manipulation des collections sont :
[1]251
[19]252 * :command:`ST_NumGeometries(geometry)` retourne le nombre de composantes d'une collection
253 * :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
[1]256
[19]257Entré / Sortie des géométries
258-----------------------------
[1]259
[37]260Dans la base de données, les géométries sont stockées dans un format utilisé uniquement par le programme PostGIS. Afin que des programmes externes puissent insérer et récupérer les données utiles, elles ont besoin d'être converties dans un format compris par l'application. Heureusement, PostGIS supporte un grand nombre de formats en entrée et en sortie :
[1]261
[20]262 * Format texte bien connu (Well-known text :term:`WKT`)
[1]263 
[20]264   * :command:`ST_GeomFromText(text)` retourne une ``geometry``
265   * :command:`ST_AsText(geometry)` retourne le ``texte``
266   * :command:`ST_AsEWKT(geometry)` retourne le ``texte``
[1]267   
[20]268 * Format binaire bien connu (Well-known binary :term:`WKB`)
[1]269 
[20]270   * :command:`ST_GeomFromWKB(bytea)` retourne ``geometry``
271   * :command:`ST_AsBinary(geometry)` retourne ``bytea``
272   * :command:`ST_AsEWKB(geometry)` retourne ``bytea``
[1]273   
274 * Geographic Mark-up Language (:term:`GML`)
275 
[20]276   * :command:`ST_GeomFromGML(text)` retourne ``geometry``
277   * :command:`ST_AsGML(geometry)` retourne ``text``
[1]278   
279 * Keyhole Mark-up Language (:term:`KML`)
280 
[20]281   * :command:`ST_GeomFromKML(text)` retourne ``geometry``
282   * :command:`ST_AsKML(geometry)` retourne ``text``
[1]283   
284 * :term:`GeoJSON`
285 
[20]286   * :command:`ST_AsGeoJSON(geometry)` retourne ``text``
[1]287   
288 * Scalable Vector Graphics (:term:`SVG`)
289 
[20]290   * :command:`ST_AsSVG(geometry)` retourne ``text``
[1]291 
[20]292La 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) :
[1]293
294.. code-block:: sql
295
296  SELECT encode(
297    ST_AsBinary(ST_GeometryFromText('LINESTRING(0 0 0,1 0 0,1 1 2)')),
298    'hex');
299
300.. image:: ./geometries/represent-04.png
301
[20]302Dans 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.
[1]303
[20]304Puisque 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.
[1]305
[20]306Voici un exemple de ligne 3D au format WKT :
[1]307
308.. code-block:: sql
309
310  SELECT ST_AsEWKT(ST_GeometryFromText('LINESTRING(0 0 0,1 0 0,1 1 2)'));
311
312.. image:: ./geometries/represent-05.png
313
314.. code-block:: sql
315
316  SELECT encode(ST_AsEWKB(ST_GeometryFromText(
317      'LINESTRING(0 0 0,1 0 0,1 1 2)')), 'hex');
318
319.. image:: ./geometries/represent-06.png
320
[37]321En plus de pouvoir générer les différents formats en sortie (WKT, WKB, GML, KML, JSON, SVG), PostGIS permet aussi de lire 4 de ces formats (WKT, WKB, GML, KML). La plupart des applications utilisent des fonctions créant des géométries à l'aide du format WKT ou WKB, mais les autres marchent aussi. Voici un exemple qui lit du GML et retourne du JSON :
[1]322
323.. code-block:: sql
324
325  SELECT ST_AsGeoJSON(ST_GeomFromGML('<gml:Point><gml:coordinates>1,1</gml:coordinates></gml:Point>'));
326
327.. image:: ./geometries/represent-07.png
328
[20]329Liste des fonctions
330-------------------
[1]331
[37]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.
[1]333
[20]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.
[1]335
[20]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.
[1]337
[20]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.
[1]339
[20]340`ST_EndPoint <http://postgis.org/docs/ST_EndPoint.html>`_: retourne le dernier point d'une ligne.
[1]341
[20]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.
[1]343
[20]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.
[1]345
[37]346`ST_AsGeoJSON <http://postgis.org/docs/ST_AsGeoJSON.html>`_: retourne la géométrie au format GeoJSON.
[1]347
[37]348`ST_AsGML <http://postgis.org/docs/ST_AsGML.html>`_: retourne la géométrie au format GML version 2 ou 3.
[1]349
[37]350`ST_AsKML <http://postgis.org/docs/ST_AsKML.html>`_: retourne la géométrie au format KML. Nombreuses variantes. Par défaut : version=2 et precision=15.
[1]351
[37]352`ST_AsSVG <http://postgis.org/docs/ST_AsSVG.html>`_: retourne la géométrie au format SVG.
[1]353
[20]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.
[1]355
[20]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.
[1]357
[20]358`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.
[1]359
[20]360`ST_GeomFromKML <http://postgis.org/docs/ST_GeomFromKML.html>`_: prend en entrée une représentation KML de la géométrie et retourne un object PostGIS de type geometry.
[1]361
[20]362`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).
[1]363
[20]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).
[1]365
[20]366`ST_GeometryType <http://postgis.org/docs/ST_GeometryType.html>`_: retourne le type de géométrie de la valeur de type ST_Geometry.
[1]367
[20]368`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.
[1]369
[20]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).
[1]371
[20]372`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.
[1]373
[20]374`ST_NPoints <http://postgis.org/docs/ST_NPoints.html>`_: retourne le nombre de points dans une géométrie.
[1]375
[20]376`ST_NRings <http://postgis.org/docs/ST_NRings.html>`_: si la géométrie est un polygone ou un multi-polygone, retourne le nombre de contours.
[1]377
[20]378`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.
[1]379
[20]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).
[1]381
[37]382`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.
[1]383
[20]384`ST_StartPoint <http://postgis.org/docs/ST_StartPoint.html>`_: retourne le premier point d'une ligne.
[1]385
[20]386`ST_X <http://postgis.org/docs/ST_X.html>`_: retourne la coordonnée X d'un point, ou NULL si non présent. L'argument passé doit être un point.
[1]387
[20]388`ST_Y <http://postgis.org/docs/ST_Y.html>`_: retourne la coordonnée Y d'un point, ou NULL si non présent. L'argument passé doit être un point.
[1]389
Note: See TracBrowser for help on using the repository browser.