Guide d'utilisation et de référence


Représentations binaires connues (WKB - well-known binary) de l'OGC

Extension Spatiale dispose de plusieurs fonctions de génération de géométries à partir de représentations binaires :

ST_GeomFromWKB
Crée une géométrie à partir d'une représentation binaire connue (WKB) d'un type de géométrie quelconque.

ST_PointFromWKB
Crée un point à partir de la représentation binaire d'un point.

ST_LineFromWKB
Crée une ligne à partir de la représentation binaire d'une ligne.

ST_PolyFromWKB
Crée un polygone à partir de la représentation textuelle d'un polygone.

ST_MPointFromWKB
Crée un multipoint à partir de la représentation binaire d'un multipoint.

ST_MLineFromWKB
Crée une multiligne à partir de la représentation binaire d'une multiligne.

ST_MPolyFromWKB
Crée un multipolygone à partir de la représentation binaire d'un multipolygone.

La représentation binaire connue est un flot contigu d'octets. Elle permet d'échanger une géométrie entre un client ODBC et une base de données SQL sous une forme binaire. Ces fonctions impliquent de définir des structures C pour le mappage de la représentation binaire ; elles sont donc destinées à être utilisées dans un programme de langage de troisième génération (3GL). Elles ne conviennent pas à un environnement de langage de quatrième génération (4GL). La fonction ST_AsBinary convertit une valeur de géométrie existante en une représentation binaire connue (WKB).

La représentation binaire connue d'une géométrie est obtenue en sérialisant une instance de la géométrie en tant que séquence de types numériques. Ces types sont extraits de l'ensemble (unsigned integer, double) et chacun d'eux est ensuite sérialisé en tant que séquence d'octets. Les types sont sérialisés en utilisant une des deux normes de représentation binaire connue associées aux types numériques (NDR et XDR). Une balise d'un octet précédant les bits sérialisés décrit le codage binaire spécifique (NDR ou XDR) appliqué au train d'octets d'une géométrie. Ces deux systèmes de codage des géométries ne se distinguent que par l'ordre des octets : le codage XDR est de type big-endian alors que le codage NDR est de type little-endian.

Définitions des types numériques

Un entier non signé (unsigned integer) est un type de données sur 32 bits (4 octets), qui encode un entier non négatif appartenant à la plage [1, 4294967295].

Un double est un type de données à double précision sur 64 bits (8 octets), qui encode un nombre à double précision en recourant au format de double précision IEEE 754.

Ces définitions s'appliquent aux deux formats, XDR et NDR.

Types numériques associés au codage XDR (Big Endian)

La représentation XDR d'un entier non signé est de type big-endian (octet le plus significatif en premier).

La représentation XDR d'un double est de type big-endian (le bit de signe constitue le premier bit).

Types numériques associés au codage NDR (Little Endian)

La représentation NDR d'un entier non signé est de type little-endian (octet le moins significatif en premier).

La représentation NDR d'un double est de type little-endian (le bit de signe est dans le dernier octet).

Conversion entre NDR et XDR

La conversion entre les types de données NDR et XDR exécutée sur les entiers non signés et les doubles est une opération simple. Elle consiste à inverser l'ordre des octets au sein de chaque entier non signé ou double appartenant au train d'octets.

Description des trains d'octets WKBGeometry

La présente section décrit la représentation binaire connue (WKB) associée aux géométries. Le bloc de construction de base est le train d'octet d'un point, qui est composé de deux doubles. Les trains d'octets des autres géométries sont créés à partir des trains d'octets de géométries déjà définies.

// Basic Type definitions
// byte : 1 byte
// uint32 : 32 bit unsigned integer (4 bytes)
// double : double precision number (8 bytes)
 
// Building Blocks : Point, LinearRing
 
Point {
  double x;
  double y;
};
LinearRing   {
  uint32   numPoints;
  Point    points[numPoints];
};
enum wkbGeometryType {
  wkbPoint = 1,
  wkbLineString = 2,
  wkbPolygon = 3,
  wkbMultiPoint = 4,
  wkbMultiLineString = 5,
  wkbMultiPolygon = 6};
enum wkbByteOrder {
  wkbXDR = 0,                                      // Big Endian
  wkbNDR = 1                                    // Little Endian
};
WKBPoint {
  byte              byteOrder;
  uint32   wkbType;                                         // 1
  Point    point;
};
WKBLineString {
  byte              byteOrder;
  uint32   wkbType;                                         // 2
  uint32   numPoints;
  Point    points[numPoints];
};
 
WKBPolygon    {
  byte              byteOrder;
  uint32            wkbType;                                // 3
  uint32            numRings;
  LinearRing        rings[numRings];
};
WKBMultiPoint    {
  byte              byteOrder;
  uint32            wkbType;                                // 4
  uint32            num_wkbPoints;
  WKBPoint            WKBPoints[num_wkbPoints];
};
WKBMultiLineString    {
  byte              byteOrder;
  uint32            wkbType;                                // 5
  uint32            num_wkbLineStrings;
  WKBLineString     WKBLineStrings[num_wkbLineStrings];
};
 
wkbMultiPolygon {
  byte              byteOrder;
  uint32            wkbType;                                // 6
  uint32            num_wkbPolygons;
  WKBPolygon        wkbPolygons[num_wkbPolygons];
};
 
;WKBGeometry  {
  union {
    WKBPoint                 point;
    WKBLineString            linestring;
    WKBPolygon               polygon;
    WKBMultiPoint            mpoint;
    WKBMultiLineString       mlinestring;
    WKBMultiPolygon          mpolygon;
  }
};
 

La figure ci-après illustre une représentation NDR.

Figure 39. Représentation au format NDR. (B=1) de type polygone (T=3) avec 2 anneaux linéaires (NR=2), chaque anneau ayant 3 points (NP=3).

[Figure]

Assertions concernant la représentation WKB

La représentation binaire connue (WKB) des géométries est conçue pour représenter des instances des types de géométrie décrits dans le modèle d'objet géométrie (Geometry Object Model) et dans la Spécification abstraite OpenGIS.

Ces assertions ont les répercutions suivantes sur les anneaux, polygones et multipolygones :

Anneaux linéaires
Les anneaux sont simples et fermés, autrement dit, des anneaux linéaires ne peuvent pas former d'intersection avec eux-mêmes.

Polygones
Deux anneaux linéaires appartenant au contour d'un polygone ne doivent pas se couper. Les anneaux linéaires du contour d'un polygone peuvent au plus former une intersection en un seul point mais uniquement si celui-ci est tangent.

Multipolygones
Les intérieurs de deux polygones composant un multipolygone ne peuvent pas former d'intersection. Les contours de deux polygones appartenant à un multipolygone ne peuvent être en contact qu'en un nombre fini de points.


[ Début de page | Page précédente | Page suivante | Table des matières | Index ]