Más

¿Cómo copiar una geometría con Python OGR?


Quiero copiar una geometría con Python OGR dentro de un bucle:

Intenté lo siguiente, pero obtengoERROR 1: No se pueden construir geometrías vacías

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

Sé que no puedo simplemente asignargPrevious = gCurrentya que solo hace referencia a la geometría. Pero, ¿por qué intenta construir una geometría vacía?


No espere que OGR sea Pythonic. De hecho, hay una gran lista de errores documentados para describirlos. Esencialmente, todas las variables son referencias a objetos descritos en C ++, por lo que a menudo no tienen sentido con los flujos de trabajo en Python. Módulos comoCopiarsolo funciona en objetos de Python, por lo que su ejemplo no funciona como se esperaba. Debe mantener vivas las referencias a las características y las geometrías, no solo a la geometría, de lo contrario, se bloqueará.

Por ejemplo, aquí hay algo que calculará la unión de las características actuales y anteriores, mostrando el área de las tres geometrías:

l = d.GetLayer () fPrevious = None para fid in range (l.GetFeatureCount ()): fCurrent = l.GetFeature (fid) if fPrevious: gCurrent = fCurrent.GetGeometryRef () gPrevious = fPrevious.GetGeometry algo con las dos geometrías gNew = gCurrent.Union (gPrevious) print ("Areas:% d vs% d vs% d"% (gPrevious.GetArea (), gCurrent.GetArea (), gNew.GetArea ())) fPrevious = fCurrent

Pero si, por ejemplo, fuera del buclegNew = gCurrent.Union (gPrevious)se bloqueará ya que las referencias a las características han cambiado.


¿Procesamiento espacial paralelo basado en GDAL / OGR con filtro espacial usando Python?

Estoy aplicando un filtro espacial secuencialmente con GDAL / OGR en Python para calcular una densidad de puntos:

Pero ahora quiero paralelizar mi código para mejorar el rendimiento.

¿Cómo puedo procesar datos espaciales en paralelo con GDAL / OGR en Python? Especialmente, ¿puedo aplicar un filtro espacial en una fuente de datos en paralelo?

Quiero usar concurrent.futures.ThreadPoolExecutor () como ejecutor


Modelado en QGIS

Debería modelar más & # 8230. Pero no lo hago & # 8217t. De nada.

De todos modos, las últimas semanas te he estado aburriendo con historias de topología y ahora voy a aburrirte con historias de construcción de un modelo. Uno de mis trabajos más prolongados ha sido el de la silvicultura y ese & # 8217 es prácticamente un conjunto de procesos repetibles. Con el bloqueo actual, he estado experimentando con los datos del cliente y cómo acelerar algo de lo que he estado haciendo.

QGIS tiene un modelador. En ArcGIS, Modelbuilder era probablemente uno de los favoritos porque siempre hago procesos repetibles. De acuerdo, he descargado un montón de cosas en PostGIS, PERO no lo haría.

Los chicos de Forestry obtienen una nueva propiedad para mirar y generalmente hago algo torpe para ingresarla en QGIS. Si es un inventario, lo recorren. Por lo general lo caminan a un intervalo determinado por lo que me llaman a mí y a mí:

  • Cree una cuadrícula con la herramienta de procesamiento Puntos regulares.
  • Elimina manualmente los puntos que quedan demasiado fuera del límite
  • Nombra los puntos

Esto toma entre 5 y 15 minutos, dependiendo de la propiedad y de lo bien que sientamos que el límite se ajusta al suelo. Un modelo simple se vería así:

Con el modelador de procesamiento de QGIS, debe configurar una entrada antes de poder hacer algo. Entonces mi entrada será una capa vectorial. Arrastraré el algoritmo de puntos regulares y le daré una salida. Si hago doble clic en Puntos regulares, necesito una extensión para dibujar los puntos. Voy a establecer eso en una entrada de modelo. Le doy un nombre y puedes ver como todo empieza a conectarse. También le doy un espacio que es de 264 pies (que son 4 cadenas):

pero necesito recortarlo al límite & # 8230 & # 8230 y asumiendo que el límite es incorrecto, probablemente necesite recortar para incluir algunos puntos fuera del límite. Tampoco quiero abrir el modelo cada vez y cambiar el espaciado. Soooooooo & # 8230..Vamos a conseguir la parte mágica & # 8220Poof & # 8221:

  • Almacenar en búfer la propiedad de entrada
  • Crea una cuadrícula basada en este polígono almacenado en búfer
  • Extraiga los puntos del área protegida
  • Crea una nueva capa

Eso es casi perfecto. Así que 5 minutos hasta esto. Por supuesto, hay cosas que necesito cambiar como & # 8220 qué pasa si quieren un crucero irregular & # 8221 que podría ser un 4 & # 2153 o un 5 & # 2153. No me he dado cuenta de la numeración de los puntos, pero supongo que me lo voy a encontrar en breve.

No he usado el modelador en bastante tiempo, pero con algo de tiempo extra voy a reducir algunos de mis procesos a lo más rápido posible. Probablemente juegue un poco con Python, pero realmente no tengo que hacerlo, esto funciona para lo que necesito hacer con algunos pequeños ajustes.


Psiespacial 0.2.4

