Suite

Fonctionnalités de PostGIS 2.0 et d'auto-intersection

Fonctionnalités de PostGIS 2.0 et d'auto-intersection


J'ai une classe d'entités surfaciques créée par OpenStreetMap qui renvoie une erreur d'auto-intersection. Existe-t-il un moyen de filtrer ces fonctionnalités ? Puis-je simplement utiliser une instruction SQL pour trouver les polygones d'erreur ?


Requête pour

ST_EstValide([votre géométrie]) = 'f'

Les auto-intersections ne sont pas aussi malveillantes que les intersections sans nœud. Voici quelques solutions 4 U :

Corrections automatiques par ST_MakeValid :

mettre à jour mytable set way = ST_Makevalid(way) où st_isvalid(way)=false

Et similaire, mais en utilisant st_buffer :

mettre à jour mytable set way = ST_Buffer(way,0) où st_isvalid(way)=false

Si cela ne vous aide pas, cela vous donnera les coordonnées des intersections :

sélectionnez abs(a1.osm_id) comme OSM_ID, Reason(ST_IsValidDetail(a1.way)) comme Reason, ST_asText(ST_TRANSFORM(ST_SetSRID(location(ST_IsValidDetail(a1.way)),900913),4326)) comme emplacement de planet_osm_polygon a1 où st_isvalid(a1.way) = faux

Vous pouvez le charger dans QGIS en tant que couche de requête en utilisant cette requête :

sélectionnez row_number() over() comme GID, location(ST_IsValidDetail(a1.way) comme chemin de planet_osm_polygon a1 où st_isvalid(a1.way) = false

Si vous utilisez le schéma osm2pgsql et que vous souhaitez le réparer dans le projet OSM, vous pouvez exécuter cette requête et enregistrer le résultat sous forme de fichier XML. Si vous l'ouvrez avec votre navigateur, vous pouvez regarder ces intersections dans OSM ou les charger dans JOSM pour les réparer (requête non testée donc peut nécessiter quelques réglages) :

sélectionnez abs(a1.osm_id) comme OSM_ID, Reason(ST_IsValidDetail(a1.way)) comme Reason, ST_asText(ST_TRANSFORM(ST_SetSRID(location(ST_IsValidDetail(a1.way)),900913),4326)) comme emplacement, a1.tags -> 'osm_user'::text as USER, 'Modifier dans JOSM' comme josm, 'Modifier dans JOSM' comme Area_in_JOSM, 'Afficher sur la carte' comme OSM de planet_osm_polygon a1 où st_isvalid(a1.way) = false order by a1.tags -> 'osm_user'::text;

PostSIG

Notre bibliothèque de logiciels fournit un téléchargement gratuit de PostSIG 2.0. Les versions suivantes : 2.0, 1.5 et 1.4 sont les plus fréquemment téléchargées par les utilisateurs du programme. PostGIS a été développé pour fonctionner sur Windows XP, Windows Vista ou Windows 7 et peut fonctionner sur des systèmes 32 bits.

PostGIS est classé dans la catégorie des outils de développement. Cet outil gratuit a été créé à l'origine par Refractions Research. Notre antivirus intégré a analysé ce téléchargement et l'a évalué comme 100 % sûr. Le fichier d'installation actuel disponible au téléchargement nécessite 11,2 Mo d'espace disque.

PostGIS est un logiciel unique qui ajoute la prise en charge des objets géographiques à la base de données relationnelle objet PostgreSQL.

En effet, PostGIS "active spatialement" le serveur PostgreSQL, lui permettant d'être utilisé comme une base de données spatiale back-end pour les systèmes d'information géographique (SIG), un peu comme l'extension ESRI's SDE ou Oracle's Spatial.

Vous voudrez peut-être consulter d'autres logiciels, tels que gshp2pgsql, Mappeur mondial ou alors Thuban, qui pourrait être similaire à PostGIS.


Ven. 29 mai 2020

Districts du conseil du comté de San Juan Bureaux de vote du conseil du comté de San Juan

Pour les guides des électeurs LWV NM de cette année sur VOTE411.org, j'ai beaucoup manipulé le SIG, car le système doit connaître les circonscriptions électorales pour chaque course.

Vous penseriez qu'il serait facile de trouver un SIG pour les circonscriptions électorales et c'est sûrement une information publique ? &mdash, mais les comtés et l'État sont remarquablement réticents à fournir toute sorte de données (ils sont heureux de vous donner un PDF ou un JPG), donc trouver les données du district demande beaucoup de recherche.

Souvent, lorsque nous parvenons enfin à obtenir des informations SIG, ce n'est pas pour ce que nous voulons. Par exemple, pour le comté de San Juan, il existe un fichier qui prétend être des districts de la commission du comté (qui ressemblerait à l'image ci-dessus à gauche), mais les formes dans le fichier sont en fait des bureaux de vote (en haut à droite). Un district est composé de plusieurs circonscriptions à San Juan, il y a 77 circonscriptions qui composent cinq districts.

Dans un cas comme celui-là, vous avez besoin d'un moyen de combiner plusieurs formes (un groupe d'enceintes) en une seule (un quartier).


агрузить для всех оступных архитектур
рхитектура азмер акета становленном иде айлы
amd64 3 252,0 Кб7 847,0 [список айлов]
bras64 3 208,17 835,0 [список айлов]
armelle 3 133,37 628,0 [список айлов]
armhf 3 152,67 375,0 [список айлов]
i386 3 277,08 044,0 [список айлов]
mips 3 167,97 924,0 [список айлов]
mips64el 3 192,97 987,0 [список айлов]
mipsel 3 174,37 920,0 [список айлов]
ppc64el 3 297,88 412,0 [список айлов]
s390x 3 201,57 849,0 [список айлов]

та страница также доступна на следующих языках (Как установить язык о умолчанию):

