qgis.yaml

qgis:addautoincrementalfield: >
  This algorithm adds a new integer field to a vector layer, with a sequential value for each feature.

  This field can be used as a unique ID for features in the layer.

  The new attribute is not added to the input layer but a new layer is generated instead.

qgis:addfieldtoattributestable: >
  This algorithm adds a new attribute to a vector layer.

  The name and characteristics of the attribute are defined as parameters.

  The new attribute is not added to the input layer but a new layer is generated instead.

qgis:adduniquevalueindexfield: >
  This algorithm takes a vector layer and an attribute and adds a new numeric field. Values in this field correspond to values in the specified attribute, so features with the same value for the attribute will have the same value in the new numeric field. This creates a numeric equivalent of the specified attribute, which defines the same classes.

  The new attribute is not added to the input layer but a new layer is generated instead.

qgis:advancedpythonfieldcalculator: >
  This algorithm adds a new attribute to a vector layer, with values resulting from applying an expression to each feature. The expression is defined as a Python function.

qgis:aggregate: >
  This algorithm take a vector or table layer and aggregate features based on a group by expression. Features for which group by expression return the same value are grouped together.

  It is possible to group all source features together using constant value in group by parameter, example: NULL.

  It is also possible to group features using multiple fields using Array function, example: Array("Field1", "Field2").

  Geometries (if present) are combined into one multipart geometry for each group.

  Output attributes are computed depending on each given aggregate definition.

qgis:barplot:

qgis:basicstatisticsforfields: >
  This algorithm generates basic statistics from the analysis of a values in a field in the attribute table of a vector layer. Numeric, date, time and string fields are supported.

  The statistics returned will depend on the field type.

  Statistics are generated as an HTML file.

qgis:boundary: >
  Returns the closure of the combinatorial boundary of the input geometries (ie the topological boundary of the geometry). For instance, a polygon geometry will have a boundary consisting of the linestrings for each ring in the polygon. Only valid for polygon or line layers.

qgis:boundingboxes: >
  This algorithm calculates the bounding box (envelope) of each feature in an input layer.

qgis:buildvirtualvector: >
  This algorithm creates a virtual layer that contains a set of vector layer.

  The output virtual layer will not be open in the current project.

qgis: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.

qgis:checkvalidity: >
  This algorithm performs a validity check on the geometries of a vector layer.

  The geometries are classified in three groups (valid, invalid and error), and a vector layer is generated with the features in each of these categories.

qgis:clip: >
  This algorithm clips a vector layer using the polygons of an additional polygons layer. Only the parts of the features in the input layer that falls within the polygons of the clipping layer will be added to the resulting layer.

  The attributes of the features are not modified, although properties such as area or length of the features will be modified by the clipping operation. If such properties are stored as attributes, those attributes will have to be manually updated.

qgis:concavehull: >
  This algorithm computes the concave hull of the features in an input layer.

qgis:convertgeometrytype: >
  This algorithm generates a new layer based on an existing one, with a different type of geometry.

  Not all conversions are possible. For instance, a line layer can be converted to a point layer, but a point layer cannot be converted to a line layer.

  See the "Polygonize" or "Lines to polygons" algorithm for alternative options.

qgis:convexhull: >
  This algorithm computes the convex hull of features in a layer.

  If a field is specified, it will divide the features into classes based on that field, and compute a separate convex hull for the features in each class.

qgis:countpointsinpolygon: >
  This algorithm takes a points layer and a polygon layer and counts the number of points from the first one in each polygons of the second one.

  A new polygons layer is generated, with the exact same content as the input polygons layer, but containing an additional field with the points count corresponding to each polygon.

  An optional weight field can be used to assign weights to each point. If set, the count generated will be the sum of the weight field for each point contained by the polygon.

  Alternatively, a unique class field can be specified. If set, 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 point in a polygon is, therefore, the count of different classes that are found in it.

  Both the weight field and unique class field cannot be specified. If they are, the weight field will take precedence and the unique class field will be ignored.

qgis:createattributeindex: >
  Creates an index to speed up queries made against a field in a table. Support for index creation is dependent on the layer's data provider and the field type.

