Class: QgsRuleBasedRenderer¶

Rule based renderer.

When drawing a vector layer with rule-based renderer, it goes through the rules and draws features with symbols from rules that match.

Class Hierarchy¶

Base classes¶

QgsFeatureRenderer

Abstract base class for all 2D vector feature renderers.

Methods

`rootRule`
`symbolForFeature`	Returns symbol for current feature.

Static Methods

`convertFromRenderer`	Creates a new `QgsRuleBasedRenderer` from an existing renderer.
`convertToDataDefinedSymbology`	helper function to convert the size scale and rotation fields present in some other renderers to data defined symbology
`create`	Creates a new rule-based renderer instance from XML
`createFromSld`	Creates a new rule based renderer from an SLD XML element.
`refineRuleCategories`	take a rule and create a list of new rules based on the categories from categorized symbol renderer
`refineRuleRanges`	take a rule and create a list of new rules based on the ranges from graduated symbol renderer
`refineRuleScales`	take a rule and create a list of new rules with intervals of scales given by the passed scale denominators

Attributes

`FeatDrawMarkers`
`FeatIsSelected`

class qgis.core.QgsRuleBasedRenderer[source]¶

Bases: QgsFeatureRenderer

__init__(root: QgsRuleBasedRenderer.Rule | None)

Constructs the renderer from given tree of rules (takes ownership)

Parameters:: root (Optional[QgsRuleBasedRenderer.Rule])

__init__(defaultSymbol: QgsSymbol | None)

Constructor for convenience. Creates a root rule and adds a default rule with symbol (takes ownership)

Parameters:: defaultSymbol (Optional[QgsSymbol])

FeatDrawMarkers = 2¶

FeatIsSelected = 1¶

class FeatureFlags¶: Bases: int

class FeatureToRender¶

Bases: object

Feature for rendering by a QgsRuleBasedRenderer. Contains a QgsFeature and some flags.

feat¶

class RenderJob¶

Bases: object

A QgsRuleBasedRenderer rendering job, consisting of a feature to be rendered with a particular symbol.

ftr¶: Feature to render

symbol¶: Symbol to render feature with (not owned by this object).

class RenderLevel¶

Bases: object

Render level: a list of jobs to be drawn at particular level for a QgsRuleBasedRenderer.

jobs¶: List of jobs to render, owned by this object.

zIndex¶

class Rule[source]¶

Bases: object

This class keeps data about a rules for rule-based renderer.

A rule consists of a symbol, filter expression and range of scales. If filter is empty, it matches all features. If scale range has both values zero, it matches all scales. If one of the min/max scale denominators is zero, there is no lower/upper bound for scales. A rule matches if both filter and scale range match.

QgsRuleBasedRenderer.Rule(symbol: Optional[QgsSymbol], maximumScale: int = 0, minimumScale: int = 0, filterExp: Optional[str] = ‘’, label: Optional[str] = ‘’, description: Optional[str] = ‘’, elseRule: bool = False) Constructor takes ownership of the symbol

Filtered = 0¶

Inactive = 1¶

class RenderResult¶: Bases: int

Rendered = 2¶

active(self) → bool[source]¶

Returns if this rule is active

Return type:: bool
Returns:: True if the rule is active

appendChild(self, rule: QgsRuleBasedRenderer.Rule | None)[source]¶

add child rule, take ownership, sets this as parent

Parameters:: rule (Optional[QgsRuleBasedRenderer.Rule])

children(self) → List[QgsRuleBasedRenderer.Rule]¶

Returns all children rules of this rule

Return type:: List[QgsRuleBasedRenderer.Rule]
Returns:: A list of rules

collectZLevels(self) → Any¶

Gets all used z-levels from this rule and children

Return type:: Any

static create(ruleElem: QDomElement, symbolMap: Any, reuseId: bool = True) → QgsRuleBasedRenderer.Rule | None[source]¶

Create a rule from an XML definition

Parameters:

ruleElem (QDomElement) – The XML rule element
symbolMap (Any) – Symbol map
reuseId (bool = True) – set to True to create an exact copy of the original symbol or False to create a new rule with the same parameters as the original but a new unique ruleKey(). (Since QGIS 3.30)

Return type:

Optional[QgsRuleBasedRenderer.Rule]

Returns:

A new rule

static createFromSld(element: QDomElement, geomType: Qgis.GeometryType) → QgsRuleBasedRenderer.Rule | None[source]¶

Create a rule from the SLD provided in element and for the specified geometry type.

Parameters:

element (QDomElement)
geomType (Qgis.GeometryType)

Return type:

Optional[QgsRuleBasedRenderer.Rule]

dependsOnScale(self) → bool[source]¶