тобы сообщить о проблеме, связанной с веб-сайтом, отправьте сообщение (на английском) список расссылки debian-debian рочую контактную информацию см. на странице Debian ак с нами связаться.

торские рава © 1997 - 2021 SPI Inc. См. словия ицензии. Debian то торговый нак омпании SPI Inc. том сайте.


Ругие пакеты, относящиеся postgis

  • ависимости
  • рекомендации
  • редложения
  • améliore
  • dep: libc6 (>= 2.27) [riscv64, sh4] иблиотека GNU C: динамически подключаемые библиотеки
    также иртуальный пакет, редоставляемый libc6-udeb dep: libc6 (>= 2.29) [не alpha, riscv64, sh4]
  • dep: libc6.1 (>= 2.29) [alpha] иблиотека GNU C: инамически подключаемые иблиотеки
    также иртуальный акет, редоставляемый libc6.1-udeb
  • dep: libgdal20 (>= 2.0.1) [sh4, x32] акет недоступен
  • dep: libgdal28 (>= 2.0.1) [не sh4, x32] Bibliothèque d'abstraction de données géospatiales
  • dep: libgeos-c1v5 (>= 3.4.2) [sh4] Moteur de géométrie pour les systèmes d'information géographique - Bibliothèque C dep: libgeos-c1v5 (>= 3.6) [x32] dep: libgeos-c1v5 (>= 3.9.0) [ не sh4, x32]
  • dep: libgmpxx4ldbl (>= 2:6.2.1+dfsg) [hppa, m68k, sparc64] Bibliothèque arithmétique multiprécision (liaisons C++)
  • dep: libjson-c5 (>= 0,15) [hppa, m68k, sparc64] иблиотека манипуляции JSON — разделяемая библиотека
  • dep: liblwgeom-2.4-0 (>= 2.0.0) [sh4] Bibliothèque PostGIS "Lightweight Geometry"
  • dep: libpq5 иентская -библиотека PostgreSQL
  • dep: libproj15 (>= 4.9.0) [x32] акет недоступен
  • dep: libproj19 (>= 4.9.0) [не sh4, x32] Bibliothèque de projection cartographique
  • dep: libsfcgal1 (>= 1.3.1) [hppa, m68k, sparc64] Bibliothèque pour ISO 19107:2013 et OGC SFA 1.2 pour les opérations 3D
  • rec: postgis-doc Prise en charge des objets géographiques pour PostgreSQL -- documentation
  • rec: postgresql-10-postgis-2.4 [sh4] Prise en charge des objets géographiques pour PostgreSQL 10
  • rec: postgresql-12-postgis-3 [x32] Prise en charge des objets géographiques pour PostgreSQL 12
  • rec: postgresql-postgis [не sh4, x32] иртуальный пакет, редоставляе postgresql-12-postgis-3, postgresql-13-postgis-3
  • sug: postgis-gui Prise en charge des objets géographiques pour PostgreSQL -- programmes GUI

  • Types de géométrie pour Points, LineStrings, Polygons, MultiPoints, MultiLineStrings, MultiPolygons et GeometryCollections.
  • Prédicats spatiaux pour déterminer les interactions de géométries à l'aide du 3x3 DE-9IM (fourni par la bibliothèque logicielle GEOS).
  • Opérateurs spatiaux pour déterminer les mesures géospatiales telles que la superficie, la distance, la longueur et le périmètre.
  • Opérateurs spatiaux pour déterminer les opérations d'ensemble géospatial, comme l'union, la différence, la différence symétrique et les tampons (fournis par GEOS). -over-GiST (Generalized Search Tree) index spatiaux pour les requêtes spatiales à grande vitesse.
  • Prise en charge de la sélectivité d'index, pour fournir des plans de requête hautes performances pour les requêtes spatiales/non spatiales mixtes.
  • Pour les données raster, PostGIS WKT Raster (maintenant intégré à PostGIS 2.0+ et renommé PostGIS Raster)

L'implémentation de PostGIS est basée sur des géométries "légères" et des index optimisés pour réduire l'empreinte disque et mémoire. L'utilisation de géométries légères aide les serveurs à augmenter la quantité de données migrées depuis le stockage sur disque physique vers la RAM, améliorant considérablement les performances des requêtes.

PostGIS est enregistré comme « implémente la norme spécifiée » pour « Fonctionnalités simples pour SQL » par l'OGC. [2] PostGIS n'a pas été certifié conforme par l'OGC.

Refractions Research a publié la première version de PostGIS en 2001 sous la licence publique générale GNU. Après six versions candidates, une version stable "1.0" a suivi le 19 avril 2005.

En 2006, l'OGC a enregistré PostGIS comme « implémentant la norme spécifiée » pour « Fonctionnalités simples pour SQL ». [3]


10 réponses 10

« tarauder » dans ce contexte signifie couper des fils dans un trou. Pour ce sujet, nous pouvons penser à trois choses de base qu'une vis peut faire - percer son propre trou, tarauder ses propres filets ou simplement se frayer un chemin dans le matériau en arrachant un trou ou des filets au cours du processus.

En utilisant cette image de cet article wikipedia :

La vis supérieure est auto-perceuse. La pointe pointue et fendue agit comme un foret pour créer un trou de la bonne taille. Au sommet de cette pointe de perçage, les filets se rétrécissent et c'est la partie autotaraudeuse. Toutes les vis autoperceuses sont également considérées comme autotaraudeuses, et le langage courant consiste à les appeler simplement "autotaraudeuses".

Les trois vis suivantes sur la photo ont une pointe émoussée, elles ne sont donc pas capables de percer. Ils nécessitent un trou pré-percé, mais ils ont une encoche ou une cannelure à la pointe, et c'est ce que la vis peut utiliser pour couper ses propres filets ou "auto-tarauder". Ce sont de pures vis "autotaraudeuses", mais vous ne les voyez pas en vente dans les grands magasins de la maison. Ils sont davantage utilisés dans l'industrie pour assembler des marchandises au niveau de l'usine. Vous pouvez les acheter - ils ne sont tout simplement pas aussi courants.