qgis:createconstantrasterlayer: >
  Given an input raster layer and a value, this algorithm generates a new layer with the same extent and cell size as the input one, and all cells with the specified value.

qgis:creategridlines: >
  This algorithm creates a line vector layer with a grid covering a given extent.

  The size of each element in the grid is defined using a horizontal and vertical spacing.

  The CRS of the output layer must be defined. The grid extent and the spacing values must be expressed in the coordinates and units of this CRS.

qgis:creategridpolygon: >
  This algorithm creates a polygon vector layer with a grid covering a given extent. The grid shape can be rectangles, diamond or hexagons.

  The size of each element in the grid is defined using a horizontal and vertical spacing.

  The CRS of the output layer must be defined. The grid extent and the spacing values must be expressed in the coordinates and units of this CRS.

qgis:createpointsalonglines: >
  This algorithm creates a points layer, with points distributed along the lines of an input vector layer. the distance between points (measured along the line) is defined as a parameter.

  Start and end points can be defined, so the first and last point do not fall on the line first and last node. Start and end points are defined as distances, measured from the first and last nodes of the lines, in the units of the projection used by the lines layer.

qgis:createspatialindex: >
  Creates an index to speed up access to the features in a layer based on their spatial location. Support for spatial index creation is dependent on the layer's data provider.

qgis:delaunaytriangulation: >
  This algorithm creates a polygon layer with the delaunay triangulation corresponding to a points layer.

qgis:deletecolumn: >
  This algorithm takes a vector layer and generates a new one that has the exact same content but without the selected columns.

qgis:deleteduplicategeometries: >
  This algorithm finds duplicated geometries and removes them. Attributes are not checked, so in case two features have identical geometries but different attributes, only one of them will be added to the result layer.

qgis:deleteholes: >
  This algorithm takes a polygon layer and removes holes in polygons. It creates a new vector layer in which polygons with holes have been replaced by polygons with only their external ring. Attributes are not modified.

  An optional minimum area parameter allows removing only holes which are smaller than a specified area threshold. Leaving this parameter as 0.0 results in all holes being removed.

qgis:densifygeometries: >
  This algorithm takes a polygon or line layer and generates a new one in which the geometries have a larger number of vertices than the original one.

  If the geometries have z or m values present then these will be linearly interpolated at the added nodes.

  The number of new vertices to add to each feature geometry is specified as an input parameter.

qgis:densifygeometriesgivenaninterval: >
  This algorithm takes a polygon or line layer and generates a new one in which the geometries have a larger number of vertices than the original one. The geometries are densified by adding regularly placed extra nodes inside each segment so that the maximum distance between any two nodes does not exceed the specified distance.

  E.g. specifying a distance 3 would cause the segment [0 0] -> [10 0] to be converted to [0 0] -> [2.5 0] -> [5 0] -> [7.5 0] -> [10 0], since 3 extra nodes are required on the segment and spacing these at 2.5 increments allows them to be evenly spaced over the segment.

  If the geometries have z or m values present then these will be linearly interpolated at the added nodes.

  The distance is expressed in the same units used by the layer CRS.

qgis:difference: >
  This algorithm extracts features from the Input layer that fall outside, or partially overlap, features in the Difference layer. Input layer features that partially overlap the difference layer feature(s) are split along the boundary of the difference layer feature(s) and only the portions outside the difference layer features are retained.

  Attributes are not modified.

qgis:dissolve: >
  This algorithm takes a polygon or line vector layer and combines their geometries into new geometries. One or more attributes can be specified to dissolve only geometries belonging to the same class (having the same value for the specified attributes), alternatively all geometries can be dissolved.

  If the geometries to be dissolved are spatially separated from each other the output will be multi geometries. In case the input is a polygon layer, common boundaries of adjacent polygons being dissolved will get erased.

qgis:distancematrix: >
  This algorithms creates a table containing a distance matrix, with distances between all the points in a points layer.