pyspatial es un paquete de Python para proporcionar estructuras de datos sobre gdal / ogr. Sus casos de uso principales se han centrado en la simplificación de los flujos de trabajo de ciencia de datos geoespaciales en Python. Las 3 estructuras de datos centrales son:

  • VectorLayer: una colección de geometrías con pandas como manipulación. Cada geometría es un objeto osgeo.ogr.Geometry. Para una referencia de objeto [vea este enlace] (http://gdal.org/python/).
  • RasterDataset: una abstracción de un ráster espacial (tanto en mosaico como sin mosaico) para admitir la consulta de píxeles que se cruzan con formas.
  • TiledWebRaster: una abstracción de un ráster espacial en mosaico que normalmente se utiliza para la visualización en la web (por ejemplo, openlayers o google maps) (aún en prueba)
  • RasterBand: una representación de matriz numerosa de un ráster con metadatos espaciales (solo en memoria, sin soporte en mosaico).

pyspatial facilita la lectura, el análisis, la consulta y la visualización de datos espaciales tanto en forma vectorial como rasterizada. Aporta la familiaridad de los pandas para trabajar con datos vectoriales y proporciona una capacidad de consulta similar a PostGIS para datos vectoriales y ráster. Dado que utiliza GDAL para gran parte de los cálculos, el rendimiento es bastante bueno. Según la experiencia de los autores, el rendimiento ha sido significativamente mejor que PostGIS y órdenes de magnitud más rápido que bibliotecas similares en R.

La documentación está disponible [aquí] (http://pyspatial.readthedocs.io/)

  • Probado en batalla: lo usamos para nuestro trabajo diario y para procesar todos los datos detrás de [AcreValue] (https://www.acrevalue.com/). De hecho, todos nuestros flujos de trabajo de PostGIS se han migrado a pyspatial.
  • Leer / escribir datos rasterizados y vectoriales (incluida la compatibilidad con fuentes en la nube http / s3 / google). También convierta a / desde objetos shapely / gdal / ogr / numpy sin problemas.
  • Consultas espaciales rápidas ya que aprovecha GDAL y libspatialindex / RTree. Para extraer datos vectoriales de un ráster, la biblioteca es de 60 a 100 veces más rápida que R.
  • Integración de estructuras de datos vectoriales / ráster para que la interoperación sea perfecta.
  • API similar a Pandas para trabajar con colecciones de geometrías.
  • Soporte de primera clase para proyecciones espaciales. Las estructuras de datos son conscientes de la proyección espacial y le permiten transformarse fácilmente entre proyecciones.
  • Al realizar operaciones entre fuentes de datos, los datos se volverán a proyectar automáticamente de forma inteligente. ¡No más gestión de proyección espacial!
  • Visualización interactiva integrada dentro de IPython (a través de Leaflet). ¡Traza marcadores, geometrías y coropletas también!
  • Código de Python: pip install -e / ruta / a / pyspatial
  • Código Cython: python setup.py build_ext –inplace
  • Pruebas: nosetests -v

## TODOs * Ajustar pruebas cronometradas. Actualmente calibrado para un Macbook Pro de 15 ”con Core i7. Estos tienden a fallar en muchas otras máquinas. Debería eliminar los decoradores @timed, o averiguar cuál es el tiempo razonable para las pruebas.


Configuración de GDAL / OGR con FileGDB Driver para Python en Windows

He decidido aventurarme en el mundo de GDAL / OGR con Pitón con mi principal motivación para imitar algunas herramientas de ArcGIS for Desktop. Espero que esto me ayude a mejorar en algunos frentes mi Pitón codificación, mayor conocimiento sobre bibliotecas geoespaciales de código abierto, y para comprender mejor los algoritmos que se mueven detrás de escena cuando hace clic en un botón en un SIG basado en GUI y realiza algún tipo de geoprocesamiento o análisis de datos.

Principalmente trabajo con Geodatabases de archivos ESRI y aunque sé que esto no es de código abierto, ESRI tiene una API para leer y escribir en un gdb a través de GDAL / OGR. El primer paso es configurar lo que necesito para comenzar mi viaje de aprendizaje. GDAL / OGR con Pitón por Ventanas. También instalaré algunas bibliotecas que ayudarán a acelerar algunos cálculos para un geoprocesamiento más eficiente.

Estoy usando & # 8230
Python 2.7.13 de 32 bits en Windows 7 Professional

1. Descargue e instale Microsoft Visual C ++ 2008 Service Pack

Haga clic aquí para descargar e instalar.

2. Vaya al sitio web de Christoph Gohlke & # 8217s y descargue la rueda GDAL.

Coge el archivo WHL GDAL. yo descargué GDAL ‑ 2.1.3 ‑ cp27 ‑ cp27m ‑ win32.whl
Abra el símbolo del sistema, cambie el directorio donde se descargó el whl y use pepita instalar.

3. Obtenga la API de File Geodatabase de ESRI (necesitará una cuenta de ESRI)

Vaya a Descargas de ESRI y descargue la versión 1.3 de File Geodatabase API para Windows (Visual Studio 2008). Esta será una carpeta zip. Abra el contenido de la carpeta comprimida de la API y extraiga FileGDBAPI.dll de la carpeta bin para

C: Python27 Lib site-packages osgeo

o donde resida la carpeta del paquete del sitio. Solo asegúrate de extraerlo a osgeo.

4. Cree una nueva variable en variables ambientales

En Configuración avanzada del sistema crear un nuevo Variable ambiental llamada GDAL_DRIVER_PATH y establezca la ruta a la carpeta osgeo en el Paso 5.

5. Abra __init__.py desde osgeo & # 8230

6. Pruebe la configuración

Abra un intérprete de Python y pruebe con & # 8230

Si no recibe un error como el de la captura de pantalla anterior, la configuración se ha realizado correctamente.

7. Descarga numpy + mkl wheel del brillante sitio web de Christoph Gohlke

Haga clic aquí y descargue el archivo whl necesario. Para mi configuración he descargado numpy ‑ 1.11.3 + mkl ‑ cp27 ‑ cp27m ‑ win32.whl
Abra el símbolo del sistema y cambie el directorio donde reside el archivo descargado. Utilizar pepita instalar.

8. Instale SciPy

De regreso vamos al repositorio de Gohlke y a SciPy Wheels. Aquí, he descargado scipy ‑ 0.19.0 ‑ cp27 ‑ cp27m ‑ win32.whl
Abra el símbolo del sistema si lo cerró después del Paso 1 y cambie el directorio donde se puede encontrar el archivo descargado.
Utilizar pepita instalar.

9. Instale Shapely

Lo tienes, vuelve a Gohlke y descarga el archivo whl de Shapely. agarré Shapely ‑ 1.5.17 ‑ cp27 ‑ cp27m ‑ win32.whl . Utilice pip para realizar una instalación similar a los pasos 7 y 8.

Ahora para sumergirme en el modo de aprendizaje y poner GDAL / OGR para algún uso. Consulte OSGP # 1.1: Midiendo distribuciones geográficas & # 8211 Mean Center para el primer intento.


¿Cómo copiar una geometría con Python OGR? - Sistemas de Información Geográfica

Un cargador de datos geográficos en GML y KML

(que necesita algo de preparación antes de cargar a través de ogr2ogr)

Autor: Astun Technology Ltd.

Contacto: soporte [at] astuntechnology.com

Un cargador GML y KML escrito en Python que hace uso de OGR 1.9. Los datos de origen pueden estar en formato GML o KML (incluidos los archivos comprimidos en formato GZ o ZIP) y se pueden enviar a cualquiera de los formatos admitidos por OGR. Los datos de origen se pueden preparar utilizando un Python simple para que sea adecuado para cargar con OGR (útil con tipos de características complejas) o para agregar valor mediante la derivación de atributos.

El cargador se escribió originalmente para cargar datos de la capa topográfica MasterMap de Ordnance Survey OS en formato GML / GZ, pero desde entonces se ha utilizado para cargar otros datos GML y KML.

  • Se requiere Python 2.6 o superior (incluidos 3). Más moderna Linux Los sistemas operativos ya tendrán 2.6 o superior.
  • Módulo Python lxml para analizar y manipular XML

Los detalles de la instalación están disponibles en la wiki del proyecto.

Primero configure Loader editando loader.config especificando:

  • src_dir
    • El directorio que contiene sus archivos de origen o un archivo individual. Se cargarán todos los archivos admitidos en el directorio especificado y sus descendientes.
    • El directorio utilizado para almacenar los datos traducidos si se escribe en un formato basado en archivos como ESRI Shape, MapInfo TAB, etc.
    • El directorio utilizado para almacenar archivos de trabajo temporales durante la carga.
    • El comando ogr2ogr que se utilizará para cargar los datos. Aquí puede especificar el formato de destino y cualquier configuración asociada (por ejemplo, los detalles de conexión de la base de datos si está escribiendo en PostGIS).
    • El comando utilizado para preparar los datos de origen para que sean adecuados para cargar con OGR, elija uno que sea adecuado para sus datos de origen, como prep_osgml.prep_osmm_topo para OS MasterMap Topo.
    • El archivo .gfs OGR utilizado para definir los atributos de características y el tipo de geometría de las características leídas desde el GML nuevamente elija un archivo gfs adecuado para sus datos de origen, como ../gfs/osmm_topo_postgres.gfs para cargar OS MasterMap Topo en PostgreSQL.

    Consulte python / loader.config para obtener más explicaciones y detalles de los tokens disponibles. Las variables de entorno se pueden usar con cualquiera de las opciones usando un token de la forma: $ HOME, $ o% TEMP% (solo Windows)

    Luego ejecute desde la línea de comandos:

    Se pueden pasar argumentos adicionales para anular los valores en el archivo de configuración (útil cuando se ejecuta más de una instancia del cargador), por ejemplo, para especificar un directorio de origen diferente (src_dir):

    Algunos ejemplos de configuración están disponibles en la wiki del proyecto.


    3.9.1 Trabajar con datos vectoriales

    OGR y GDAL existen como módulos separados en el paquete osgeo junto con algunos otros módulos como OSR para tratar con diferentes proyecciones y algunos módulos auxiliares. Al igual que con los paquetes anteriores, probablemente necesitará instalar gdal (que los encapsula a todos en su última versión) para acceder a estos paquetes. Por lo general, un proyecto de Python que usa GDAL importaría los módulos necesarios de manera similar a esto:

    Empecemos por echar un vistazo más de cerca al módulo ogr para trabajar con datos vectoriales. El siguiente código, por ejemplo, ilustra cómo se abriría un conjunto de datos vectoriales existente, en este caso un shapefile de Esri. OGR utiliza los llamados controladores para acceder a archivos en diferentes formatos, por lo que lo importante a tener en cuenta es cómo obtenemos primero un objeto de controlador para "ESRI Shapefile" con GetDriverByName (.) y luego usar eso para abrir el shapefile con el Abierto(. ) método del objeto controlador. El shapefile que estamos usando en este ejemplo es un archivo con polígonos para todos los países del mundo (disponible aquí) y lo usaremos nuevamente en el tutorial de la lección. Cuando lo descargue, es posible que aún tenga que adaptar la ruta en la primera línea del código a continuación.

    dataSet ahora proporciona acceso a los datos en el shapefile como capas, en este caso solo una capa, a la que se puede acceder con el GetLayer (.) método. Luego usamos el objeto de capa resultante para obtener las definiciones de los campos con GetLayerDefn (), recorre los campos con la ayuda de GetFieldCount () y GetFieldDefn ()y luego imprima los nombres de los campos con GetName ():

    Si desea recorrer las entidades en una capa, por ejemplo, para leer o modificar sus valores de atributo, puede usar un bucle for simple y el GetField (.) método de características. Es importante que, si desea poder iterar a través de las funciones en otro momento, debe llamar al ResetReading () método de la capa después del bucle. El siguiente bucle imprime los valores del campo "NOMBRE" para todas las funciones:

    Podemos ampliar el ejemplo anterior para acceder también a la geometría de la función a través de la GetGeometryRef () método. Aquí usamos este enfoque para obtener el centroide de cada polígono de país (método Centroide ()) y luego imprímalo en forma legible con la ayuda del ExportToWkt () método. El resultado será la misma lista de nombres de países que antes, pero esta vez, cada uno seguido de las coordenadas del centroide respectivo.

    También podemos filtrar capas vectoriales por atributo y espacialmente. El siguiente ejemplo utiliza SetAttributeFilter (.) para obtener solo entidades con una población (campo "POP2005") superior a cien millones.

    Podemos eliminar la selección llamando SetAttributeFilter (.) con la cadena vacía:

    El siguiente ejemplo utiliza SetSpatialFilter (.) para obtener solo países que se superponen en un área poligonal determinada, en este caso, un área que cubre la parte sur de África. Primero creamos el polígono a través del CreateGeometryFromWkt (.) función que crea objetos geométricos a partir de cadenas de texto conocido (WKT). Luego aplicamos el filtro y usamos un bucle for nuevamente para imprimir las características seleccionadas:

    El acceso a todas las características y sus geometrías junto con las operaciones geométricas proporcionadas por GDAL permite escribir código que realiza operaciones de geoprocesamiento y otros análisis en uno o varios archivos de entrada y crear nuevos archivos de salida con los resultados. Para mostrar un ejemplo, el siguiente código toma nuestra selección de países del sur de África y luego crea búferes de 2 grados decimales alrededor de los centroides de cada país. Los búferes resultantes se escriben en un nuevo shapefile llamado centroidbuffers.shp. Agregamos dos campos al shapefile de centroides almacenados en búfer recién producido, uno con el nombre del país y otro con la población, copiando los valores de campo correspondientes del archivo de país de entrada. Cuando luego tenga que usar GDAL en una de las partes de la tarea de la lección, puede usar el mismo orden de operaciones, solo que con diferentes parámetros y valores de entrada.

    Para lograr esta tarea, primero creamos un objeto de referencia espacial para EPSG: 4326 que será necesario para crear la capa en el nuevo shapefile. Luego, el shapefile se genera con el objeto controlador de shapefile que obtuvimos anteriormente, y el CreateDataSource (.) método. Se crea una nueva capa dentro de este shapefile a través de CreateLayer (.) y proporcionando el objeto de referencia espacial como parámetro. Luego creamos los dos campos para almacenar los nombres de los países y los números de población con la función FieldDefn (.) y agréguelos a la capa creada con el CreateField (.) método utilizando los objetos de campo como parámetros. Al agregar nuevos campos, asegúrese de que el nombre que proporcione no tenga más de 8 caracteres o GDAL / OGR truncará automáticamente el nombre. Finalmente, necesitamos las definiciones de campo de la capa disponibles a través de GetLayerDefn () para poder agregar más tarde nuevas características al shapefile de salida. El resultado se almacena en variable featureDefn.

    Ahora que hemos preparado el nuevo shapefile y la capa de salida, podemos recorrer nuestras entidades seleccionadas en la capa de entrada en variable capa, obtenga la geometría de cada característica, produzca una nueva geometría tomando su centroide y luego llamando al Buffer(. ) y finalmente crear una nueva entidad a partir de la geometría resultante dentro de nuestra capa de salida.


    Las preguntas sobre el uso de Shapely se pueden hacer en GIS StackExchange usando la etiqueta "shapely".

    • Allan Adair y ltallan. m. adair @ gmail. com & gt
    • Andrew Blakey y ltablakey @ gmail. com & gt
    • Andy Freeland y ltandy @ andyfreeland. net & gt
    • Ariel Kadouri y ltariel @ arielsartistry. com & gt
    • Aron Bierbaum y ltaronbierbaum @ gmail. com & gt
    • Bart Broere & lt2715782 + bartbroere @ usuarios. sin respuesta . github. com & gt
    • Bas Couwenberg y ltsebastic @ xs4all. nl & gt
    • Benjamin Root & ltben. v. root @ gmail. com & gt
    • BertrandGervais & ltbertrand. gervais. pro @ gmail. com & gt
    • Brad Hards y ltbradh @ boca de rana. net & gt
    • Brandon Wood y ltbtwood @ geometeor. com & gt
    • Chad Hawkins y ltcwh @ chadwhawkins. com & gt
    • Christian Prior & ltcprior @ gmail. com & gt
    • Christian Quest & ltgithub @ cquest. org & gt
    • Christophe Pradal y ltchristophe. pradal @ inria. fr & gt
    • Usuarios de Daniele Esposti & ltexpobrain @. sin respuesta . github. com & gt
    • Dave Collins y ltdave @ hopest. net & gt
    • David Baumgold y ltdavid @ davidbaumgold. com & gt
    • David Swinkels y ltdavidswinkelss @ gmail. com & gt
    • Denis Rykov y ltrykovd @ gmail. com & gt
    • Erwin Sterrenburg & lte. w. sterrenburg @ gmail. com & gt
    • Felix Yan y ltfelixonmars @ archlinux. org & gt
    • Filipe Fernandes y ltocefpaf @ gmail. com & gt
    • Frédéric Junod y ltfrederic. junod @ camptocamp. com & gt
    • Gabi Davar y ltgrizzly. nyo @ gmail. com & gt
    • Gerrit Holl & ltgerrit. holl @ dwd. de & gt
    • Usuarios de Hannes & ltkannes @. sin respuesta . github. com & gt
    • Hao Zheng & ltFurioushaozheng @ gmail. com & gt
    • Henry Walshaw y lthenry. walshaw @ gmail. com & gt
    • Howard Butler y lthobu. inc @ gmail. com & gt
    • Usuarios de Hugo & lthugovk @. sin respuesta . github. com & gt
    • Jacob Wasserman y ltjwasserman @ gmail. com & gt
    • James Douglass y ltjamesdouglassusa @ gmail. com & gt
    • James Gaboardi y ltjgaboardi @ gmail. com & gt
    • James Lamb y ltjaylamb20 @ gmail. com & gt
    • James McBride y ltjdmcbr @ gmail. com & gt
    • James Spencer y ltjames. s . spencer @ gmail. com & gt
    • Jamie Hall y ltjamie1212 @ gmail. com & gt
    • Jason Sanford y ltjason. sanford @ mapmyfitness. com & gt
    • Jeethu Rao & ltjeethu @ jeethurao. com & gt
    • Jeremiah England & lt34973839 + Jeremiah-England @ usuarios. sin respuesta . github. com & gt
    • Jinkun Wang & ltmejkunw @ gmail. com & gt
    • Johan Euphrosine & ltproppy @ aminche. com & gt
    • Johannes Schönberger y ltjschoenberger @ demuc. de & gt
    • Jonathan Schoonhoven y ltjschoonhoven @ lyft. com & gt
    • Joris Van den Bossche y ltjorisvandenbossche @ gmail. com & gt
    • Joshua Arnott y ltjosh @ snorfalorpagus. net & gt
    • Juan Luis Cano Rodríguez & ltjuanlu @ satellogic. com & gt
    • Kai Lautaportti y ltdokai @ b426a367-1105-0410-b9ff-cdf4ab011145 & gt
    • Kelsey Jordahl y ltkjordahl @ entusiasmados. com & gt
    • Kevin Wurster y ltwursterk @ gmail. com & gt
    • Konstantin Veretennicov y ltkveretennicov @ gmail. com & gt
    • Koshy Thomas & ltkoshy1123 @ gmail. com & gt
    • Kristian Evers y ltkristianevers @ gmail. com & gt
    • Kyle Barron y ltkylebarron2 @ gmail. com & gt
    • Leandro Lima y ltleandro @ limaesilva. com. br & gt
    • Usuarios de Lukasz & ltuhho @. sin respuesta . github. com & gt
    • Luke Lee y ltdurdenmisc @ gmail. com & gt
    • Maarten Vermeyen y ltmaarten. vermeyen @ rwo. vlaanderen. be & gt
    • Marc Jansen y ltjansen @ terrestris. de & gt
    • Marco De Nadai & ltme @ marcodena. it & gt
    • Mathieu y ltmathieu. nivel @ gmail. com & gt
    • Matt Amos & ltmatt. amos @ mapzen. com & gt
    • Michel Blancard & ltmichel. blancard @ data. gouv. fr & gt
    • Mike Taves y ltmwtoews @ gmail. com & gt
    • Morris Tweed & lttweed. morris @ gmail. com & gt
    • Naveen Michaud-Agrawal y ltnaveen. michaudagrawal @ gmail. com & gt
    • Oliver Tonnhofer y ltolt @ bogosoft. com & gt
    • Paveł Tyślacki & lttbicr @ usuarios. sin respuesta . github. com & gt
    • Peter Sagerson y ltpsagers. github @ ignorare. net & gt
    • Phil Elson y ltpelson. pub @ gmail. com & gt
    • Pierre PACI & ltvillerupt @ gmail. com & gt
    • Ricardo Zilleruelo & lt51384295 + zetaatlyft @ usuarios. sin respuesta . github. com & gt
    • Usuarios de S Murthy & ltsr-murthy @. sin respuesta . github. com & gt
    • Sampo Syrjanen y ltsampo. syrjanen @ aquí. com & gt
    • Samuel Chin y ltsamuelchin91 @ gmail. com & gt
    • Sean Gillies y ltsean. gillies @ gmail. com & gt
    • Sobolev Nikita y ltmail @ sobolevn. me & gt
    • Stephan Hügel y lturschrei @ gmail. com & gt
    • Steve M. Kim & ltsteve @ clima. com & gt
    • Taro Matsuzawa también conocido como. btm & ltbtm @ tech. Email . ne. jp & gt
    • Thibault Deutsch & ltthibault. deutsch @ gmail. com & gt
    • Thomas Kluyver y lttakowl @ gmail. com & gt
    • Tobias Sauerwein y lttobias. sauerwein @ camptocamp. com & gt
    • Tom Caruso y ltcarusot42 @ gmail. com & gt
    • Tom Clancy & lt17627475 + clncy @ usuarios. sin respuesta . github. com & gt
    • WANG Aiyong & ltgepcelway @ gmail. com & gt
    • Will May & ltwilliamcmay @ live. com & gt
    • Zachary Ware & ltzachary. ware @ gmail. com & gt
    • cclauss & ltcclauss @ me. com & gt
    • clefrks & lt33859587 + clefrks @ usuarios. sin respuesta . github. com & gt
    • davidh-ssec y ltdavid. hoese @ ssec. wisc. edu & gt
    • georgeouzou & ltgeothrock @ gmail. com & gt
    • giumas & ltgmasetti @ ccom. unh. edu & gt
    • joelostblom & ltjoelostblom @ usuarios. sin respuesta . github. com & gt
    • ljwolf y ltlevi. Juan . lobo @ gmail. com & gt
    • mindw & ltgrizzly. nyo @ gmail. com & gt
    • Usuarios de rsmb y ltrsmb @. sin respuesta . github. com & gt
    • shongololo & ltgarethsimons @ me. com & gt
    • solarjoe & ltwalterwhite666 @ googlemail. com & gt
    • stephenworsley & lt49274989 + stephenworsley @ usuarios. sin respuesta . github. com & gt
    • Justin Bronn (GeoDjango) para inspirarse en ctypes
    • Martin Davis (JTS)
    • Sandro Santilli, Mateusz Loskot, Paul Ramsey, et al (Proyecto GEOS)

    La mayor parte de este trabajo fue financiada por una subvención (para las Pléyades) de la Fundación Nacional para las Humanidades de EE. UU. (Https://www.neh.gov).


    Cómo procesar datos meteorológicos GRIB2 para aplicaciones de paneles solares (GeoJSON)

    Escrito por
    Elliott Wobler
    Ingeniero Técnico Comercial

    Visión general

    Este tutorial cubre cómo trabajar con Spire Weather & # 8217s datos de pronóstico global en formato GRIB2 usando Python.

    Si nunca antes ha trabajado con datos GRIB2, se recomienda comenzar con el tutorial de introducción, ya que este actual abordará temas un poco más avanzados.

    Específicamente, este tutorial demuestra cómo recuperar la radiación solar de onda corta entrante dentro de los límites de un polígono complejo (por ejemplo, una nación y la frontera # 8217s).

    Al final de este tutorial, sabrá cómo:

    1. Cargar archivos que contienen mensajes GRIB2 en un programa Python
    2. Inspeccione los datos de GRIB2 para comprender qué variables meteorológicas están incluidas
    3. Filtrar los datos de GRIB2 a una variable meteorológica acumulada de interés (es decir, radiación de onda corta entrante)
    4. Cree acumulaciones de datos más pequeñas (por ejemplo, cada hora) a partir del valor acumulado total de pronóstico mediante la diferenciación
      los totales de los plazos de entrega adyacentes (consulte aquí para obtener más detalles)
    5. Recorta los datos GRIB2 al área definida por una entrada de archivo GeoJSON
    6. Convierta los datos GRIB2 transformados en un archivo de salida CSV para su posterior análisis y visualización.

    Descarga de datos

    El primer paso es descargar datos de Spire Weather & # 8217s File API.

    Este tutorial espera que los mensajes GRIB2 contengan datos NWP del paquete de datos de energía renovable Spire & # 8217s.

    Para obtener información sobre el uso de los puntos finales de la API de Spire Weather & # 8217s File, consulte la documentación de la API y las preguntas frecuentes.

    Las preguntas frecuentes también contienen ejemplos detallados que cubren cómo descargar varios archivos de pronóstico a la vez usando cURL.

    Para los propósitos de este tutorial, se asume que los datos de GRIB2 ya se han descargado con éxito, si no, obtenga una muestra aquí.

    Entendiendo los nombres de archivo

    Los archivos descargados de los productos API Spire Weather & # 8217s comparten la misma convención de nomenclatura de archivos.

    Con solo mirar el nombre del archivo, podemos determinar:

    • la fecha y hora en que se emitió el pronóstico
    • la fecha y hora en que los datos pronosticados son válidos para
    • la resolución horizontal de los datos de pronóstico global
    • las variables de datos meteorológicos que se incluyen en el archivo (consulte la lista completa de paquetes de datos comerciales de Spire Weather & # 8217s)

    Para obtener información más detallada sobre lo anterior, consulte nuestras preguntas frecuentes.

    Requisitos de Python

    Los siguientes paquetes de Python son necesarios para este tutorial.

    Aunque el uso de conda no es estrictamente necesario, es el método recomendado oficialmente para instalar PyNIO (consulte el enlace a continuación).

    Una vez que se ha creado y activado un entorno conda, los siguientes comandos se pueden ejecutar directamente:

    Inspeccionar los datos

    Después de descargar los datos y configurar un entorno Python con los paquetes requeridos, el siguiente paso es inspeccionar el contenido de los datos para determinar qué variables meteorológicas están disponibles para acceder. La inspección de datos se puede realizar únicamente con PyNIO, pero en este tutorial usaremos PyNIO como el motor para xarray y cargaremos los datos en un conjunto de datos de xarray para su transformación. Tenga en cuenta que no se requiere una importación explícita de PyNIO, siempre y cuando esté instalado correctamente en el entorno activo de Python.

    Primero, importe el paquete xarray:

    A continuación, abra los datos de GRIB2 con xarray utilizando PyNIO como motor (tenga en cuenta que los datos de GRIB2 deben ser de Spire & # 8217s Energía renovable paquete de datos):

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

    Finalmente, para cada una de las variables, imprima la clave de búsqueda, el nombre legible por humanos y las unidades de medida:

    El resultado de lo anterior debería tener un aspecto similar a esto, dando una descripción clara de los campos de datos disponibles:

    Este tutorial cubre cómo trabajar con el flujo de radiación de onda corta descendente. Observe que el nombre de la variable DSWRF_P8_L1_GLL0_acc tiene un sufijo _acc mientras que las otras variables no. Este sufijo indica que los valores de radiación de onda corta entrantes acumular durante el transcurso del pronóstico. Puede leer más sobre los campos de datos acumulados en nuestras preguntas frecuentes, y cubriremos cómo manejarlos más adelante en este tutorial.

    Procesando los datos

    Ahora que sabemos qué variables meteorológicas y niveles verticales se incluyen en los datos de GRIB2, podemos comenzar a procesar nuestro conjunto de datos de matriz x.

    Filtrar los datos de la matriz x a una variable específica

    Con xarray, filtrar el contenido del conjunto de datos a una sola variable de interés es muy sencillo:

    Se recomienda realizar este paso antes de convertir el conjunto de datos de matriz x en un DataFrame de pandas (en lugar de filtrar el DataFrame más adelante), ya que minimiza el tamaño de los datos que se están convirtiendo y, por lo tanto, reduce el tiempo de ejecución general.

    Conversión de los datos de la matriz x en un pandas.

    Para convertir el conjunto de datos de matriz x filtrado en un DataFrame de pandas, simplemente ejecute lo siguiente:

    Cargando un archivo GeoJSON con el paquete GDAL Python

    Aunque el paquete que instalamos con conda se llamó gdal, lo importamos a Python como osgeo. Esta es una abreviatura de Open Source Geospatial Foundation, a través de la cual GDAL / OGR (un software gratuito y de código abierto) tiene licencia.

    Para cargar datos de GeoJSON en GDAL, solo usamos la función GDAL & # 8217s CreateGeometryFromJSON:

    El formato GeoJSON es un estándar común en el mundo de los sistemas de información geográfica. Muchas regiones GeoJSON preexistentes se pueden descargar de forma gratuita en línea (por ejemplo, fronteras nacionales, zonas económicas exclusivas, etc.) y también se pueden crear formas personalizadas en una variedad de herramientas de software gratuitas, como geojson.io o geoman.io. Para este tutorial usamos el país de Italia como nuestro polígono complejo, pero esto podría ser fácilmente la extensión de una granja o alguna otra área subregional.

    Al cargar datos de GeoJSON en GDAL, solo se necesita la sección de geometría de la Característica. Aquí hay un ejemplo simple de lo que podría contener el archivo de entrada GeoJSON:

    El archivo GeoJSON se puede cargar en Python usando el paquete json estándar y luego se debe convertir en una cadena de Python:

    Una vez que hayamos cargado nuestra definición de GeoJSON en una cadena de Python, podemos crear un objeto de geometría GDAL como este:

    Obtener el cuadro delimitador que contiene un área GeoJSON

    Finalmente, recortaremos los datos al área precisa definida por el archivo GeoJSON, pero este es un proceso computacionalmente costoso, por lo que es mejor limitar primero el tamaño de los datos. En teoría, podríamos omitir el paso de recortar a un cuadro simple por completo, pero en la práctica vale la pena hacerlo para reducir el tiempo de ejecución general.

    GDAL facilita el cálculo del cuadro delimitador aproximado que contiene un área compleja de GeoJSON:

    A continuación, se puede acceder a los valores de coordenadas individualmente desde la matriz resultante:

    El orden de las coordenadas geoespaciales es una fuente común de confusión, así que tenga cuidado de tener en cuenta que la función GetEnvelope de GDAL & # 8217s devuelve una matriz donde los valores de longitud vienen antes que los valores de latitud.

    Recortando el pandas.DataFrame a un cuadro delimitador geoespacial

    Ahora que los datos filtrados se convierten en un DataFrame de pandas y tenemos los límites que contienen nuestra área de interés, podemos recortar los datos en un cuadro simple.

    El primer paso en este proceso es desempaquetar los valores de latitud y longitud del índice DataFrame & # 8217s, al que se puede acceder a través de los nombres de índice de lat_0 y lon_0:

    Aunque los valores de latitud ya se encuentran en el rango estándar de -90 degreso a +90 grados, los valores de longitud están en el rango de 0 para +360.

    Para facilitar el trabajo con los datos, convertimos los valores de longitud en el rango estándar de -180 grados a +180 grados:

    Con los datos de latitud y longitud ahora en los rangos de valores deseados, podemos almacenarlos como nuevas columnas en nuestro DataFrame existente:

    Luego, usamos los valores del cuadro delimitador de la sección anterior (los componentes de la matriz bbox) para construir las expresiones de filtro de DataFrame:

    Finalmente, aplicamos los filtros a nuestro DataFrame existente:

    El DataFrame resultante se ha recortado hasta los límites del cuadro que contiene el área compleja de GeoJSON.

    Recortando el pandas.DataFrame a los límites precisos de un área GeoJSON

    Para recortar el DataFrame a los límites precisos del área compleja de GeoJSON, necesitaremos verificar cada par de coordenadas en nuestros datos. De manera similar a la sección anterior donde reasignamos cada valor de longitud, realizaremos esta acción con una expresión de mapa.

    Para pasar cada par de coordenadas a la función de mapa, creamos una nueva columna de DataFrame llamada punto donde cada valor es una tupla que contiene tanto la latitud como la longitud:

    Luego podemos pasar cada valor de tupla de par de coordenadas a la función del mapa, junto con el área GeoJSON previamente cargada, y procesarlos en una función llamada check_point_in_area que definiremos a continuación. La función check_point_in_area devolverá True o False para indicar si el par de coordenadas proporcionado está dentro del área o no. Como resultado, terminaremos con una nueva columna DataFrame de valores booleanos llamada inArea:

    Una vez que se llena la columna inArea, realizamos un filtro simple para eliminar filas donde el valor inArea es False. Esto elimina efectivamente los datos de todas las ubicaciones de puntos que no están dentro del área de GeoJSON:

    Por supuesto, el éxito de lo anterior depende de la lógica dentro de la función check_point_in_area, que aún no hemos implementado. Dado que el área GeoJSON se cargó con GDAL, podemos aprovechar un método de geometría GDAL llamado Contiene para verificar rápidamente si el área contiene un punto específico. Para hacer esto, el par de coordenadas primero debe convertirse en una geometría wkbPoint en GDAL:

    Una vez que tenemos nuestra geometría wkbPoint, simplemente la pasamos al método area.Contains para verificar si el área contiene el punto:

    Juntando las piezas, esto es lo que obtenemos para nuestra función final check_point_in_area:

    Como puede ver, la única variable devuelta por la función check_point_in_area es un valor booleano que indica si el punto especificado está en el área o no. Estos valores booleanos luego completan la nueva columna inArea DataFrame. Esto nos permite aplicar el filtro desde arriba y terminar con los datos recortados con precisión que queremos:

    Analizar el tiempo de previsión a partir del nombre de archivo

    Cada archivo individual contiene datos de previsión meteorológica global para el mismo momento.

    Usando nuestro conocimiento de la Comprensión de los nombres de archivo sección de este tutorial, y asumiendo que el argumento del nombre del archivo está en el formato esperado, podemos escribir una función para analizar el tiempo de pronóstico válido del nombre del archivo:

    Luego, podemos crear una nueva columna DataFrame para el tiempo que almacena este valor como una cadena en cada fila:

    Aunque puede parecer innecesario almacenar el mismo valor de marca de tiempo exacto en cada fila, este es un paso importante si queremos concatenar eventualmente nuestro DataFrame con datos de pronóstico para otros momentos (que se muestra a continuación en Procesamiento de varios archivos de datos).

    Filtrar el DataFrame final

    Realice un filtro final en nuestro DataFrame para seleccionar solo las columnas que queremos en nuestra salida, donde la variable es una cadena como "DSWRF_P8_L1_GLL0_acc":

    Procesamiento de campos de datos acumulados

    En esta etapa, los datos para un tiempo de entrega de pronóstico se han recortado a un área de interés y se han filtrado solo a los campos relevantes, reduciendo así el tamaño total de nuestro DataFrame. Ahora podemos encontrar la diferencia entre este y el tiempo de entrega anterior & # 8217s valores de datos & # 8212 cambiando efectivamente de un valor acumulado total de pronóstico a acumulaciones de datos más pequeñas (por ejemplo, cada hora o cada 6 horas). Sin embargo, antes de hacer eso, duplicamos el DataFrame acumulado porque necesitaremos una copia para tomar la diferencia con el próximo tiempo de espera previsto.

    Una vez que tenemos una copia de los datos acumulados, podemos restar el tiempo de entrega anterior y los datos acumulados # 8217s del tiempo de entrega actual y los datos acumulados # 8217s:

    Si los datos GRIB2 que estamos procesando están en intervalos de tiempo de entrega por hora (de Spire y el pronóstico de corto alcance), entonces el nuevo DataFrame df ahora contiene valores acumulados para un intervalo de 1 hora, en lugar de todo el pronóstico hasta ese momento. tiempo. Del mismo modo, si los datos GRIB2 que estamos procesando están en intervalos de tiempo de entrega de 6 horas (del pronóstico de rango medio de Spire), entonces el DataFrame df ahora contiene valores acumulados para solo un intervalo de 6 horas. Para comprender mejor cómo se ve esto desde una perspectiva de datos, le recomendamos que consulte las visualizaciones simples en nuestras Preguntas frecuentes.

    Como paso final, es importante establecer previous_df al tiempo de entrega actual y # 8217s datos acumulados, de modo que podamos repetir el proceso anterior para el próximo tiempo de entrega en el pronóstico:

    Cuando todas las piezas se juntan en una secuencia de comandos Python operativa, este proceso debe tener lugar dentro de un ciclo que itera a través de cada tiempo de anticipación de interés. El código completo al final de este tutorial se implementa de tal manera, y el ciclo relevante está al final del archivo.

    Guardar los datos en un archivo de salida CSV

    Guarde el DataFrame procesado en un archivo CSV de salida:

    Establecer el parámetro index = False garantiza que las columnas de índice de DataFrame no se incluyan en la salida. De esta manera, excluimos los valores lat_0 y lon_0 ya que ya tenemos columnas para latitud y longitud reasignadas.

    Tenga en cuenta que la conversión de GRIB2 a CSV puede resultar en tamaños de archivo muy grandes, especialmente si los datos no se recortan o filtran significativamente.

    Procesamiento de varios archivos de datos

    A menudo es deseable procesar varios archivos de datos a la vez para combinar los resultados en un solo archivo de salida CSV unificado.

    Por ejemplo, digamos & # 8217s que acabamos de utilizar la API de Spire Weather para descargar un pronóstico completo & # 8217s de datos GRIB2 en un directorio local llamado Forecast_data /. Luego podemos leer esos nombres de archivo en una lista y ordenarlos alfabéticamente por si acaso:

    Desde aquí, podemos iterar a través de los nombres de archivo y pasar cada uno a una función que realiza los pasos descritos en el Procesando los datos sección de este tutorial.

    Una vez que todos nuestros DataFrames finales estén listos, podemos usar pandas para concatenarlos juntos así (donde final_dataframes es una lista de DataFrames):

    Terminamos con un DataFrame combinado llamado output_df que podemos guardar en un archivo CSV de salida como lo hicimos antes:

    Código completo

    A continuación se muestra un script Python operativo que utiliza las técnicas descritas en este tutorial y también incluye comentarios explicativos en línea.

    El guión toma tres argumentos:

    La variable de interés acumulada de datos de PNT

    El directorio local donde se almacenan los datos GRIB2

    Por ejemplo, el script se puede ejecutar así:

    Aquí está el código completo:

    Notas finales

    Usando la salida de datos CSV de nuestro script final, ahora podemos visualizar fácilmente los datos procesados ​​en una herramienta gratuita como kepler.gl. También podemos establecer umbrales para alertas, generar estadísticas o fusionarnos con otros conjuntos de datos.

    Spire Weather también ofrece visualizaciones creadas previamente a través de la API del Servicio de mapas web (WMS), sobre la que puede leer más aquí.

    Para obtener muestras de código adicionales, consulte el repositorio público de GitHub de Spire Weather & # 8217s.

    ¿Le gustaría reservar una consulta?

    Obtenga más información sobre nuestras API meteorológicas y cómo Spire Weather puede ayudarlo a habilitar la ventaja de los datos.


    ¿Cómo copiar una geometría con Python OGR? - Sistemas de Información Geográfica

    Un cargador de datos geográficos en GML y KML

    (que necesita algo de preparación antes de cargar a través de ogr2ogr)

    Autor: Astun Technology Ltd.

    Contacto: soporte [at] astuntechnology.com

    Un cargador GML y KML escrito en Python que hace uso de OGR 1.9. Los datos de origen pueden estar en formato GML o KML (incluidos archivos comprimidos en formato GZ o ZIP) y se pueden enviar a cualquiera de los formatos admitidos por OGR. Los datos de origen se pueden preparar utilizando un Python simple para que sea adecuado para cargar con OGR (útil con tipos de características complejas) o para agregar valor mediante la derivación de atributos.

    El cargador se escribió originalmente para cargar datos de la capa topográfica MasterMap de Ordnance Survey OS en formato GML / GZ, pero desde entonces se ha utilizado para cargar otros datos GML y KML.

    • Se requiere Python 2.6 o superior (incluidos 3). Más moderna Linux Los sistemas operativos ya tendrán 2.6 o superior.
    • Módulo Python lxml para analizar y manipular XML

    Los detalles de instalación están disponibles en la wiki del proyecto.

    Primero configure Loader editando loader.config especificando:

    • src_dir
      • El directorio que contiene sus archivos de origen o un archivo individual. Se cargarán todos los archivos admitidos en el directorio especificado y sus descendientes.
      • El directorio utilizado para almacenar los datos traducidos si se escribe en un formato basado en archivos como ESRI Shape, MapInfo TAB, etc.
      • El directorio utilizado para almacenar archivos de trabajo temporales durante la carga.
      • El comando ogr2ogr que se utilizará para cargar los datos. Aquí puede especificar el formato de destino y cualquier configuración asociada (por ejemplo, los detalles de conexión de la base de datos si está escribiendo en PostGIS).
      • El comando utilizado para preparar los datos de origen para que sean adecuados para cargar con OGR, elija uno que sea adecuado para sus datos de origen, como prep_osgml.prep_osmm_topo para OS MasterMap Topo.
      • El archivo OGR .gfs utilizado para definir los atributos de las características y el tipo de geometría de las características leídas desde el GML nuevamente elija un archivo gfs adecuado para sus datos de origen, como ../gfs/osmm_topo_postgres.gfs para cargar OS MasterMap Topo en PostgreSQL.

      Consulte python / loader.config para obtener más explicaciones y detalles de los tokens disponibles. Las variables de entorno se pueden usar con cualquiera de las opciones usando un token de la forma: $ HOME, $ o% TEMP% (solo Windows)

      Luego ejecute desde la línea de comandos:

      Se pueden pasar argumentos adicionales para anular los valores en el archivo de configuración (útil cuando se ejecuta más de una instancia del cargador), por ejemplo, para especificar un directorio de origen diferente (src_dir):

      Algunos ejemplos de configuración están disponibles en la wiki del proyecto.