Suite

Comment copier une géométrie avec Python OGR ?

Comment copier une géométrie avec Python OGR ?


Je veux copier une géométrie avec Python OGR dans une boucle :

J'ai essayé ce qui suit, mais j'obtiensERREUR 1 : Les géométries vides ne peuvent pas être construites

import ogr import copy d = ogr.Open('sampleData.geojson') l = d.GetLayer() pour f dans l: gCurrent = f.GetGeometryRef() gPrevious = copy.copy(gCurrent)

Je sais que je ne peux pas simplement attribuergPrécédent = gCurentpuisqu'il ne fait référence qu'à la géométrie. Mais pourquoi essaie-t-il de construire une géométrie vide ?


Ne vous attendez pas à ce que OGR soit Pythonic. En fait, il existe une longue liste de pièges documentés pour les décrire. Essentiellement, toutes les variables sont des références à des objets décrits en C++, elles n'ont donc souvent aucun sens avec les workflows en Python. Des modules commecopiene fonctionne que sur les objets Python, c'est pourquoi votre exemple ne fonctionne pas comme prévu. Vous devez conserver les références aux entités et aux géométries vivantes, pas seulement la géométrie, sinon cela se bloquera.

Par exemple, voici quelque chose qui calculera l'union des caractéristiques actuelles et précédentes, montrant l'aire des trois géométries :

l = d.GetLayer() fPrevious = None pour fid in range(l.GetFeatureCount()): fCurrent = l.GetFeature(fid) if fPrevious: gCurrent = fCurrent.GetGeometryRef() gPrevious = fPrevious.GetGeometryRef() # Faire quelque chose avec les deux géométries gNew = gCurrent.Union(gPrevious) print("Areas: %d vs %d vs %d" % (gPrevious.GetArea(), gCurrent.GetArea(), gNew.GetArea())) fPrevious = fCurrent

Mais si, par exemple, en dehors de la bouclegNouveau = gCurrent.Union(gPrécédent)il plantera car les références aux fonctionnalités ont changé.


Traitement spatial parallèle basé sur GDAL/OGR avec filtre spatial utilisant python ?

J'applique séquentiellement un filtre spatial avec GDAL/OGR en Python afin de calculer une densité de points :

Mais maintenant, je veux paralléliser mon code, pour améliorer les performances.

Comment puis-je traiter des données spatiales en parallèle avec GDAL/OGR en Python ? Surtout, puis-je appliquer un filtre spatial sur une source de données en parallèle ?

Je veux utiliser concurrent.futures.ThreadPoolExecutor() comme exécuteur


Modélisation dans QGIS

Je devrais modéliser davantage, mais je ne le fais pas. Vous êtes le bienvenu.

Quoi qu'il en soit, ces dernières semaines, je vous ai ennuyé avec des histoires de topologie et maintenant je vais vous ennuyer avec des histoires de construction d'un modèle. L'un de mes emplois les plus anciens a été en foresterie et c'est à peu près un ensemble de processus reproductibles. Avec le verrouillage actuel, j'ai expérimenté les données des clients et comment accélérer certaines de mes activités.

QGIS a un modeleur. Dans ArcGIS, Modelbuilder était probablement un favori car je fais toujours des processus répétables. Certes, j'ai déchargé une tonne de choses sur PostGIS MAIS – ne serait pas si c'était cool si… ..

Les gars de la foresterie ont une nouvelle propriété à examiner et je fais généralement quelque chose de maladroit pour l'intégrer dans QGIS. S'il s'agit d'un inventaire, ils vont le parcourir. Ils le parcourent généralement à un certain intervalle alors ils m'appellent et moi :

  • Créez une grille à l'aide de l'outil de traitement des points réguliers.
  • Supprimer manuellement les points qui tombent trop loin de la limite
  • Nommer les points

Cela prend de 5 minutes à 15 minutes selon la propriété et la façon dont nous pensons que la limite s'adapte au sol. Un modèle simple ressemblerait à ceci :

Avec QGIS Processing Modeler, vous devez configurer une entrée avant de pouvoir faire quoi que ce soit. Donc, mon entrée sera une couche vectorielle. Je vais faire glisser l'algorithme de points réguliers et lui donner une sortie. Si je double-clique sur Points réguliers, j'ai besoin d'une étendue pour dessiner les points. Je vais définir cela sur une entrée de modèle. Je lui donne un nom et vous pouvez voir comment tout commence à se connecter. Je lui donne également un espacement de 264 pieds (soit 4 chaînes):

mais j'ai besoin de le couper à la limite & en supposant que la limite est fausse, je dois probablement couper certains points à l'extérieur de la limite. Je ne veux pas non plus ouvrir le modèle à chaque fois et modifier l'espacement. Soooooooo…..Obtenons la partie magique “Poof” :

  • Tamponner la propriété d'entrée
  • Créer une grille basée sur ce polygone tamponné
  • Extraire les points de la zone tamponnée
  • Créer un nouveau calque

C'est presque parfait. Donc 5 minutes pour ça. Bien sûr, il y a des choses que je dois changer comme “et s'ils veulent une croisière irrégulière” qui pourrait être un 4ࡩ ou un 5ࡩ. Je n'ai pas tout à fait compris la numérotation des points, mais je suppose que je vais y tomber sous peu.

Je n'ai pas utilisé le modeleur depuis un certain temps, mais avec un peu de temps supplémentaire, je vais réduire certains de mes processus aussi "rapidement que possible". Je joue probablement avec Python, mais je n'ai pas vraiment besoin de le faire, cela fonctionne pour ce que je dois faire avec quelques petits ajustements.


Pyspatial 0.2.4

pyspatial est un package python pour fournir des structures de données au-dessus de gdal/ogr. Ses principaux cas d'utilisation ont consisté à simplifier les flux de travail de science des données géospatiales en Python. Les 3 structures de données de base sont :

  • VectorLayer : une collection de géométries avec des pandas comme la manipulation. Chaque géométrie est un objet osgeo.ogr.Geometry. Pour une référence d'objet [voir ce lien](http://gdal.org/python/).
  • RasterDataset : une abstraction d'un raster spatial (tous deux en mosaïque) pour prendre en charge l'interrogation des pixels qui se croisent avec des formes.
  • TiledWebRaster : une abstraction d'un raster spatial en mosaïque généralement utilisé pour la visualisation sur le Web (par exemple, openlayers ou google maps) (encore en test)
  • RasterBand : une représentation de tableau numpy d'un raster avec des métadonnées spatiales (en mémoire uniquement, pas de support en mosaïque).

