Labeling count points within dissolved buffers in QGIS

Question

I am using the following expression to visualize with a buffer, the nearest neighbors at a given distance:

case when

distance(
  $geometry,
  array_get(
    overlay_nearest(
      layer:=@layer,
      expression:=$geometry,
      limit:=2
    ),
    1
  )
)<0.9

then

with_variable(
    'dista',
        distance(
          $geometry,
          array_get(
            overlay_nearest(
              layer:=@layer,
              expression:=$geometry,
              limit:=2
            ),
            1
          )
),
    collect_geometries (
        array_foreach (
                overlay_nearest(
                    @layer,
                    $geometry,
                    limit:=1
                ),
            buffer(@element,@dista/1)
        )
    )
)

end

Screenshot:

I have developed this expression from the solutions presented by user Babel in the questions Clustering vectorpoints and Dissolve buffers if the intersection/overlap is greater than 50%.

My goal is to label count points within dissolved buffers.

Here is a handmade screenshot of the expected idea of counting points within dissolved buffers:

Implementing the solution proposed by user Babel:

For the label, I have adapted the constant buffer radius to a variable buffer radius according to distance:

case when 

distance(
  $geometry,
  array_get(
    overlay_nearest(
      layer:=@layer,
      expression:=$geometry,
      limit:=2
    ),
    1
  )
)<0.9

then 

with_variable(
    'radius',
    0.45,  -- change buffer size here
    array_length( 
        array_agg( 
            $id,
            group_by:= array_foreach (
                generate_series (
                    0,
                    array_length(
                        geometries_to_array( 
                            buffer (
                                collect(
                                    buffer ($geometry, @radius)
                                ),
                                0
                            )
                        )
                    )-1
                ),
                intersects (
                    $geometry,  
                    geometries_to_array( 
                        buffer (
                            collect(
                                buffer ($geometry, @radius)
                            ),
                            0
                        )
                    )[@element]
                )
            )
        )
    )
)
end

For the label placement properties (avoid text repetitions), I do something messy (copy/paste the same expression and injecting the centroid function):

with_variable(
    'radius',
    0.45,  -- change buffer size here
centroid (
        collect(
            $geometry,
            group_by:= array_foreach (
                generate_series (
                    0,
                    array_length(
                        geometries_to_array(
                            buffer (
                                collect(
                                    buffer ($geometry, @radius)
                                ),
                                0
                            )
                        )
                    )-1
                ),
                intersects (
                    $geometry,  
                    geometries_to_array(
                        buffer (
                            collect(
                                buffer ($geometry, @radius)
                            ),
                            0
                        )
                    )[@element]
                )
            )
        )
        )  
)

At the beginning the objective is achieved, but now the problem is the expression performance. For a layer with 57 points geometry, the labeling and the placement expressions needs 3 minutes to finish with an i7 processor (32GB RAM). I think it is too long for a layer with little information.

I would like, if possible, to ask for optimize a little more the efficiency of the first solution.

Answer 1

This isn't a complete answer but might provide you or others some ideas to combine with other suggestions.

Considerations:

• Assumes you are OK with clustering algorithm approach (not necessarily same as nearest neighbour)

• You need to forego a dynamic expression for clustering (which will significantly increase complexity and processing speed - I'm not aware of any way to do it in QGIS other than importing your data to PostGIS and using the ST_ClusterDBScan() function)

• This is an alternative to Babel's dissolved buffer tool approach, still uses a processing tool with a static result but lets you change buffer size on the fly

---

1. Use the DBSCAN clustering tool in the Processing Toolbox and set your maximum distance (0.9 metres?) and minimum cluster size (2). Your result is the same layer but with new columns CLUSTER_ID and CLUSTER_SIZE. If you want, use the Categorised symbology by CLUSTER_ID to check that the clusters are defined as expected.

2. Create a geometry generator symbol with Polygon geometry type and generate your buffer with the appropriate expression:

• static 100m buffer, merged by CLUSTER_ID: buffer(collect($geometry,"cluster_id"),100)
• dynamic buffer based on distance to closest feature, merged by CLUSTER_ID: buffer(collect(buffer($geometry,distance($geometry,overlay_nearest(@layer,$geometry)[0])),"cluster_id"),0)

3. To limit symbol generation to only one feature per cluster, and excluding points not in a cluster at all, use a data-defined override for Enable symbol layer with the following expression: "cluster_size" is not null and $id = array_agg($id,"cluster_id")[0]

4. Set CLUSTER_SIZE as your label expression, and under Placement > Geometry generator, use the same expression in step 2 and select Geometry type as Polygon. You can configure your label placement like it's in a polygon (e.g. placement mode Outside polygons, Offset from centroid, etc.)

5. To limit label generation to one feature per cluster, go to label Rendering > Show label and use the following expression: $id = array_agg($id,"cluster_id")[0]

---

Result (clusters generated with max 10m distance):

5m buffer:

Dynamic buffer:

Answer 2

What is a bit tricky: expressions work on a per-feature basis, so there is no direct way to only label the dissolved buffer (and any indirect way would be too complicated for the task, an overkill). You can, however, label each point with the number of points inside the same buffer using the following expression. For other options, see my other solution.

Points labeled with the expression - red dissolved buffers just for visualisation purpose:

with_variable(
    'radius',
    50,  -- change buffer size here
    array_length( 
        array_agg( 
            $id,
            group_by:= array_foreach (
                generate_series (
                    0,
                    array_length(
                        geometries_to_array( 
                            buffer (
                                collect(
                                    buffer ($geometry, @radius)
                                ),
                                0
                            )
                        )
                    )-1
                ),
                intersects (
                    $geometry,  
                    geometries_to_array( 
                        buffer (
                            collect(
                                buffer ($geometry, @radius)
                            ),
                            0
                        )
                    )[@element]
                )
            )
        )
    )
)

Answer 3

If you want indeed to create one label per buffer, it is easier to indeed create dissolved buffers with the box Keep disjoint features separate checked to get one separate feature per "cluster". Then use this expression on the buffer layer to count points inside each buffer:

array_length(overlay_contains('points',$id))