Alternative all'utilizzo di Arcpy

Mi sembra di usare il pacchetto del sito Arcpy di ESRI praticamente per tutto il mio geoprocessing di Python. A merito di ESRI, si tratta di un'incredibile serie di strumenti che possono aiutare a realizzare molto. Tuttavia, vorrei anche creare script di geoprocessing al di fuori del dominio Arcpy ESRI. Ad esempio, se voglio collegare un raster a un poligono, vorrei iniziare con il seguente script di ESRI :

# Import system modules
import arcpy
from arcpy import env
from arcpy.sa import *

# Set environment settings
env.workspace = "C:/sapyexamples/data"

# Set local variables
inRaster = "elevation"
inMaskData = "mask.shp"

# Check out the ArcGIS Spatial Analyst extension license
arcpy.CheckOutExtension("Spatial")

# Execute ExtractByMask
outExtractByMask = ExtractByMask(inRaster, inMaskData)

# Save the output 
outExtractByMask.save("C:/sapyexamples/output/extractmask")  

Non sono sicuro di come farei lo stesso compito a livello di programmazione senza Arcpy. Le mie domande per i programmatori seri là fuori: quale raccolta di strumenti Python usi per compiere compiti che gli utenti ESRI porterebbero con il pacchetto del sito Arcpy? Da dove comincio?

GDAL è lo strumento da utilizzare. In effetti, l'intera chiamata è una riga per gdal_rasterize:

gdal_rasterize -l mask -i -burn -9999 mask.shp elevation.tif

se conoscessi il valore senza dati del dem

Per alcuni controlli Python:

lyr = 'mask'
shp = 'mask.shp'
dem = 'elevation.tif'
ndv = -9999
p = os.Popen('gdal_rasterize -l %s -i -burn %d %s %s' % (lyr,ndv,shp,dem)

dove le tue variabili potrebbero essere impostate in Python

Per il pitone completo:

from osgeo import gdal, ogr
from osgeo.gdalconst import *
shp = ogr.Open('mask.shp')
lyr = shp.GetLayer('mask')
dem = gdal.Open('elevation.tif', GA_Update)
ndv = dem.GetRasterBand(1).GetNoDataValue()
gdal.RasterizeLayer(dem, 1, lyr, None, ndv) # other options, such as transformer func, creation options...
dem = None

Ho appena dato una rapida occhiata alla sintassi per l'API C, quindi la mia sintassi per Python è probabilmente un po 'fuori. Vedi gdal_alg.h: http://gdal.org/gdal__alg_8h.html

Su questo sito troverai una serie di altre domande simili che pongono la stessa domanda di base e hanno ottime referenze. Il più simile (e dettagliato) è:

• Quali sono gli strumenti / moduli / componenti aggiuntivi di Python cruciali in GIS?

Altri includono:

• Esempi di script Python per gli shapefile di geoprocessing senza usare arcpy
• Pure Python Library for Geometry Operations
• Quali strumenti in Python sono disponibili per creare una grande distanza del cerchio + creazione di linee?
• Modulo Python per eliminare le funzionalità SHP (senza Desktop GIS installato)

Un buon punto di partenza sarebbe la Biblioteca di astrazione dei dati geospaziali . In realtà è composto da due librerie: GDAL per manipolare dati raster geospaziali e OGR per manipolare dati vettoriali geospaziali, ma le persone di solito lo chiamano semplicemente GDAL.

C'è un geoprocessing con Python che utilizza un corso GIS open source presso la Utah State University. Potresti voler dare un'occhiata anche tu.

In molte mie ricerche accademiche lavoro con i dati LiDAR facendo analisi di superficie per la geomorfologia. Ho scoperto rapidamente che eseguire molte operazioni usando arcpy era molto lento, specialmente su grandi set di dati. Di conseguenza ho iniziato a utilizzare:

• pyshp per manipolare gli shapefile e aggiornare le tabelle degli attributi
• intorpidito per gestire i raster ASCII ed eseguire analisi basate sul kernel come calcoli di curvatura
• scipy per eseguire analisi statistiche sui risultati ed eseguire adattamenti di curve per superfici
• matplotlib per tracciare grafici e altri risultati grafici, come mappe di base per visualizzazioni rapide

Consiglierei anche il libro, Modellistica quantitativa dei processi di superficie terrestre a chiunque voglia saperne di più sull'analisi delle superfici raster. Il libro viene fornito con ottimi esempi di codice in C ++, che sono molto più efficienti degli strumenti ArcGIS. Questi algoritmi possono anche essere portati su Python senza bisogno di qualcosa di più complesso di numpy, sebbene funzionino molto più velocemente in C ++.

Per le persone che usano ESRI penso che GRASS sarebbe un ambiente molto simile con un ambiente Python GUI e organizzato in "toolkit" separati per compiti diversi (raster, vettore, toolkit solari ecc.). Lo scripting ha altre opzioni oltre a Python ma è così che lo uso.

Sicuramente dai un'occhiata a questo fantastico link aggiornato (credo): http://grass.osgeo.org/wiki/GRASS_and_Python

EDIT: un altro link per coloro che hanno esperienza in ESRI: http://grass.osgeo.org/wiki/GRASS_migration_hints

Secondo anche il movimento di GDAL. È inestimabile e sarei perso senza di essa.

Penso che le risposte fornite finora coprano praticamente tutti i pacchetti che vale la pena menzionare (in particolare GDAL, OGR, pyshp, NumPy)

Ma c'è anche il GIS e il Python Software Laboratory , che ospita un paio di moduli interessanti. Loro sono:

• Fiona : API più ordinata di OGR
• Rtree : indice spaziale per Python GIS
• Shapely : pacchetto Python per manipolazione e analisi di caratteristiche nel piano cartesiano

Personalmente ho iniziato a giocare con GDAL / OGR ultimamente e li ho trovati molto impressionanti per quanto riguarda la velocità e la copertura degli strumenti di analisi.

Ecco alcuni esempi di come usare i metodi (presi da questa eccellente fonte che è un ottimo punto di partenza):

# To select by attribute:
.SetAttributeFilter("soil = 'clay'")

# To select by location, either:
.SetSpatialFilter(<geom>)   

# or
.SetSpatialFilterRect(<minx>, <miny>, <maxx>, <maxy>)

# DataSource objects have a method `ExecuteSQL(<SQL>)`
.ExecuteSQL("SELECT* FROM sites WHERE soil = 'clay' ORDER BY id DESC")


# Plus all the well known tools, like:

# intersect
poly2.Intersect(<geom_1>)

# disjoint?
<geom>.Disjoint(geom_1)

# touches (on the edge?)
<geom>.Touches(geom_1)

# cross each other?
<geom>.Crosses(geom_1)

# within?
<geom>.Within(geom_1)

#contains?
<geom>.Contains(ptB)

# overlaps?
<geom>.Overlaps(geom_1)

## geoprecessing
<geom>.Union(<geom_1>)
<geom>.Intersection(<geom_1>)
<geom>.Difference(<geom_1>)
<geom>.SymmetricDifference(<geom_1>)

# Buffer (returns a new geometry)
<geom>.Buffer(<distance>)

# Are the geometries equal?
<geom1>.Equal(<geom2>)

# Returns the shortest distance between the two geometries
<geom1>.Distance(<geom2>)

# Returns the geometry's extent as a list (minx, maxx, miny, maxy)
<geom>.GetEnvelope()

La cosa bella di questi strumenti è che sei molto flessibile su come implementarli. Ho scritto ad esempio la mia classe CreateGeometry()per creare facilmente file vettoriali da zero. Se sei interessato, posso anche pubblicarlo qui, anche se penso che esuli dalla portata della domanda.

So che la tua domanda è incentrata su Python, ma R ha molti metodi di analisi statistica di valore, alcuni dei quali possono essere utilizzati per l'analisi spaziale. @Whuberha una buona risposta qui che illustra come fissare un raster a una scatola in due righe.

La mia soluzione, la soluzione rapida, è usare GDAL con Python.

Devi

importare sottoprocessi

command = "gdalwarp -of GTiff -cutline clipArea.shp -cl area_of_interest -crop_to_cutline inData.asc outData.tiff"

subprocess.call ([ 'C: \ Temp \ abc \ Notepad.exe'])

(Dalla risposta qui: ritaglio di raster con layer vettoriale mediante GDAL )

Ovviamente, dovresti essere in grado di raggiungere questo obiettivo usando Python puro, ma non ho avuto bisogno di farlo. E ho quasi sempre GDAL in giro! La flessibilità di GDAL è fantastica, specialmente in un ambiente Linux. Gestisce enormi raster, può essere legato insieme a script Python o Shell e ci sono funzioni per molte cose. Vedi anche OGR per strumenti basati su vettori.

Se non ti dispiace eseguire PostGIS, può eseguire la maggior parte dei dati spaziali per te.

PDF cheatsheet:

http://www.postgis.us/downloads/postgis20_cheatsheet.pdf

Si integra con Python:

https://publicwiki.deltares.nl/display/OET/Accessing+PostgreSQL+PostGIS+with+Python

Con strumenti di supporto come SPIT in Quantum GIS o pgAdmin sei ben equipaggiato per configurare PostGIS. È quindi possibile utilizzare il controllo Python delle operazioni PostGIS sui dati spaziali.

Ho lavorato su una libreria di geoprocessing open source chiamata WhiteboxTools che può essere utilizzata al posto di ArcPy in molte applicazioni. Attualmente ci sono quasi 300 strumenti disponibili per l'elaborazione di dati raster, vettoriali e LiDAR (LAS), anche se il piano prevede eventualmente il porting su tutti gli oltre 400 strumenti disponibili in Whitebox GAT . Sebbene gli strumenti siano sviluppati utilizzando il linguaggio di programmazione Rust (per efficienza), ogni strumento è richiamabile da Python, come nell'esempio seguente:

from whitebox_tools import WhiteboxTools

wbt = WhiteboxTools()

# Set the working directory. This is the path to the folder containing the data,
# i.e. files sent to tools as input/output parameters. You don't need to set
# the working directory if you specify full path names as tool parameters.
wbt.work_dir = "/path/to/data/"

# The most convenient way to run a tool is to use its associated method, e.g.:
wbt.elev_percentile("DEM.tif", "output.tif", 15, 15)

# You may also provide an optional custom callback for processing output from the
# tool. If you don't provide a callback, and verbose is set to True, tool output
# will simply be printed to the standard output.
def my_callback(value):
    if user_selected_cancel_btn: # Assumes a 'Cancel' button on a GUI
        print('Cancelling operation...')
        wbt.cancel_op = True
    else:
        print(value)

wbt.breach_depressions('DEM.flt', 'DEM_breached.flt', callback=my_callback)

# List all available tools in WhiteboxTools
print(wbt.list_tools())

# Lists tools with 'lidar' or 'LAS' in tool name or description.
print(wbt.list_tools(['lidar', 'LAS']))

# Print the help for a specific tool.
print(wbt.tool_help("ElevPercentile"))

# Want to read the source code for a tool?
# 'view_code' opens a browser and navigates to a tool's  
# source code in the WhiteboxTools GitHub repository
wbt.view_code('watershed')

Informazioni più dettagliate sono disponibili nel manuale utente di WhiteboxTools . La libreria è autonoma e non ha altre dipendenze. Devi semplicemente scaricare il piccolo file (<5Mb) che si trova qui . Il file di download contiene l'ex WhiteboxTools, lo script whitebox_tools.py , che fornisce l'API Python per la libreria (importata nella riga superiore dello script precedente) e il manuale dell'utente. Esiste anche una GUI tkinter di base (wb_runner.py) per l'interfacciamento con la libreria.

La licenza MIT permissiva ha lo scopo di consentire l'integrazione di WhiteboxTools come back-end con altri GIS open source; Alexander Bruy ha sviluppato un plug-in QGIS per il back-end di WhiteboxTools. Puoi anche mescolare e abbinare gli strumenti di WhiteboxTools e ArcPy in un singolo script, se necessario. La biblioteca è ancora in qualche modo sperimentale, sviluppata dal gruppo di ricerca sulla geomorfometria e l'idrogeomatica dell'Università di Guelfa , ed è attualmente in versione pre-1.0, che dovrebbe essere presa in considerazione durante l'uso.

Utilizzo di Python per fissare un raster a un file di forma senza ArcPy: http://geospatialpython.com/2011/02/clip-raster-using-shapefile.html