qgis:distancetonearesthub: >
  Given a layer with source point and another one representing destination points, this algorithm computes the distance between each source point and the closest destination one.

  The resulting layer can contain only source points with an additional field indicating the distance to the nearest point and the name of the destination point, or lines linking each source point with its nearest destination point.

qgis:dropgeometries: >
  This algorithm removes any geometries from an input layer and returns a layer containing only the feature attributes.

qgis:dropmzvalues: >
  This algorithm can remove any measure (M) or Z values from input geometries.

qgis:eliminateselectedpolygons: >
  This algorithm combines selected polygons of the input layer with certain adjacent polygons by erasing their common boundary. The adjacent polygon can be either the one with the largest or smallest area or the one sharing the largest common boundary with the polygon to be eliminated. The selected features will always be eliminated whether the option "Use only selected features" is set or not.
  Eliminate is normally used to get rid of sliver polygons, i.e. tiny polygons that are a result of polygon intersection processes where boundaries of the inputs are similar but not identical.

qgis:explodelines: >
  This algorithm takes a lines layer and creates a new one in which each line is replaced by a set of lines representing the segments in the original line. Each line in the resulting layer contains only a start and an end point, with no intermediate nodes between them.

qgis:exportaddgeometrycolumns: >
  This algorithm computes geometric properties of the features in a vector layer. It generates a new vector layer with the same content as the input one, but with additional attributes in its attributes table, containing geometric measurements.

  Depending on the geometry type of the vector layer, the attributes added to the table will be different.

qgis:extendlines: >
  This algorithm extends line geometries by a specified amount at the start and end of the line. Lines are extended using the bearing of the first and last segment in the line.

qgis:extractbyattribute: >
  This algorithm creates a new vector layer that only contains matching features from an input layer. The criteria for adding features to the resulting layer is defined based on the values of an attribute from the input layer.

qgis:extractbyexpression: >
  This algorithm creates a new vector layer that only contains matching features from an input layer. The criteria for adding features to the resulting layer is based on a QGIS expression.

  For more information about expressions see the <a href ="{qgisdocs}/user_manual/working_with_vector/expression.html">user manual</a>

qgis:extractbylocation: >
  This algorithm creates a new vector layer that only contains matching features from an input layer. The criteria for adding features to the resulting layer is defined based on the spatial relationship between each feature and the features in an additional layer.

qgis:extractnodes: >
  This algorithm takes a line or polygon layer and generates a point layer with points representing the nodes in the input lines or polygons. The attributes associated to each point are the same ones associated to the line or polygon that the point belongs to.

  Additional fields are added to the nodes indicating the node index (beginning at 0), distance along original geometry and bisector angle of node for original geometry.

qgis:extractspecificnodes: >
  This algorithm takes a line or polygon layer and generates a point layer with points representing specific nodes in the input lines or polygons. For instance, this algorithm can be used to extract the first or last nodes in the geometry. The attributes associated to each point are the same ones associated to the line or polygon that the point belongs to.

  The node indices parameter accepts a comma separated string specifying the indices of the nodes to extract. The first node corresponds to an index of 0, the second node has an index of 1, etc. Negative indices can be used to find nodes at the end of the geometry, e.g., an index of -1 corresponds to the last node, -2 corresponds to the second last node, etc.

  Additional fields are added to the nodes indicating the specific node position (e.g., 0, -1, etc), the original node index, distance along the original geometry and bisector angle of node for the original geometry.

qgis:fieldcalculator: >
  This algorithm computes a new vector layer with the same features of the input layer, but with an additional attribute. The values of this new attribute are computed from each feature using a mathematical formula, based on the properties and attributes of the feature.

qgis:findprojection: >
  This algorithm allows creation of a shortlist of possible candidate coordinate reference systems for a layer with an unknown projection.

  The expected area which the layer should reside in must be specified via the target area parameter. Additionally, the coordinate reference system for this target area must also be set.

  The algorithm operates by testing the layer's extent in every known reference system and listing any in which the bounds would fall near the target area if the layer was in this projection.

