[GIS] Create mid point from line layer

distancelinepointpoints-to-lineqgis

In QGIS I am trying to create a new point layer based on the mid point of a line layer (and keep all the feature attributes in the table).

For example, one line feature becomes one point, located on the mid/center point of the line. Points to lines only seems to work on nodes, and Create points along lines only seems to work at fixed distances?

Best Answer

If python is Ok for you, you can easily do that with that code snippet. Copy/paste this code in the editor of the python console, select your line layer and run the script!

layer = iface.activeLayer()

temp = QgsVectorLayer("Point?crs=epsg:2154", "result", "memory")
temp.startEditing()

attrs = layer.dataProvider().fields().toList()
temp_prov = temp.dataProvider()
temp_prov.addAttributes(attrs)
temp.updateFields()

for elem in layer.getFeatures():
    feat = QgsFeature()
    geom = elem.geometry().interpolate(elem.geometry().length()/2)
    feat.setGeometry(geom)
    feat.setAttributes(elem.attributes())
    temp.addFeatures([feat])
    temp.updateExtents()

temp.commitChanges()
QgsMapLayerRegistry.instance().addMapLayer(temp)

This code also take care about keeping the attributes of the line Layer. Here is my result on a set of line :

Related Solutions

[GIS] Length of line on specific point (from point layer)

NOTE I edited the code because the questioner preferred to choose the track and the points he wanted to measure. The update in the code is the possibility to create a number of point output layers equal to the number of the line features but, if selected in the main dialog, this number could be lower.

I propose a solution using PyQGIS. My idea was creating a certain number of temporary points along the line and then using the nearest neighbor of them from each point of the input points (i.e. your Blackpoints) for measuring the distance from the start/end of the line.

Before posting the code, I need to do some remarks:

in addition to the point layer and the line layer, my solution requires an additional parameter, called step, which is simply the spatial interval for the creation of the temporary points (remember that the accuracy of the result heavily depend from this parameter!);
all the distances are calculated from the nearest neighbor of each Blackpoint to the start/end of the line (this means that the distance between the Blackpoint and its nearest neighbor is NOT evaluated, but I can immediately and easily add it to the code if needed).

The code will return a point memory layer which stores the same geometries and attributes of the input layer, plus two additional fields:

"DIST_START", which stores the distance from the start of the line;
"DIST_END", which stores the distance from the end of the line.

This is the code:

##Points=vector point
##Only_use_selected_points=boolean False
##Line=vector line
##Only_use_selected_lines=boolean False
##step=number 1

from qgis.core import *
from qgis.PyQt.QtCore import QVariant

layer1 = processing.getObject(Points)
crs = layer1.crs().toWkt()
layer2 = processing.getObject(Line)

if Only_use_selected_lines:
    line_feats = layer2.selectedFeatures()
else:
    line_feats = layer2.getFeatures()

for ft in line_feats:
    index = QgsSpatialIndex()
    tmp_points = {}
    line_geom = ft.geometry()
    len = line_geom.length()
    current = 0

    # This layer contains all the points created along the line (it isn't an output)
    temp_pts = QgsVectorLayer('Point?crs='+ crs, 'temp_pts' , 'memory')
    prov = temp_pts.dataProvider()
    # Uncomment the next line if you want to see the 'temp_pts' layer
    #QgsMapLayerRegistry.instance().addMapLayer(temp_pts)

    while current < len:
        point = line_geom.interpolate(current) # Create a point along the line at the current distance
        fet = QgsFeature()
        fet.setGeometry(point)
        (result, feat) = prov.addFeatures([fet])
        tmp_points[feat[0].id()] = current
        index.insertFeature(feat[0])
        current += step # Increase the distance by the step provided

    # This layer is the final output which stores the distances from the closest point along the line and the start/end of the line
    out = 'output_%s' % (ft.id())
    output = QgsVectorLayer('Point?crs='+ crs, out, 'memory') 
    prov2 = output.dataProvider()
    fields = layer1.pendingFields() # Fields from the input layer
    fields.append(QgsField('DIST_START', QVariant.Double, '', 10, 3)) # Name for the new field in the output layer
    fields.append(QgsField('DIST_END', QVariant.Double, '', 10, 3)) # Name for the new field in the output layer
    prov2.addAttributes(fields) # Add input layer fields to the outLayer
    output.updateFields()

    if Only_use_selected_points:
        point_feats = layer1.selectedFeatures()
    else:
        point_feats = layer1.getFeatures()

    for feat in point_feats:
        geom = feat.geometry()
        attrs = feat.attributes()
        nearest = index.nearestNeighbor(geom.asPoint(), 1)
        dist_start = tmp_points[nearest[0]]
        attrs.append(dist_start)
        dist_end = len - tmp_points[nearest[0]]
        attrs.append(dist_end)
        outGeom = QgsFeature()
        outGeom.setGeometry(geom)
        outGeom.setAttributes(attrs)
        prov2.addFeatures([outGeom])

    # Add the 'output' layer to the Layers panel
    QgsMapLayerRegistry.instance().addMapLayer(output)

Now let's give an example. Starting from these sample layers (14 points, the line has a length of about 16 km) and using a step of 1 m:

I obtain this point layer:

with this Attribute Table (the values are expressed in meters):

Best Answer

Related Solutions

[GIS] Length of line on specific point (from point layer)

Related Question