Return type:: bool

descendants(self) → List[QgsRuleBasedRenderer.Rule][source]¶

Returns all children, grand-children, grand-grand-children, grand-gra… you get it

Return type:: List[QgsRuleBasedRenderer.Rule]
Returns:: A list of descendant rules

description(self) → str[source]¶

A human readable description for this rule

Return type:: str
Returns:: Description

filterExpression(self) → str[source]¶

A filter that will check if this rule applies

Return type:: str
Returns:: An expression

findRuleByKey(self, key: str | None) → QgsRuleBasedRenderer.Rule | None[source]¶

Try to find a rule given its unique key

Parameters:: key (Optional[str])
Return type:: Optional[QgsRuleBasedRenderer.Rule]

hasActiveChildren(self) → bool[source]¶

Returns True if the rule has any active children.

Note

Must be called after startRender()

Added in version 3.30.

Return type:: bool

initFilter(self)[source]¶

insertChild(self, i: int, rule: QgsRuleBasedRenderer.Rule | None)[source]¶

add child rule, take ownership, sets this as parent

Parameters:

i (int)
rule (Optional[QgsRuleBasedRenderer.Rule])

isElse(self) → bool[source]¶

Check if this rule is an ELSE rule

Return type:: bool
Returns:: True if this rule is an else rule

isFilterOK(self, f: QgsFeature, context: QgsRenderContext | None = None) → bool[source]¶

Check if a given feature shall be rendered by this rule

Parameters:

f (QgsFeature) – The feature to test
context (Optional[QgsRenderContext] = None) – The context in which the rendering happens

Return type:

bool

Returns:

True if the feature shall be rendered

isScaleOK(self, scale: float) → bool[source]¶

Check if this rule applies for a given scale. The scale value indicates the scale denominator, e.g. 1000.0 for a 1:1000 map. If set to 0, it will always return True.

Return type:: bool
Returns:: If the rule will be evaluated at this scale
Parameters:: scale (float)

label(self) → str[source]¶

Return type:: str

maximumScale(self) → float[source]¶

Returns the maximum map scale (i.e. most “zoomed in” scale) at which the rule will be active. The scale value indicates the scale denominator, e.g. 1000.0 for a 1:1000 map. A scale of 0 indicates no maximum scale visibility.

See also

minimumScale()

See also

setMaximumScale()

Return type:: float

minimumScale(self) → float[source]¶

Returns the minimum map scale (i.e. most “zoomed out” scale) at which the rule will be active. The scale value indicates the scale denominator, e.g. 1000.0 for a 1:1000 map. A scale of 0 indicates no minimum scale visibility.

See also

maximumScale()

See also

setMinimumScale()

Return type:: float

needsGeometry(self) → bool[source]¶

Returns True if this rule or one of its children needs the geometry to be applied.

Return type:: bool

parent(self) → QgsRuleBasedRenderer.Rule | None[source]¶

The parent rule

Return type:: Optional[QgsRuleBasedRenderer.Rule]
Returns:: Parent rule

removeChild(self, rule: QgsRuleBasedRenderer.Rule | None)[source]¶

delete child rule

Parameters:: rule (Optional[QgsRuleBasedRenderer.Rule])

removeChildAt(self, i: int)[source]¶

delete child rule

Parameters:: i (int)

ruleKey(self) → str[source]¶

Unique rule identifier (for identification of rule within renderer)

Return type:: str

rulesForFeature(self, feature: QgsFeature, context: QgsRenderContext | None = None, onlyActive: bool = True) → List[QgsRuleBasedRenderer.Rule][source]¶

Returns the list of rules used to render the feature in a specific context.

Parameters:

feature (QgsFeature) – The feature for which rules have to be find
context (Optional[QgsRenderContext] = None) – The rendering context
onlyActive (bool = True) – True to search for active rules only, False otherwise

Return type:

List[QgsRuleBasedRenderer.Rule]

setActive(self, state: bool)[source]¶

Sets if this rule is active

Parameters:: state (bool) – Determines if the rule should be activated or deactivated

setDescription(self, description: str | None)[source]¶

Set a human readable description for this rule

Parameters:: description (Optional[str]) – Description

setFilterExpression(self, filterExp: str | None)[source]¶

Set the expression used to check if a given feature shall be rendered with this rule

Parameters:: filterExp (Optional[str]) – An expression

setIsElse(self, iselse: bool)[source]¶

Sets if this rule is an ELSE rule

Parameters:: iselse (bool) – If True, this rule is an ELSE rule

setLabel(self, label: str | None)[source]¶

Parameters:: label (Optional[str])

setMaximumScale(self, scale: float)[source]¶