qgis:fixeddistancebuffer: >
  This algorithm computes a buffer area for all the features in an input layer, using a fixed distance.

  The segments parameter controls the number of line segments to use to approximate a quarter circle when creating rounded offsets.

  The end cap style parameter controls how line endings are handled in the buffer.

  The join style parameter specifies whether round, miter or beveled joins should be used when offsetting corners in a line.

  The miter limit parameter is only applicable for miter join styles, and controls the maximum distance from the offset curve to use when creating a mitered join.

qgis:fixgeometries: >
  This algorithm attempts to create a valid representation of a given invalid geometry without losing any of the input vertices. Already-valid geometries are returned without further intervention. Always outputs multi-geometry layer.

  NOTE: M values will be dropped from the output.

qgis:frequencyanalysis: >
  This algorithm generates a table with frequency analysis of the values of a selected attribute from an input vector layer

qgis:geometrybyexpression: >
  This algorithm updates existing geometries (or creates new geometries) for input features by use of a QGIS expression. This allows complex geometry modifications which can utilize all the flexibility of the QGIS expression engine to manipulate and create geometries for output features.

  For help with QGIS expression functions, see the inbuilt help for specific functions which is available in the expression builder.

qgis:generatepointspixelcentroidsalongline:


qgis:generatepointspixelcentroidsinsidepolygons:


qgis:hublines:
  This algorithm creates hub and spoke diagrams with lines drawn from points on the Spoke Point layer to matching points in the Hub Point 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.

qgis:hypsometriccurves: >
  This algorithm computes hypsometric curves  for an input Digital Elevation Model. Curves are produced as table files in an output folder specified by the user.

qgis:importintospatialite: >
  This algorithm imports a vector layer into a SpatiaLite database, creating a new table.

qgis:importintopostgis: >
  This algorithm imports a vector layer into a PostGIS database, creating a new table.

  Prior to this a connection between QGIS and the PostGIS database has to be created (for example with the DB Manager).

qgis:intersection: >
  This algorithm extracts the overlapping portions of features in the Input and Intersect layers. Features in the Intersection layer are assigned the attributes of the overlapping features from both the Input and Intersect layers.

  Attributes are not modified.

qgis:joinattributesbylocation: >
  This algorithm takes an input vector layer and creates a new vector layer that is an extended version of the input one, with additional attributes in its attribute table.

  The additional attributes and their values are taken from a second vector layer. A spatial criteria is applied to select the values from the second layer that are added to each feature from the first layer in the resulting one.


qgis:joinattributestable: >
  This algorithm takes an input vector layer and creates a new vector layer that is an extended version of the input one, with additional attributes in its attribute table.

  The additional attributes and their values are taken from a second vector layer. An attribute is selected in each of them to define the join criteria.

qgis:keepnbiggestparts: >
  This algorithms takes a polygon layer and creates a new polygon layer in which multipart geometries have been removed, leaving only the n largest (in terms of area) parts.

qgis:lineintersections: >
  This algorithm creates point features where the lines in the Intersect layer intersect the lines in the Input layer.

  An ID field is specified for each of the input layers. Each point in the resulting layer will have the ID's of both input layers, allowing to identify them.

  If no Input Unique and Intersect Unique ID fields are specified then the point features are given the values of the last field (i.e. the last field/column in the attribute table) of the intersecting lines.

qgis:linestopolygons: >
  This algorithm generates a polygon layer using as polygon rings the lines from an input line layer.

  The attribute table of the output layer is the same as the one from of the input line layer.

qgis:listuniquevalues: >
  This algorithm generates a report with information about the categories found in a given attribute of a vector layer.

qgis:meanandstandarddeviationplot:


qgis:meancoordinates: >
  This algorithm 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  <Unique ID field> parameters, 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.

qgis:mergelines: >
  This algorithm joins all connected parts of MultiLineString geometries into single LineString geometries.

  If any parts of the input MultiLineString geometries are not connected, the resultant geometry will be a MultiLineString containing any lines which could be merged and any non-connected line parts.

