Suite

Fermer la chaîne de ligne à la doublure dans PostGis


y a-t-il une fonction qui ferme unchaîne de ligneà undoublure? Je n'ai pas trouvé une telle fonction dans la documentation.


Voulez-vous dire connecter l'extrémité d'une ligne au point de départ ? Cela devrait aider http://postgis.net/docs/ST_AddPoint.html.


Fermer la chaîne de ligne à la doublure dans PostGis - Systèmes d'information géographique

Extension de base de données spatiale PostGIS à PostgreSQL

Utilisez Git ou passez à la caisse avec SVN en utilisant l'URL Web.

Travaillez rapidement avec notre CLI officielle. Apprendre encore plus.

Lancement du bureau GitHub

Si rien ne se passe, téléchargez GitHub Desktop et réessayez.

Lancement du bureau GitHub

Si rien ne se passe, téléchargez GitHub Desktop et réessayez.

Lancer Xcode

Si rien ne se passe, téléchargez Xcode et réessayez.

Lancement du code Visual Studio

Votre espace de code s'ouvrira une fois prêt.

Un problème est survenu lors de la préparation de votre espace de code, veuillez réessayer.

Cette branche n'est pas en avance sur postgis:main en amont.

Aucun nouveau commit pour le moment. Profitez de votre journée!


Activation et suppression de la prise en charge de PostGIS

L'extension PostGIS de la base de données Greenplum contient le script postgis_manager.sh qui installe ou supprime les fonctionnalités PostGIS et PostGIS Raster dans une base de données. Une fois le package d'extension PostGIS installé, le script se trouve dans $GPHOME/share/postgresql/contrib/postgis-2.1/ . Le script postgis_manager.sh exécute des scripts SQL qui installent ou suppriment PostGIS et PostGIS Raster d'une base de données.

Pour plus d'informations sur les scripts SQL PostGIS et PostGIS Raster et les variables d'environnement PostGIS Raster requises, consultez Scripts de support PostGIS.

Activation de la prise en charge de PostGIS

Le script exécute tous les scripts SQL PostGIS qui activent PostGIS dans une base de données : install/postgis.sql , install/rtpostgis.sql install/spatial_ref_sys.sql , install/postgis_comments.sql et install/raster_comments.sql .

L'installation du package postGIS ajoute ces lignes au fichier greenplum_path.sh pour la prise en charge de PostGIS Raster.

Suppression de la prise en charge de PostGIS

Le script exécute à la fois les scripts SQL PostGIS qui suppriment PostGIS et PostGIS Raster d'une base de données : uninstall_rtpostgis.sql et uninstall_postgis.sql .

Le script postgis_manager.sh ne supprime pas ces variables d'environnement PostGIS Raster du fichier greenplum_path.sh : GDAL_DATA , POSTGIS_ENABLE_OUTDB_RASTERS , POSTGIS_GDAL_ENABLED_DRIVERS . Les variables d'environnement sont supprimées lorsque vous désinstallez le package d'extension PostGIS avec l'utilitaire gppkg.


Usage

Les exemples d'instructions SQL suivants créent des tables et des géométries non OpenGIS.

Les exemples d'instructions SQL suivants créent une table et ajoutent une colonne de géométrie à la table avec une valeur entière SRID qui fait référence à une entrée dans la table SPATIAL_REF_SYS. Les instructions INSERT ajoutent deux géopoints à la table.

Index spatiaux

PostgreSQL prend en charge l'indexation spatiale GiST. Le schéma GiST offre une indexation même sur des objets volumineux. Il utilise un système d'indexation avec perte dans lequel les objets plus petits agissent comme des proxys pour les plus grands de l'index. Dans le système d'indexation PostGIS, tous les objets utilisent leurs cadres de délimitation comme proxy dans l'index.

Construire un index spatial

Vous pouvez créer un index GiST comme suit :


Traitement de la géométrie

Une partie importante de ce que fait osm2pgsql est de créer des géométries à partir des données OSM. Dans OSM, seuls les nœuds ont un emplacement, les chemins obtiennent leur géométrie à partir des nœuds membres et les relations obtiennent leur géométrie à partir des chemins membres et des nœuds. Osm2pgsql assemble toutes les données des objets associés dans des géométries valides.

Types de géométrie

Les types de géométrie pris en charge par PostGIS proviennent des fonctionnalités simples définies par l'OpenGIS Consortium (OGC). Osm2pgsql crée des géométries de ces types à partir de données OSM.

Type de géométrie Créé à partir des données OSM
Indiquer Créé à partir de nœuds.
ChaîneLigne Créé à partir de manières.
Polygone Créé à partir de voies fermées ou de certaines relations.
Multipoint Jamais créé.
Chaîne multiligne Créé à partir de voies (séparées) ou de certaines relations.
Multipolygone Créé à partir de voies fermées ou de certaines relations.

Géométries simples ou multiples

En général, osm2pgsql créera la géométrie la plus simple possible. Les nœuds se transformeront en points, les chemins en lignes ou en polygones. Une relation multipolygone peut être transformée en Polygone ou MultiPolygone, selon qu'elle possède un ou plusieurs anneaux externes. De même, une relation de route peut être transformée en LineString si la route est connectée du début à la fin ou en MultiLineString si elle n'est pas connectée ou s'il y a des endroits où la route se divise.

