import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.2. Climb along line
Calculates the total climb and descent along line geometries.
The input layer must have Z values present. If Z values are not
available, the  Drape (set Z value from raster) algorithm may be used to add
Z values from a DEM layer.
The output layer is a copy of the input layer with additional fields
that contain the total climb (climb), total descent (descent),
the minimum elevation (minelev) and the maximum elevation
(maxelev) for each line geometry.
If the input layer contains fields with the same names as these added
fields, they will be renamed (field names will be altered to “name_2”,
“name_3”, etc, finding the first non-duplicate name).
Parameters
Specification of the output (line) layer. One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
[vector: line]
Line layer containing new attributes with the
results from climb calculations.
Total climb
TOTALCLIMB
[number]
The sum of the climb for all the line geometries
in the input layer
Total descent
TOTALDESCENT
[number]
The sum of the descent for all the line geometries
in the input layer
Minimum elevation
MINELEVATION
[number]
The minimum elevation for the geometries in the
layer
Maximum elevation
MAXELEVATION
[number]
The maximum elevation for the geometries in the
layer
Algorithm ID: qgis:climbalongline
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.3. Count points in polygon
Takes a point and a polygon layer and counts the number of points from
the point layer in each of the polygons of the polygon layer.
A new polygon layer is generated, with the exact same content as the
input polygon layer, but containing an additional field with the
points count corresponding to each polygon.
Fig. 28.40 The labels in the polygons show the point count
An optional weight field can be used to assign weights to each point.
Alternatively, a unique class field can be specified.
If both options are used, the weight field will take precedence and
the unique class field will be ignored.
 Allows
features in-place modification
of polygon features
Default menu: Vector ► Analysis Tools
Parameters
[vector: polygon]
Polygon layer whose features are associated with the count of
points they contain
Points
POINTS
[vector: point]
Point layer with features to count
Weight field
Optional
WEIGHT
[tablefield: any]
A field from the point layer.
The count generated will be the sum of the weight field of the
points contained by the polygon.
If the weight field is not numeric, the count will be 0.




    