qgis:mergevectorlayers: >
  This algorithm combines multiple vector layers of the same geometry type into a single one.

  If attributes tables are different, the attribute table of the resulting layer will contain the attributes from all input layers. New attributes will be added for the original layer name and source.

  The layers will all be reprojected to match the coordinate reference system of the first input layer.

qgis:multiparttosingleparts: >
  This algorithm takes a vector layer with multipart geometries and generates a new one in which all geometries contain a single part. Features with multipart geometries are divided in as many different features as parts the geometry contain, and the same attributes are used for each of them.

qgis:nearestneighbouranalysis: >
  This algorithm performs nearest neighbor analysis for a point layer.

  Output is generated as an html file with the computed statistical values.


qgis:numberofuniquevaluesinclasses: >
  This algorithm counts the different values that appear in a specified attributes for features of the same class.

  Classes are defined according to a given attribute. For all layers that share the same value of this attribute, the values of a second attribute are analyzed.

  The resulting layer contains the same features as the input layer, but with an additional attribute containing the count of unique values for that class.

qgis:offsetline: >
  This algorithm offsets lines by a specified distance. Positive distances will offset lines to the left, and negative distances will offset to the right of lines.

  The segments parameter controls the number of line segments to use to approximate a quarter circle when creating rounded offsets.

  The join style parameter specifies whether round, miter or beveled joins should be used when offsetting corners in a line.

  The miter limit parameter is only applicable for miter join styles, and controls the maximum distance from the offset curve to use when creating a mitered join.

qgis:orientedminimumboundingbox: >
  This algorithm takes a vector layer and generate a new one with the minimum rectangle that covers all the input features.

  As an alternative, the output layer can contain not just a single rectangle, but one for each input feature, representing the minimum rectangle that covers each of them.

qgis:orthogonalize: >
  This algorithm takes a line or polygon layer and attempts to orthogonalize all the geometries in the layer. This process shifts the nodes in the geometries to try to make every angle in the geometry either a right angle or a straight line.

  The angle tolerance parameter is used to specify the maximum deviation from a right angle or straight line a node can have for it to be adjusted. Smaller tolerances mean that only nodes which are already closer to right angles will be adjusted, and larger tolerances mean that nodes which deviate further from right angles will also be adjusted.

  The algorithm is iterative. Setting a larger number for the maximum iterations will result in a more orthogonal geometry at the cost of extra processing time.

qgis:pointonsurface: >
  Returns a point guaranteed to lie on the surface of a geometry.


qgis:pointsalonglines: >
  Creates points at regular intervals along line or polygon geometries. Created points will have new attributes added for the distance along the geometry and the angle of the line at the point.

  An optional start and end offset can be specified, which controls how far from the start and end of the geometry the points should be created.

qgis:pointsdisplacement:
  Offsets nearby point features by moving nearby points by a preset amount to minimize overlapping features.

qgis:pointslayerfromtable: >
  This algorithm generates a points layer based on the values from an input table.

  The table must contain a field with the X coordinate of each point and another one with the Y coordinate. A CRS for the output layer has to be specified, and the coordinates in the table are assumed to be expressed in the units used by that CRS.

  The attributes table of the resulting layer will be the input table.

qgis:pointstopath:
  Converts a point layer to a line layer, by joining points in a defined order.

  Points can be grouped by a field to output individual line features per group.

qgis:polarplot: >
  This algorithm generates a polar plot based on the value of an input vector layer.

  Two fields must be entered as parameters: one that define the category each feature two (to group features) and another one with the variable to plot (this has to be a numeric one)

qgis:poleofinaccessibility: >
  This algorithm calculates the pole of inaccessibility for a polygon layer, which is the most distant internal point from the boundary of the surface. This algorithm uses the 'polylabel' algorithm (Vladimir Agafonkin, 2016), which is an iterative approach guaranteed to find the true pole of inaccessibility within a specified tolerance (in layer units). More precise tolerances require more iterations and will take longer to calculate.

  The distance from the calculated pole to the polygon boundary will be stored as a new attribute in the output layer.