Dans certains cas, osm2pgsql divisera les géométries Multi* en géométries simples et ajoutera chacune dans sa propre ligne de base de données. Cela peut accélérer le rendu, car le moteur de rendu peut gérer plusieurs géométries plus petites au lieu d'avoir à gérer une grande géométrie. Mais, selon ce que vous faites avec les données, cela peut également entraîner des problèmes. Cet article de blog a une discussion plus approfondie sur cette question. Voir les chapitres de sortie flex et pgsql pour plus de détails sur la façon de configurer cela.

Cela signifie également que vos colonnes d'identification ne sont pas uniques, car plusieurs lignes sont désormais créées à partir du même objet OSM. Consultez la section Clés primaires et identifiants uniques pour savoir comment contourner ce problème.

Validité de la géométrie

Les géométries des points sont toujours valides (tant que les coordonnées se trouvent dans la plage correcte). Les géométries LineString sont également toujours valides, les lignes peuvent se croiser, mais ce n'est pas grave. C'est plus complexe pour les géométries Polygon et MultiPolygon : il existe plusieurs manières pour une telle géométrie d'être invalide. Par exemple, si la limite d'un polygone est tracée en huit, le résultat ne sera pas un polygone valide. La base de données stockera volontiers ces polygones invalides, mais cela peut entraîner des problèmes plus tard, lorsque vous essayez de les dessiner ou de faire des calculs (tels que la zone) sur la base de la géométrie invalide. C'est pourquoi osm2pgsql ne charge jamais de géométries invalides dans votre base de données. Au lieu de cela, l'objet est simplement ignoré sans aucun message.

Vous pouvez utiliser la vue Zones de l'inspecteur OpenStreetMap pour aider à diagnostiquer les problèmes liés aux multipolygones.

Traitement des nœuds

Les géométries de nœuds sont toujours converties en géométries de points.

Traitement des manières

Selon les balises, les méthodes OSM modélisent soit un LineString, soit un Polygon, soit les deux ! Un chemin étiqueté avec Highway=primary est généralement une entité linéaire, un chemin étiqueté landuse=farmland est généralement une entité surfacique. Si un chemin avec des balises de type polygone n'est pas fermé, la géométrie est invalide, c'est une erreur et l'objet est ignoré. Pour certaines balises, comme man_made=pier, les voies non fermées sont des entités linéaires et les voies fermées sont des entités surfaciques.

Si un mappeur veut remplacer la façon dont un chemin doit être interprété, il peut utiliser la balise area : La balise area=yes transforme une entité normalement linéaire en une entité polygonale, par exemple, elle transforme une rue piétonne ( autoroute=piéton ) en piéton surface. La balise area=no transforme une entité surfacique en une entité linéaire.

Il n'y a pas de liste définie des balises indiquant une entité linéaire ou surfacique. Osm2pgsql laisse l'utilisateur décider. Cela dépend de la sortie choisie (voir chapitre suivant) comment la configurer. Les exemples de fichiers de configuration contiennent des listes qui devraient couvrir la plupart des balises couramment utilisées, mais vous devrez peut-être étendre les listes si vous utilisez des balises plus inhabituelles.

Osm2pgsql peut diviser les longues chaînes de lignes créées à partir de manières en segments plus petits. Cela peut accélérer le rendu des tuiles, car des géométries plus petites doivent être extraites de la base de données lors du rendu d'une tuile spécifique. La sortie de pgsql divise toujours les longues LineStrings, en projection latlong, les lignes ne seront pas plus longues que 1°, dans Web Mercator les lignes ne dépasseront pas 100 000 unités (environ 100 000 mètres à l'équateur). La sortie flex ne divisera les LineStrings que si le paramètre de transformation split_at est utilisé, voir la section Transformations géométriques dans le chapitre sur la sortie flex pour plus de détails. Voir également la section Géométries simples ou multiples ci-dessus.

Traitement des relations

Les relations se présentent sous de nombreuses variantes et peuvent être utilisées pour toutes sortes de géométries. Habituellement, cela dépend de la balise de type d'une relation, du type de géométrie qu'elle devrait avoir :

Type de relation Géométrie typique créée
type=multipolygone (Multi)Polygone
type=limite (Multi)LineString ou (Multi)Polygon selon que vous vous intéressez à la frontière elle-même ou à la zone qu'elle délimite.
type=itinéraire (Multi)LigneChaîne

La sortie osm2pgsql flex peut créer une géométrie (Multi)Polygon ou (Multi)LineString à partir de n'importe quelle relation, les autres géométries ne sont actuellement pas prises en charge. Voir la section Transformations géométriques dans le chapitre sur la sortie flex pour plus de détails.

Si vous utilisez l'ancienne « transformation C » de la sortie pgsql, les types de géométrie pour les relations de type multipolygone , frontière et route sont codés en dur. Si vous utilisez la « transformation Lua », vous pouvez les configurer.

Projections

Osm2pgsql peut créer des géométries dans de nombreuses projections. Si vous utilisez la sortie pgsql, la projection peut être choisie avec les options de la ligne de commande, lors de l'utilisation de la sortie flex, les projections sont spécifiées dans le fichier de style Lua. La valeur par défaut est toujours « Web Mercator ».