L'entrée Wikipédia se trompe

Cette image de la page Wiki est juste vis à tôle ordinaire et ne devrait pas figurer sur une page décrivant les vis autotaraudeuses :

Ceux-ci n'ont pas de pointe de perçage et ils n'ont pas de cannelure pour couper les fils. Bien sûr, ils sont un peu tranchants, mais pas assez tranchants pour faire un trou dans la tôle. Ils ont besoin d'un trou de la bonne taille. S'ils sont enfoncés dans un trou trop petit, ils vont déchirer le trou plus large (s'ils sont plus solides que la tôle) et créer une connexion plus faible qu'un autotaraudeur qui coupe correctement les bons filets.


Le numéro de version a été supprimé du fichier lib address_standardize dans PostGIS 2.5.0. Les fonctions de support raster ne peuvent être chargées que dans le même schéma avec les fonctions PostGIS principales. Le type pgis_abs factice a été supprimé des routines d'agrégation/collecte. La prise en charge a été supprimée pour la prise en charge de la suppression GEOS < 3.5 et PostgreSQL < 9.4.

  • Il y a eu une amélioration des performances pour le tri des géométries POINT dans PostGIS 2.5.0.
  • Un index de bande raster externe a été ajouté à ST_BandMetaData. En outre, une section Conseils sur les rasters a été ajoutée dans la documentation pour plus d'informations sur le comportement des rasters (par exemple, performances Out-DB, nombre maximal de fichiers ouverts).
  • L'utilisation de GEOS dans l'implémentation de la topologie a été réduite dans PostGIS 2.5.0.
  • Un bogue qui créait des MVT avec des valeurs de propriété incorrectes sous des plans parallèles a été corrigé.
  • La géométrie dans PostGIS 2.5.0 a été simplifiée en utilisant la taille des cellules de la grille de la carte avant de générer MVT.
  • L'ordre de tri BTree a maintenant été défini sur les collections de géométries VIDE et de même préfixe dans PostGIS 2.5.0.
  • La fonction de géométrie hachable permet une utilisation directe dans les signatures CTE dans PostGIS 2.5.0.
  • PostGIS 2.5.0 n'acceptera pas les points VIDE comme nœuds de topologie.
  • ST_GeometricMedian prend désormais en charge les pondérations ponctuelles dans PostGIS 2.5.0.
  • Le code dupliqué dans lwgeom_geos a été supprimé.

Pour plus d'informations sur les autres mises à jour et correctifs de PostGIS 2.5.0, consultez les notes de version officielles.


Un guide pour la rastérisation des couvertures vectorielles dans PostGIS

Une question fréquente depuis le début de l'aventure PostGIS Raster est « Comment puis-je convertir ma table géométrique en une couverture raster ? (ici aussi). Les gens décrivent souvent la façon de rastériser une seule géométrie à l'aide de ST_AsRaster(), mais je ne connais aucun texte ou tutoriel expliquant comment convertir une couverture vectorielle complète en un seul raster ou en une couverture raster en mosaïque.

Dans cet article je vais décrire deux méthodes pour rastériser une couverture vectorielle : une très rapide mais peu flexible et une très flexible mais malheureusement un peu lente ! Je vais pixelliser une couverture forestière vectorielle afin qu'elle s'aligne parfaitement avec une couche d'altitude raster déjà chargée. J'utiliserai la colonne "hauteur" du couvert forestier pour attribuer des valeurs aux pixels. Je supposerai que les deux couches sont dans le même SRID et que la forêt ne couvre que partiellement la couche d'altitude. La couche d'élévation est divisée en 625 tuiles de 100x100 pixels pour un total de 6 250 000 pixels.


"Intelligente" vecteur VS "stupide" trame !

Pourquoi passer d'une table vectorielle « intelligente » analysée par l'homme, précise, orientée objet, à une couche raster « stupide » non analysée, irrégulière, à variable unique ? Au fil des ans, je n'ai pu identifier que deux bonnes raisons de le faire. La première consiste à regrouper toutes vos couches de données dans un seul paradigme d'analyse (dans ce cas le raster) pour simplifier la chaîne de géotraitement. La seconde est que ce paradigme raster "stupide" est toujours aussi le plus rapide lorsqu'il est temps d'analyser un grand volume de données. Le traitement d'une pile raster repose sur des opérations matricielles très simples généralement disponibles via ce que les géologues appellent des opérations d'algèbre cartographique. Ceci est encore généralement plus rapide que l'algèbre linéaire nécessaire pour analyser les couvertures vectorielles. Quoi qu'il en soit, notre tâche ici n'est pas de décider si le faire en mode vectoriel est meilleur qu'en mode raster. Notre tâche consiste simplement à effectuer la conversion correctement…


"Rasterisation" vs "le rendu"

Une autre question intéressante est la différence entre la pixellisation et le rendu. Le rendu est la conversion d'un modèle vectoriel en une image à des fins d'affichage. La rastérisation est la conversion d'un modèle vectoriel en un raster à des fins d'analyse de données. Les moteurs de rendu, comme MapServer, GeoServer et Mapnik, en plus de mélanger de nombreuses couches ensemble, de symboliser les géométries et de les étiqueter, produiront généralement un anticrénelage le long du bord des polygones et traduiront les valeurs en couleurs symboliques. Toute valeur de données d'origine est perdue et il n'y a aucun moyen d'utiliser le produit d'un moteur de rendu pour l'analyse SIG. D'un autre côté, une fonction de rastérisation, comme celles fournies par GDAL, QGIS, ArcGIS ou PostGIS, produira des pixels bruts en essayant de représenter la surface vectorielle d'origine de manière aussi nette et précise que possible, en attribuant à chaque pixel l'une des valeurs (et uniquement ces valeurs) associées à la géométrie d'origine. Le raster résultant d'un processus de rastérisation est une entrée précieuse dans une chaîne d'analyse de géotraitement. Le résultat d'un processus de rendu ne l'est pas. Nous devons également dire que bien qu'il existe certaines méthodes pour rastériser une couverture vectorielle dans PostGIS, il n'y a toujours aucun moyen d'en rendre une (à moins que vous ne considériez ST_AsJPEG(), ST_AsTIFF() et ST_AsPNG() comme des moteurs de rendu très basiques).


Méthode 1.1 – Basic ST_Union() et ST_Tile()

La première méthode de rastérisation que je présente est celle qui a été planifiée dès le début du projet PostGIS Raster : il suffit de convertir toutes les géométries en petits rasters et de les réunir en un seul raster comme nous unissons plusieurs géométries ensemble en utilisant ST_Union(geometry). Une requête complète, alignant le raster résultant sur une couverture raster d'altitude existante, devrait ressembler à ceci :


Gros plan sur les syndiqués rastérisés
version du couvert forestier résultant
dans des zones "déchiquetées" de même hauteur.
Ce résultat est un "grand" raster unique, agrégeant toutes les "petites" rastérisations des géométries.

Notez les arguments de ST_AsRaster(). Le premier est la géométrie à rastériser. Le second est le raster de référence à partir duquel les paramètres d'alignement sont empruntés (un coin de pixel x et y, l'échelle (ou taille de pixel) et l'inclinaison (ou rotation)). Le troisième argument est le type de pixel du raster attendu (flottant 32 bits). Le quatrième paramètre est la valeur à attribuer au pixel. Voici la colonne 'hauteur' du tableau du couvert forestier. Le dernier paramètre ('-9999') est la valeur nodata à attribuer aux pixels remplissant la zone entourant chaque géométrie rastérisée. Il s'agit de la toute première variante de la fonction ST_AsRaster() dans la référence PostGIS Raster.

Comme son homologue géométrique, ST_Union() agrège (fusionne) simplement tous ces petits rasters ensemble en un seul raster. Sans ST_Union(), la requête aurait généré 2755 petits rasters. Un pour chaque géométrie.

Notez également que nous n'avons choisi qu'un seul raster de la couche d'altitude comme raster de référence pour ST_AsRaster(). En effet, tous les rasters de cette table sont bien alignés et nous n'avons besoin que d'un seul ensemble de coordonnées de coins de pixels pour tout aligner. Nous aurions également pu mettre cette requête en sélectionnant un seul raster directement dans la partie SELECT :


Normalement, nous ne voulons pas conserver de gros rasters dans PostGIS afin de pouvoir diviser le raster fusionné en tuiles plus petites ayant les mêmes dimensions que la couverture d'altitude avec la fonction ST_Tile() :


Le pavage du couvert forestier rastérisé, en rouge, n'est pas bien
aligné avec le pavage du raster d'altitude, en gris.
Notez que les carrés sont des tuiles de 100x100 pixels, pas des pixels.
Il en résulte 48 tuiles, la plupart étant de 100x100 pixels. Certains ne font que 18x100 pixels et certains ne font que 100x46 pixels. Celui en bas à droite ne fait que 18x46 pixels.

Il y a 625 tuiles de 100x100 pixels dans la couverture d'altitude et 2755 géométries dans la couverture forestière. Ces géométries ne couvrent que 31 de ces tuiles et le grand raster qui en résulte en couvre 56. La requête pour créer le "gros" raster prend 5 secondes (merci à Bborie Park qui a accéléré ST_Union() d'un facteur énorme dans PostGIS 2.1) et la requête pour rééchantillonner/retiler ne prend que 2 secondes.

Un problème avec ce résultat est que même si les pixels sont bien alignés avec la couche d'altitude et que la plupart des tuiles ont les mêmes dimensions, les tuiles elles-mêmes ne sont pas alignées avec la couverture d'altitude et elles ne couvrent pas la même zone. La méthode 1.2 corrigera cela.


Méthode 1.2 – ST_Union() et ST_MapAlgebra()

Afin de produire une couverture raster ayant une empreinte identique à la couverture d'altitude, nous devons utiliser cette couverture non seulement pour l'alignement mais aussi comme base pour nos tuiles finales. L'astuce consiste à "graver" le grand raster en tuiles vides en fonction de chacune des tuiles d'élévation. Pour cela nous utiliserons un appel assez simple (!) à deux rasters ST_MapAlgebra() :


La fonction ST_MapAlgebra() des deux rasters superpose les deux rasters et calcule une expression pour chaque ensemble aligné de deux pixels. Le résultat de cette expression devient la valeur attribuée à chaque pixel d'un nouveau raster.

Comme les deux rasters ne sont pas nécessairement bien alignés, la nouvelle étendue raster peut être égale à 1) l'étendue de l'union des deux rasters, 2) l'étendue de la zone d'intersection 3) l'étendue du premier raster ou 4) l'étendue du deuxième raster. Ici, deux rasters impliqués dans l'algèbre cartographique n'ont pas la même étendue. Puisque nous voulons "graver" le grand raster en tuiles ayant la même étendue que les tuiles d'élévation, qui sont en deuxième position dans la liste des arguments, nous devons spécifier que le nouveau raster aura la même étendue que le "DEUXIÈME" raster.

Le premier argument est le "grand" raster de hauteur de forêt. C'est la seule ligne de la table forestheight_rast.

Le deuxième argument est une nouvelle tuile générée avec ST_MakeEmptyRaster() et ST_AddBand() à partir de chacune des 626 tuiles d'élévation. Nous aurions pu utiliser les tuiles d'origine directement, mais puisque nous spécifions que l'étendue résultante est « DEUXIÈME » et que la valeur nodata du résultat de ST_MapAlgebra() est sélectionnée dans le raster « PREMIER » ou « DEUXIÈME » lorsque ces valeurs sont spécifiés, alors le raster résultant aurait eu 32767 comme valeur nodata. Il s'agit de la valeur nodata de la couverture raster d'altitude. Nous voulons que la valeur nodata du résultat soit la même que celle de la couverture de la hauteur de la forêt, qui est de -9999. L'astuce consiste donc à "construire" une nouvelle tuile à partir de zéro avec ST_MakeEmptyRaster() avec les tuiles d'altitude d'origine comme référence d'alignement et de leur ajouter une bande avec ST_AddBand() spécifiant un type de pixel ('32BF'), une valeur initiale ('- 9999') et une valeur nodata ('-9999') identique au raster de hauteur de forêt.

Le troisième argument est l'expression calculant la valeur à attribuer à chaque pixel. Les valeurs de pixels du premier raster sont appelées "[rast1]" et les valeurs de pixels du deuxième raster sont appelées "[rast1]". Vous pouvez également référencer la coordonnée x du pixel avec "[rast.x]" et la coordonnée y avec "[rast.y]". L'expression est n'importe quelle expression PostgreSQL normale comme par exemple "([rast1] + [rast2]) / 2".

Dans notre cas, l'expression est simplement la valeur du premier raster, celui de la hauteur de la forêt, que nous voulons "graver" dans la tuile. Elle n'implique pas les valeurs du raster d'altitude. En d'autres termes, les tuiles d'élévation sont simplement utilisées comme des feuilles de papier vierges bien alignées sur lesquelles nous "imprimons" la valeur du raster de hauteur de forêt.

Le quatrième argument est le type de pixel ('32BF') attendu pour le raster résultant. C'est le même que le raster de hauteur de forêt.