qgis:polygoncentroids: >
  This algorithm creates a new point layer, with points representing the centroid of polygons of an input layer.

  The attributes associated to each point in the output layer are the same ones associated to the original polygon.

  NOTE: This algorithm is deprecated and the generic "centroids" algorithm (which works for line and multi geometry layers) should be used instead.

qgis:polygonfromlayerextent: >
  This algorithm takes a vector layer and generates a new one with the minimum bounding box (rectangle with N-S orientation) that covers all the input features.

  As an alternative, the output layer can contain not just a single bounding box, but one for each input feature, representing the bounding box of each of them.

qgis:polygonfromrasterextent: >
  This algorithm takes a raster layer and generates a vector layer containing a feature with the minimum bounding box that covers the raster layer's extent.

qgis:polygonize:  >
  This algorithm takes a lines layer and creates a polygon layer, with polygons generated from the lines in the input layer.

qgis:polygonstolines: >
  This algorithm takes a polygon layer and creates a line layer, with lines representing the rings of the polygons in the input layer.

qgis:spatialiteexecutesql: >
  This algorithm performs a SQL database query on a SpatiaLite database.

qgis:postgisexecutesql: >
  This algorithm performs a SQL database query on a PostGIS database connected to QGIS.

qgis:randomextract: >
  This algorithm takes a vector layer and generates a new one that contains only a subset of the features in the input layer.

  The subset is defined randomly, using a percentage or count value to define the total number of features in the subset.

qgis:randomextractwithinsubsets: >
  This algorithm takes a vector layer and generates a new one that contains only a subset of the features in the input layer.

  The subset is defined randomly, using a percentage or count value to define the total number of features in the subset.

  The percentage/count value is not applied to the whole layer, but instead to each category. Categories are defined according to a given attribute, which is also specified as an input parameter for the algorithm.

qgis:randompointsalongline: >
  This algorithm creates a new point layer, with points placed in the lines of another layer.

  For each line in the input layer, a given number of points is added to the resulting layer. A minimum distance can be specified to avoid point being too close to each other.

qgis:randompointsinextent: >
  This algorithm creates a new point layer with a given number of random points, all of them within a given extent. A distance factor can be specified, to avoid points being too close to each other.

qgis:randompointsinlayerbounds: >
  This algorithm creates a new point layer with a given number of random points, all of them within the extent of a given layer. A distance factor can be specified, to avoid points being too close to each other.

qgis:randompointsinsidepolygonsfixed: >
  This algorithm creates a new point layer with random points inside the polygons of a given layer. The number of points in each polygon can be defined as a fixed count or as a density value, and it will be the same for all polygons.

qgis:randompointsinsidepolygonsvariable: >
  This algorithm creates a new point layer with random points inside the polygons of a given layer. The number of points in each polygon can be defined as a fixed count or as a density value. The count/density value is taken from an attribute, so it can be different for each polygon in the input layer.

qgis:randomselection: >
  This algorithm takes a vector layer and selects a subset of its features. No new layer is generated by this algorithm.

  The subset is defined randomly, using a percentage or count value to define the total number of features in the subset.

qgis:randomselectionwithinsubsets: >
  This algorithm takes a vector layer and selects a subset of its features. No new layer is generated by this algorithm.

  The subset is defined randomly, using a percentage or count value to define the total number of features in the subset.

  The percentage/count value is not applied to the whole layer, but instead to each category. Categories are defined according to a given attribute, which is also specified as an input parameter for the algorithm.

qgis:rastercalculator: >
  This algorithm allows performing algebraic operations using raster layers.

  The resulting layer will have its values computed according to an expression. The expression can contain numerical values, operators and references to any of the layers in the current project. The following functions are also supported:

  - sin(), cos(), tan(), atan2(), ln(), log10()

  The extent and cell size can be defined by the user. If the extent is not specified, the minimum extent that covers the input layers will be used. If the cell size is not specified, the minimum cell size of all input layers will be used.

  The cell size is assumed to be the same in both X and Y axes.

  Layers are referred by their name as displayed in the layer list and the number of the band to use (based on 1), using the pattern 'layer_name@band number'. For instance, the first band from a layer named DEM will be referred as DEM@1.

  When using the calculator in the batch interface or from the console, the files to use have to be specified. The corresponding layers are referred using the base name of the file (without the full path). For instance, if using a layer at path/to/my/rasterfile.tif, the first band of that layer will be referred as rasterfile.tif@1.

