Sådan bruges QGIS rumlige algoritmer med python-scripts | af Nikhil S Hubbali

QGIS er et af de første værktøjer, du støder på, når du lærer om GIS og rumlig analyse. Du kan håndtere næsten alle aspekter af rumlige data og deres behandling ved hjælp af denne open source-softwarepakke. Selvom det har omfattende GUI-funktioner at arbejde på, er det nogle gange vigtigt at have en måde at håndtere scripts på. Især for dataforskere og dataingeniører, der bygger arbejdsgange, er behovet for at have automatiserede scripts, der er skalerbare, stort. QGIS tilbyder et Python API kaldet PyQGIS til netop dette formål. Du kan automatisere de fleste af de QGIS-relaterede handlinger og rumlige algoritmer gennem python-scripts. Lad os udforske mere om denne Python API og lære, hvordan du bruger QGIS rumlige algoritmer på python.

Hvis du gerne vil læse mere om, hvordan placerings(geospatiale) data stiger i betydning og er vejen frem inden for dataanalyse, så tjek min artikel om emnet.

QGIS, som en del af sin python API, tilbyder en python-konsol på sin software. Du kan bruge dette til at få adgang til næsten alt lige fra QGIS menuer og lag til at køre nogle algoritmer på datalagene. Konsollen gør et anstændigt stykke arbejde med at håndtere nogle småskala udførelse af funktioner. Men hvis målet er at arbejde med komplekse arbejdsgange og håndtere større datasæt, mister denne konsol sin glans. Det har grundlæggende funktionaliteter og mangler den sofistikering, der kræves til komplekse arbejdsgange.

Du kan ikke importere QGIS-biblioteket fra dit standard python-miljø. QGIS har sin version af python installeret til at håndtere alle de nødvendige moduler for at køre softwaren. Så hvis du skal bruge QGIS-biblioteket fra python-konsollen/jupyter-notesbogen, skal du sørge for, at din python kan finde QGIS-biblioteksstierne. Eller du kan installere QGIS-biblioteket i dit python-miljø. Lad os se på disse muligheder mere detaljeret.

Hvis du bruger Anaconda til at administrere python-biblioteker og arbejde med datavidenskabelige projekter, vil du for det meste være opmærksom på conda. I lighed med pip er conda et pakkehåndteringssystem til Python og et par andre sprog. Ved at bruge conda kan du installere QGIS-pakken som ethvert andet bibliotek på Python. Du kan installere pakken direkte i dit standard (læs ‘globale’) python-miljø. Men da QGIS normalt har sine specifikke krav til afhængighedsmodulerne. Så det kan opgradere eller nedgradere kritiske pakker, der kan skabe afhængighedsmodulversionskonflikter for dine andre projekter.

Ideelt set, hvis du bruger Python til forskellige projekter, skal du konfigurere et miljø for hvert projekt eller i det mindste et til datavidenskab-workflowet. Ved at holde disse adskilt fra det globale python-miljø, vil du holde dit system fri for pakkeafhængighedsrelaterede fejl. Derfor er den bedste mulighed for at installere QGIS-biblioteker at gøre det i et virtuelt miljø. Det hjælper med at isolere dine QGIS-pakker fra det globale Python-miljø.

For at installere QGIS fra conda i dit aktive Python virtuelle miljø skal du køre følgende kommando fra terminalen i det aktive Python virtuelle miljø. Denne kommando installerer de nødvendige QGIS-biblioteker.

conda install -c conda-forge qgis

Ovenstående metode kan installere et par kerne QGIS-biblioteker til brug med dine python-scripts. Men dette vil stadig ikke give dig adgang til alle de QGIS rumlige algoritmer, du bruger på Desktop-pakken. For eksempel, hvis du ønsker at bruge en GRASS- eller SAGA-behandlingsalgoritme, der er tilgængelig på Processing Toolbox i QGIS, er det ikke muligt ved kun at installere QGIS-kernebiblioteker. Hvis du bruger desktopsoftwaren regelmæssigt, vil du måske opleve, at installationen er tung og lagerkrævende. Hver gang du opretter et projektmiljø, optager installationen af ​​sådan en stor pakke meget lagerplads.

