Getting the bounding box of labels with QgsLabelingEngine in PyQGIS

Question

I am trying to get the bounding box of my labels in a vector layer in PyQGIS (Version: 3.30.2-'s-Hertogenbosch) with the following script but I need to create a vector layer from a WKT file and not a GeoPackage file.

But here is my attempt to to render the labels with the source of the vector layer being a WKT file. Notice I am using a style file as well.

I am getting the following error - see Zero Results comment below: 'NoneType' object has no attribute 'allLabels' Why am I getting zero results for the labels with the WKT file but not using a GeoPackage file. Does a GeoPackage file contain more or different information that would effect this?

layer_name = 'MyLayer'
crs = QgsCoordinateReferenceSystem()
crs.createFromWkt(wkt)

layer = QgsVectorLayer('Point?crs=epsg:4326', layer_name, 'memory')
layer.setCrs(crs)
layer.startEditing()

# Add attribute field for label text
field_name = "Name"
field = QgsField(field_name, QVariant.String)
layer.addAttribute(field)

# Open the input file
with open(input_file, "r") as file:
    header = file.readline().strip().split("|")
    label_index = header.index(label_column)

    for line in file:
        values = line.strip().split("|")
        wkt = values[0]
        label = values[label_index]
        feature = QgsFeature()

        geometry = QgsGeometry.fromWkt(wkt)
        print(QgsWkbTypes.displayString(geometry.wkbType()))
        if geometry.wkbType() == QgsWkbTypes.Point:
            print(geometry.asPoint())

        feature.setGeometry(geometry)
        feature.setAttributes([label])
        layer.addFeature(feature)


print("Feature Count:", layer.featureCount())

if layer.isValid():

    QgsProject.instance().addMapLayer(layer)

    canvas = QgsMapCanvas()
    canvas.setLayers([layer])
    canvas.setExtent(layer.extent())

    layer_settings = QgsPalLayerSettings()
    layer_settings.fieldName = field_name

    layer_settings = QgsVectorLayerSimpleLabeling(layer_settings)
    layer.setLabelsEnabled(True)
    layer.setLabeling(layer_settings)

    map_settings = canvas.mapSettings()
    render = QgsMapRendererParallelJob(map_settings)
    render.start()
    render.waitForFinished()
    labeling_results = render.takeLabelingResults() # <== Zero Results
    # labels = labeling_results.allLabels()
    
    # if labels:
    #     for l in labels:
    #         if l.featureId == feature.id() and l.layerID == layer.id():
    #             geometry = l.labelGeometry

    for feature in layer.getFeatures():

        print("Dump features ...")
        attributes = feature.attributes()
        print("Feature ID:", feature.id())
        print("Geometry wkt:", feature.geometry().asWkt())
        print("Geometry alternate:", feature.geometry())

        label_field_name = layer.labeling().settings().fieldName
        print("Attributes:", attributes)
        for idx, attribute in enumerate(attributes):
            print(label_field_name + ":", attribute)
            print("------")

---

GeoPackage approach (this works!):

layer = QgsVectorLayer(layer_file, "my-layer", "ogr")

canvas = QgsMapCanvas()
canvas.setLayers([layer])
canvas.setExtent(layer.extent())

layer_settings = QgsPalLayerSettings()
layer_settings.fieldName = "name"

layer_settings = QgsVectorLayerSimpleLabeling(layer_settings)
layer.setLabelsEnabled(True)
layer.setLabeling(layer_settings)

map_settings = canvas.mapSettings()
render = QgsMapRendererParallelJob(map_settings)
render.start()
render.waitForFinished()

labeling_results = render.takeLabelingResults()
labels = labeling_results.allLabels()
print(labels)

if labels:
        for l in labels:
            print("label labelRect: ", l.labelRect)
            print("label labelText: ", l.labelText)
            print("label width: ", l.width)
            print("label height: ", l.height)
            geometry = l.labelGeometry
            print(geometry)
            label_bounding_box = geometry.boundingBox()  
            print("bounding box: ", label_bounding_box)
            print("bb center: ", label_bounding_box.center)
            print("bb x1: ", label_bounding_box.xMinimum)
            print("bb y1: ", label_bounding_box.yMinimum)
            print("bb x2: ", label_bounding_box.xMaximum)
            print("bb y2: ", label_bounding_box.yMaximum)

Answer 1

I'm assuming that label bounds can only be obtained after rendering. Rendering is performed for a specific location (extent) on the canvas.

The simplest way to get the bounds of the label from the current canvas is:

canvas = iface.mapCanvas()
labels = canvas.labelingResults().allLabels()
for l in labels:
    print(l.labelRect)

Here is a more complex example of getting label geometry. The "get_label_geometry" function independently renders each selected feature on the active layer and returns the geometry of its label.

In this example, rendering is performed at a scale of 20_000, the projection of the feature layer should be EPSG:4326.

In this example, we'll get the label geometry (in the layer's coordinate system) for all selected features, including those that are "outside" the current extent of the canvas.