qgis:rasterlayerhistogram: >
  This algorithm generates a histogram with the values of a raster layer.

  The raster layer must have a single band.

qgis:rasterlayerstatistics: >
  This algorithm computes basic statistics from the values in a given band of the raster layer.

qgis:rasterize: >
  This algorithm rasterizes map canvas content.

  A map theme can be selected to render a predetermined set of layers with a defined style for each layer.

  Alternatively, a single layer can be selected if no map theme is set.

  If neither map theme nor layer is set, the current map content will be rendered.

  The minimum extent entered will internally be extended to be a multiple of the tile size.

qgis:refactorfields: >
  This algorithm allows editing the structure of the attributes table of a vector layer. Fields can be modified in their type and name, using a fields mapping.

  The original layer is not modified. A new layer is generated, which contains a modified attribute table, according to the provided fields mapping.

qgis:regularpoints:

qgis:removenullgeometries: >
  This algorithm removes any features which do not have a geometry from a vector layer. All other features will be copied unchanged.

qgis:reprojectlayer: >
  This algorithm reprojects a vector layer. It creates a new layer with the same features as the input one, but with geometries reprojected to a new CRS.

  Attributes are not modified by this algorithm.

qgis:saveselectedfeatures: >
  This algorithm creates a new layer with all the selected features in a given vector layer.

  If the selected layer has no selected features, all features will be added to the resulting feature.

qgis:selectbyattribute: >
  This algorithm creates a selection in a vector layer. The criteria for selected features is defined based on the values of an attribute from the input layer.

qgis:selectbyattributesum:


qgis:selectbyexpression: >
  This algorithm creates a selection in a vector layer. The criteria for selecting features is based on a QGIS expression.

  For more information about expressions see the <a href ="{qgisdocs}/user_manual/working_with_vector/expression.html">user manual</a>


qgis:selectbylocation: >
  This algorithm creates a selection in a vector layer. The criteria for selecting features is based on the spatial relationship between each feature and the features in an additional layer.

qgis:setmvalue: >
  This algorithm sets the M value for geometries in a layer.

  If M values already exist in the layer, they will be overwritten with the new value. If no M values exist, the geometry will be upgraded to include M values and the specified value used as the initial M value for all geometries.

qgis:setstyleforrasterlayer: >
  This algorithm sets the style of a raster layer. The style must be defined in a QML file.

qgis:setstyleforvectorlayer: >
  This algorithm sets the style of a vector layer. The style must be defined in a QML file.

qgis:setzvalue: >
  This algorithm sets the Z value for geometries in a layer.

  If Z values already exist in the layer, they will be overwritten with the new value. If no Z values exist, the geometry will be upgraded to include Z values and the specified value used as the initial Z value for all geometries.

qgis:simplifygeometries: >
  This algorithm simplifies the geometries in a line or polygon layer. It creates a new layer with the same features as the ones in the input layer, but with geometries containing a lower number of vertices.

  The algorithm gives a choice of simplification methods, including distance based (the "Douglas-Peucker" algorithm), area based ("Visvalingam" algorithm) and snapping geometries to grid.

qgis:singlepartstomultipart:


qgis:singlesidedbuffer: >
  This algorithm buffers lines by a specified distance on one side of the line only.

  The segments parameter controls the number of line segments to use to approximate a quarter circle when creating rounded buffers.

  The join style parameter specifies whether round, miter or beveled joins should be used when buffering corners in a line.

  The miter limit parameter is only applicable for miter join styles, and controls the maximum distance from the buffer to use when creating a mitered join.