I stedet kan du bruge en meget enklere løsning. Du kan bruge den eksisterende installation af QGIS Desktop og dets biblioteker (selv GRASS, SAGA og andre algoritmer installeret ved hjælp af QGIS plugins) ved at kortlægge dets systemmiljøstier fra dit standard Virtual Python-miljø. Du kan bruge én eksisterende QGIS-installation til flere Python-miljøer uden problemet med afhængighedspakker, alt imens du bruger mere end blot kernebibliotekerne i QGIS.

I dette tilfælde demonstrerer jeg processen på et Mac OS. Men du kan følge lignende trin for Linux og Windows med små ændringer.

Åbn QGIS Desktop app og åbn Python konsol. Kør derefter følgende linjer først for at eksportere systemstier til en CSV-fil.

import sys
import pandas as pd
paths = sys.path
df = pd.DataFrame({'paths':paths})
df.to_csv('./qgis_sys_paths.csv', index=False)

Når du har eksporteret systemstier, skal du eksportere miljøvariablerne i QGIS.

import os
import json
env = dict(os.environ)
rem = ['SECURITYSESSIONID', 'LaunchInstanceID', 'TMPDIR']
_ = [env.pop(r, None) for r in rem]with open('./qgis_env.json', 'w') as f:
json.dump(env, f, ensure_ascii=False, indent=4)

Den python-version, du bruger, skal ideelt set være den samme som eller tidligere version af den, der blev brugt med QGIS-installationen. For at finde Python-versionen og dens sti installeret med QGIS, kør følgende kode og se efter den tilsvarende python-eksekverbare i stien /Applications/Qgis.app/Contents/MacOS/bin/ til Mac OS.

from platform import python_version
print(python_version())

Før du kan bruge QGIS-bibliotekerne og deres rumlige algoritmer i dit python-script, skal vi konfigurere de miljøvariabler og stier, vi lige har eksporteret. Vi er også nødt til at initialisere behandlingsmodulet i QGIS.

Først importerer vi et par nødvendige pythonbiblioteker til at håndtere opsætning af miljøet.

# necessary imports
import os
import sys
import json
import pandas as pd

Når vi først har importeret disse biblioteker, skal vi indstille miljøvariablerne og systemstierne.

# set up system paths
qspath = './qgis_sys_paths.csv' 
# provide the path where you saved this file.
paths = pd.read_csv(qspath).paths.tolist()
sys.path += paths# set up environment variables
qepath = './qgis_env.json'
js = json.loads(open(qepath, 'r').read())
for k, v in js.items():
os.environ[k] = v# In special cases, we might also need to map the PROJ_LIB to handle the projections
# for mac OS
os.environ['PROJ_LIB'] = '/Applications/Qgis.app/Contents/Resources/proj'

Så kan vi faktisk importere QGIS-bibliotekerne fra vores python.

# qgis library imports
import PyQt5.QtCore
import gdal
import qgis.PyQt.QtCore
from qgis.core import (QgsApplication,
QgsProcessingFeedback,
QgsProcessingRegistry)
from qgis.analysis import QgsNativeAlgorithms

I det næste trin initialiserer vi behandlingsmodulet og dets algoritmer ved at tilføje de indfødte algoritmer fra QGIS til behandlingsregistret.

feedback = QgsProcessingFeedback()# initializing processing module
QgsApplication.setPrefixPath(js['HOME'], True)
qgs = QgsApplication([], False)
qgs.initQgis() # use qgs.exitQgis() to exit the processing module at the end of the script.# initialize processing algorithms
from processing.core.Processing import Processing
Processing.initialize()
import processingQgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())

Ved dette trin har du adgang til alle QGIS-biblioteker og deres rumlige algoritmer til brug fra python. Du kan tjekke alle de algoritmer, du har adgang til, ved at køre følgende kode.

algs = dict()
for alg in QgsApplication.processingRegistry().algorithms():
algs[alg.displayName()] = alg.id()
print(algs)

I øjeblikket løser disse trin importen af ​​algoritmer fra udbydere som QGIS native algoritmer & GRASS. Jeg arbejder stadig på at aktivere SAGA og andre plugins som Orfeo Toolbox osv., til brug med Python. Hold øje med denne blog for opdateringer, eller hvis du ved hvordan, så lad mig det vide.