Sets the maximum map scale (i.e. most “zoomed in” scale) at which the rule will be active. The scale value indicates the scale denominator, e.g. 1000.0 for a 1:1000 map. A scale of 0 indicates no maximum scale visibility.

See also

maximumScale()

See also

setMinimumScale()

Parameters:: scale (float)

setMinimumScale(self, scale: float)[source]¶

Sets the minimum map scale (i.e. most “zoomed out” scale) at which the rule will be active. The scale value indicates the scale denominator, e.g. 1000.0 for a 1:1000 map. A scale of 0 indicates no minimum scale visibility.

See also

minimumScale()

See also

setMaximumScale()

Parameters:: scale (float)

setRuleKey(self, key: str | None)[source]¶

Override the assigned rule key (should be used just internally by rule-based renderer)

Parameters:: key (Optional[str])

setSymbol(self, sym: QgsSymbol | None)[source]¶

Sets a new symbol (or None). Deletes old symbol.

Parameters:: sym (Optional[QgsSymbol])

symbol(self) → QgsSymbol | None[source]¶

Return type:: Optional[QgsSymbol]

takeChild(self, rule: QgsRuleBasedRenderer.Rule | None) → QgsRuleBasedRenderer.Rule | None[source]¶

take child rule out, set parent as None

Parameters:: rule (Optional[QgsRuleBasedRenderer.Rule])
Return type:: Optional[QgsRuleBasedRenderer.Rule]

takeChildAt(self, i: int) → QgsRuleBasedRenderer.Rule | None[source]¶

take child rule out, set parent as None

Parameters:: i (int)
Return type:: Optional[QgsRuleBasedRenderer.Rule]

static convertFromRenderer(renderer: QgsFeatureRenderer | None, layer: QgsVectorLayer | None = None) → QgsRuleBasedRenderer | None[source]¶

Creates a new QgsRuleBasedRenderer from an existing renderer.

Since QGIS 3.20, the optional layer parameter is required for conversions of some renderer types.

Return type:

Optional[QgsRuleBasedRenderer]

Returns:

a new renderer if the conversion was possible, otherwise None.

Parameters:

renderer (Optional[QgsFeatureRenderer])
layer (Optional[QgsVectorLayer] = None)

static convertToDataDefinedSymbology(symbol: QgsSymbol | None, sizeScaleField: str | None, rotationField: str | None = '')[source]¶

helper function to convert the size scale and rotation fields present in some other renderers to data defined symbology

Parameters:

symbol (Optional[QgsSymbol])
sizeScaleField (Optional[str])
rotationField (Optional[str] = '')

static create(element: QDomElement, context: QgsReadWriteContext) → QgsFeatureRenderer | None[source]¶

Creates a new rule-based renderer instance from XML

Parameters:

element (QDomElement)
context (QgsReadWriteContext)

Return type:

Optional[QgsFeatureRenderer]

static createFromSld(element: QDomElement, geomType: Qgis.GeometryType) → QgsFeatureRenderer | None[source]¶

Creates a new rule based renderer from an SLD XML element.

Parameters:

element (QDomElement)
geomType (Qgis.GeometryType)

Return type:

Optional[QgsFeatureRenderer]

static refineRuleCategories(initialRule: QgsRuleBasedRenderer.Rule | None, r: QgsCategorizedSymbolRenderer | None)[source]¶

take a rule and create a list of new rules based on the categories from categorized symbol renderer

Parameters:

initialRule (Optional[QgsRuleBasedRenderer.Rule])
r (Optional[QgsCategorizedSymbolRenderer])

static refineRuleRanges(initialRule: QgsRuleBasedRenderer.Rule | None, r: QgsGraduatedSymbolRenderer | None)[source]¶

take a rule and create a list of new rules based on the ranges from graduated symbol renderer

Parameters:

initialRule (Optional[QgsRuleBasedRenderer.Rule])
r (Optional[QgsGraduatedSymbolRenderer])

static refineRuleScales(initialRule: QgsRuleBasedRenderer.Rule | None, scales: Iterable[int])[source]¶

take a rule and create a list of new rules with intervals of scales given by the passed scale denominators

Parameters:

initialRule (Optional[QgsRuleBasedRenderer.Rule])
scales (Iterable[int])

rootRule(self) → QgsRuleBasedRenderer.Rule | None[source]¶

Return type:: Optional[QgsRuleBasedRenderer.Rule]

symbolForFeature(self, feature: QgsFeature, context: QgsRenderContext) → QgsSymbol | None[source]¶

Returns symbol for current feature. Should not be used individually: there could be more symbols for a feature

Parameters:

feature (QgsFeature)
context (QgsRenderContext)

Return type:

Optional[QgsSymbol]