Aligning multiple points to line in QGIS?

Question

I would like to align multiple points to a line, or lines within a layer, using a specified tolerance or buffer around the line objects. Please refer to the sample sketch attached.

For the sake of this example, the points closest to the line in the BEFORE picture are within 5 map units of the line, while the outermost points are over 10 map units away. I would like to snap the closest points onto the nearest line, using a tolerance of 5 map units to achieve the result in the AFTER picture.

Answer 1

There's a built-in tool to do this in the (unreleased) QGIS 3.0 version. You can get a nightly snapshot from the QGIS website to test this in advance.

To do this:

1. Run the "Snap geometries to layer" processing algorithm
2. Select your points layer as the "input layer"
3. Select the line layer as the "reference layer"
4. Enter a suitable tolerance (maximum distance to move points while snapping)
5. Change the behavior to "Prefer closest point"

Here's the result, showing the original points as "x", and the snapped points as green dots. I've used a tolerance here so that only some of the input points are snapped.

Answer 2

This can be afforded with PyQGIS. For next situation:

following code, considering a tolerance of 5 map units, was ran at the Python Console of QGIS:

from math import sqrt

registry = QgsMapLayerRegistry.instance()

points = registry.mapLayersByName('points')
line = registry.mapLayersByName('line')

feat_points = [ feat for feat in points[0].getFeatures() ]
feat_line = line[0].getFeatures().next()

new_points = []

for feat in feat_points:
    pt = feat.geometry().asPoint()
    sqrdist, point, vertex = feat_line.geometry().closestSegmentWithContext(pt)
    if sqrt(sqrdist) <= 5:
        new_points.append(point)
    else:
        new_points.append(pt)

epsg = points[0].crs().postgisSrid()

uri = "Point?crs=epsg:" + str(epsg) + "&field=id:integer""&index=yes"

mem_layer = QgsVectorLayer(uri,
                           'new_points',
                           'memory')

prov = mem_layer.dataProvider()

feats = [ QgsFeature() for i in range(len(new_points)) ]

for i, feat in enumerate(feats):
    feat.setAttributes([i])
    feat.setGeometry(QgsGeometry.fromPoint(new_points[i]))

prov.addFeatures(feats)

QgsMapLayerRegistry.instance().addMapLayer(mem_layer)

It was produced a memory layer where points were snapped according to previously considered tolerance of 5 map units and a perpendicular path to the line.

Answer 3

You can also do this in the Field Calculator with the refFunctions plugin. You can use the Field Calculator to update a layer geometry as well as fields. refFunctions gives you a "geomdistance" function to find the nearest line within a given distance(or "geomnearest" if you don't want a threshold) and will return an attribute or the geometry, and the "closest_point" function will find the closest point on a given geometry. String them together like so to calculate new geometries for your point layer:

closest_point(geom_from_wkt(geomdistance('snap_lines','$geometry',10)) , $geometry)

Instead of directly updating the geometry you can calculate a field with the snapped geometry instead. I store multiple geometries for snapping culvert points to different stream layers and I can easily update the point geometry in the Field Calculator depending on whose stream lines I need to use.

There are some limitations with this, both layers need to be the the same CRS and the geomdistance function will give you an error if you have more than 100,000 points but you can change this limit if you edit refFunctions plugin file.