Der er en masse algoritmer, du kan få adgang til fra biblioteket. Du kan køre algoritmen for at hjælpe med at se beskrivelsen af ​​hver af algoritmerne. Parametrene, der skal leveres til algoritmen, vises også med hjælpeoutputtet. For at se hjælpen skal du bare køre følgende kode ved at angive algoritme-id’et:

processing.algorithmHelp("native:centroids")# which would print this on the console.
"""
Centroids (native:centroids)This algorithm creates a new point layer, with points representing the centroid of the geometries in an input layer.The attributes associated to each point in the output layer are the same ones associated to the original features.----------------
Input parameters
----------------INPUT: Input layer	Parameter type:	QgsProcessingParameterFeatureSource	Accepted data types:
- str: layer ID
- str: layer name
- str: layer source
- QgsProcessingFeatureSourceDefinition
- QgsProperty
- QgsVectorLayerALL_PARTS: Create centroid for each part	Parameter type:	QgsProcessingParameterBoolean	Accepted data types:
- bool
- int
- str
- QgsPropertyOUTPUT: Centroids	Parameter type:	QgsProcessingParameterFeatureSink	Accepted data types:
- str: destination vector file, e.g. 'd:/test.shp'
- str: 'memory:' to store result in temporary memory layer
- str: using vector provider ID prefix and destination URI, e.g. 'postgres:…' to store result in PostGIS table
- QgsProcessingOutputLayerDefinition
- QgsProperty----------------
Outputs
----------------OUTPUT:  <QgsProcessingOutputVectorLayer>
Centroids
"""

Så vi kender til tilfældet med at køre tyngdepunktsalgoritme på ethvert vektorlag, vi ved, at vi skal levere 3 parametre og deres accepterede datatype. Lad os køre en simpel tyngdepunktsalgoritme på en vektorfil, der indeholder nogle få polygoner.

For algoritmen skal vi oprette en parameterordbog, og når vi er færdige, kører vi tyngdepunktsalgoritmen.

parameters = {
'ALL_PARTS': 1,
'INPUT': './grid-polygons.geojson',
'OUTPUT': './grid-centroids.geojson'
}
processing.run("native:centroids", parameters)# this would print out the output, once the algorithm is run.
"""
{'OUTPUT': './grid-centroids.geojson'}
"""

Og vi kan visualisere og se det endelige output af grid-centroider på QGIS Desktop-appen.

• Det er ideelt at holde Python-versionen af ​​dit virtuelle miljø den samme som eller tidligere version af den, der er installeret med QGIS. Ellers kan dette skabe problemer med nogle moduler, der er bygget til en tidligere version af Python.
• Glem ikke at afslutte QGIS-modulet, du initialiserede ved at køre qgs.exitQgis() hvor qgs er den variabel du brugte til at initialisere modulet.
• For Windows-brugere, da der er en OSgeo4W-skal, håndteres hele denne proces lidt anderledes og er ikke dækket her.
• For brugere med M1 MacBooks er QGIS installeret med intel-arkitektur ved hjælp af Rosetta. Og den python, der er installeret globalt, er bygget på arm64-arkitektur. Selvom du bruger Anaconda Python med intel-arkitektur, er der stadig biblioteker (især datavidenskab og rumlig datavidenskab), der ikke kan installeres. Det er vigtigt at matche arkitekturen for installationen af ​​moduler, så du kan bruge QGIS og andre biblioteker med python.
• Hvis du opdager, at din globale python-installation ikke stemmer overens med en på QGIS, f.eks. i M1 MacBooks kan du bruge selve QGIS-pythonen til datavidenskabens arbejdsgang. Da det er bygget til rumlige datavidenskabelige behov, er der ikke meget tilbage at tilføje for at bruge det til projekterne. Du kan få denne python-sti ved at følge trin 1 ovenfor.
  macOS: /Applications/Qgis.app/Contents/MacOS/bin/python[version] Linux: /usr/share/qgis/python
• Du kan bruge QGIS Python som nævnt ovenfor til at installere spyder- og jupyter-notebooks ved hjælp af pip til brug med dine daglige arbejdsgange.