Alternativas ao uso do Arcpy

Eu pareço usar o pacote de sites Arcpy da ESRI para praticamente todo o meu geoprocessamento python. Para crédito da ESRI, esse é um conjunto incrível de ferramentas que podem ajudar a realizar muitas coisas. No entanto, também gostaria de criar scripts de geoprocessamento fora do domínio ESRI Arcpy. Por exemplo, se eu quiser recortar uma varredura em um polígono, começaria com o seguinte script da 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")  

Não tenho certeza de como realizaria a mesma tarefa programaticamente sem o Arcpy. Minhas perguntas para os programadores sérios: Que coleção de ferramentas python você usa para realizar tarefas que os usuários de ESRI realizariam com o pacote de sites do Arcpy? Por onde começo?

GDAL é a ferramenta a ser usada. De fato, toda a chamada é uma linha para gdal_rasterize:

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

se você soubesse o valor sem dados do dem

Para algum controle 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)

onde suas variáveis ​​podem ser definidas em python

Para python 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

Eu apenas dei uma olhada rápida na sintaxe da API C, portanto minha sintaxe para python provavelmente está um pouco fora. Veja gdal_alg.h: http://gdal.org/gdal__alg_8h.html

Você encontrará várias outras perguntas semelhantes neste site que fazem a mesma pergunta básica e têm boas referências. O mais semelhante (e detalhado) é:

• Quais são as ferramentas / módulos / suplementos Python cruciais no GIS?

Outros incluem:

• Exemplos de scripts Python para geoprocessamento de shapefiles sem usar arcpy
• Biblioteca Pure Python para operações de geometria
• Quais ferramentas no Python estão disponíveis para criar uma grande distância do círculo + criação de linha?
• Módulo Python para excluir recursos do SHP (sem o Desktop GIS instalado)

Um bom ponto de partida seria a Biblioteca de Abstração de Dados Geoespaciais . Na verdade, é composta de duas bibliotecas - GDAL para manipular dados raster geoespaciais e OGR para manipular dados vetoriais geoespaciais, mas as pessoas costumam chamá-lo de GDAL.

Há um geoprocessamento com Python usando o curso GIS de código aberto na Utah State University. Você pode querer dar uma olhada também.

Em muitas das minhas pesquisas acadêmicas, trabalho com dados LiDAR fazendo análises de superfície para geomorfologia. Eu rapidamente descobri que a realização de muitas operações usando o arcpy era muito lenta, especialmente em grandes conjuntos de dados. Como resultado, comecei a usar:

• pyshp para manipular shapefiles e atualizar tabelas de atributos
• numpy para gerenciar rasters ASCII e executar análises baseadas em kernel, como cálculos de curvatura
• Scipy para realizar análises estatísticas dos resultados e realizar ajustes de curvas para superfícies
• matplotlib para plotar gráficos e outros resultados gráficos, como mapas básicos para visualizações rápidas

Eu também recomendaria o livro Modelagem Quantitativa dos Processos de Superfície da Terra para quem quiser aprender mais sobre a análise de superfícies raster. O livro vem com ótimos exemplos de código em C ++, que são muito mais eficientes do que as ferramentas do ArcGIS. Esses algoritmos também podem ser portados para o Python sem precisar de algo mais complexo que o numpy, embora sejam executados muito mais rapidamente no C ++.

Para pessoas que usam ESRI, acho que o GRASS seria um ambiente muito semelhante ao ambiente python da GUI e organizado em 'kits de ferramentas' separados para tarefas diferentes (raster, vetor, kits de ferramentas solares etc.). O script tem outras opções além do Python, mas é assim que eu o uso.

Definitivamente, confira este ótimo link que está atualizado (acredito): http://grass.osgeo.org/wiki/GRASS_and_Python

EDIT: outro link para pessoas com experiência em ESRI: http://grass.osgeo.org/wiki/GRASS_migration_hints

Também apóio a moção da GDAL. É inestimável e eu estaria perdido sem ele.