def get_label_geometry(layer, feature):

    """returns the label geometry"""

    # GEOMETRY PROJECTION TRANSFORMATION OBJECTS
    # coordinate system of the current QGIS project
    map_crs = iface.mapCanvas().mapSettings().destinationCrs()
    # layer coordinate system (EPSG:4326)
    lyr_crs = QgsCoordinateReferenceSystem(4326)  
    # geometry to map projection
    to_map_crs = QgsCoordinateTransform(lyr_crs, map_crs, QgsProject.instance())
    # geometry to layer projection
    to_lyr_crs = QgsCoordinateTransform(map_crs, lyr_crs, QgsProject.instance())

    canvas = iface.mapCanvas()
    map_settings = canvas.mapSettings()
    zoom_scale = 20_000
    extent = feature.geometry().boundingBox()
    extent = to_map_crs.transformBoundingBox(extent)
    extent = map_settings.computeExtentForScale(extent.center(), zoom_scale)
    map_settings.setExtent(extent)
    render = QgsMapRendererParallelJob(map_settings)
    render.start()
    render.waitForFinished()
    render.cancel()
    labeling_results = render.takeLabelingResults()
    labels = labeling_results.allLabels()
    if labels:
        for l in labels:
            if l.featureId == feature.id() and l.layerID == layer.id():
                geometry = l.labelGeometry
                geometry.transform(to_lyr_crs)
                return geometry
                    
layer = iface.activeLayer()
features = layer.getSelectedFeatures()
for f in features:
    geom = get_label_geometry(layer, f)
    print(geom)

Answer 2

Here is a standalone script that worked well for me.

from qgis.core import (
    QgsApplication,
    QgsVectorLayer,
    QgsMapRendererParallelJob,
    QgsVectorLayerSimpleLabeling,
    QgsPalLayerSettings
)
from qgis.gui import QgsMapCanvas


qgis_path = "C:/Program Files/QGIS 3.30.1/"
QgsApplication.setPrefixPath(qgis_path, True)
qgs = QgsApplication([], False)
qgs.initQgis()

layer = QgsVectorLayer("D:/mus/test_points.gpkg", "НАЗВАНИЕ_СЛОЯ", "ogr")

canvas = QgsMapCanvas()
canvas.setLayers([layer])
canvas.setExtent(layer.extent())

layer_settings = QgsPalLayerSettings()
layer_settings.fieldName = "name"

layer_settings = QgsVectorLayerSimpleLabeling(layer_settings)
layer.setLabelsEnabled(True)
layer.setLabeling(layer_settings)

map_settings = canvas.mapSettings()
render = QgsMapRendererParallelJob(map_settings)
render.start()
render.waitForFinished()

labeling_results = render.takeLabelingResults()
labels = labeling_results.allLabels()
print(labels)

I find it more convenient to test this code in QGIS, as there you can use canvas.show() to see the style of the layer and its labels. And then transfer this code to a standalone script.