Skip to main content
100%

Example of running standalone QGIS 3 processing algorithms in Ubuntu Linux (typical installation)

✓ Published0🌍 Public
Aalpha-beta-soup
Last edited Feb 12, 2019
Created on Feb 12, 2019

This example demonstrates how to run QGIS 3 processing algorithms directly from a standalone Python script on a typical Ubuntu Linux installation, using the `QgsApplication`, `QgsProcessingFeedback`, and `QgsRasterLayer` classes from the `qgis.core` module. It computes raster statistics—specifically a requested stat like `SUM`—via the `processing.run` call with the `"qgis:rasterlayerstatistics"` algorithm. The script initializes QGIS with `app.initQgis()`, registers native algorithms through `QgsNativeAlgorithms`, and prints the selected statistic from a raster file provided as a command-line argument.

AI-generated description

Similar vizzes

Loading thumbnail…

Run Jupyter notebook with PyQGIS

The example demonstrates how to run a Jupyter notebook with PyQGIS, showing the initialization of a QGIS application in a headless Python environment and listing available processing algorithms. It configures the QGIS prefix path, initializes the application with `QgsApplication.initQgis()`, and registers native algorithms via `QgsNativeAlgorithms` and `Processing.initialize()`. The code also prints each algorithm’s ID and display name from `QgsApplication.processingRegistry().algorithms()`, then exits cleanly. This workflow targets Ubuntu setups, using a virtual environment with `notebook` and `jupyterlab`.

TThomasG77
70% match
Loading thumbnail…

Gist 4e22024b5742c4550f00cbddf2b6deed

A gallery of QGIS processing algorithms demonstrates raster and vector geospatial operations, including GDAL tools for terrain analysis like slope, hillshade, and aspect, alongside GRASS GIS modules for image classification and evapotranspiration modeling. The visualizations show how these algorithms transform data layers, with outputs ranging from contour lines and tessellated polygons to color-relief rasters and interpolated surfaces.

TThomasG77
62% match
Loading thumbnail…

Gist 71def7a758bfa75425d5bc87dde68906

This example demonstrates how to run a QuickOSM query from within QGIS’s Python processing framework using the QuickOSM provider. It initializes a QGIS application, registers native algorithms and the QuickOSM provider, then attempts to build a query inside a defined extent (bounding box coordinates) via the `quickosm:buildqueryextent` algorithm. The code prints all registered algorithm IDs and names, revealing that QuickOSM algorithms are not properly registered, which causes the subsequent processing run to fail. It relies on PyQt5, QgsApplication, QgsProcessingFeedback, and the processing registry API.

TThomasG77
58% match
Loading thumbnail…

Standalone QGIS app for QGIS 3.0 (borrowed code for QGIS 2.x from https://subscription.packtpub.com/book/application_development/9781783984985/1/ch01lvl1sec18/creating-a-standalone-application)

This example demonstrates a standalone GIS application built with the QGIS 3.0 Python API, rendering a map canvas that displays a single line vector layer. It uses `QgsApplication` to initialize the QGIS environment, `QgsMapCanvas` to display the map, and `QgsVectorLayer` with a memory data provider containing a hard-coded `LINESTRING` geometry. The code also employs `QgsProject` to manage the layer and `QgsGeometry.fromWkt` to define the line. The application runs its own event loop via `app.exec()`, showing a minimal interactive map viewer without needing the full QGIS GUI.

TThomasG77
58% match
Loading thumbnail…

QGIS 3 standalone application sample

This example demonstrates a standalone QGIS 3 application that displays a world map with country boundaries over an OpenStreetMap basemap. The code initializes a QgsApplication, creates a QgsMapCanvas, and sets up a QgsLayerTreeMapCanvasBridge to sync the project layer tree with the canvas. It loads Natural Earth administrative country polygons as a QgsVectorLayer and an XYZ tile layer via QgsRasterLayer with WMS parameters, then writes the project to a .qgz file. The application runs an event loop, handling project save and state-change signals.

TThomasG77
57% match
Loading thumbnail…

About PyQGIS processing to print atlas

This example demonstrates how to generate PDF and image atlases directly from QGIS processing scripts using the native algorithms `native:atlaslayouttopdf` and `native:atlaslayouttoimage`. It shows two workflows: exporting a single multi-page PDF for all features in a coverage layer, and creating one PDF per feature by filtering with a `FILTER_EXPRESSION`. The code relies on the QGIS Python API (`qgis.processing`) to run the algorithms with dictionary-based parameters. A third snippet loops through features with `coverage_layer.getFeatures()`, applying an `id` filter to produce individual PDFs per feature.

TThomasG77
55% match
Loading thumbnail…

Gist 61afda568887fcc603e1f9ef963925ec

This example demonstrates a QGIS Processing model that exports spatial data to a PostgreSQL/PostGIS database. The model chains two algorithms: `qgis:postgisexecuteandloadsql` to run SQL and load the result, followed by `qgis:importintopostgis` to write the output to a table named "out2" in the public schema. It uses the PostgreSQL connection "EPSG demo," sets UTF-8 encoding, and creates a geometry column. The model shows a reusable workflow for automating database ingestion directly from the QGIS Processing framework.

TThomasG77
55% match
Loading thumbnail…

Gist fcc5e496a00471f276d798a8f64a39e4

This visualization demonstrates the QGIS processing framework’s ability to generate and display 3D tessellated terrain models alongside raster analysis outputs. The algorithm triangulates polygon geometries into multipolygon triangular components, creating a mesh-like surface that can be rendered with depth and dimension. The example pairs this 3D tessellation with related GDAL raster operations including aspect calculation, projection assignment, vector buffering, and virtual raster construction, showing how different processing algorithms can be combined in a single workflow. The visualization highlights the contrast between the raw vector tessellation output and the processed raster derivatives, illustrating the flexibility of QGIS's processing toolbox for both vector and raster data manipulation.

TThomasG77
55% match