Latlong (WGS84)

Les coordonnées de latitude et de longitude d'origine d'OpenStreetMap dans le système de référence de coordonnées WGS84. Ceci est généralement choisi si vous souhaitez effectuer une sorte d'analyse sur les données ou les reprojeter plus tard.

Web Mercator

Il s'agit de la projection la plus souvent utilisée pour les cartes Web en mosaïque. C'est la valeur par défaut dans osm2pgsql.

Les données au-delà d'environ 85° Nord et Sud seront coupées, car elles ne peuvent pas être représentées dans cette projection.

Autres projections

Si osm2pgsql a été compilé avec la prise en charge de la bibliothèque PROJ, il prend en charge toutes les projections prises en charge par cette bibliothèque.

Version >= 1.4.0 Appelez osm2pgsql --version pour voir si votre binaire a été compilé avec PROJ et avec quelle version.

Notez que les styles de mappage dépendent souvent de la projection utilisée. La plupart des configurations de style de cartographie activent ou désactivent certains styles de rendu en fonction de l'échelle de la carte ou du niveau de zoom. Mais une échelle significative dépendra de la projection. La plupart des styles que vous rencontrez sont probablement conçus pour Web Mercator et auront besoin de modifications pour obtenir de belles cartes dans d'autres projections.


Fermer la chaîne de ligne à la doublure dans PostGis - Systèmes d'information géographique

Auteur: Sean Gillies, [email protected]>
Version: 1.7.0
Date: |aujourd'hui|
Droits d'auteur: Ce travail est sous licence Creative Commons Attribution 3.0 États-Unis.
Abstrait:Ce document explique comment utiliser le package Shapely Python pour la géométrie computationnelle.

L'analyse spatiale déterministe est une composante importante des approches informatiques des problèmes de l'agriculture, de l'écologie, de l'épidémiologie, de la sociologie et de nombreux autres domaines. Quel est le rapport périmètre/superficie arpenté de ces parcelles d'habitat animal? Quelles propriétés de cette ville croisent le contour des crues de 50 ans de ce nouveau modèle d'inondation ? Quelle est l'étendue des zones de découverte pour les céramiques anciennes portant les marques de fabricant « A » et « B », et où se chevauchent les étendues ? Quel est le chemin de la maison au bureau qui contourne le mieux les zones identifiées de spam géolocalisé ? Ce ne sont là que quelques-unes des questions possibles qui peuvent être abordées à l'aide d'une analyse spatiale non statistique, et plus particulièrement de la géométrie computationnelle.

Shapely est un package Python pour l'analyse et la manipulation de la théorie des ensembles d'entités planaires à l'aide (via le module Python :mod:`ctypes`) des fonctions de la bibliothèque GEOS bien connue et largement déployée. GEOS, un portage de Java Topology Suite (JTS), est le moteur géométrique de l'extension spatiale PostGIS pour le SGBDR PostgreSQL. Les conceptions de JTS et de GEOS sont largement guidées par la spécification d'accès aux fonctionnalités simples de l'Open Geospatial Consortium [1] et Shapely adhère principalement au même ensemble de classes et d'opérations standard. Shapely est ainsi profondément ancré dans les conventions du monde des systèmes d'information géographique (SIG), mais aspire à être également utile aux programmeurs travaillant sur des problèmes non conventionnels.

La première prémisse de Shapely est que les programmeurs Python devraient être capables d'effectuer des opérations géométriques de type PostGIS en dehors d'un SGBDR. Toutes les données géographiques ne proviennent pas ou ne résident pas dans un SGBDR ou ne sont pas mieux traitées à l'aide de SQL. Nous pouvons charger des données dans un SGBDR spatial pour travailler, mais s'il n'y a pas de mandat pour gérer (le "M" dans "SGBDR") les données au fil du temps dans la base de données, nous utilisons le mauvais outil pour le travail. La deuxième prémisse est que la persistance, la sérialisation et la projection cartographique des entités sont des problèmes importants, mais orthogonaux. Vous n'avez peut-être pas besoin d'une centaine de lecteurs et d'écrivains au format SIG ou de la multitude de projections State Plane, et Shapely ne vous en impose pas. La troisième prémisse est que les idiomes Python l'emportent sur les idiomes SIG (ou Java, dans ce cas, puisque la bibliothèque GEOS est dérivée de JTS, un projet Java).

Si vous appréciez et tirez profit de Python idiomatique, appréciez les packages qui font bien une chose et convenez qu'un SGBDR activé dans l'espace est souvent le mauvais outil pour votre travail de géométrie informatique, Shapely pourrait être pour vous.

Les types fondamentaux d'objets géométriques mis en œuvre par Shapely sont les points, les courbes et les surfaces. Chacun est associé à trois ensembles de points (éventuellement infinis) dans le plan. Les ensembles intérieur, limite et extérieur d'une entité s'excluent mutuellement et leur union coïncide avec le plan entier [2].

  • Un point a un ensemble intérieur d'exactement un point, un ensemble de limites d'exactement aucun point et un ensemble extérieur de tous les autres points. Un point a une dimension topologique de 0.
  • Une courbe a un ensemble intérieur composé d'une infinité de points sur sa longueur (imaginez un point traîné dans l'espace), un ensemble de limites composé de ses deux extrémités et un ensemble extérieur de tous les autres points. Une courbe a une dimension topologique de 1.
  • Une surface a un ensemble intérieur composé d'une infinité de points à l'intérieur (imaginez une courbe traînée dans l'espace pour couvrir une zone), un ensemble de limites composé d'une ou plusieurs courbes et un ensemble extérieur de tous les autres points, y compris ceux à l'intérieur des trous qui pourraient existent en surface. Une surface a une dimension topologique de 2.

Cela peut sembler un peu ésotérique, mais aidera à clarifier les significations des prédicats spatiaux de Shapely, et c'est aussi profond dans la théorie que ce manuel ira. Les conséquences de la théorie des ensembles de points, y compris certaines qui se manifestent comme des « pièges », pour différentes classes seront discutées plus loin dans ce manuel.

Le type de point est implémenté par une classe Point curve par les classes LineString et LinearRing et surface par une classe Polygon. Shapely n'implémente pas de courbes lisses (c'est-à-dire ayant des tangentes continues). Toutes les courbes doivent être approximées par des splines linéaires. Tous les patchs arrondis doivent être approximés par des régions délimitées par des splines linéaires.

Les collections de points sont implémentées par une classe MultiPoint, les collections de courbes par une classe MultiLineString et les collections de surfaces par une classe MultiPolygon. Ces collections ne sont pas significatives en termes de calcul, mais sont utiles pour modéliser certains types de fonctionnalités. Une caractéristique de ligne en forme de Y, par exemple, est bien modélisée dans son ensemble par un MultiLineString.

Le modèle de données standard comporte des contraintes supplémentaires spécifiques à certains types d'objets géométriques qui seront abordées dans les sections suivantes de ce manuel.

Le modèle de données spatiales est accompagné d'un groupe de relations en langage naturel entre les objets géométriques – contient, intersections, chevauchements, touches, etc. – et d'un cadre théorique pour les comprendre en utilisant la matrice 3x3 des intersections mutuelles de leurs ensembles de points composants [3 ] : le DE-9IM. Un examen complet des relations en termes de DE-9IM se trouve dans [4] et ne sera pas réitéré dans ce manuel.

Suivant les spécifications techniques du JTS [5], ce manuel fera une distinction entre les opérations constructives (tampon, enveloppe convexe) et les opérations ensemblistes (intersection, union, etc.). Les opérations individuelles seront décrites en détail dans une section suivante du manuel.

Même si la Terre n'est pas plate - et d'ailleurs pas exactement sphérique - il existe de nombreux problèmes analytiques qui peuvent être approchés en transformant les caractéristiques de la Terre en un plan cartésien, en appliquant des algorithmes éprouvés, puis en transformant les résultats en coordonnées géographiques. Cette pratique est aussi ancienne que la tradition des cartes papier précises.

Shapely ne prend pas en charge les transformations du système de coordonnées. Toutes les opérations sur deux entités ou plus supposent que les entités existent dans le même plan cartésien.

Les objets géométriques sont créés à la manière typique de Python, en utilisant les classes elles-mêmes comme fabriques d'instances. Quelques-unes de leurs propriétés intrinsèques seront discutées dans cette section, d'autres dans les sections suivantes sur les opérations et les sérialisations.

Les instances de Point , LineString et LinearRing ont comme attribut le plus important une séquence finie de coordonnées qui détermine leurs ensembles de points intérieurs, limites et extérieurs. Une chaîne de lignes peut être déterminée par aussi peu que 2 points, mais contient un nombre infini de points. Les séquences de coordonnées sont immuables. Une troisième valeur de coordonnée z peut être utilisée lors de la construction d'instances, mais n'a aucun effet sur l'analyse géométrique. Toutes les opérations sont effectuées dans le plan x-y.

Dans tous les constructeurs, les valeurs numériques sont converties en type float . En d'autres termes, Point(0, 0) et Point(0.0, 0.0) produisent des instances géométriquement équivalentes. Shapely ne vérifie pas la simplicité topologique ou la validité des instances lorsqu'elles sont construites car le coût est injustifié dans la plupart des cas. Les usines de validation sont facilement implémentées à l'aide du prédicat :attr: is_valid par les utilisateurs qui en ont besoin.

Shapely est une bibliothèque de géométrie plane et z, la hauteur au-dessus ou au-dessous du plan, est ignorée dans l'analyse géométrique. Il existe ici un écueil potentiel pour les utilisateurs : les tuples de coordonnées qui ne diffèrent que par z ne sont pas distingués les uns des autres et leur application peut entraîner des objets géométriques étonnamment invalides. Par exemple, LineString([(0, 0, 0), (0, 0, 1)]) ne renvoie pas une ligne verticale de longueur unitaire, mais une ligne invalide dans le plan avec une longueur nulle. De même, Polygon([(0, 0, 0), (0, 0, 1), (1, 1, 1)]) n'est pas limité par un anneau fermé et n'est pas valide.


Les cartes sémantiques ajoutent aux cartes de robots classiques des instances d'objets spatialement ancrées de manière appropriée pour la représentation et le raisonnement des connaissances. Ils permettent à un robot de résoudre des problèmes de raisonnement de nature géométrique, topologique, ontologique et logique en plus de la localisation et de la planification de chemin. La littérature récente sur la cartographie sémantique manque d'approches efficaces et efficientes pour fonder des relations spatiales qualitatives à travers l'analyse des données géométriques quantitatives des entités cartographiées. Pourtant, de telles relations qualitatives sont essentielles pour effectuer un raisonnement spatial et ontologique sur les objets dans l'environnement du robot.

Cet article fournit un cadre pour la représentation sémantique des cartes, appelé SEMAP, pour surmonter cet aspect manquant. Il est capable de gérer des cartes 3D complètes avec des modèles d'objets géométriques et les annotations sémantiques correspondantes ainsi que leurs relations spatiales relatives. Pour cela, la technologie des bases de données spatiales est utilisée pour résoudre efficacement les problèmes de représentation et d'interrogation. Cet article décrit les extensions nécessaires pour rendre une base de données spatiale adaptée aux applications robotiques. En particulier, nous ajoutons des opérateurs spatiaux 3D et un arbre de transformations pour représenter les informations de position relative. Nous évaluons les capacités mises en œuvre et présentons des cas d'utilisation réels de SEMAP dans différents domaines d'application.


Comment réellement apprendre ou pratiquer la programmation ?

Je comprends qu'apprendre à programmer est techniquement l'une des exigences du SIG. Je sais qu'il existe de nombreux cours gratuits en ligne, mais comment étudieriez-vous réellement pour cela ? Regardez-vous simplement la vidéo et essayez-vous d'apprendre? Que conseilleriez-vous aux débutants ? J'essaie d'apprendre python et SQL de préférence.

Tout avis sera le bienvenu!

Edits : Merci à tous pour vos commentaires !!

Il y a une tonne de choses que vous pouvez faire avec python sans jamais accéder au module arcpy. Commencez par créer un script qui vide automatiquement le contenu d'une carte SD montée sur un disque dur, qui s'exécute à chaque fois qu'une est montée. Cela peut être accompli de différentes manières, mais si vous pouvez vous familiariser avec le planificateur de tâches et python, c'est un bon point de départ. Une fois que vous êtes à l'aise avec cela, travaillez sur l'itération des dossiers pour recréer des structures de dossiers complexes et des éléments. Google beaucoup.

SQL peut être un peu plus difficile à utiliser si vous n'avez pas accès à SSMS et SQL express ou à mon SQL ou quelque chose comme ça, car il a un peu plus de configuration en amont. Cependant, vous pouvez utiliser MS Access pour en apprendre beaucoup sur SQL. Créez une base de données simple dans Access et utilisez les outils de requête de génération pour y écrire et interroger à partir de celle-ci. Une fois que vous en avez écrit quelques-uns, regardez la vue SQL de vos scripts et essayez de décompresser ce que vous regardez et de les réécrire sans utiliser le générateur, mais avec les scripts écrits comme aide-mémoire lorsque vous besoin de ça. J'ai appris moi-même les deux sur le tas en faisant cela et bien que je sois sûr qu'il existe un moyen plus direct d'accomplir la même chose, apprendre à apprendre est extrêmement gratifiant. Envoyez-moi un message si vous voulez des conseils. J'ai vécu la même chose que toi il y a 3 ans. Obtenir un emploi aidera beaucoup.


GeoPointer – approche de l'augmentation tangible du monde réel

Objectif &ndash L'objectif de cet article est de présenter une architecture et une implémentation prototypique d'un système logiciel sensible au contexte qui combine l'approche d'interface utilisateur tangible avec une application de réalité augmentée (RA) mobile. Conception/méthodologie/approche &ndash Le travail qui est décrit dans cet article est basé sur une approche créationnelle, ce qui signifie qu'une mise en œuvre prototypique est utilisée pour recueillir d'autres résultats de recherche. L'approche prototypique permet d'effectuer des tests continus concernant la précision et les différentes fonctions de seuil sensibles au contexte. Résultats &ndash Dans cet article, la mise en œuvre et l'utilisation pratique d'interfaces utilisateur tangibles pour la sélection extérieure d'objets géographiques sont rapportées et discutées en détail. Limitations/implications de la recherche &ndash Des recherches supplémentaires sont nécessaires dans le domaine des fonctions de seuil à changement dynamique sensibles au contexte, ce qui permettrait d'améliorer la précision de l'approche d'interface utilisateur tangible sélectionnée. Implications pratiques &ndash L'implication pratique de l'utilisation d'interfaces utilisateur tangibles dans les applications extérieures devrait améliorer la convivialité des applications AR. Originalité/valeur &ndash Malgré le fait qu'il existe une multitude de résultats de recherche dans le domaine de la reconnaissance gestuelle et des applications AR, ce travail de recherche se concentre sur le geste de pointage pour sélectionner des objets géographiques extérieurs.

Journal

Journal international de l'informatique omniprésente et des communications &ndash Emerald Publishing

Publié : 5 avr. 2011

Mots clés: Interfaces utilisateurs Navigation Systèmes d'Information Géographique Identification