pyspatial facilite la lecture, l'analyse, l'interrogation et la visualisation des données spatiales sous forme vectorielle et matricielle. Il apporte la familiarité des pandas au travail avec des données vectorielles et fournit une capacité de requête similaire à PostGIS pour les données vectorielles et raster. Comme il utilise GDAL pour la plupart des calculs, les performances sont assez bonnes. Sur la base de l'expérience des auteurs, les performances ont été nettement meilleures que celles de PostGIS et des ordres de grandeur plus rapides que les bibliothèques similaires dans R.

La documentation est disponible [ici] (http://pyspatial.readthedocs.io/)

  • Testé au combat : nous l'utilisons pour notre travail quotidien et pour traiter toutes les données derrière [AcreValue](https://www.acrevalue.com/). En fait, tous nos workflows PostGIS ont été migrés vers pyspatial.
  • Lecture/écriture de données raster et vectorielles (y compris la prise en charge des sources cloud http/s3/google). Convertissez également vers/depuis des objets shapely/gdal/ogr/numpy de manière transparente.
  • Requêtes spatiales rapides car il exploite GDAL et libspatialindex/RTree. Pour extraire des données vectorielles d'un raster, la bibliothèque est 60x - 100x plus rapide que R.
  • Intégration de structures de données vectorielles/raster pour rendre l'interopérabilité transparente.
  • API de type Pandas pour travailler avec des collections de géométries.
  • Support de première classe pour les projections spatiales. Les structures de données prennent en charge la projection spatiale et vous permettent de vous transformer facilement entre les projections.
  • Lors de l'exécution d'opérations entre les sources de données, les données seront automatiquement reprojetées intelligemment. Fini la gestion des projections spatiales !
  • Visualisation interactive intégrée dans IPython (via Leaflet). Trace des marqueurs, des géométries et des choroplèthes aussi !
  • Code Python : pip install -e /chemin/vers/pyspatial
  • Code Cython : python setup.py build_ext –inplace
  • Tests : nosetests -v

## TODOs * Ajuster les tests chronométrés. Actuellement calibré sur un premier Macbook Pro 15" avec Core i7. Ceux-ci ont tendance à échouer sur de nombreuses autres machines. Devrait soit supprimer les décorateurs @timed, soit déterminer quel est un délai raisonnable pour les tests.


Configuration de GDAL/OGR avec le pilote FileGDB pour Python sous Windows

J'ai décidé de m'aventurer dans le monde de GDAL/OGR avec Python avec ma principale motivation pour imiter certains outils de ArcGIS pour le bureau. J'espère que cela m'aidera à améliorer sur quelques fronts mon Python codage, une connaissance accrue des bibliothèques géospatiales open source et pour mieux comprendre les algorithmes qui se déroulent dans les coulisses lorsque vous cliquez sur un bouton dans un SIG basé sur une interface graphique et effectuez une sorte de géotraitement ou d'analyse de données.

Je travaille principalement avec Géodatabases de fichiers ESRI et bien que je sache que ce n'est pas open source, ESRI a une API en place pour lire et écrire sur un gdb via GDAL/OGR. La première étape consiste à configurer ce dont j'ai besoin pour commencer mon parcours d'apprentissage GDAL/OGR avec Python pour les fenêtres. Je vais également installer quelques bibliothèques qui permettront d'accélérer certains calculs pour un géotraitement plus efficace.

j'utilise…
Python 2.7.13 32 bits sur Windows 7 Professionnel

1. Téléchargez et installez le Service Pack Microsoft Visual C++ 2008

Cliquez ici pour télécharger et installer.

2. Accédez au site Web de Christoph Gohlke et téléchargez la roue GDAL.

Récupérez le fichier whl GDAL. j'ai téléchargé GDAL-2.1.3-cp27-cp27m-win32.whl
Ouvrez l'invite de commande, changez le répertoire où le whl a été téléchargé et utilisez pépin à installer.

3. Obtenez l'API File Geodatabase d'ESRI (vous aurez besoin d'un compte ESRI)

Accédez à ESRI Dowloads et téléchargez la version 1.3 de l'API File Geodatabase pour Windows (Visual Studio 2008). Ce sera un dossier zip. Ouvrez le contenu du dossier zippé de l'API et extrayez FileGDBAPI.dll du dossier bin vers

C:Python27Libsite-packagesosgeo

ou où que réside votre dossier site-package. Assurez-vous simplement de l'extraire dans osgeo.

4. Créer une nouvelle variable dans les variables d'environnement

Dans Réglages avancés du système créer un nouveau Variable environnementale appelé GDAL_DRIVER_PATH et définissez le chemin d'accès au dossier osgeo à l'étape 5.

5. Ouvrez __init__.py depuis osgeo…

6. Testez la configuration

Ouvrez un interpréteur Python et testez avec…

Si vous n'obtenez pas d'erreurs comme la capture d'écran ci-dessus, la configuration a réussi.

7. Téléchargez numpy + mkl wheel depuis le site génial de Christoph Gohlke

Cliquez ici et téléchargez le fichier whl nécessaire. Pour ma configuration, j'ai téléchargé numpy‑1.11.3+mkl‑cp27‑cp27m‑win32.whl
Ouvrez l'invite de commande et changez le répertoire où réside le fichier téléchargé. Utilisation pépin à installer.

8. Installez SciPy

De retour, nous allons au référentiel Gohlke et aux roues SciPy. Voilà, j'ai téléchargé scipy‑0.19.0‑cp27‑cp27m‑win32.whl
Ouvrez l'invite de commande si vous l'avez fermée après l'étape 1 et changez le répertoire où se trouve le fichier téléchargé.
Utilisation pépin à installer.

9. Installez Shapely

Vous l'avez compris, retournez sur Gohlke et téléchargez le fichier Shapely whl. j'ai attrapé Shapely‑1.5.17‑cp27‑cp27m‑win32.whl . Utilisez pip pour une installation similaire aux étapes 7 et 8.

Maintenant pour me plonger en mode apprentissage et mettre GDAL/OGR à une certaine utilité. Consultez OSGP n°1.1 : Mesurer les distributions géographiques – Mean Center pour la première tentative.


Comment copier une géométrie avec Python OGR ? - Systèmes d'information géographique

Un chargeur de données géographiques en GML et KML

(qui nécessite une certaine préparation avant le chargement via ogr2ogr)

Auteur : Astun Technology Ltd.

Contact : support [at] astuntechnology.com

Un chargeur GML et KML écrit en Python qui utilise OGR 1.9. Les données sources peuvent être au format GML ou KML (y compris les fichiers compressés au format GZ ou ZIP) et peuvent être sorties dans l'un des formats pris en charge par OGR. Les données source peuvent être préparées à l'aide d'un simple Python pour les rendre adaptées au chargement avec OGR (utile avec des types de fonctionnalités complexes) ou pour ajouter de la valeur en dérivant des attributs.

Le chargeur a été initialement écrit pour charger les données de la couche topographique MasterMap du système d'exploitation Ordnance Survey au format GML/GZ, mais a depuis été utilisé pour charger d'autres données GML et KML.

  • Python 2.6 ou supérieur (y compris 3) est requis. Le plus moderne Linux les systèmes d'exploitation auront déjà la version 2.6 ou supérieure.
  • Module Python lxml pour l'analyse et la manipulation de XML

Les détails de l'installation sont disponibles sur le wiki du projet

Configurez d'abord Loader en modifiant loader.config en spécifiant :

  • src_dir
    • Le répertoire contenant vos fichiers source ou un fichier individuel. Tous les fichiers pris en charge dans le répertoire spécifié et ses descendants seront chargés.
    • Le répertoire utilisé pour stocker les données traduites si vous écrivez dans un format basé sur un fichier tel que ESRI Shape, MapInfo TAB, etc.
    • Le répertoire utilisé pour stocker les fichiers de travail temporaires pendant le chargement.
    • La commande ogr2ogr qui sera utilisée pour charger les données. Ici, vous pouvez spécifier le format de destination et tous les paramètres associés (par exemple, les détails de connexion à la base de données si vous écrivez sur PostGIS).
    • La commande utilisée pour préparer les données source afin qu'elles conviennent au chargement avec OGR, choisissez-en une qui convient à vos données source, telle que prep_osgml.prep_osmm_topo pour OS MasterMap Topo.
    • Fichier OGR .gfs utilisé pour définir les attributs d'entité et le type de géométrie des entités lues à partir du GML, choisissez à nouveau un fichier gfs approprié pour vos données source, tel que ../gfs/osmm_topo_postgres.gfs pour charger OS MasterMap Topo dans PostgreSQL.

    Voir python/loader.config pour plus d'explications et de détails sur les jetons disponibles. Les variables d'environnement peuvent être utilisées avec n'importe laquelle des options en utilisant un jeton de la forme : $HOME , $ ou %TEMP% (Windows uniquement)

    Exécutez ensuite à partir de la ligne de commande :

    Des arguments supplémentaires peuvent être passés pour remplacer les valeurs du fichier de configuration (utile lors de l'exécution de plusieurs instances du chargeur) par exemple pour spécifier un répertoire source différent ( src_dir ):

    Quelques exemples de configuration sont disponibles sur le wiki du projet


    3.9.1 Travailler avec des données vectorielles

    OGR et GDAL existent en tant que modules séparés dans le package osgeo avec d'autres modules tels que OSR pour gérer différentes projections et certains modules auxiliaires. Comme pour les packages précédents, vous aurez probablement besoin d'installer gdal (qui les encapsule tous dans sa dernière version) pour accéder à ces packages. Donc, généralement, un projet Python utilisant GDAL importerait les modules nécessaires similaires à ceci :

    Commençons par examiner de plus près le module ogr pour travailler avec des données vectorielles. Le code suivant, par exemple, illustre comment ouvrir un ensemble de données vectorielles existant, dans ce cas un fichier de formes Esri. OGR utilise des pilotes pour accéder aux fichiers dans différents formats, donc la chose importante à noter est comment nous obtenons d'abord un objet pilote pour « ESRI Shapefile » avec ObtenirPiloteParNom(. ) puis utilisez-le pour ouvrir le fichier de formes avec le Ouvert(. ) méthode de l'objet pilote. Le fichier de formes que nous utilisons dans cet exemple est un fichier avec des polygones pour tous les pays du monde (disponible ici) et nous l'utiliserons à nouveau dans la procédure pas à pas de la leçon. Lorsque vous le téléchargerez, vous devrez peut-être encore adapter le chemin dans la première ligne du code ci-dessous.

    base de données permet désormais d'accéder aux données du fichier de formes sous forme de couches, dans ce cas une seule couche, accessible avec le ObtenirCouche(. ) méthode. Nous utilisons ensuite l'objet de couche résultant pour obtenir les définitions des champs avec GetLayerDefn(), parcourez les champs à l'aide de GetFieldCount() et GetFieldDefn(), puis imprimez les noms des champs avec ObtenirNom() :

    Si vous souhaitez parcourir les entités d'une couche, par exemple pour lire ou modifier leurs valeurs attributaires, vous pouvez utiliser une simple boucle for et le ObtenirChamp(. ) méthode des fonctionnalités. Il est important que, si vous voulez pouvoir parcourir les fonctionnalités une autre fois, vous devez appeler le RéinitialiserLecture() méthode de la couche après la boucle. La boucle suivante imprime les valeurs du champ « NAME » pour toutes les fonctionnalités :

    Nous pouvons étendre l'exemple précédent pour accéder également à la géométrie de l'entité via le GetGeometryRef() méthode. Ici, nous utilisons cette approche pour obtenir le centroïde de chaque polygone de pays (méthode Centre de gravité()) puis l'imprimer sous une forme lisible à l'aide du Exporter versWkt() méthode. La sortie sera la même liste de noms de pays qu'auparavant, mais cette fois, chacun suivi des coordonnées du centroïde respectif.

    Nous pouvons également filtrer les couches vectorielles par attribut et spatialement. L'exemple suivant utilise SetAttributeFilter(. ) pour n'obtenir que les entités dont la population (champ « POP2005 ») est supérieure à cent millions.

    Nous pouvons supprimer la sélection en appelant SetAttributeFilter(. ) avec la chaîne vide :

    L'exemple suivant utilise SetSpatialFilter(. ) pour n'obtenir que les pays chevauchant une zone polygonale donnée, dans ce cas une zone qui couvre la partie australe de l'Afrique. Nous créons d'abord le polygone via le CreateGeometryFromWkt(. ) fonction qui crée des objets géométriques à partir de chaînes de texte bien connu (WKT). Ensuite, nous appliquons le filtre et utilisons à nouveau une boucle for pour imprimer les caractéristiques sélectionnées :

    L'accès à toutes les entités et à leurs géométries ainsi que les opérations géométriques fournies par GDAL permettent d'écrire du code qui réalise des opérations de géotraitement et d'autres analyses sur un ou plusieurs fichiers d'entrée et de créer de nouveaux fichiers de sortie avec les résultats. Pour montrer un exemple, le code suivant prend notre sélection de pays d'Afrique australe, puis crée 2 tampons de degrés décimaux autour des centroïdes de chaque pays. Les tampons résultants sont écrits dans un nouveau fichier de formes appelé centroidbuffers.shp. Nous ajoutons deux champs au fichier de formes des centroïdes tamponnés nouvellement produit, l'un avec le nom du pays et l'autre avec la population, en copiant les valeurs de champ correspondantes du fichier de pays d'entrée. Lorsque vous devrez plus tard utiliser GDAL dans l'une des parties du devoir de la leçon, vous pouvez utiliser le même ordre d'opérations, avec des paramètres et des valeurs d'entrée différents.

    Pour réaliser cette tâche, nous créons d'abord un objet de référence spatiale pour EPSG:4326 qui sera nécessaire pour créer la couche dans le nouveau fichier de formes. Ensuite, le fichier de formes est généré avec l'objet pilote de fichier de formes que nous avons obtenu précédemment, et le CréerSourceDonnées(. ) méthode. Un nouveau calque à l'intérieur de ce fichier de formes est créé via CréerCouche(. ) et en fournissant l'objet de référence spatiale en tant que paramètre. Nous créons ensuite les deux champs pour stocker les noms de pays et les numéros de population avec la fonction ChampDefn(. ) et ajoutez-les au calque créé avec le CréerChamp(. ) méthode utilisant les objets champ comme paramètres. Lors de l'ajout de nouveaux champs, assurez-vous que le nom que vous fournissez ne dépasse pas 8 caractères ou GDAL/OGR tronquera automatiquement le nom. Enfin, nous avons besoin des définitions de champ de la couche disponibles via GetLayerDefn() pour pouvoir ajouter ultérieurement de nouvelles fonctionnalités au fichier de formes de sortie. Le résultat est stocké dans la variable featureDefn.

    Maintenant que nous avons préparé le nouveau fichier de formes et la nouvelle couche de sortie, nous pouvons parcourir nos entités sélectionnées dans la couche d'entrée en variable couche, obtenez la géométrie de chaque entité, produisez une nouvelle géométrie en prenant son centroïde puis en appelant le Amortir(. ) méthode, et enfin créer une nouvelle entité à partir de la géométrie résultante dans notre couche de sortie.


    Des questions sur l'utilisation de Shapely peuvent être posées sur le GIS StackExchange en utilisant la balise "shapely".

    • Allan Adair & Itallan . m. [email protected] com>
    • Andrew Blakey <ablakey @ gmail . com>
    • Andy Freeland <andy @ andyfreeland . net>
    • Ariel Kadouri <ariel @ arielsartistry . com>
    • Aron Bierbaum <aronbierbaum @ gmail . com>
    • Bart Broere <2715782+bartbroere @ utilisateurs . aucune réponse . github. com>
    • Bas Couwenberg <sebastic @ xs4all . nl>
    • Benjamin Root <ben . v. [email protected] com>
    • Bertrand Gervais <bertrand . gervais. [email protected] com>
    • Brad Hards <bradh @ frogmouth . net>
    • Brandon Wood <btwood @ geometeor . com>
    • Chad Hawkins [email protected] com>
    • Christian Prior <cprior @ gmail . com>
    • Christian Quest <github @ cquest . org>
    • Christophe Pradal <christophe . [email protected] fr>
    • Daniele Esposti <expobrain @ utilisateurs . aucune réponse . github. com>
    • Dave Collins <dave @ espoir . net>
    • David Baumgold <david @ davidbaumgold . com>
    • David Swinkels <davidswinkelss @ gmail . com>
    • Denis Rykov [email protected] . com>
    • Erwin Sterrenburg <e . w. sterrenbourg @ gmail . com>
    • Felix Yan <felixonmars @ archlinux . org>
    • Filipe Fernandes <ocefpaf @ gmail . com>
    • Frédéric Junod <frédéric . [email protected] com>
    • Gabi Davar <grizzly . [email protected] com>
    • Gerrit Holl <gerrit . holl @ dwd . de>
    • Hannes <kannes @ utilisateurs . aucune réponse . github. com>
    • Hao Zheng <Furioushaozheng @ gmail . com>
    • Henry Walshaw <henry . [email protected] com>
    • Howard Butler & lthobu . [email protected] com>
    • Hugo <hugovk @ utilisateurs . aucune réponse . github. com>
    • Jacob Wasserman [email protected] com>
    • James Douglass <jamesdouglassusa @ gmail . com>
    • James Gaboardi <jgaboardi @ gmail . com>
    • James Lamb <jaylamb20 @ gmail . com>
    • James McBride [email protected] com>
    • James Spencer et James . s. [email protected] com>
    • Jamie Hall <jamie1212 @ gmail . com>
    • Jason Sanford <jason. sanford @ mapmyfitness . com>
    • Jeethu Rao <jeethu @ jeethurao . com>
    • Jeremiah England <34973839+Jeremiah-England @ utilisateurs . aucune réponse . github. com>
    • Jinkun Wang <mejkunw @ gmail . com>
    • Johan Euphrosine <proppy @ aminche . com>
    • Johannes Schönberger <jschoenberger @ demuc . de>
    • Jonathan Schoonhoven <jschoonhoven @ lyft . com>
    • Joris Van den Bossche <jorisvandenbossche @ gmail . com>
    • Joshua Arnott <josh @ snorfalorpagus . net>
    • Juan Luis Cano Rodríguez <juanlu @ satellogic . com>
    • Kai Lautaportti <dokai @ b426a367-1105-0410-b9ff-cdf4ab011145>
    • Kelsey Jordahl <kjordahl @ enthought . com>
    • Kevin Wurster <wursterk @ gmail . com>
    • Konstantin Veretennicov <kveretennicov @ gmail . com>
    • Koshy Thomas <koshy1123 @ gmail . com>
    • Kristian Evers <kristianevers @ gmail . com>
    • Kyle Barron <kylebarron2 @ gmail . com>
    • Leandro Lima <leandro @ limaesilva . com. br>
    • Lukasz <uhho @ utilisateurs . aucune réponse . github. com>
    • Luke Lee <durdenmisc @ gmail . com>
    • Maarten Vermeyen <maarten . vermeyen @ rwo . vlaanderen. être>
    • Marc Jansen <jansen @ terrestris . de>
    • Marco De Nadai <me @ marcodena . il>
    • Mathieu <mathieu . [email protected] com>
    • Matt Amos <matt . amos @ mapzen . com>
    • Michel Blancard <michel . blancard @ data . gouv. fr>
    • Mike Taves [email protected] com>
    • Morris Tweed <tweed . [email protected] com>
    • Naveen Michaud-Agrawal <naveen . [email protected] com>
    • Oliver Tonnhofer <olt @ bogosoft . com>
    • Paveł Tyślacki [email protected] aucune réponse . github. com>
    • Peter Sagerson <psagers . github @ ignorer . net>
    • Phil Elson <pelson . [email protected] com>
    • Pierre PACI <villerupt @ gmail . com>
    • Ricardo Zilleruelo <51384295+zetaatlyft @ utilisateurs . aucune réponse . github. com>
    • S Murthy <sr-murthy @ utilisateurs . aucune réponse . github. com>
    • Sampo Syrjanen <sampo . syrjanen @ ici . com>
    • Samuel Chin <samuelchin91 @ gmail . com>
    • Sean Gillies <sean. gillies @ gmail . com>
    • Sobolev Nikita <mail @ sobolevn . moi>
    • Stephan Hügel [email protected] com>
    • Steve M. Kim <steve @climat . com>
    • Taro Matsuzawa alias. btm <btm @ tech . e-mail . ne. jp>
    • Thibault Deutsch <thibault . [email protected] com>
    • Thomas Kluyver et lttakowl @ gmail . com>
    • Tobias Sauerwein <obias . [email protected] com>
    • Tom Caruso <carusot42 @ gmail . com>
    • Tom Clancy <17627475+clncy @ utilisateurs . aucune réponse . github. com>
    • WANG Aiyong <gepcelway @ gmail . com>
    • Will May <williamcmay @ live . com>
    • Zachary Ware <zachary . ware @ gmail . com>
    • cclauss <cclauss @ moi . com>
    • clefrks <33859587+clefrks @ utilisateurs . aucune réponse . github. com>
    • davidh-ssec <david . hoese @ ssec . wsc. édu>
    • georgeouzou [email protected] . com>
    • giumas [email protected] . euh. édu>
    • joelostblom <joelostblom @ utilisateurs . aucune réponse . github. com>
    • ljwolf <levi . John . loup @ gmail . com>
    • mindw <grizzly . [email protected] com>
    • rsmb <rsmb @ utilisateurs . aucune réponse . github. com>
    • shongololo <garethsimons @ moi . com>
    • solarjoe <walterwhite666 @ googlemail . com>
    • stephenworsley <49274989+stephenworsley @ utilisateurs . aucune réponse . github. com>
    • Justin Bronn (GeoDjango) pour l'inspiration ctypes
    • Martin Davis (JTS)
    • Sandro Santilli, Mateusz Loskot, Paul Ramsey, et al (projet GEOS)

    La majeure partie de ce travail a été financée par une subvention (pour les Pléiades) du National Endowment for the Humanities des États-Unis (https://www.neh.gov).


    Comment traiter les données météorologiques GRIB2 pour les applications de panneaux solaires (GeoJSON)

    Écrit par
    Elliott Wobler
    Ingénieur technico-commercial

    Aperçu

    Ce didacticiel explique comment utiliser les données de prévision mondiales de Spire Weather au format GRIB2 à l'aide de Python.

    Si vous n'avez jamais travaillé avec des données GRIB2 auparavant, il est recommandé de commencer par le didacticiel de démarrage, car celui-ci abordera des sujets légèrement plus avancés.

    Plus précisément, ce didacticiel montre comment récupérer le rayonnement solaire entrant à ondes courtes dans les limites d'un polygone complexe (par exemple, une frontière nationale).

    À la fin de ce tutoriel, vous saurez comment :

    1. Charger des fichiers contenant des messages GRIB2 dans un programme Python
    2. Inspectez les données GRIB2 pour comprendre quelles variables météorologiques sont incluses
    3. Filtrez les données GRIB2 sur une variable météorologique d'intérêt accumulée (c'est-à-dire le rayonnement entrant à ondes courtes)
    4. Créez des accumulations de données plus petites (par exemple toutes les heures) à partir de la valeur cumulée prévisionnelle totale en différenciant
      les totaux des délais de livraison adjacents (voir ici pour plus de détails)
    5. Recadrer les données GRIB2 à la zone définie par une entrée de fichier GeoJSON
    6. Convertissez les données GRIB2 transformées en un fichier de sortie CSV pour une analyse et une visualisation plus poussées

    Téléchargement des données

    La première étape consiste à télécharger les données de l'API de fichier de Spire Weather.

    Ce didacticiel s'attend à ce que les messages GRIB2 contiennent des données NWP provenant du paquet de données d'énergie renouvelable de Spire.

    Pour plus d'informations sur l'utilisation des points de terminaison de l'API de fichier Spire Weather’s, veuillez consulter la documentation de l'API et la FAQ.

    La FAQ contient également des exemples détaillés expliquant comment télécharger plusieurs fichiers de prévision à la fois à l'aide de cURL.

    Pour les besoins de ce didacticiel, il est supposé que les données GRIB2 ont déjà été téléchargées avec succès, sinon obtenez un échantillon ici.

    Comprendre les noms de fichiers

    Les fichiers téléchargés à partir des produits API de Spire Weather partagent tous la même convention de dénomination de fichier.

    En regardant simplement le nom du fichier, nous pouvons déterminer :

    • la date et l'heure d'émission de la prévision
    • la date et l'heure de validité des données prévisionnelles
    • la résolution horizontale des données de prévision globales
    • les variables de données météorologiques incluses dans le fichier (voir la liste complète des ensembles de données commerciales Spire Weather)

    Pour plus d'informations sur ce qui précède, veuillez vous référer à notre FAQ.

    Configuration requise pour Python

    Les packages Python suivants sont requis pour ce didacticiel.

    Bien que l'utilisation de conda ne soit pas strictement requise, c'est la méthode officiellement recommandée pour installer PyNIO (voir le lien ci-dessous).

    Une fois qu'un environnement conda a été créé et activé, les commandes suivantes peuvent être exécutées directement :

    Inspection des données

    Après avoir téléchargé les données et configuré un environnement Python avec les packages requis, l'étape suivante consiste à inspecter le contenu des données afin de déterminer les variables météorologiques auxquelles il est possible d'accéder. L'inspection des données peut être effectuée uniquement avec PyNIO, mais dans ce didacticiel, nous utiliserons plutôt PyNIO comme moteur pour xarray et chargerons les données dans un ensemble de données xarray pour la transformation. Notez qu'une importation explicite de PyNIO n'est pas requise, tant qu'il est correctement installé dans l'environnement Python actif.

    Tout d'abord, importez le package xarray :

    Ensuite, ouvrez les données GRIB2 avec xarray en utilisant PyNIO comme moteur (notez que les données GRIB2 doivent provenir de Spire’s Énergie renouvelable paquet de données):

    ds = xr.open_dataset("path_to_renewable_energy_file.grib2", engine="pynio")

    Enfin, pour chacune des variables, imprimez la clé de recherche, le nom lisible par l'homme et les unités de mesure :

    La sortie de ce qui précède devrait ressembler à ceci, donnant un aperçu clair des champs de données disponibles :

    Ce didacticiel explique comment travailler avec le flux de rayonnement à ondes courtes descendant . Notez que le nom de variable DSWRF_P8_L1_GLL0_acc a un suffixe de _acc alors que les autres variables n'en ont pas. Ce suffixe indique que les valeurs de rayonnement à ondes courtes entrantes accumuler au cours de la prévision. Vous pouvez en savoir plus sur les champs de données accumulés dans notre FAQ, et nous verrons comment les gérer plus tard dans ce didacticiel.

    Traitement des données

    Maintenant que nous savons quelles variables météorologiques et quels niveaux verticaux sont inclus dans les données GRIB2, nous pouvons commencer à traiter notre jeu de données xarray.

    Filtrage des données xarray vers une variable spécifique

    Avec xarray , le filtrage du contenu de l'ensemble de données sur une seule variable d'intérêt est très simple :

    Il est recommandé d'effectuer cette étape avant de convertir le jeu de données xarray en un DataFrame pandas (plutôt que de filtrer le DataFrame ultérieurement), car cela minimise la taille des données à convertir et réduit donc le temps d'exécution global.

    Conversion des données xarray en pandas.DataFrame

    Pour convertir l'ensemble de données xarray filtré en un DataFrame pandas, exécutez simplement ce qui suit :

    Chargement d'un fichier GeoJSON avec le package GDAL Python

    Bien que le package que nous avons installé avec conda s'appelle gdal , nous l'importons dans Python sous le nom osgeo . Il s'agit d'une abréviation de l'Open Source Geospatial Foundation, par laquelle GDAL/OGR (un logiciel libre et open source) est concédé sous licence.

    Pour charger les données GeoJSON dans GDAL, nous utilisons simplement la fonction CreateGeometryFromJSON de GDAL :

    Le format GeoJSON est un standard courant dans le monde des systèmes d'information géographique. De nombreuses régions GeoJSON préexistantes peuvent être téléchargées gratuitement en ligne (par exemple, les frontières nationales, les zones économiques exclusives, etc.) et des formes personnalisées peuvent également être créées dans une variété d'outils logiciels gratuits, tels que geojson.io ou geoman.io. Pour ce didacticiel, nous utilisons le pays de l'Italie comme polygone complexe, mais cela pourrait tout aussi bien être l'étendue d'une ferme ou d'une autre zone sous-régionale.

    Lors du chargement de données GeoJSON dans GDAL, seule la section de géométrie de la fonctionnalité est nécessaire. Voici un exemple simple de ce que le fichier d'entrée GeoJSON pourrait contenir :

    Le fichier GeoJSON peut être chargé dans Python à l'aide du package json standard, et doit ensuite être converti en une chaîne Python :

    Une fois que nous avons chargé notre définition GeoJSON dans une chaîne Python, nous pouvons créer un objet de géométrie GDAL comme celui-ci :

    Obtenir le cadre de délimitation qui contient une zone GeoJSON

    Finalement, nous recadrerons les données dans la zone précise définie par le fichier GeoJSON, mais il s'agit d'un processus coûteux en calcul, il est donc préférable de limiter d'abord la taille des données. En théorie, nous pourrions sauter complètement l'étape du recadrage dans une simple boîte, mais en pratique, cela vaut la peine de le faire pour réduire le temps d'exécution global.

    GDAL facilite le calcul de la boîte englobante grossière qui contient une zone GeoJSON complexe :

    Les valeurs de coordonnées sont ensuite accessibles individuellement à partir du tableau résultant :

    L'ordre des coordonnées géospatiales est une source courante de confusion, alors prenez soin de noter que la fonction GetEnvelope de GDAL renvoie un tableau où les valeurs de longitude précèdent les valeurs de latitude.

    Recadrage du pandas.DataFrame dans un cadre de délimitation géospatial

    Maintenant que les données filtrées sont converties en un DataFrame pandas et que nous avons les limites contenant notre zone d'intérêt, nous pouvons recadrer les données dans une simple boîte.

    La première étape de ce processus consiste à décompresser les valeurs de latitude et de longitude de l'index DataFrame’s, accessible via les noms d'index lat_0 et lon_0 :

    Bien que les valeurs de latitude soient déjà dans la plage standard de -90 dégresser à +90 degrés, les valeurs de longitude sont dans la plage de 0 à +360.

    Pour faciliter l'utilisation des données, nous convertissons les valeurs de longitude dans la plage standard de -180 degrés à +180 degrés:

    Avec les données de latitude et de longitude maintenant dans les plages de valeurs souhaitées, nous pouvons les stocker en tant que nouvelles colonnes dans notre DataFrame existant :

    Ensuite, nous utilisons les valeurs de la zone de délimitation de la section précédente (les composants du tableau bbox) pour construire les expressions de filtre DataFrame :

    Enfin, nous appliquons les filtres à notre DataFrame existant :

    Le DataFrame résultant a été rogné aux limites de la boîte qui contient la zone GeoJSON complexe.

    Recadrage du pandas.DataFrame aux limites précises d'une zone GeoJSON

    Afin de recadrer le DataFrame aux limites précises de la zone GeoJSON complexe, nous devrons vérifier chaque paire de coordonnées dans nos données. Semblable à la section précédente où nous avons remappé chaque valeur de longitude, nous effectuerons cette action avec une expression de carte.

    Pour transmettre chaque paire de coordonnées à la fonction de carte, nous créons une nouvelle colonne DataFrame appelée point où chaque valeur est un tuple contenant à la fois la latitude et la longitude :

    Nous pouvons ensuite passer chaque valeur de tuple de paire de coordonnées dans la fonction map, avec la zone GeoJSON précédemment chargée, et les traiter dans une fonction appelée check_point_in_area que nous définirons ci-dessous. La fonction check_point_in_area renverra True ou False pour indiquer si la paire de coordonnées fournie est à l'intérieur de la zone ou non. En conséquence, nous allons nous retrouver avec une nouvelle colonne DataFrame de valeurs booléennes appelée inArea :

    Une fois la colonne inArea renseignée, nous effectuons un simple filtre pour supprimer les lignes où la valeur inArea est False . Cela supprime efficacement les données de tous les emplacements de points qui ne se trouvent pas dans la zone GeoJSON :

    Bien sûr, le succès de ce qui précède dépend de la logique à l'intérieur de la fonction check_point_in_area, que nous n'avons pas encore implémentée. Étant donné que la zone GeoJSON a été chargée avec GDAL, nous pouvons tirer parti d'une méthode de géométrie GDAL appelée Contains pour vérifier rapidement si la zone contient un point spécifique. Pour ce faire, la paire de coordonnées doit d'abord être convertie en une géométrie wkbPoint dans GDAL :

    Une fois que nous avons notre géométrie wkbPoint, nous la passons simplement dans la méthode area.Contains pour vérifier si la zone contient le point :

    En rassemblant les pièces, voici ce que nous obtenons pour notre dernière fonction check_point_in_area :

    Comme vous pouvez le voir, la seule variable renvoyée par la fonction check_point_in_area est une valeur booléenne indiquant si le point spécifié est dans la zone ou non. Ces valeurs booléennes remplissent ensuite la nouvelle colonne inArea DataFrame. Cela nous permet d'appliquer le filtre d'en haut et d'obtenir les données recadrées avec précision que nous voulons :

    Analyser l'heure de prévision à partir du nom de fichier

    Chaque fichier individuel contient des données de prévisions météorologiques mondiales pour le même moment.

    En utilisant nos connaissances de la Comprendre les noms de fichiers section de ce didacticiel, et en supposant que l'argument de nom de fichier est dans le format attendu, nous pouvons écrire une fonction pour analyser l'heure de prévision valide à partir du nom de fichier :

    Ensuite, nous pouvons créer une nouvelle colonne DataFrame pour le temps qui stocke cette valeur sous forme de chaîne dans chaque ligne :

    Bien qu'il puisse sembler inutile de stocker la même valeur d'horodatage exacte dans chaque ligne, il s'agit d'une étape importante si nous voulons éventuellement concaténer notre DataFrame avec des données de prévision pour d'autres moments (démontré ci-dessous dans Traitement de plusieurs fichiers de données).

    Filtrage du DataFrame final

    Effectuez un filtre final sur notre DataFrame pour sélectionner uniquement les colonnes que nous voulons dans notre sortie, où la variable est une chaîne comme "DSWRF_P8_L1_GLL0_acc":

    Traitement des champs de données accumulés

    À ce stade, les données d'un délai de prévision ont été recadrées dans une zone d'intérêt et filtrées uniquement sur les champs pertinents, réduisant ainsi la taille totale de notre DataFrame. Nous pouvons maintenant trouver la différence entre celle-ci et les valeurs de données du délai d'exécution précédent — en passant d'une valeur cumulée totale prévue à des accumulations de données plus petites (par exemple, toutes les heures ou toutes les 6 heures). Avant de faire cela, nous dupliquons le DataFrame accumulé car nous aurons besoin d'une copie pour prendre la différence par rapport au prochain délai de prévision.

    Une fois que nous avons une copie des données accumulées, nous pouvons soustraire les données accumulées du délai d'approvisionnement précédent des données accumulées du délai d'approvisionnement actuel :

    Si les données GRIB2 que nous traitons sont dans des intervalles de temps d'avance (à partir des prévisions à court terme de Spire), alors le nouveau df DataFrame contient désormais des valeurs accumulées pour un intervalle d'une heure seulement, plutôt que l'ensemble des prévisions jusqu'à cela. temps. De même, si les données GRIB2 que nous traitons sont à intervalles de 6 heures (à partir des prévisions à moyen terme de Spire), alors le df DataFrame contient désormais des valeurs accumulées pour un intervalle de 6 heures seulement. Pour mieux comprendre à quoi cela ressemble du point de vue des données, nous vous recommandons de consulter les visualisations simples dans notre FAQ.

    Comme dernière étape, il est important de définir previous_df sur les données accumulées du délai actuel, afin que nous puissions répéter le processus ci-dessus pour le prochain délai dans la prévision :

    Lorsque toutes les pièces sont rassemblées dans un script Python opérationnel, ce processus doit avoir lieu à l'intérieur d'une boucle qui parcourt chaque délai de prévision d'intérêt. Le code complet au bas de ce didacticiel est implémenté de cette manière et la boucle correspondante se trouve à la fin du fichier.

    Enregistrement des données dans un fichier de sortie CSV

    Enregistrez le DataFrame traité dans un fichier CSV de sortie :

    La définition du paramètre index = False garantit que les colonnes d'index DataFrame ne sont pas incluses dans la sortie. De cette façon, nous excluons les valeurs lat_0 et lon_0 car nous avons déjà des colonnes pour la latitude et la longitude remappées .

    Veuillez noter que la conversion de GRIB2 en CSV peut entraîner fichiers de très grande taille, en particulier si les données ne sont pas rognées ou filtrées de manière significative.

    Traitement de plusieurs fichiers de données

    Il est souvent souhaitable de traiter plusieurs fichiers de données à la fois, afin de combiner les résultats en un seul fichier de sortie CSV unifié.

    Par exemple, disons que nous venons d'utiliser l'API Spire Weather pour télécharger une prévision complète de données GRIB2 dans un répertoire local appelé Forecast_data/ . Nous pouvons ensuite lire ces noms de fichiers dans une liste et les trier par ordre alphabétique pour faire bonne mesure :

    À partir de là, nous pouvons parcourir les noms de fichiers et passer chacun d'eux dans une fonction qui exécute les étapes décrites dans le Traitement des données section de ce tutoriel.

    Une fois que tous nos DataFrames finaux sont prêts, nous pouvons utiliser des pandas pour les concaténer comme ceci (où final_dataframes est une liste de DataFrames) :

    Nous nous retrouvons avec un DataFrame combiné appelé output_df que nous pouvons enregistrer dans un fichier CSV de sortie comme nous l'avons fait auparavant :

    Code complet

    Vous trouverez ci-dessous un script Python opérationnel qui utilise les techniques décrites dans ce didacticiel et comprend également des commentaires explicatifs en ligne.

    Le script prend trois arguments :

    La variable d'intérêt des données NWP accumulées

    Le répertoire local où sont stockées les données GRIB2

    Par exemple, le script peut être exécuté comme ceci :

    Voici le code complet :

    Notes finales

    En utilisant la sortie de données CSV de notre script final, nous pouvons maintenant facilement visualiser les données traitées dans un outil gratuit tel que kepler.gl. Nous pouvons également définir des seuils pour les alertes, générer des statistiques ou fusionner avec d'autres ensembles de données.

    Spire Weather propose également des visualisations pré-créées via l'API Web Map Service (WMS) dont vous pouvez en savoir plus ici.

    Pour des exemples de code supplémentaires, consultez le référentiel GitHub public de Spire Weather.

    Vous souhaitez réserver une consultation ?

    En savoir plus sur nos API météo et comment Spire Weather peut vous aider à tirer parti de l'avantage des données.


    Comment copier une géométrie avec Python OGR ? - Systèmes d'information géographique

    Un chargeur de données géographiques en GML et KML

    (qui nécessite une certaine préparation avant le chargement via ogr2ogr)

    Auteur : Astun Technology Ltd.

    Contact : support [at] astuntechnology.com

    Un chargeur GML et KML écrit en Python qui utilise OGR 1.9. Les données sources peuvent être au format GML ou KML (y compris les fichiers compressés au format GZ ou ZIP) et peuvent être sorties dans l'un des formats pris en charge par OGR. Les données source peuvent être préparées à l'aide d'un simple Python pour les rendre adaptées au chargement avec OGR (utile avec des types de fonctionnalités complexes) ou pour ajouter de la valeur en dérivant des attributs.

    Le chargeur a été initialement écrit pour charger les données de la couche topographique MasterMap du système d'exploitation Ordnance Survey au format GML/GZ, mais a depuis été utilisé pour charger d'autres données GML et KML.

    • Python 2.6 ou supérieur (y compris 3) est requis. Le plus moderne Linux les systèmes d'exploitation auront déjà la version 2.6 ou supérieure.
    • Module Python lxml pour l'analyse et la manipulation de XML

    Les détails de l'installation sont disponibles sur le wiki du projet

    Configurez d'abord Loader en modifiant loader.config en spécifiant :

    • src_dir
      • Le répertoire contenant vos fichiers source ou un fichier individuel. Tous les fichiers pris en charge dans le répertoire spécifié et ses descendants seront chargés.
      • Le répertoire utilisé pour stocker les données traduites si vous écrivez dans un format basé sur un fichier tel que ESRI Shape, MapInfo TAB, etc.
      • Le répertoire utilisé pour stocker les fichiers de travail temporaires pendant le chargement.
      • La commande ogr2ogr qui sera utilisée pour charger les données. Ici, vous pouvez spécifier le format de destination et tous les paramètres associés (par exemple, les détails de connexion à la base de données si vous écrivez sur PostGIS).
      • La commande utilisée pour préparer les données source afin qu'elles conviennent au chargement avec OGR, choisissez-en une qui convient à vos données source, telle que prep_osgml.prep_osmm_topo pour OS MasterMap Topo.
      • Fichier OGR .gfs utilisé pour définir les attributs d'entité et le type de géométrie des entités lues à partir du GML, choisissez à nouveau un fichier gfs approprié pour vos données source, tel que ../gfs/osmm_topo_postgres.gfs pour charger OS MasterMap Topo dans PostgreSQL.

      Voir python/loader.config pour plus d'explications et de détails sur les jetons disponibles. Les variables d'environnement peuvent être utilisées avec n'importe laquelle des options en utilisant un jeton de la forme : $HOME , $ ou %TEMP% (Windows uniquement)

      Exécutez ensuite à partir de la ligne de commande :

      Des arguments supplémentaires peuvent être passés pour remplacer les valeurs du fichier de configuration (utile lors de l'exécution de plusieurs instances du chargeur) par exemple pour spécifier un répertoire source différent ( src_dir ):

      Quelques exemples de configuration sont disponibles sur le wiki du projet


      Voir la vidéo: Read and write vector files with GDALOGR in Python