qgis:smoothgeometry: >
  This algorithm smooths the geometries in a line or polygon layer. It creates a new layer with the same features as the ones in the input layer, but with geometries containing a higher number of vertices and corners in the geometries smoothed out.

  The iterations parameter dictates how many smoothing iterations will be applied to each geometry. A higher number of iterations results in smoother geometries with the cost of greater number of nodes in the geometries.

  The offset parameter controls how "tightly" the smoothed geometries follow the original geometries. Smaller values results in a tighter fit, and larger values will create a looser fit.

  The maximum angle parameter can be used to prevent smoothing of nodes with large angles. Any node where the angle of the segments to either side is larger than this will not be smoothed. For example, setting the maximum angle to 90 degrees or lower would preserve right angles in the geometry.

qgis:snapgeometries: >
  This algorithm snaps the geometries in a layer. Snapping can be done either to the geometries from another layer, or to geometries within the same layer.

  A tolerance is specified in layer units to control how close vertices need to be to the reference layer geometries before they are snapped.

  Snapping occurs to both nodes and edges. Depending on the snapping behavior, either nodes or edges will be preferred.

  Vertices will be inserted or removed as required to make the geometries match the reference geometries.

qgis:snappointstogrid: >
  This algorithm modifies the position of points in a vector layer, so they fall in the coordinates of a grid.

qgis:splitwithlines: >
  This algorithm splits the lines or polygons in one layer using the lines in another layer to define the breaking points. Intersection between geometries in both layers are considered as split points.

  Output will contain multi geometries for split features.

qgis:splitvectorlayer: >
  This algorithm takes a vector layer and an attribute and generates a set of vector layers in an output folder. Each of the layers created in that folder contains all features from the input layer with the same value for the specified attribute.

  The number of files generated is equal to the number of different values found for the specified attribute.

qgis:statisticsbycategories:


qgis:sumlinelengths: >
  This algorithm 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. The names of these two fields can be configured in the algorithm parameters.

qgis:symmetricaldifference: >
  This algorithm creates a layer containing features from both the Input and Difference layers but with the overlapping areas between the two layers removed. The attribute table of the Symmetrical Difference layer contains attributes from both the Input and Difference layers.


qgis:texttofloat: >
  This algorithm modifies the type of a given attribute in a vector layer, converting a text attribute containing numeric strings into a numeric attribute.

qgis:topologicalcoloring: >
  This algorithm assigns a color index to polygon features in such a way that no adjacent polygons share the same color index, whilst minimizing the number of colors required.

  An optional minimum distance between features assigned the same color can be set to prevent nearby (but non-touching) features from being assigned equal colors.

  The algorithm allows choice of method to use when assigning colors. The default method attempts to assign colors so that the count of features assigned to each individual color index is balanced.

  The 'by assigned area' mode instead assigns colors so that the total area of features assigned to each color is balanced. This mode can be useful to help avoid large features resulting in one of the colors appearing more dominant on a colored map.

  The 'by distance between colors' mode will assign colors in order to maximize the distance between features of the same color. This mode helps to create a more uniform distribution of colors across a map.

  A minimum number of colors can be specified if desired. The color index is saved to a new attribute named color_id.

qgis:translate: >
  This algorithm moves the geometries within a layer, by offsetting them with a specified x and y displacement.

qgis:truncatetable: >
  This algorithm truncates a layer, by deleting all features from within the layer.

  Warning - this algorithm modifies the layer in place, and deleted features cannot be restored!

qgis:union: >
  This algorithm creates a layer containing all the features from both input layers. In the case of polygon layers, separate features are created for overlapping and non-overlapping features. The attribute table of the union layer contains attribute values from the respective input layer for non-overlapping features, and attribute values from both input layers for overlapping features.


qgis:variabledistancebuffer: >
  This algorithm computes a buffer area for all the features in an input layer. The size of the buffer for a given feature is defined by an attribute, so it allows different features to have different buffer sizes.


qgis:vectorgrid:


qgis:vectorlayerhistogram: >
  This algorithm generates a histogram with the values of the attribute of a vector layer.

  The attribute to use for computing the histogram must be a numeric attribute.

qgis:vectorlayerscatterplot:


qgis:voronoipolygons: >
  This algorithm takes a points layer and generates a polygon layer containing the voronoi polygons corresponding to those input points.

qgis:zonalstatistics: