Suite

Comment convertir/transformer de polygone en multipolygone dans PostGIS ?


Existe-t-il un moyen de transtyper des polygones en type multipolygone ?

Par exemple, j'ai créé un cercle en utilisant ST_Buffer() sur un point. Le type de retour de cette fonction est de type Polygone. Le problème est que sur la colonne de géométrie il y a une restriction la limitant au type Multipolygon. Donc, je ne peux pas insérer un simple polygone.

J'ai utilisé la fonction ST_MPolyFromText(), mais comme d'habitude, elle renvoie null pour cela et ST_Dump() ne donne pas la sortie appropriée.

La contrainte est :

CONTRAINTE force_geotype_geom VÉRIFIER (geometrytype(geom) = 'MULTIPOLYGON'::text OR geom IS NULL),

ST_Multi - Renvoie la géométrie sous forme de géométrie MULTI*. Si la géométrie est déjà un MULTI*, elle est retournée inchangée.

Exemple:

SELECT ST_AsText(ST_Multi(ST_GeomFromText('POLYGONE((743238 2967416,743238 2967450, 743265 2967450,743265.625 2967416,743238 2967416))'))); st_astext ------------------------------------------------- ------------------------------------------------- MULTIPOLYGONE (((743238 2967416,743238 2967450,743265 2967450,743265,625 2967416, 743238 2967416))) (1 rangée)

AdaBase

AdaBase fournit un support naturel pour les données spatiales en utilisant OpenGIS notions. Un support est spécifiquement fourni pour MySQL (extensions de données spatiales) et PostgreSQL (extension PostGIS).

Aucune précaution particulière ne doit être prise pour récupérer les données géométriques. Si AdaBase détecte un type de géométrie, il convertira les données internes au format "Well Known Binary" (WKB) et les stockera en interne. Si une conversion de chaîne est demandée, AdaBase convertit le WKB au format "Well Known Text" qui peut être utilisé dans d'autres requêtes. Plus important encore, les formes géométriques primitives telles que les points, les chaînes de lignes et les polygones peuvent être extraites et les coordonnées des points, qui sont des nombres réels à 16 chiffres, sont directement disponibles si nécessaire. Les collections de géométries homogènes qui contiennent un nombre indéfini d'éléments similaires tels que multi-points, multi-lignes et multi-polygones sont également prises en charge. Enfin, les "collections de géométries" qui peuvent contenir un mélange hétérogène de toutes les géométries sont prises en charge. Dans le cas de PostGIS, une collection peut contenir d'autres collections à travers de nombreux niveaux récursifs -- une collection peut contenir jusqu'à 23 autres collections. Sur MySQL, cela n'est pas pris en charge et le type de collection de géométrie ne peut contenir que 6 types (trois types simples et les types multiples analogues).

Pour récupérer et manipuler des données géométriques

Après avoir récupéré une ligne, utilisez la conversion de champ standard "as_geometry" pour renvoyer un fichier privé géométrie taper. Pour récupérer la représentation Well-Known-Text de la géométrie, utilisez la conversion de champ standard "as_string", ou transmettez la géométrie au Well_Known_Text fonction, qui renvoient toutes deux des chaînes standard.

Vous savez peut-être déjà quel type de géométrie se trouve sur le terrain, mais il est possible que la table de la base de données soit construite pour autoriser n'importe quelle forme. Pour déterminer le Collection_Type de la géométrie, la transmettre au type_de_collection une fonction. Pour déterminer le nombre de composants contenus dans la géométrie, utilisez le taille_de_collection une fonction. Les géométries simples (point, chaîne de lignes, polygone) renvoient toujours 1 pour cette fonction. Si la Collection_Type est hétérogène, il peut être souhaitable de savoir à quel type de géométrie correspond chaque élément de collection. Pour ces informations, utilisez le collection_item_type une fonction.

Chaque géométrie peut être décomposée en son élément le plus fondamental, le point bidimensionnel. Alors que les points sont constitués de coordonnées X, Y de Géométrique_Réel Type à 18 chiffres, les conversions arrondiront la valeur à 16 chiffres significatifs. Pour récupérer un point du point unique ou alors multi_point géométries, utilisez le récupérer_point une fonction.

De même, une chaîne de lignes n'est qu'un tableau de points. Pour obtenir une chaîne de ligne (tapez Geometric_Line_String, Utilisez le récupérer_ligne fonction sur chaîne_ligne_single et chaîne_multi_ligne types de géométrie.

Les polygones sont plus complexes. Structurellement, ils sont similaires aux chaînes de lignes, mais le premier et le dernier point doivent être identiques (donc la forme est fermée) et leurs éléments structurels sont appelés anneaux. Le premier est l'anneau extérieur. Un polygone peut avoir de zéro à un nombre indéfini d'anneaux « intérieurs », également appelés trous. Il existe certaines règles liées aux trous (par exemple, ils ne peuvent pas se toucher, doivent être fermés, etc.), donc un polygone est essentiellement un tableau d'un tableau de points. On extrait des polygones comme le type Géométrique_Polygone en utilisant le récupérer_polygone en passant à cette fonction une géométrie de type single_polygone ou alors multi_polygone. Le polygone est un type privé, donc pour déterminer combien d'anneaux il a (1 ou plus), utilisez le nombre_de_anneaux une fonction. Pour obtenir une bague de type Géométrique_Anneau, qui est similaire à une chaîne de ligne, utilisez le récupérer_anneau une fonction.

Les collections de géométrie sont des géométries de type hétérogène. Après avoir déterminé le nombre d'éléments contenus à l'intérieur, utilisez le récupérer_sous-collection fonction pour décoller l'élément de collection en tant que nouvelle géométrie. Par exemple, si le troisième élément d'une collection est un polygone, utilisez la fonction de récupération pour extraire la géométrie du polygone qui peut être décomposée davantage avec récupérer_polygone une fonction. Sur PostGIS, les extensions PostgreSQL GIS, la géométrie extraite peut bien être une autre collection hétérogène qui doit également avoir ses propres sous-collections extraites.

Comment créer des géométries

Pour diverses raisons, telles que le désir de Well-Known-Text en tant que produit dans le but de prendre en charge une requête d'insertion ou de mise à jour, il peut être souhaitable de créer des géométries qui sont généralement accomplies en les construisant.

Comment créer une géométrie à point unique

C'est facile. Il suffit de passer une variable de type Geometric_Point à la initialize_as_pointfonction, et une géométrie contenant ce point sera renvoyée.

Comment créer une géométrie multi-points

Cela se fait exactement de la même manière qu'un seul point, mais à la place le initialize_as_multi_point fonction est utilisée. Cette géométrie n'est requise que pour contenir un seul point, de sorte que la différence entre une géométrie à un seul point et une géométrie à plusieurs points réside dans la classification uniquement lorsqu'un seul point est impliqué.

Comment créer une géométrie de chaîne à une seule ligne

Créez d'abord un Geometric_Line_String variable (un tableau de points) ou simplement passer un tableau de points directement au initialize_as_line fonction, et la géométrie appropriée est renvoyée.

Comment créer une géométrie à chaînes multiples

Le processus est identique à la chaîne à une seule ligne, sauf que le initialize_as_multi_line la fonction est utilisée à la place. Cette géométrie n'est requise que pour contenir une seule chaîne.

Comment créer une géométrie polygonale

Un polygone ne peut être construit qu'un anneau à la fois, et la géométrie doit être construite en deux étapes. La première étape consiste à créer le privé Géométrique_Polygone tapez en passant un Géométrique_Anneau (un tableau de points) au start_polygone une fonction. Si le polygone comporte des trous, ceux-ci doivent être définis à l'aide de la procédure append_inner_ring en utilisant le polygone existant et un autre anneau. Lorsque le polygone est entièrement construit, une géométrie peut être créée à l'aide de la initialize_as_polygon ou alors initialize_as_multi_polygon les fonctions.

Comment ajouter des points à une géométrie multi-points

Le augmenter_multi_point La procédure est utilisée pour ajouter des points supplémentaires aux géométries multi-points existantes.

Comment ajouter des lignes à une géométrie de chaîne multiligne

Le augmenter_multi_ligne La procédure est utilisée pour ajouter des chaînes de lignes supplémentaires aux géométries de chaînes multilignes existantes.

Comment ajouter des lignes à une géométrie multi-polygone

Le augmenter_multi_polygone La procédure est utilisée pour ajouter des polygones supplémentaires aux géométries multi-polygones existantes.

Comment créer des géométries hétérogènes

Pour construire des collections de géométries, vous devez d'abord obtenir une géométrie via l'une des méthodes mentionnées précédemment, puis initialiser une nouvelle collection avec elle en utilisant le initialize_as_collection. Des géométries supplémentaires sont ajoutées en utilisant le augmenter_collection procédure aussi souvent que nécessaire.


SIG sur rails

Traiter avec des données géospatiales est encombrant et en même temps, c'est amusant. Les développeurs qui le font pour la première fois peuvent rencontrer des obstacles, mais au fur et à mesure que vous progressez, cela donne une joie d'apprendre. SIG signifie Système d'information géographique qui traite de la collecte, de la cartographie et de l'analyse des données géospatiales. Mais ce n'est pas aussi facile qu'il y paraît. Laissez-moi vous expliquer les défis que j'ai rencontrés récemment dans mon projet :

Exigence : importez les informations sur les polygones existants et cartographiez les données de latitude et de longitude avec le polygone.

Défi 1 : Comprendre les bases et le jargon

Puisque je fais pour la première fois, comme quel SRID dois-je utiliser, quel type de données dois-je utiliser, quel système de coordonnées dois-je utiliser ? Après des recherches approfondies, j'ai fini par utiliser le srid 4326, le type de données multipolygone et le système de coordonnées WGS 84.

Beaucoup d'entre vous ne comprennent peut-être pas ce que signifie WGS 84 ? WGS 84 signifie World Geodetic System est une sorte d'enquête (norme) qui a été effectuée en 1984. Il existe différents types de normes qui existent actuellement comme WGS 72, WGS 66 et WGS 60 etc. Ce sont les enquêtes (normes) qui sont menées au cours de ces années respectives en faisant quelques hypothèses sur la terre. Ainsi, par exemple, si nous calculons l'emplacement de l'Inde à l'aide de WGS 84, cela pourrait être différent si nous calculons à l'aide de WGS 72.

SRID signifie Spatial Reference System Identifier, qui nous renseigne sur le système de coordonnées que nous utilisions lors de la collecte de données spatiales.

Défi-2 : Importation de données

Étant donné que nous utilisons des rails alimentés par postgresql, l'importation de données dans la base de données est assez facile, mais pas dans ce cas, car nous avons obtenu des informations au format geojson que je n'avais jamais vues auparavant. Heureusement, ruby ​​fournit une gemme appelée rgeo-json qui nous facilite la vie. Voici l'extrait de code que j'ai écrit pour importer des données geojson.

où polygone est notre modèle. Voici notre fichier de migration ressemble à :

Défi-3 : mapper un point avec un polygone à l'aide d'une requête SQL

PostGIS est une extension de base de données postgres qui permet à postgres d'effectuer des calculs spatiaux. Pour trouver ce point donné se trouve quel polygone nous devons utiliser la fonction st_contains. Pour utiliser st_contains, nous devons d'abord nous assurer que deux géométries doivent utiliser le même SRID ou non, c'est-à-dire dans notre cas, il s'agit de 4326. Étant donné que dans ma base de données, nous stockons la latitude et la longitude sous forme de colonnes flottantes, nous devons d'abord les convertir en en tant que POINT et définissez le SRID sur 4326 comme suit :

Maintenant, dernière requête pour trouver le polygone approprié :

Bien qu'il ait fallu du temps pour répondre aux exigences, à la fin, j'ai senti que j'avais fait quelque chose de différent de ce que je fais habituellement. J'espère que cet article jettera un peu de lumière sur les SIG.


AsGML

Disponibilité: Oracle, PostGIS, SpatiaLite

Accepte un champ ou une expression géographique unique et renvoie une représentation GML (Geographic Markup Language) de la géométrie.

Argument de mot clé La description
précision Spécifie le nombre de chiffres significatifs pour les coordonnées dans la représentation GML – la valeur par défaut est 8. Ignoré sur Oracle.
version Spécifie la version GML à utiliser : 2 (par défaut) ou 3.

Technologies géospatiales ouvertes

La fonction readOGR du package rgdal est utilisée pour importer des sources de données spatiales vectorielles dans R. readOGR() repose sur OGR (partie de la bibliothèque GDAL/OGR) pour la conversion de format. Malheureusement, alors que OGR prend en charge la possibilité de sous-ensemble des colonnes (avec le commutateur -select) ou des lignes (avec le commutateur -where), ou même de demander une couche à l'aide d'une instruction SQL complète, aucune de ces fonctionnalités n'est disponible dans readOGR . De temps en temps, cela est discuté dans les listes de diffusion, mais la fonctionnalité n'a pas encore été implémentée.

Si vos données sont déjà dans une base de données SQL, vous avez de la chance. Vous pouvez accomplir la même chose dans R en créant une vue spatiale dans la base de données, en chargeant la vue spatiale avec readOGR , puis en supprimant la vue. J'ai créé une fonction qui fait exactement cela pour les sources de données PostGIS.

Étant donné que readOGR ne peut pas envoyer de code SQL arbitraire à la source de données, la fonction nécessite également le package RPostgreSQL. Parce que je voulais que la fonction readOgrSql se conforme le plus possible à readOGR, la fonction prend le DSN comme une chaîne de caractères, puis le découpe pour transmettre les paramètres DSN à dbConnect . readOGR attend le DSN dans ce format :

L'utilisateur a besoin de privilèges pour créer des objets dans le schéma public.

Ensuite, readOgrSql peut être appelé comme suit :

(La dernière ligne n'est pas strictement nécessaire, mais c'est une petite astuce que j'utilise pour faciliter la référence à des fonctionnalités spécifiques par leur nom.)

Pour le moment, cela ne fonctionne que pour PostGIS 2.0+. Cela repose sur le fait que dans les versions récentes de PostGIS, les vues spatiales sont automatiquement enregistrées car la géométrie_columns “table” est en fait une vue qui trouve toutes les colonnes géométriques dans toutes les tables. Mais pour que la vue fonctionne comme une couche spatiale complète, la colonne de géométrie dans l'instruction SELECT doit être explicitement convertie à l'aide d'une géométrie typmodded. Dans l'exemple, cela est accompli avec ::geometry(MultiPolygon, 2263) , mais en général ::geometry(<geometry type>, <srid>) . S'il n'y a pas de transformations sur la géométrie, le transtypage explicite peut être évité tant que la table sous-jacente est définie à l'aide des colonnes de géométrie typmodded PostGIS 2.0+ :

ne fonctionnera que partiellement, car la géométrie transformée est générique. Voir Enregistrement manuel des colonnes géométriques dans geometry_columns pour plus de détails. Notez que rgdal est suffisamment intelligent pour charger la couche dans un Spatial*DataFrame approprié (par exemple, SpatialPolygonsDataFrame pour un polygone OGC ou un multipolygone), mais perdra les informations de référence spatiale (c'est-à-dire la projection ou le système de coordonnées). Il tracera correctement, mais à moins que vous ne le répariez dans R, vous ne pourrez pas le combiner avec des couches dans différents systèmes de référence de coordonnées.

Étendre cela pour fonctionner pour PostGIS pre-2.0 ou pour SpatiaLite ne devrait pas être trop difficile, mais nécessitera l'enregistrement manuel de la vue spatiale dans geometry_columns .


Quelqu'un serait-il prêt à répondre à ma question sur SO concernant PostGIS ?

Oui, donc en gros, chaque fois que je fais des calculs sur un multipolygone, par exemple en calculant si un point particulier se trouve à l'intérieur d'un (multi)polygone, le multipolygone sera pris comme 1 caractéristique, n'est-ce pas ?

Cela signifie-t-il qu'il calcule également ces choses plus rapidement sur 1 multipolygone par rapport au même calcul sur une collection de polygones ?

La façon la plus simple d'expliquer cela :

Polygone - Fournit un accès plus rapide aux polygones individuels dans une recherche car ce seront des lignes et, par conséquent, ils seront chacun indexés.

Multipolygone - Si vous ne recherchez pas beaucoup et que vous avez toujours besoin de tous les polygones à la fois, ce sera un stockage plus dense car vous n'aurez pas à répéter d'autres informations de champ.

La chose la plus importante à considérer lors de la prise de ces décisions est vos données et la façon dont vous y accéderez. L'analyse comparative est toujours votre ami, mais sachez qu'elle changera radicalement en fonction de vos données et de ce que vous demandez.


Introduction à PostGIS : Partie 1

PostGIS est une extension prometteuse pour la base de données PostgreSQL qui ajoute des objets spatiaux à une base de données. En termes simples, PostGIS ajoute des capacités géographiques à une base de données. Avec l'importance croissante des systèmes géolocalisés (LBS) dans notre vie quotidienne, PostGIS est une bénédiction déguisée pour les développeurs et les architectes qui créent des applications géo-conscientes.

PostGIS supprime la méthode d'essai et d'erreur de stockage, de récupération et de recherche de contenu basé sur l'emplacement, en fournissant un back-end concis et précis pour effectuer de tels calculs.

Les développeurs ayant une formation MySQL sauront à quel point il est difficile de créer et de faire évoluer une base de données basée sur la localisation dans MySQL. Bien que MySQL dispose de certaines extensions spatiales, elles sont loin d'offrir les avantages et la vitesse fournis par PostGIS.

Avec la récente version de PostGIS 2.1, la puissance de PostGIS a triplé, de la prise en charge de l'analyse raster et vectorielle dans la base de données à la prise en charge des géométries 3D (latitude, longitude et hauteur/altitude).

Dans la partie 1 de ce tutoriel, nous aborderons :

  1. Installation des bibliothèques prérequises pour PostGIS.
  2. Configuration de PostGIS sous Linux.
  3. Création de votre première base de données spatiale – TestGIS.
  4. Importation de données dans TestGIS

Dans la partie 2, nous continuerons à couvrir

  1. Se connecter à TestGIS avec PHP
  2. Se connecter à TestGIS avec Java
  3. Se connecter à TestGIS avec .Net
  4. Visualiser les données de TestGIS sur une carte

Installation des bibliothèques prérequises pour PostGIS

PostGIS est une extension complexe - si elle n'est pas configurée correctement, la base de données ne donnera pas le résultat souhaité. PostGIS s'appuie sur quelques projets open source qui doivent être installés avant d'installer PostGIS.

Les conditions préalables requises pour notre installation PostGIS sont les suivantes :

  • PROJ4 4.8
  • GÉOS 3.3.3+
  • GDAL 1.9
  • PostgreSQL 9.1+
  • LibXML2 ou supérieur.
  • JSON-C 0.9 ou supérieur.
  • Compilateur GNU C et GNU Make – En cas d'installation à partir des sources.

Les bibliothèques facultatives qu'il serait bon d'installer sont :

Se préparer

Nous utiliserons une appliance VirtualBox installée avec la dernière version d'Ubuntu Linux et nous configurerons la même chose pour notre installation PostGIS 2.1.

Comment faire

Téléchargez et installez VirtualBox depuis http://www.virtualbox.org/. Téléchargez l'ISO de la dernière version d'Ubuntu Linux (14.04) et créez une nouvelle appliance VirtualBox nommée Ubuntu et terminer l'installation du système d'exploitation Ubuntu.

Dans le système d'exploitation Ubuntu, créez un utilisateur nommé postgis avec le mot de passe comme postgis ainsi que. Assurez-vous que l'utilisateur dispose des autorisations administratives.

Ensuite, ouvrez le Terminal et installez la bibliothèque PROJ4 par la commande suivante

Installez ensuite la bibliothèque GEOS en

Maintenant, nous installons le SGBDR PostgreSQL 9.3 en

Nous avons également besoin des packages de développement du serveur PostgreSQL, alors installez-les en utilisant

La bibliothèque JSON-C est installée par

C'est une bonne idée d'installer les bibliothèques ci-dessus à partir de leurs sources respectives, car les référentiels Ubuntu peuvent avoir une ancienne version des bibliothèques. Pour compiler les bibliothèques ci-dessus à partir des sources, assurez-vous que la collection de compilateurs GNU (GCC) et le compilateur GNU C++ (G++) sont installés.

Si vous ne l'avez pas encore installé, utilisez la commande suivante pour le faire.

Pour nous assurer que nous avons les dernières bibliothèques, nous téléchargeons les sources de PROJ4 à partir de http://trac.osgeo.org/proj/, GEOS à http://trac.osgeo.org/geos/ et GDAL à partir de http:// trac.osgeo.org/gdal/wiki/DownloadSource. Pour installer les dernières bibliothèques, vous devrez décompresser les packages téléchargés et exécuter les commandes suivantes

Comment ça fonctionne

L'OSGeo : Open Source Geospatial Foundation (osgeo.org) est un effort de collaboration visant à regrouper tous les projets géospatiaux open source sous un même toit. Il maintient la dernière version et les versions de développement des principales bibliothèques géospatiales. Elle apporte également un soutien juridique, financier et infrastructurel à ces projets. Nous utilisons les dernières versions de ces bibliothèques pour nous assurer que nous avons la dernière version de celles-ci, afin que notre installation PostGIS ne rencontre pas de problèmes.

C'est une bonne idée d'installer pgAdmin3 - une interface graphique pour gérer la base de données PostgreSQL que vous pouvez faire en sudo apt-get install pgadmin3 sur votre terminal.

Si vous rencontrez des problèmes pour installer les prérequis mentionnés ci-dessus, assurez-vous que la bibliothèque libxml2 (XML C Parser) est installée, si elle n'est pas déjà présente sur votre distribution Ubuntu. Installez le même si nécessaire par

Configuration de PostGIS sous Linux

PROJ, GEOS et GDAL sont des bibliothèques clés nécessaires au fonctionnement de PostGIS. A côté de ces bibliothèques, PostgreSQL 9.3 est la base de données que nous utiliserons pour configurer PostGIS. À partir de PostgreSQL 9.1 et PostGIS 2.0, il existe deux méthodes pour ajouter la bibliothèque PostGIS à PostgreSQL : en utilisant des extensions ou en utilisant les scripts d'activation de PostGIS (fichiers .sql). Nous utiliserons la méthode des extensions.

Se préparer

Téléchargez le dernier code source de la bibliothèque PostGIS sur http://download.osgeo.org/postgis/source/postgis-2.1.2.tar.gz

Comment faire

Ouvrez votre terminal et décompressez le code source postgis téléchargé à l'aide de la commande gunzip, ce qui créera un postgis-2.1.2.tar fichier.

Extraire le contenu du fichier tar en utilisant la commande tar

Passez maintenant au postgis-2.1.2 répertoire et exécutez les commandes suivantes pour installer la bibliothèque postgis sur votre système.

Si tout fonctionne parfaitement, vous devriez voir les deux lignes suivantes à la fin de la commande make install

  1. Quitter le répertoire / home / postgis / postgis - 2.1 . 2 / extensions / postgis / topologie
  2. Quitter le répertoire / home / postgis / postgis - 2.1 . 2/ rallonges

Mettez à jour votre PATH pour inclure les programmes de ligne de commande PostGIS comme shp2pgsql , sous Linux, modifiez votre .bashrc fichier et ajoutez la ligne suivante export PATH=$:/usr/lib/postgresql/9.3/bin/ .

Si vous utilisez un système d'exploitation différent, assurez-vous de télécharger les bons fichiers, de bons développeurs ont publié les fichiers RPMS, DEB et autres référentiels non officiels pour l'installation de PostGIS 2.1, car la mise à jour du canal de distribution officiel prend un certain temps. la gestion des versions des packages, en fonction de leur propre calendrier de publication et de leurs tests.

La dernière version stable de PostGIS dans le référentiel Ubuntu 14.04 est postgis-2.1, elle peut être installée avec une seule commande sudo apt-get install postgresql-9.3-postgis-2.1.

Création de votre première base de données spatiale – TestGIS

Avec PostGIS 2.1 configuré sur notre distribution Ubuntu, créons une nouvelle base de données compatible PostGIS appelée TestSIG. Nous utiliserons cette base de données tout au long du didacticiel pour décrire un scénario d'utilisation du monde réel pour la compréhension des lecteurs.

Se préparer

pgAdmin3 est un bon outil GUI pour travailler avec le serveur PostgreSQL. Si vous ne l'avez pas encore installé, c'est le bon moment pour le faire. Cependant, ce n'est pas une condition préalable, nous pouvons nous frayer un chemin avec juste l'invite du terminal.

Avant de créer une base de données PostGIS, nous devons modifier la valeur par défaut pg_hba.conf fichier de configuration de notre serveur PostgreSQL afin qu'il accepte les connexions de notre hôte local et/ou de nos hôtes distants (au besoin).

Ouvrez votre pg_hba.conf (sur notre configuration Ubuntu, le fichier se trouve à /etc/postgresql/9.3/main/ et accédez aux lignes d'authentification client comme indiqué ci-dessous et modifiez la MÉTHODE à approuver pour toutes les connexions locales.

Redémarrez le serveur PostgreSQL en exécutant la commande suivante sur le terminal

Ajoutez ensuite un nouvel utilisateur PostgreSQL nommé postgis avec le mot de passe postgis en utilisant la commande interactive createuser.

  1. sudo createuser postgis – Upostgres – P
  2. Entrez le mot de passe pour le nouveau rôle :
  3. Saisissez-le à nouveau :
  4. Le nouveau rôle sera-t-il un superutilisateur ? ( oui / non ) oui

Vous pouvez confirmer l'utilisateur nouvellement créé en visitant le package d'interface graphique Webmin sur votre navigateur local. Webmin est un outil d'administrateur système basé sur le Web pour Linux - plus besoin de rechercher des fichiers de configuration, Webmin fournit tous les services au sein d'une interface graphique riche. Téléchargez-le sur http://www.webmin.com/. Voici notre capture d'écran du module PostgreSQL qui montre notre utilisateur nouvellement créé en tant qu'entrée.

Comment faire

La première étape pour créer notre première base de données PostGIS consiste à créer une base de données PostgreSQL standard à l'aide de la commande createdb. Sur votre terminal, lancez la commande suivante pour créer une nouvelle base de données nommée TestSIG.

Entrer le mot de passe postgis lorsque demandé par l'invite de commande.

Maintenant, à partir de la console PostgreSQL (psql), sélectionnez la base de données TestGIS nouvellement créée en tapant la commande suivante

Ensuite, activez l'extension postgis pour la base de données TestGIS avec

Nous pouvons utiliser pgAdmin3 pour vérifier notre base de données TestGIS nouvellement créée, ouvrir l'outil pgAdmin3 et créer un nouveau serveur avec le nom d'utilisateur et le mot de passe comme "postgis" et le port défini sur 5432 (port PostgreSQL par défaut). Nommez la connexion TestGIS. Voir la capture d'écran ci-dessous pour un exemple.

Une fois que vous cliquez d'accord, développez l'arborescence en cliquant sur le nœud Databases->TestGIS et vérifiez que postgis est répertorié en tant qu'extension, comme illustré dans la figure ci-dessous.

Comment ça fonctionne

PostgreSQL 9.1 et supérieur inclut la directive CREATE EXTENSION qui nous permet de charger une nouvelle extension dans la base de données actuelle avec une simple commande. PostGIS 2.1 prend en charge ce mécanisme, donc lorsque nous avons utilisé CREATE EXTENSION postgis sur notre base de données TestGIS, le système a importé la géométrie, la géographie, le raster, l'espaceréfsys et tout ce qui s'y rapporte dans notre base de données. De même, la fonctionnalité de topologie de PostGIS 2.1 est une autre extension qui peut être chargée par CREATE EXTENSION postgis_topology .

Charger une extension équivaut à exécuter le extensions fichier .sql. Postgresonline.com a un excellent article sur les extensions à http://www.postgresonline.com/journal/archives/216-PostgreSQL-9.1-Exploring-Extensions.html visitez le lien pour en savoir plus sur les extensions.

Importation de données dans TestGIS

Après avoir créé notre première base de données compatible Postgis, il est maintenant temps d'importer des données du monde réel. Quand nous disons monde réel, nous parlons de données du monde réel. Nous tirons ces informations de Yahoo's Flickr Geo API Explorer et en particulier de ce lien contenant la limite géographique des États-Unis - http://www.flickr.com/places/info/23424977

Notez le lien vers le fichier Shape (enfermé dans le rectangle dans la capture d'écran suivante). Shapefile est un format de fichier open source pour stocker des données géospatiales. Ce format a été développé et réglementé par ESRI – Environmental Systems Research Institute (http://www.esri.com/).

Se préparer

Pour stocker la limite géographique du pays, nous définissons une table de pays dans la base de données TestGIS avec les instructions SQL suivantes :

  1. psql – Upostgis – W TestGIS
  2. TestGIS = # CREATE TABLE country(id entier NON NULL, texte du nom, géographie des limites (MultiPolygon,4326),texte name_alias, CONSTRAINT "countryId" PRIMARY KEY (id ))

Notez le type de données de la colonne nommée « boundary » qui n'est pas votre colonne de base de données traditionnelle de type int, varchar ou datetime, mais un type de données géographique. Cette colonne peut stocker des données multipolygones (comme le montre également la capture d'écran ci-dessus). Le numéro 4326 est le SRID (Spatial Reference System Identifier) ​​correspondant au WGS-84 (World Geodetic System). La cartographie correspondante peut être inspectée dans la table spatial_ref_sys de notre base de données TestGIS.

Notez que le WGS-84 est d'abord la longitude, puis la latitude. Par conséquent, lorsque vous travaillez avec des données, assurez-vous de stocker et de récupérer les données par paires lon/lat et non par paires lat/lon.

Comment faire

Redémarrez votre terminal et exécutez la commande shp2pgsql sur votre fichier de forme pour convertir le fichier de forme en SQL, puis insérez de manière sélective les données converties dans la table des pays.

Accédez au dossier où nous avons téléchargé le fichier Shape, dans notre cas, il s'agit de $USER/Downloads/Geo-Data/country/US

Exécutez maintenant la commande shp2pgsql en

Ouvrez le US.sql fichier ainsi généré, il devrait ressembler à ci-dessous.

À partir du fichier, copiez la première instruction d'insertion, à savoir

  1. INSÉRER DANS �" ( "tag" , "count" , "area" , "perimeter" , "density" , geog )
  2. VALEURS
  3. (& # 3923424977 & # 39, & # 395738246 & # 39, & # 393.986.508,50 & # 39, & # 3.917.812,86 & # 39, & # 391,44 & # 39, & # 390106000020E6100000010000000103000000010000002D010000000000406B555EC0000000C02C804840000000C0EA495EC0000000E0188048400000008026445EC0000000A0518048400000000074315EC0000000C0C5824840000000E057295EC0000000A0BA7F484000000080BF0B5EC000000020AD7F484000000040FAFB5DC000000080F67F4840000000009DEA5DC000000080FE814840000000C05DD35DC000000040D2814840000000E0ACCC5DC0000000000000809FE15CC0000000009A794840000000001AC95CC000000000047E48400000000048C35CC0000000A00B8148400000002078AC5CC00000004089914840000000204FAC5CC000000080A49148400000004044AC5CC000000000AA914840000000203CAC5CC000000080A491484000000060E5825CC000000080818248400000004029795CC0000000E01F804840000000A0606A5CC0000000A0F27F4840000000404B585CC00000006001804840000000C033585CC000000060F87F48400000004070325CC0000000A0D17 .......... & # 39)

Nous avons juste besoin des valeurs de la dernière colonne nommée "densité", qui est essentiellement un seul polygone du fichier de forme de frontière américain que nous avons téléchargé auparavant. En utilisant ce texte brut, nous construisons notre instruction insert comme

  1. INSERT INTO country ( id , name , bound , name _alias ) VALUES ( 1 , 'United
  2. États', �E6100000010000000103000000010000002D010000000000406B555EC0000000C02C8048400000000C0EA495EC0000000E01880484000000008026445EC0000000A051804840000000007. ' , 'États-Unis' )

Enregistrez ce fichier sous insert.sql et importez le même dans votre base de données TestGIS.

Pour vérifier les données, ouvrez l'interface graphique pgAdmin3 et exécutez la requête suivante dans l'éditeur SQL

Vous devriez voir la sortie suivante.

Comment ça fonctionne

La commande shp2pgsql fournie avec PostGIS 2.0 offre un moyen simple d'importer des données géospatiales à partir des fichiers ESRI Shape. Il existe également une interface graphique pour la commande, nommée shp2pgsql-gui qui permet l'import/export de données de fichiers de formes. Il existe des bibliothèques et des programmes pour lire les Shapefiles dans différentes langues et plateformes : visitez http://en.wikipedia.org/wiki/Shapefile ou votre moteur de recherche de quartier convivial pour plus d'informations.

Une autre meilleure façon d'obtenir les limites des pays à partir du service Flickr est via l'API, sur la même page des États-Unis sur l'explorateur d'API Flickr Geo, cliquez sur la vue de la boîte flickr.places.getInfo dans l'explorateur d'API, le lien API brut est http : //api.flickr.com/services/rest/?method=flickr.places.getInfo&api_key=907997443d2d8f1f06aa5073c4d9dfeb&woe_id=23424977, qui peut être analysé dans n'importe quel langage de programmation populaire et les données insérées dans notre table de pays.

Dans l'exemple précédent, nous avons appris à importer des données Shapefile dans notre base de données PostGIS. Cependant, il s'agissait d'un travail de copier-coller manuel et il n'importait pas tous les polygones nécessaires pour les limites complètes des États-Unis. De plus, si nous avons besoin d'automatiser ce processus et que nous voulons importer tous les pays du monde dans notre base de données, alors cela devient une tâche herculéenne à faire en mode copier-coller.

Pour résoudre ce problème, nous utilisons les fonctions PostgreSQL pour PHP, JDBC pour Java et Npgsql pour .Net.

Dans la partie 2 de ce didacticiel, nous expliquerons comment se connecter à TestGIS en utilisant respectivement PHP, Java et .NET.


Plusieurs éléments extérieurs

Actuellement, le texte indique qu'un seul élément extérieur est autorisé.

Cela devrait être modifié en plusieurs éléments tant qu'ils forment 1 contour. Par exemple. pour les grands lacs utilisant le littoral, la forme extérieure est divisée de plusieurs manières, mais il devrait néanmoins être possible d'utiliser la même relation multipolygone pour ceux-ci également (en particulier à des fins de nommage, . ).

Les modifications suggérées sont donc :

  • Autoriser plusieurs chemins extérieurs tant qu'ils s'accumulent en un seul chemin fermé lorsqu'ils sont joints
  • Autorisez également plusieurs voies internes divisées (il n'est indiqué nulle part que ce n'est pas autorisé, mais cela devrait être explicite)

Ceci serait résolu par la #Suggestion pour les multipolygones avancés, ci-dessous. --achadwick 11:07, 27 novembre 2008 (UTC)


Didacticiel¶

Cette section contient une brève introduction et un didacticiel sur l'utilisation GEOSGéométrie objets.

Créer une géométrie¶

GEOSGéométrie les objets peuvent être créés de plusieurs manières. La première consiste à simplement instancier l'objet sur une entrée spatiale. Voici des exemples de création de la même géométrie à partir de WKT, HEX, WKB et GeoJSON :

Une autre option consiste à utiliser le constructeur pour le type de géométrie spécifique que vous souhaitez créer. Par exemple, un Indiquer L'objet peut être créé en passant les coordonnées X et Y dans son constructeur :

Enfin, il y a destr() et à partir du fichier() méthodes d'usine, qui renvoient un GEOSGéométrie objet à partir d'une chaîne d'entrée ou d'un fichier :

Les géométries sont Pythonic

GEOSGeometry objects are ‘Pythonic’, in other words components may be accessed, modified, and iterated over using standard Python conventions. For example, you can iterate over the coordinates in a Point :

With any geometry object, the GEOSGeometry.coords property may be used to get the geometry coordinates as a Python tuple:

You can get/set geometry components using standard Python indexing techniques. However, what is returned depends on the geometry type of the object. For example, indexing on a LineString returns a coordinate tuple:

Whereas indexing on a Polygon will return the ring (a LinearRing object) corresponding to the index:

In addition, coordinates/components of the geometry may added or modified, just like a Python list:


Package Structure

Features:
The Features package contains the basic building block features of the GIS. These are the features such as Point, MultiPoint, LineString, MultiLineString, Polygon, and MultiPolygon. There is also a RasterShape for displaying images. There are a couple of sub packages of Features that are used for manipulating the features.

Common:
This pacakge contains all of the non feature classes that are used for the operation of the system. The only class contained in common at the moment is the "Node" class. This class is used to save configuration information from all layers of the toolkit, and is used by the application to generate configuration files using the Config package.

Config:
Config is used to convert the "Node" information into configuration information. It reads and writes to an XML file at the moment, but configuration information could presumably be stored in any persistent storage that supports trees of named value pairs.

Projection:
Projections are used in several layers of the toolkit. This is mostly for performance reasons, and to enable the support of database level projection features. There are two levels of projection, the projection the map uses, and the projection the data resides within. This allows the toolkit to display data in a dynamic projection, while reading data in a static projection. A common use of this functionality is the storing of imagery in a UTM projection, but displaying it in a Connic Conformal Projection. Most common projections are cuurently supported, and adding more can be done fairly easilly.

Datasources:
Data can be read from a variety of data sources. Each data source has it's own package, with the generic base classes and interfaces residing in the root. Datasources include ESRI shapefile, ARCSDE, IBM DB2, Image, PostGIS, memory (kind of a scratch data source), seamless, terraserver, and webservice. It is expected that more datasources will be added in the future. The AGCSDE and ARCIMS datasources are kept in a separate package under proprietary, because they statically links to a priprietary ESRI jar file, these packages are "proprietary.datasources.arcsde" and "proprietary.datasources.arcims".

Display:
All Elements associated with displaying geographic objects are stored in the display class. The basic element is the GISDisplay which is a swing widget for embedding GIS functionality into swing GUIs. The basic building block of the display package is the Layer object. Each layer object is responsible for drawing it's data on to the graphics context it is sent. Assisting it is a Converter object which is responsible for converting pixel screen coordinates to World coordinates and back. Each layer has a single data source, and contains the Style object which tells actually renders the data.

Style objects contain multiple Labelers and Renderers but only a single Shader. The Renderers determine how the features should be drawn, the Labelers determine how the labels should be drawn, and the Shader provids the colors, patterns, and other information required by the Labelers and Shaders for them to render the objects.

Drawmodels are used bye the GISDisplay to add behavior. They determine what happens when a user clicks on a map, drags a map, etc. They provide the select tools, and add highlight information to the map. Mostly they react to mouse movement on the map.

Shapeeditors are gui classes that can be used to modify a shape. They allow the user to type in exact coordinates to a shape, as well as modify shape contents from a tabular point of view, instead of a geographical one.

In addition, there is a scale bar that allows the user interface to represent distances on the map, and some commonly used gui widgets that may help in generating an application with this toolkit.

Application:
The application package contains the classes that are used to create the GISToolkitEditor. This package has become rather large, and uses every other part of the GISToolkit, except for the Server. It serves as an example of how an applicaiton could be created using this toolkit.

Server:
These are the classes that are used to create the WebMapService. They are an example of how this toolkit can be used to create a server side application that generates maps for a client.