Class field
Optional
CLASSFIELD
[tablefield: any]
Points are classified based on the selected attribute and if
several points with the same attribute value are within the
polygon, only one of them is counted.
The final count of the points in a polygon is, therefore, the
count of different classes that are found in it.
Count field name
FIELD
[string]
Default: ‘NUMPOINTS’
The name of the field to store the count of points
Count
OUTPUT
[vector: polygon]
Default: [Create temporary layer]
Specification of the output layer. One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
Append to Layer…
The file encoding can also be changed here.
Algorithm ID: native:countpointsinpolygon
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.4. DBSCAN clustering
Clusters point features based on a 2D implementation of Density-based
spatial clustering of applications with noise (DBSCAN) algorithm.
The algorithm requires two parameters, a minimum cluster size,
and the maximum distance allowed between clustered points.
See also
ST-DBSCAN clustering, K-means clustering
Parameters
Basic parameters
Minimum number of features to generate a cluster
Maximum distance between clustered points
[number]
Default: 1.0
Distance beyond which two features can not belong
to the same cluster (eps)
Clusters
OUTPUT
[vector: point]
Default: [Create temporary layer]
Specify the vector layer for the result of the clustering. One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
If checked, points on the border of a cluster are
themselves treated as unclustered points, and only
points in the interior of a cluster are tagged as
clustered.
Cluster field name
FIELD_NAME
[string]
Default: ‘CLUSTER_ID’
Name of the field where the associated cluster number
shall be stored
Cluster size field name
SIZE_FIELD_NAME
[string]
Default: ‘CLUSTER_SIZE’
Name of the field with the count of features in the same cluster
[vector: point]
Vector layer containing the original features with a
field setting the cluster they belong to
Number of clusters
NUM_CLUSTERS
[number]
The number of clusters discovered
Algorithm ID: native:dbscanclustering
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.5. Distance matrix
Calculates for point features distances to their nearest features in
the same layer or in another layer.
Default menu: Vector ► Analysis Tools
See also
Join attributes by nearest
Parameters
[tablefield: any]
Field to use to uniquely identify features of the
input layer. Used in the output attribute table.
Target point layer
TARGET
[vector: point]
Point layer containing the nearest point(s) to search
(to points)
Target unique ID field
TARGET_FIELD
[tablefield: any]
Field to use to uniquely identify features of the target
layer.
Used in the output attribute table.
Output matrix type
MATRIX_TYPE
[enumeration]
Default: 0
Different types of calculation are available:
0 — Linear (N * k x 3) distance matrix: for each
input point, reports the distance to each of the k
nearest target points.
The output matrix consists of up to k rows per
input point, and each row has three columns:
InputID, TargetID and Distance.
1 — Standard (N x T) distance matrix
2 — Summary distance matrix (mean, std. dev., min,
max): for each input point, reports statistics on
the distances to its target points.
Use only the nearest (k) target points
NEAREST_POINTS
[number]
Default: 0
You can choose to calculate the distance to all the
points in the target layer (0) or limit to a number
(k) of closest features.
Distance matrix
OUTPUT
[vector: point]
Default: [Create temporary layer]
Specification of the output vector layer. One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
[vector: point]
Point (or MultiPoint for the “Linear (N * k x 3)”
case) vector layer containing the distance calculation
for each input feature.
Its features and attribute table depend on the selected
output matrix type.
Algorithm ID: qgis:distancematrix
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.6. Distance to nearest hub (line to hub)
Creates lines that join each feature of an input vector to the nearest
feature in a destination layer.
Distances are calculated based on the
center of each feature.
Fig. 28.41 Display the nearest hub for the red input features
See also
Distance to nearest hub (points),
Join attributes by nearest
Parameters
Field to use to uniquely identify features of the
destination layer.
Used in the output attribute table
Measurement unit
[enumeration]
Default: 0
Units in which to report the distance to the closest
feature:
0 — Meters
1 — Feet
2 — Miles
3 — Kilometers
4 — Layer units
Hub distance
OUTPUT
[vector: line]
Default: [Create temporary layer]
Specify the output line vector layer connecting the matching points.
One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
[vector: line]
Line vector layer with the attributes of the input
features, the identifier of their closest feature
and the calculated distance.
Algorithm ID: qgis:distancetonearesthublinetohub
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.7. Distance to nearest hub (points)
Creates a point layer representing the
center of the input features with the
addition of two fields containing the identifier of the nearest
feature (based on its center point) and the distance between the
points.
See also
Distance to nearest hub (line to hub),
Join attributes by nearest
Parameters
Field to use to uniquely identify features of the
destination layer.
Used in the output attribute table
Measurement unit
[enumeration]
Default: 0
Units in which to report the distance to the closest
feature:
0 — Meters
1 — Feet
2 — Miles
3 — Kilometers
4 — Layer units
Hub distance
OUTPUT
[vector: point]
Default: [Create temporary layer]
Specify the output point vector layer with the nearest hub.
One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
[vector: point]
Point vector layer representing the center of the source features
with their attributes, the identifier of their closest
feature and the calculated distance.
Algorithm ID: qgis:distancetonearesthubpoints
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.8. Join by lines (hub lines)
Creates hub and spoke diagrams by connecting lines from points on
the Spoke layer to matching points in the Hub layer.
Determination of which hub goes with each point is based on a match
between the Hub ID field on the hub points and the Spoke ID field on
the spoke points.
If input layers are not point layers, a point on the surface of the
geometries will be taken as the connecting location.
Optionally, geodesic lines can be created, which represent the
shortest path on the surface of an ellipsoid.
When geodesic mode is used, it is possible to split the created lines
at the antimeridian (±180 degrees longitude), which can improve
rendering of the lines.
Additionally, the distance between vertices can be specified.
A smaller distance results in a denser, more accurate line.
Fig. 28.42 Join points based on a common field / attribute
Parameters
Basic parameters
Field of the hub layer with ID to join
Hub layer fields to copy (leave empty to copy all fields)




    

Optional
HUB_FIELDS
[tablefield: any] [list]
The field(s) of the hub layer to be copied.
If no field(s) are chosen all fields are taken.
Spoke layer
SPOKES
[vector: any]
Additional spoke point layer
Spoke ID field
SPOKE_FIELD
[tablefield: any]
Field of the spoke layer with ID to join
Spoke layer fields to copy (leave empty to copy all fields)
Optional
SPOKE_FIELDS
[tablefield: any] [list]
Field(s) of the spoke layer to be copied.
If no fields are chosen all fields are taken.
Create geodesic lines
GEODESIC
[boolean]
Default: False
Create geodesic lines (the shortest path on the surface of
an ellipsoid)
Hub lines
OUTPUT
[vector: line]
Default: [Create temporary layer]
Specify the output hub line vector layer. One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
Distance between consecutive vertices (in kilometers).
A smaller distance results in a denser, more accurate line
Split lines at antimeridian (±180 degrees longitude)
ANTIMERIDIAN_SPLIT
[boolean]
Default: False
Split lines at ±180 degrees longitude (to improve rendering
of the lines)
Algorithm ID: native:hublines
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.9. K-means clustering
Calculates the 2D distance based k-means cluster number for each input
feature.
K-means clustering aims to partition the features into k clusters in
which each feature belongs to the cluster with the nearest mean.
The mean point is represented by the barycenter of the clustered
features.
If input geometries are lines or polygons, the clustering is based on
the centroid of the feature.
Fig. 28.43 A five class point clusters
See also
DBSCAN clustering, ST-DBSCAN clustering
Parameters
Default:[Create temporary layer]
Specify the output vector layer for generated the clusters.
One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
Algorithm ID: native:kmeansclustering
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.10. List unique values
Lists unique values of an attribute table field and counts their
number.
Default menu: Vector ► Analysis Tools
Parameters
Default:[Create temporary layer]
Specify the summary table layer with unique values. One of:
Skip Output
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
HTML report
Optional
OUTPUT_HTML_FILE
[html]
Default:[Save to temporary file]
HTML report of unique values in the
Processing ► Results viewer. One of:
Skip Output
Save to a Temporary File
Save to File…
Algorithm ID: qgis:listuniquevalues
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.11. Mean coordinate(s)
Computes a point layer with the center of mass of geometries in an
input layer.
An attribute can be specified as containing weights to be applied to
each feature when computing the center of mass.
If an attribute is selected in the parameter, features will be grouped
according to values in this field.
Instead of a single point with the center of mass of the whole layer,
the output layer will contain a center of mass for the features in
each category.
Default menu: Vector ► Analysis Tools
Parameters
Default:[Create temporary layer]
Specify the (point vector) layer for the result. One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
Algorithm ID: native:meancoordinates
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.12. Nearest neighbour analysis
Performs nearest neighbor analysis for a point layer. The output tells you
how your data are distributed (clustered, randomly or distributed).
Output is generated as an HTML file with the computed statistical
values:
Observed mean distance
Expected mean distance
Nearest neighbour index
Number of points
Z-Score: Comparing the Z-Score with the normal distribution tells
you how your data are distributed.
A low Z-Score means that the data are unlikely to be the result of a
spatially random process, while a high Z-Score means that your data
are likely to be a result of a spatially random process.
Default:[Save to temporary file]
Specification of the HTML file for the computed statistics.
One of:
Skip Output
Save to a Temporary File
Save to File…
Algorithm ID: native:nearestneighbouranalysis
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.13. Overlap analysis
Calculates the area and percentage cover by which features from an
input layer are overlapped by features from a selection of overlay
layers.
New attributes are added to the output layer reporting the
total area of overlap and percentage of the input feature
overlapped by each of the selected overlay layers.
Parameters
Basic parameters
Default: Not set
If provided, the input geometries are snapped to a grid of the given size,
and the result vertices are computed on that same grid. Requires GEOS 3.9.0 or higher.
[same as input]
The output layer with additional fields reporting the
overlap (in map units and percentage) of the input feature
overlapped by each of the selected layers.
Algorithm ID: native:calculatevectoroverlaps
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.14. Shortest line between features
Creates a line layer as the shortest line between the source and the destination layer. By default only the first nearest feature of the destination layer is taken into account. The n-nearest neighboring features number can be specified.
If a maximum distance is specified, then only features which are closer than this distance will be considered.
The output features will contain all the source layer attributes, all the attributes from the n-nearest feature and the additional field of the distance.
Important
This algorithm uses purely Cartesian calculations for distance,
and does not consider geodetic or ellipsoid properties when determining
feature proximity. The measurement and output coordinate system is based
on the coordinate system of the source layer.
[vector: line]
Line vector layer joining source features to their nearest
neighbor(s) in the destination layer. Contains all attributes for
both source and destination features, and the computed distance.
Algorithm ID: native:shortestline
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.15. ST-DBSCAN clustering
Clusters point features based on a 2D implementation of spatiotemporal
Density-based clustering of applications with noise (ST-DBSCAN) algorithm.
See also
DBSCAN clustering, K-means clustering
Parameters
Basic parameters
Minimum number of features to generate a cluster
Maximum distance between clustered points
[number]
Default: 1.0
Distance beyond which two features can not belong
to the same cluster (eps)
Maximum time duration between clustered points
[number]
Default: 0.0 (days)
Time duration beyond which two features can not belong
to the same cluster (eps2).
Available time units are milliseconds, seconds, minutes,
hours, days and weeks.
Clusters
OUTPUT
[vector: point]
Default: [Create temporary layer]
Specify the vector layer for the result of the clustering. One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
If checked, points on the border of a cluster are
themselves treated as unclustered points, and only
points in the interior of a cluster are tagged as
clustered.
Cluster field name
FIELD_NAME
[string]
Default: ‘CLUSTER_ID’
Name of the field where the associated cluster number
shall be stored
Cluster size field name
SIZE_FIELD_NAME
[string]
Default: ‘CLUSTER_SIZE’
Name of the field with the count of features in the same cluster
[vector: point]
Vector layer containing the original features with a
field setting the cluster they belong to
Number of clusters
NUM_CLUSTERS
[number]
The number of clusters discovered
Algorithm ID: native:stdbscanclustering
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.16. Statistics by categories
Calculates statistics of a field depending on a parent class.
The parent class is a combination of values from other fields.
Parameters
Input vector layer with unique classes and values
Field to calculate statistics on (if empty, only count is calculated)
Optional
VALUES_FIELD_NAME
[tablefield: any]
If empty only the count will be calculated
Field(s) with categories
CATEGORIES_FIELD_NAME
[vector: any] [list]
The fields that (combined) define the categories
Statistics by category
OUTPUT
[table]
Default: [Create temporary layer]
Specify the output table for the generated statistics. One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
Algorithm ID: qgis:statisticsbycategories
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.
28.1.19.17. Sum line lengths
Takes a polygon layer and a line layer and measures the total length
of lines and the total number of them that cross each polygon.
The resulting layer has the same features as the input polygon layer,
but with two additional attributes containing the length and count of
the lines across each polygon.
 Allows
features in-place modification
of polygon features
Default menu: Vector ► Analysis Tools
Parameters
Default: [Create temporary layer]
Specify the output polygon layer with generated statistics. One of:
Create Temporary Layer (TEMPORARY_OUTPUT)
Save to File…
Save to Geopackage…
Save to Database Table…
The file encoding can also be changed here.
Algorithm ID: native:sumlinelengths
import processing
processing.run("algorithm_id", {parameter_dictionary})
The algorithm id is displayed when you hover over the algorithm in
the Processing Toolbox.
The parameter dictionary provides the parameter NAMEs and values.
See Using processing algorithms from the console for details on how to run processing algorithms
from the Python console.