13.6 Envoi de fonctionnalités à la base de données

13.6.1 Définition des autorisations de la base de données

Dans le dernier exemple ( example-13-04.html ), les calques dessinés n'étaient pas vraiment envoyés n'importe où, juste imprimés dans la console. Outre une interface d'entrée, pour disposer d'une application de crowdsourcing fonctionnelle, nous avons également besoin d'un emplacement de stockage permanent et d'un mécanisme pour écrire les entrées utilisateur dans cet emplacement. Dans le reste de ce chapitre, nous verrons comment les formes dessinées peuvent être envoyées à une base de données CARTO, ce qui permet de stocker de manière persistante les entrées de l'utilisateur, finalisant ainsi notre application de crowdsourcing.

Avant de commencer à écrire un code JavaScript pour envoyer les données, nous devons disposer d'un emplacement de stockage permanent pour collecter les données. Lorsque nous utilisons une base de données relationnelle comme stockage permanent, nous avons besoin d'une table (vide) dans notre base de données, contenant les colonnes et les types de données correspondants en fonction des données que nous avons l'intention de collecter. Sur CARTO, on peut créer une nouvelle table (Figure 13.8) avec le Nouvel ensemble de données bouton que nous avons déjà utilisé pour télécharger une couche existante, telle que plants.geojson (Section 9.7.3). Cette fois, au lieu de télécharger un fichier GeoJSON, nous devons choisir CRÉER UN ENSEMBLE DE DONNÉES VIDE. La nouvelle table est vide et est livrée avec les colonnes par défaut the_geom (géométrie), description (chaîne) et nom (chaîne), ce qui est exactement ce dont nous avons besoin. Au cas où nous aurions besoin d'un ensemble de colonnes différent, nous pouvions toujours ajouter ou supprimer des colonnes, ou modifier les types de données de colonne, à l'aide de l'interface CARTO. Nous appellerons la nouvelle table beer_sheva .

FIGURE 13.8 : Création d'une table vide sur CARTO

Dans le cas où nous travaillons avec une base de données SQL via la ligne de commande, plutôt que l'interface Web CARTO, nous pouvons également créer la table beer_sheva à l'aide de la commande SQL équivalente :

Supposons maintenant que la carte Web de crowdsourcing est prête et que l'utilisateur a dessiné un point, que nous avons décodé dans la chaîne GeoJSON suivante avec JSON.stringify , comme nous le faisons dans example-13-04.html :

Supposons ensuite également que l'utilisateur ait renseigné les valeurs « Point 1 » et « Michael » dans les champs de description et de nom du formulaire contextuel (Figure 13.6), respectivement. Comment pouvons-nous réellement insérer ces données dans la table CARTO nouvellement créée ? Nous pouvons utiliser les mots clés SQL INSERT INTO et VALUES pour insérer de nouvelles données, comme illustré dans l'exemple de requête SQL suivant :

La requête semble assez longue et complexe, mais notez la structure de haut niveau utilisée pour spécifier les noms de colonnes et les valeurs à insérer :

Les trois premiers. les symboles sont remplacés par les noms de colonne dans lesquels les valeurs entrent. Les trois derniers. les symboles sont remplacés par les valeurs elles-mêmes. Notez que l'ordre des noms de colonnes doit correspondre à l'ordre des valeurs, de sorte que la bonne valeur sera insérée dans la bonne colonne. Dans le présent exemple, l'ordre du premier triplet (les noms de colonne the_geom , description et name ) correspond à l'ordre du deuxième triplet après le mot-clé VALUES (la géométrie, 'Point 1' et 'Michael' ).

Pour créer la valeur de géométrie qui va dans la colonne the_geom, la requête utilise la fonction ST_GeomFromGeoJSON pour convertir de GeoJSON en WKB. C'est exactement le contraire du décodage de la colonne de géométrie en texte GeoJSON avec ST_AsGeoJSON (Section 9.6.3). La fonction ST_SetSRID spécifie que nos coordonnées GeoJSON sont en lon/lat, c'est-à-dire dans le système de référence de coordonnées WGS84 avec lequel nous travaillons tout au long du livre (section 11.3), spécifié avec le code EPSG 4326.

La requête API CARTO SQL correspondante est donnée ci-dessous :

Hélas, l'appel d'API ci-dessus ne fonctionnera pas sur une table nouvellement créée. Au lieu de cela, un message d'erreur tel que le suivant sera renvoyé :

Ce message d'erreur, comme le suggère l'expression « autorisation refusée », concerne le problème de la base de données autorisations, que nous n'avons pas encore vraiment envisagé. Toute base de données, en effet, est associée à une ou plusieurs bases de données utilisateurs, chaque utilisateur ayant son propre le mot de passe et associé à un ensemble de privilèges, c'est-à-dire des règles pour ce que l'utilisateur peut et ne peut pas faire dans la base de données. Par exemple, un administrateur peut avoir l'ensemble maximal de privilèges, ce qui signifie qu'il peut tout faire dans la base de données : lire et écrire dans des tables, créer de nouvelles tables, supprimer des tables existantes, ajouter ou supprimer d'autres utilisateurs, accorder ou révoquer des privilèges à d'autres utilisateurs, etc. sur. D'autre part, un utilisateur en lecture seule peuvent avoir des privilèges limités en « lecture seule », de sorte qu'ils ne peuvent consommer que le contenu de la base de données mais ne peuvent apporter aucune modification aux tables, ni à leurs propres privilèges ou à ceux d'autres utilisateurs.

La façon dont nous avons accédé à notre base de données CARTO avec l'API SQL CARTO impliquait en fait une connexion à la base de données avec l'utilisateur par défaut nommé publicuser , qui est automatiquement créé par CARTO lors de la configuration de notre compte. L'utilisateur publicuser a lis autorisations sur toutes les tables de notre base de données, c'est pourquoi nous pourrions exécuter n'importe laquelle des requêtes SQL commençant par SELECT tout au long des chapitres 9 à 12. Le publicuser , cependant, par défaut, n'a pas d'autorisations d'écriture. C'est pourquoi la requête INSERT ci-dessus a échoué avec une erreur « autorisation refusée ».

En plus de publicuser , CARTO définit un clé API utilisateur, qui dispose de tous les privilèges possibles sur les tables de la base de données : lecture, écriture, mise à jour, création, suppression, etc. Pour utiliser l'API CARTO SQL avec l'utilisateur « API Key », nous devons fournir un paramètre api_key supplémentaire dans notre requête, comme dans :

L'api_key est une longue chaîne, qui agit comme un mot de passe. Vous pouvez obtenir la clé API à partir du panneau des paramètres de votre compte dans l'interface Web CARTO.

Ainsi, il existe en fait deux solutions possibles au problème « autorisation refusée » lorsque vous essayez d'insérer un nouvel enregistrement dans la table beer_sheva :

  • Nous pouvons nous connecter à la base de données avec le clé API user, qui a les privilèges maximaux et peut donc exécuter des requêtes INSERT sur la table beer_sheva.
  • Nous pouvons accorder l'utilisateur publicuser un nouveau privilège, pour exécuter des requêtes INSERT sur la table beer_sheva .

La première option peut sembler la plus pratique, car la seule chose que nous devons faire est de localiser notre chaîne de clé API dans l'interface CARTO et de la joindre à l'URL de requête de l'API SQL, comme indiqué ci-dessus. Cependant, il y a un sérieux problème de sécurité que nous devons prendre en compte lors de l'utilisation de cette approche. Si nous incluons la clé API dans notre code JavaScript, en principe, toute personne consultant le code source de notre page pourra copier la clé API et l'utiliser pour effectuer tout type de requête SQL sur notre compte, avec un maximum de privilèges. Par exemple, si quelqu'un le souhaite, il peut même supprimer définitivement n'importe quelle table de notre compte à l'aide de la commande DROP TABLE. Exposer la clé API dans côté client scripts est donc un risque sérieux pour la sécurité. La clé API est vraiment destinée uniquement aux du côté serveur scripts, dont le code source n'est pas accessible aux utilisateurs de la page Web. Par exemple, le script côté serveur peut accepter des requêtes avec un mot de passe que l'utilisateur a entré si le mot de passe est valide, le serveur peut faire une requête à l'API SQL CARTO et renvoyer le résultat, sinon la requête sera rejetée. Cette approche nécessite la mise en place d'un serveur dynamique (Section 5.4.3), ce qui signifie que, pour l'utiliser en toute sécurité, la solution API Key n'est finalement pas si simple. Dans ce livre, nous nous concentrons sur les solutions côté client, nous ne développerons donc pas davantage l'approche API Key.

Pour une application de crowdsourcing simple, destinée à un public de confiance, la deuxième option d'octroi de privilèges INSERT à publicuser est une solution simple et efficace. D'une certaine manière, cela rend notre base de données exposée : toute personne qui entre sur notre page Web pourra insérer de nouveaux enregistrements dans la table beer_sheva. D'un autre côté, le pire des cas est simplement que notre table sera remplie de nombreux enregistrements inutiles. Le seul privilège que nous accorderons est INSERT , ce qui signifie que publicuser ne peut supprimer aucun enregistrement précédemment saisi ni modifier la table de quelque manière que ce soit. De plus, lorsque l'URL de notre page est partagée avec un public de confiance, comme parmi les étudiants participant à un sondage dans une classe, les chances que quelqu'un prenne la peine de trouver notre page et sabote intentionnellement notre base de données en la remplissant d'une grande quantité de les faux dossiers sont très petits. Ainsi, dans des cas d'utilisation à petite échelle, l'effort de faire un serveur dynamique avec un système d'authentification peut être superflu, puisque la solution simple présentée ci-dessous est suffisante.

Pour accorder l'autorisation d'effectuer des requêtes INSERT sur la table beer_sheva, la requête SQL suivante doit être exécutée. L'utilisateur public n'a évidemment pas la permission de s'octroyer des privilèges supplémentaires. Par conséquent, la requête doit être exécutée à l'intérieur du Éditeur SQL sur l'interface Web CARTO, ce qui implique des privilèges complets (Figure 13.9), ou en utilisant l'API SQL avec la clé API.

FIGURE 13.9 : Octroi de l'autorisation INSERT via l'interface Web CARTO