Eu acho que as respostas dadas até agora abrangem basicamente todo o pacote que vale a pena mencionar (especialmente GDAL, OGR, pyshp, NumPy)

Mas também há o GIS e o Python Software Laboratory , que hospeda alguns módulos interessantes. Eles são:

• Fiona : API mais limpa do OGR
• Rtree : índice espacial para Python GIS
• Shapely : pacote Python para manipulação e análise de características no plano cartesiano

Pessoalmente, comecei a brincar com o GDAL / OGR recentemente e os achei muito impressionantes em relação à velocidade e cobertura das ferramentas de análise.

Aqui estão alguns exemplos de como usar os métodos (extraídos dessa excelente fonte, que é um excelente ponto de partida):

# 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()

O bom dessas ferramentas é que você é muito flexível em como implementá-las. Escrevi, por exemplo, minha própria classe CreateGeometry()para criar facilmente arquivos vetoriais do zero. Se você estiver interessado, também posso postá-lo aqui, apesar de achar que está além do escopo da pergunta.

Sei que sua pergunta é centrada em Python, mas R tem muitos métodos de análise estatística de valor, alguns dos quais podem ser usados ​​para análise espacial. @Whubertem uma boa resposta aqui ilustrando como recortar uma varredura em uma caixa em duas linhas.

Minha solução, a solução rápida, é usar GDAL com Python.

Você precisa

subprocesso de importação

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

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

(Da resposta aqui: Clipping raster com camada vetorial usando GDAL )

Obviamente, você deve conseguir isso usando Python puro, mas eu não precisei fazê-lo. E quase sempre tenho GDAL por perto! A flexibilidade do GDAL é fantástica, especialmente em um ambiente Linux. Ele lida com rasters enormes, pode ser vinculado a scripts Python ou Shell e existem funções para muitas coisas. Veja também OGR para ferramentas baseadas em vetores.

Se você não se importa de executar o PostGIS, ele pode fazer o processamento de dados espaciais para você.

Folha de dicas em PDF:

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

Ele se integra ao python:

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

Com ferramentas de suporte como SPIT no Quantum GIS ou pgAdmin, você está bem equipado para configurar o PostGIS. Você pode usar o python para controlar as operações do PostGIS em seus dados espaciais.

Eu tenho trabalhado em uma biblioteca de geoprocessamento de código aberto chamada WhiteboxTools que pode ser usada no lugar do ArcPy em muitos aplicativos. Atualmente, existem quase 300 ferramentas disponíveis para o processamento de dados de varredura, vetor e LiDAR (LAS), embora o plano seja eventualmente portar todas as mais de 400 ferramentas disponíveis no Whitebox GAT . Embora as ferramentas sejam desenvolvidas usando a linguagem de programação Rust (para maior eficiência), cada ferramenta pode ser acessada no Python, como no exemplo a seguir:

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')

Informações mais detalhadas podem ser encontradas no manual do usuário do WhiteboxTools . A biblioteca é independente e não possui outras dependências. Você simplesmente precisa fazer o download do pequeno arquivo (<5Mb) localizado aqui . O arquivo de download contém o WhiteboxTools exe, o script whitebox_tools.py , que fornece a API do Python para a biblioteca (importada na linha superior do script acima) e o manual do usuário. Há também uma GUI tkinter (wb_runner.py) muito básica para interface com a biblioteca.

A licença permissiva do MIT tem como objetivo permitir que o WhiteboxTools seja integrado como back-end com outro GIS de código aberto; Alexander Bruy desenvolveu um plugin QGIS para o back-end do WhiteboxTools. Você também pode misturar e combinar ferramentas do WhiteboxTools e ArcPy em um único script, conforme necessário. A biblioteca ainda é um pouco experimental, desenvolvida pelo Grupo de Pesquisa em Geomorfometria e Hidrogeomática da Universidade de Guelph , e atualmente é uma versão anterior à 1.0, que deve ser levada em consideração no uso.

Usando Python para recortar uma varredura para um shapefile sem ArcPy: http://geospatialpython.com/2011/02/clip-raster-using-shapefile.html