Le dernier argument ('SECOND') indique à ST_MapAlgebra() d'utiliser l'étendue du deuxième raster (les tuiles d'altitude) pour construire le raster résultant.

ST_MapAlgebra() copiera donc chaque valeur du raster de hauteur de forêt vers de nouvelles tuiles vides dont les dimensions sont basées sur celles de l'altitude. La requête donne 625 tuiles. Lorsqu'une tuile ne coupe pas la zone couverte par le couvert forestier, tous ses pixels sont simplement définis sur nodata.

Si votre gros raster ne couvre pas une grande partie de la couverture raster de référence, vous pouvez accélérer le processus en ajoutant un index spatial à la couverture de référence (il devrait déjà être là) et en restreignant le calcul ST_MapAlgebra() aux tuiles coupant la couverture vectorielle :


Gardez toutefois à l'esprit que cette requête est plus rapide car elle ne traite pas et ne renvoie donc pas de tuiles ne touchant pas la zone de couverture forestière. Si vous souhaitez produire un ensemble complet de tuiles, identiques en nombre et en étendue à la couverture d'altitude, continuez avec la requête précédente.


Quelques inconvénients des méthodes utilisant ST_AsRaster() et ST_Union()

  • ST_Union limitée par RAM - Toute requête impliquant ST_Union() est limitée par la RAM disponible pour PostgreSQL. Si le grand raster résultant de l'union de toutes les géométries rastérisées est plus grand que la RAM disponible, la requête échouera. L'astuce pour éviter cela est d'agréger les petits rasters non pas en un énorme raster unique, mais en plus petits groupes de rasters coupant les tuiles du raster de référence. La méthode 1.3 montrera comment faire cela.

Cela est dû au fait que ST_AsRaster() rastérise une seule géométrie à la fois sans tenir compte des autres géométries intersectant le pixel. Si vous considérez toutes les géométries d'un calque lors de l'attribution d'une valeur, vous souhaiterez peut-être attribuer d'autres métriques aux pixels comme le nombre de géométries coupant le pixel, la longueur totale de toutes les polylignes coupant le pixel, la valeur associée à le plus petit polygone coupant le pixel, etc.

Cette méthode est sûre pour la RAM car elle ne produit jamais un "grand" raster plus grand que la zone couverte par une tuile du raster de référence. C'est un peu plus lent que la première requête de la méthode 1.2 car elle réunit plusieurs rasters plusieurs fois lorsqu'ils touchent plusieurs tuiles. Il produit également 625 tuiles comme la couverture d'élévation.


La première requête de l'instruction WITH (forestrast) rastérise les géométries, les regroupe par groupe coupant les tuiles raster de référence et grave chacune d'elles dans une nouvelle tuile comme vu précédemment. Cela se fait par l'ajout d'une clause WHERE limitant l'opération aux géométries intersectant des tuiles et d'une clause GROUP BY assurant que ST_Union() n'agrège que les petits rasters "appartenant" à la même tuile.

La clause WHERE a cependant pour effet de limiter l'étendue à la superficie couverte par le couvert forestier. Cette première partie à elle seule ne renverrait que 32 tuiles. La deuxième partie de la requête s'assure que nous obtenons les 593 tuiles restantes. Il utilise un LEFT OUTER JOIN pour s'assurer qu'une ligne est renvoyée pour chaque 625 tuiles de la couverture raster de référence. Lorsque la suppression de la couverture raster de référence correspond à l'une des 32 tuiles, ces tuiles sont renvoyées. Sinon, une nouvelle tuile vide est renvoyée. Vous pouvez ignorer cette partie si votre couche vectorielle source couvre toute la zone du raster de référence ou si vous souhaitez limiter la zone rastérisée à celle de la couche vectorielle.


Méthode 2 – Modules complémentaires PostGIS ST_ExtractToRaster()

Comme dit précédemment, ST_AsRaster() est assez limité en termes de type de valeur qu'il peut attribuer aux pixels. Peu de valeurs peuvent être extraites d'un même polygone : la valeur au centroïde, la proportion de la zone de pixel couverte, la valeur pondérée par cette proportion, la longueur de la partie d'intersection d'une polyligne étant tramée. ST_AsRaster() cependant, parce qu'il est basé sur GDAL, n'implémente que le premier.

De plus, on peut imaginer beaucoup plus de métriques si la valeur attribuée à chaque pixel provient non seulement d'une géométrie mais de l'agrégation de toutes les géométries (ou des valeurs qui leur sont associées) d'une couverture vectorielle coupant le centroïde ou la surface du pixel . Nous pourrions, par exemple, vouloir calculer le nombre de géométries coupant le pixel. Nous pourrions être intéressés par la valeur du polygone couvrant la plus grande partie du pixel ou de la polyligne ayant la plus grande longueur à l'intérieur du pixel sont. Nous pourrions vouloir fusionner des géométries ayant la même valeur avant de calculer la métrique. J'ai pu identifier près de 76 métriques possibles différentes extractibles à partir de couvertures de points, de polylignes et de polygones.

Nous avons donc besoin d'une fonction capable d'extraire des métriques d'une couverture vectorielle dans son ensemble et qui nous permette d'implémenter facilement de nouvelles méthodes d'extraction. La fonction PostGIS Add-ons ST_ExtractToRaster() a été écrite avec exactement cet objectif en tête.

Les modules complémentaires PostGIS sont un ensemble d'environ 15 fonctions écrites par la communauté PL/pgSQL pures aidant à écrire des requêtes PostGIS avancées. L'une des fonctions les plus utiles est ST_ExtractToRaster().

Une requête utilisant ST_ExtractToRaster(), renvoyant le même ensemble de tuiles que la méthode 1.3 et ne souffrant pas non plus de limitations de RAM ressemblerait à ceci :


Première remarque très importante : cette requête prend environ 200 secondes ! C'est environ 16 fois plus que la requête RAM safe équivalente de la méthode 1.3 ! C'est parce que ST_ExtractToRaster() fait bien plus que ST_AsRaster(). Il ne considère pas seulement l'ensemble de la couverture, il peut calculer des choses très différentes à partir de cette couverture. Il ne vaut certainement pas la peine d'utiliser ST_ExtractToRaster() si vous voulez la valeur de la géométrie coupant le centroïde du pixel. L'intérêt de cette fonction réside dans les autres méthodes disponibles.

Notez le dernier argument de ST_ExtractToRaster() : 'MEAN_OF_VALUES_AT_PIXEL_ CENTROID'. C'est la méthode utilisée pour extraire une valeur pour le pixel. Quinze (15) de ces méthodes ont été implémentées avec ST_ExtractToRaster() jusqu'à présent. Ils sont listés ci-dessous avec une brève description.

La méthode 'MEAN_OF_VALUES_AT_PIXEL_CENTROID' renvoie une couverture raster dont les valeurs sont identiques à la couverture raster produite avec les méthodes précédentes. La plupart des autres méthodes, cependant, renverront des rasters assez différents…

Les autres arguments de ST_ExtractToRaster() sont assez triviaux : le premier est le raster vers lequel les valeurs sont extraites. C'est une bonne pratique de transmettre une nouvelle bande raster vide ayant le bon type de pixel, la valeur initiale et la valeur nodata et dont l'alignement est basé sur les tuiles du raster de référence. C'est identique à ce que nous avons fait en 1.2 et 1.3. Le deuxième argument est le schéma de la table vectorielle à rastériser ('public'). Le troisième et le quatrième sont le nom de la table ('forestcover') et le nom de la colonne ('geom') contenant la géométrie à rastériser. Le cinquième argument est la colonne contenant la valeur à utiliser dans le calcul d'une nouvelle valeur lorsque cela est nécessaire ('hauteur'). Lorsque le calcul n'implique que des géométries (par exemple COUNT_OF_VALUES_AT_PIXEL_CENTROID ou SUM_OF_LENGTHS), cet argument n'est pas nécessaire.

La requête renverra un nouveau raster pour chaque raster de la table d'altitude, dans ce cas 625.

  • COUNT_OF_VALUES_AT_PIXEL_CENTROID : Nombre de géométries coupant le centroïde du pixel.
  • MEAN_OF_VALUES_AT_PIXEL_CENTROID : Moyenne de toutes les valeurs coupant le centroïde du pixel.
  • COUNT_OF_POLYGONS : Nombre de polygones ou de multipolygones coupant la surface du pixel.
  • COUNT_OF_LINESTRINGS : Nombre de chaînes de lignes ou de chaînes de lignes multiples coupant la surface du pixel.
  • COUNT_OF_POINTS : Nombre de points ou multipoints coupant la surface du pixel.
  • COUNT_OF_GEOMETRIES : Nombre de géométries (quelles qu'elles soient) intersectant la surface du pixel.
  • VALUE_OF_BIGGEST : Valeur associée au polygone couvrant la plus grande zone d'intersection avec la surface du pixel.
  • VALUE_OF_MERGED_BIGGEST : Valeur associée au polygone couvrant la plus grande zone d'intersection avec la surface du pixel. Les polygones avec des valeurs identiques sont fusionnés avant de calculer l'aire de la surface.
  • VALUE_OF_MERGED_SMALLEST : Valeur associée au polygone couvrant la plus petite zone du pixel. Les polygones avec des valeurs identiques sont fusionnés avant de calculer l'aire de la surface.
  • MIN_AREA : Aire de la géométrie occupant la plus petite portion de la surface du pixel.
  • SUM_OF_AREAS : Somme des aires de tous les polygones coupant la surface du pixel.
  • SUM_OF_LENGTHS : Somme des longueurs de toutes les chaînes de lignes coupant la surface du pixel.
  • PROPORTION_OF_COVERED_AREA : Proportion, comprise entre 0,0 et 1,0, de la surface de pixel couverte par l'union de tous les polygones coupant la surface de pixel.
  • AREA_WEIGHTED_MEAN_OF_VALUES : Moyenne de toutes les valeurs de polygones pondérées par la zone qu'ils occupent par rapport au pixel en cours de traitement. La somme pondérée est divisée par le maximum entre la zone d'intersection de la géométrie et la somme de toutes les zones géométriques pondérées. Cela signifie que si le pixel en cours de traitement n'est pas complètement couvert par des polygones, la valeur est multipliée par la proportion de la zone de couverture. Par exemple, si un polygone ne couvre que 25 % de la surface du pixel et qu'il n'y a pas d'autres polygones couvrant la surface, seulement 25 % de la valeur associée au polygone de couverture est attribuée au pixel. C'est généralement le comportement préféré.
  • AREA_WEIGHTED_MEAN_OF_VALUES_2 : Moyenne de toutes les valeurs de polygones pondérées par la zone qu'ils occupent par rapport au pixel en cours de traitement. La somme pondérée est divisée par la somme de toutes les zones géométriques pondérées. Cela signifie que si le pixel en cours de traitement n'est pas complètement couvert par des polygones, la valeur pondérée complète est attribuée au pixel. Par exemple, même si un polygone ne couvre que 25 % de la surface du pixel, 100 % de sa valeur est attribuée au pixel.

Vous voulez calculer d'autres métriques ésotériques avec ST_ExtracToRaster() ? En interne, la fonction utilise la version de rappel de ST_MapAlgebra() qui appelle l'un des deux rappels prédéfinis selon si la valeur est calculée pour le centroïde du pixel ou si la valeur est calculée en utilisant toute la surface du pixel. Ces fonctions sont nommées ST_ExtractPixelCentroidValue4ma() et ST_ExtractPixelValue4ma(). Ils remplissent les critères des fonctions de rappel ST_MapAlgebra(). Ils prennent trois arguments définissant la valeur du pixel d'entrée (il peut y en avoir plusieurs), la position du pixel dans le raster et quelques paramètres supplémentaires si nécessaire. Afin de construire une requête pour chaque pixel, les deux fonctions attendent des paramètres supplémentaires : les paramètres d'alignement du raster pour lequel les valeurs sont calculées et les paramètres de la colonne géométrique pour laquelle les valeurs sont extraites. Les rappels définissent alors une série de méthodes d'extraction.

To add a new method to these callbacks, you can simply copy the query associated with an existing method that extract a value similar to what you want to extract, give it a proper name, modify it to compute the expected value and make sure it uses the callback extra arguments properly. It is a good idea to test the query directly on the vector coverage prior to test it in one of the two callback. Most of the methods do a ST_Intersects() between the shape of the pixel and the vector coverage (this is why it is important that the vector coverage be spatially indexed) and extract some metrics from the list of intersecting geometries.

If you add a new method which might be useful to others, let me know. I will add it to the PostGIS Add-ons code…

Rasterizing a complete vector coverage can be done very quickly with ST_AsRaster() and ST_Union() but some projects require more sophisticated methods to assign values to pixels considering the coverage as a whole. PostGIS Add-ons ST_ExtractToRaster() is slow but provides much more control on the metric that is extracted from the vector coverage.

In both case it is possible to extract values following a preloaded reference tiled coverage. That should be the case for most applications. It is also easy to add more extraction methods to ST_ExtractToRaster().


PostGIS 2.0 and Self Intersecting Features - Geographic Information Systems

The AST-PostGIS is an extension for PostgreSQL/PostGIS that incorporates advanced spatial data types and implements spatial integrity constraints. The extension reduces the distance between the conceptual and the physical designs of spatial databases, by providing richer representations for geo-object and geo-field geometries. It also offers procedures to assert the consistency of spatial relationships during data updates. Such procedures can also be used before enforcing spatial integrity constraints for the first time.

Geometric primitives defined by OGC and ISO standards, implemented in most modern spatially-enabled database management systems (DBMS), are unable to capture the semantics of richer representation types, as found in current geographic data models. Moreover, relational DBMSs do not extend referential integrity mechanisms to cover spatial relationships and to support spatial integrity constraints. Rather, they usually assume that all spatial integrity checking will be carried out by the application, during the data entry process. This is not practical if the DBMS supports many applications, and can lead to redundant work.

This module has been tested on:

And requires the extensions:

If you aren't using the pg_config on your path (or don't have it on your path), specify the correct one to build against:

Or to build with what's on your path, just:

After you've built and installed the artifacts, fire up psql :

Use the pre-builded docker with:

Here is explained how the extension works.

Advanced Spatial Data Types

Advanced Spatial Types are essentially the primitive geometric types of PostGIS together with a set of spatial integrity constraints to control their behavior. These new spatial data types can be handled in the same way the primitive types are, as they can be employed as column definition of tables, as variables in PL/pgSQL scripts or as arguments of functions or stored procedures. They can also be stored, retrieved and updated with the geometry processing functions of PostGIS.

The following table shows the eleven advanced spatial data types implemented by the extension and how they are mapped to the PostGIS types. These types are derived from the concepts of geo-objects and geo-fields classes of the OMT-G data model.

Spatial Class Advanced spatial datatypes PostGIS Type
Polygon ast_polygon geometry(polygon)
Ligne ast_line geometry(linestring)
Indiquer ast_point geometry(point)
Node ast_node geometry(point)
Isoline ast_isoline geometry(linestring)
Planar subdivision ast_planarsubdivision geometry(polygon)
Triangular Irregular Network (TIN) ast_tin geometry(polygon)
Tesselation ast_tesselation raster
Goûter ast_sample geometry(point)
Unidirectional line ast_uniline geometry(linestring)
Bidirectional line ast_biline geometry(linestring)

Trigger procedures for relationship integrity constraints

The following procedures can be called by triggers to assert the consistency of spatial relationships, like topological relationship, arc-node and arc-arc networks or spatial aggregation.

Spatial Relationship Trigger Procedure
Topological Relationship ast_topologicalrelationship(a_tbl, a_geom, b_tbl, b_geom, spatial_relation)
Topological Relationship (distant, near) ast_topologicalrelationship(a_tbl, a_geom, b_tbl, b_geom, spatial_relation, distance)
Arc-Node Network ast_arcnodenetwork(arc_tbl, arc_geom, node_tbl, node_geom)
Arc-Arc Network ast_arcnodenetwork(arc_tbl, arc_geom)
Spatial Aggregation ast_aggregation(part_tbl, part_geom, whole_tbl, whole_geom)

The spatial_relation argument, which are passed as an argument to the topological relationship procedure, can be one of the following:

  • contient
  • containsproperly
  • couvre
  • coveredby
  • crosses
  • disjoint
  • loin
  • se croise
  • à proximité
  • overlaps
  • touches
  • dans

Consistency check functions

The SQL functions listed in this section can be called to analyze the consistency of the spatial database before the initial enforcement of constraints. These functions return the state of the database ( true = valid, false = invalid) and register, in the ast_validation_log table, the details of each inconsistency encountered.

Spatial Relationship Check functions
Topological Relationship ast_isTopologicalRelationshipValid(a_tbl text, a_geom text, b_tbl text, b_geom text, relation text)
Topological Relationship (near) ast_isTopologicalRelationshipValid(a_tbl text, a_geom text, b_tbl text, b_geom text, dist real)
Arc-Node Network ast_isNetworkValid(arc_tbl text, arc_geom text, node_tbl text, node_geom text)
Arc-Arc Network ast_isNetworkValid(arc_tbl text, arc_geom text)
Spatial Aggregation ast_isSpatialAggregationValid(part_tbl text, part_geom text, whole_tbl text, whole_geom text)

This section shows an use case example (also available in the examples folder) intended to clarify the use of this extension.

The following figure shows a schema fragment for a bus transportation network (nodes at bus stops and unidirectional arcs corresponding to route segments) that serves a set of school districts. A conventional class holds the attributes for the bus line. The schema embeds spatial integrity constraints for (1) the network relationship (each route segment must be related to two bus stops), (2) a “contains” relationship (school district cannot exists without a bus stop), and (3) the geometry of route segments and school districts (lines and polygons must be simple, i.e., with no self-intersections).

The implementation of this schema that uses the ast_postgis extension and considers all the spatial constraints is as follows:

AST-PostGIS is released under a MIT license.

Copyright (c) 2016 Luís Eduardo Oliveira Lizardo.

[1] K. A. V. Borges, C. A. Davis Jr., and A. H. F. Laender. OMT-G: an object-oriented data model for geographic applications. GeoInformatica, 5(3):221–260, 2001.

[2] L. E. O. Lizardo and C. A. Davis Jr. OMT-G Designer: a web tool for modeling geographic databases in OMT-G. In Advances in Conceptual Modeling: 33rd International Conference on Conceptual Modeling, ER 2014, volume 8823 of Lecture Notes in Computer Science, pages 228–233. Springer International Publishing, 2014.

[3] Lizardo, L. E. O., & Davis Jr, C. A. (2017, November). A PostGIS extension to support advanced spatial data types and integrity constraints. In Proceedings of the 25th ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems (pp. 1-10).


PostGIS 2.0 and Self Intersecting Features - Geographic Information Systems

An open source geospatial trajectory data management & analysis platform

MobilityDB is a database management system for moving object geospatial trajectories, such as GPS traces. It adds support for temporal and spatio-temporal objects to the PostgreSQL database and its spatial extension PostGIS.

MobilityDB is developed by the Computer & Decision Engineering Department of the Université Libre de Bruxelles (ULB) under the direction of Prof. Esteban Zimányi. ULB is an OGC Associate Member and member of the OGC Moving Feature Standard Working Group (MF-SWG).

The MobilityDB project is managed by a steering committee.

Compact geospatial trajectory data storage

Big data scale and performance

Easy to use full SQL interface

Compatible with the PostgreSQL ecosystem

Compliant with the Moving Features standards from the Open Geospatial Consortium (OGC).

Database adapters to access MobilityDB from Python are also available

    supports both the psycopg2 and the asyncpg adapters for PostgreSQL and uses the postgis adapter for PostGIS. This package is developed by the MobilityDB Team. is another independent package that provides extensions to SQLAlchemy for interacting with MobilityDB.

Data generator and benchmark tool based on the BerlinMOD benchmark. The data generator takes input data from Open Street Map and uses pgRouting to generate routes between pairs of source and target locations.

  • Le Maître branch has the latest release
  • Le develop branch has the development of the next release. The complete list of releases is available here

The extension is under development. We are planning to release the first version in 2021.

  • Linux (other UNIX-like systems may work, but remain untested)
  • PostgreSQL > 10
  • CMake >= 3.1
  • PostGIS == 2.5
  • JSON-C
  • GNU Scientific Library (GSL)
  • Development files for PostgreSQL, PostGIS/liblwgeom, PROJ & JSON-C

For example, you can build the following command to install all MobilityDB build dependencies for Debian-based systems:

You should also set the following in postgresql.conf:

Docker containers with MobilityDB and all its dependencies are available here. These images are based on the official Postgres and Postgis docker images, please refer to them for more information.

If you have docker installed in your system you can run:

The first command is to download the latest most up-to-date image of MobilityDB. The second command creates a volume container on the host, that we will use to persist the PostgreSQL database files outside of the MobilityDB container. The third command executes this binary image of PostgreSQL, PostGIS, and MobilityDB with the TCP port 5432 in the container mapped to port 25432 on the Docker host (user = pw = docker, db = mobilitydb). The fourth command is to connect to the database using psql.

Please report any issues you may have

If you are in the doc directory of MobilityDB you can generate the user's manual from the sources as follows:


Voir la vidéo: Ajout de couche Postgis