Une fois la requête d'octroi de nouvelles autorisations exécutée, l'appel d'API INSERT ci-dessus, pour ajouter un nouvel enregistrement dans la table beer_sheva, devrait fonctionner même sans la clé API. Si vous voyez toujours un message tel que :

vous devez également exécuter la requête suivante, soit dans l'interface Web, soit avec la clé API 114 :

Pour désactiver la nouvelle autorisation, par exemple lorsque la collecte de données est terminée et que nous ne voulons plus accepter d'entrées dans la table beer_sheva, nous pouvons toujours révoquer le privilège accordé à publicuser comme suit :

Une fois la table beer_sheva créée et les autorisations INSERT prises en charge, la base de données est prête et attend de recevoir les données de crowdsourcing. Now, let us move on to defining the web-map script for processing and sending the user-edited data to the database.

13.6.2 Adding the drawing control

Like in the previous examples, first thing we need in our script is to have a drawing control definition. We use the same definition from example-13-04.html (Section 13.5), with circles, circle markers, and rectangles disabled 115 :

Next, in case we would like the map to display the previous shapes drawn by other users, we can set up a layer group named cartoData to contain them:

Accordingly, we need to load the items already contained in the beer_sheva table from previous editing sessions, using the following code section:

Note that the popup for each of the loaded features displays the name and the description properties, which were entered in previous sessions when submitting drawn shapes and saved in the beer_sheva table.

Other than loading previously stored shapes using the above code, the major change compared to example-13-04.html is in the setData function, which is responsible for saving the drawn shapes whenever the “submit” button is clicked. The new version is quite longer, since instead of just printing the data in the console it now sends the data for permanent storage in the CARTO database:

We will now go over the code, step by step.

The first two expressions are exactly the same as in example-13-04.html (Section 13.5). Again, these two expressions are used to extract the entered text in the name and description fields, as given at the precise moment when the “submit” button was clicked. The name and description values are assigned into variables named enteredUsername and enteredDescription , respectively:

The central code block inside the setData function is contained inside the .eachLayer iteration on drawnItems . As shown in example-13-02.html (Section 13.4.1) and example-13-04.html (Section 13.5), using .eachLayer we basically apply a function on each of the layers comprising drawnItems . The function has a parameter named layer , which is assigned with the current layer in each step of the iteration:

What does the internal function in the .eachLayer iteration do in the present case of example-13-05.html ? Three things:

  • Construction the INSERT query for adding a new record into the beer_sheva table
  • Send the query to the CARTO SQL API
  • Copie the submitted drawing to the CARTO layer, to display it on the map

Here is the code for the first part, the SQL query construction:

This code section builds the SQL query for sending the currently iterated drawn shape to the database. Basically, instead of a fixed INSERT query, such as the one shown above ( 'Point 1' created by 'Michael' ), we are constructing the query dynamiquement, using the three variables:

  • drawing —The GeoJSON string for the current layer, goes into the the_geom column
  • enteredDescription —The description entered into the popup, goes into the description column
  • enteredUsername —The name entered into the popup, goes into the name column

The complete query is assigned into a variable named sql . Using console.log , the value of sql is then printed into the console, which is helpful when inspecting our web map for potential problems.

The second part of the code takes care of sending the SQL query contained in sql to CARTO:

The query is sent as part of an Ajax POST request, which is something we haven’t used yet. POST requests are more rarely used than GET and a little less convenient to work with (Section 5.3.2.3). However, POST requests are more appropriate when sending data to be processed on the server, as opposed to GET , which is mostly used to avoir data from the server. It is important to note that the CARTO SQL API can accept both GET and POST requests, so the same request can be achieved in both ways. In this case, however, making a POST request is safer because the URL in GET requests is limited in character length. The exact lower limit depends on the browser, but can be as low as 2048 characters. So, if the user has drawn a very complex geometry which results in a very long GeoJSON string, the resulting GET request may be rejected. In a POST request, the parameters are sent as part of associated Les données, rather than being part of the URL, which resolves the limitation.

To make a POST request we are going to use the fetch function with slighly modified parameters. Until now, we have been extensively using fetch in Chapters 7–12for making GET requests. As mentioned in Section 7.7.3, however, the fetch function can also be used to make POST request. In our case, we need to make a POST request to the URL of the CARTO SQL API ( "https://michaeldorman.carto.com/api/v2/sql" ), with the sent data being the sql string and the data we expect back from the server being JSON. Finally, we specify what to do when the request is successful ( success ) or when it fails ( error ). In this case, we choose to simply print either the "Data saved" or the "Problem saving the data" string in the console.

The third part of the eachLayer iteration, inside our setData function code body, transfers the drawn data to the cartoData layer to display it on the map without reloading the map. Basically, the drawn layer is translated to GeoJSON, combined with the description and name properties, then added on the map with L.geoJSON . Without this part, our drawing would only be sent to the database without being shown on the map, unless we reload the web page:

Finally, outside of the .eachLayer iteration, we close the editable popup and clear the drawnItems feature group. The map is now ready for making a new drawing and sending it to the database.

The complete crowdsourcing app ( example-13-05.html ) is shown in Figure 13.10.


Voir la vidéo: Ajout de couche Postgis (Octobre 2021).