Join a set of sequential points with individual line segments QGIS

Question

My data set contains radar plots for flights on approach to an airport. For each unique flight I have hundreds of points as they are recorded every four seconds. Using Points2One I can join the points to form individual flight lines for each unique flight. In using Points2One by its nature it only creates a single line and a single record entry in the attribute table hence I'm loosing the data granularity of altitude and speed at each four second segment of the flight. Is there a way that I can create a single flight path that is composed of individual line segments, where each individual line segement would have the same record identifier (Operation No) and attrbutes as either the starting or ending point node of that line segement.

Example radar plot data

So with the data sample I'd like to end up with eight line segments that all have the Operation No. 16173263 and each segment would have the time delay, Latitude, Lon, Altitude & Velocity attributes of the starting point.

The radar plots for a single day contain approximately 1200 different flights and over 100,000 data points.

I have no python or coding experience and so far all QGIS experience consists purely of using menu driven functions.

Operation No, Time Delay (seconds), Latitude, Longitude, Altitude (ft), Velocity (knots)    
16173263,0,42.005191,-81.987368,12444,0
16173263,1,42.003938,-81.986167,12418,328.5
16173263,5,41.999006,-81.981324,12303,326.6
16173263,9,41.994118,-81.976394,12182,326.6
16173263,13,41.989301,-81.971414,12054,324.6
16173263,17,41.98452,-81.966409,11919,322.7
16173263,21,41.979784,-81.961404,11778,320.7
16173263,25,41.975057,-81.956437,11637,320.7
16173263,29,41.970348,-81.95152,11490,318.8
16173264,0,41.512822,-82.082972,5331,0
16173264,3,41.513811,-82.078243,5266,258.5
16173264,7,41.515101,-82.071902,5180,258.5
16173264,11,41.516373,-82.065547,5105,258.5
16173264,15,41.517608,-82.059206,5036,258.5
16173264,19,41.518844,-82.052913,4970,256.6
16173264,23,41.520053,-82.04672,4905,252.7
16173264,27,41.521254,-82.040638,4846,246.9

Answer 1

Here's a python script to get the job done.

Before you use this you'll need to know a few things:

• This script creates a memory layer which means the layer is not saved until you right-click it in the layers panel and select save-as.
• In order for this script to work, you'll need to make sure that the layer name and attribute names match yours perfectly. I've put variables containing those up at the top so you can adjust. They are capital and whitespace sensitive.

To run this script, open the python window in Qgis:

Then open the editor:

And finally, paste in the script (or open it from a saved location) then hit run:

New Approach: The old script ran through the sample points in 0.51s, this new one runs through the sample points in 0.017s. It relies on getting the points from QGIS in the correct order to begin with rather then sorting them all into a dictionary. At any one time it only has to keep two points in memory instead of literally all of them.

# To avoid 'QVariant' is not defined error
from PyQt4.QtCore import *
import time

starttime = time.time()
# update these:
lyrName = 'test'
attributeList = [QgsField("Operation No", QVariant.String),
                        QgsField("Time Delay (seconds)", QVariant.Int),
                        QgsField("Latitude", QVariant.Double),
                        QgsField("Longitude", QVariant.Double),
                        QgsField("Altitude(ft)",QVariant.Double),
                        QgsField("Velocity(knots)",QVariant.Double)]
# get old layer
lyr = QgsMapLayerRegistry.instance().mapLayersByName(lyrName)[0]
# create new layer in memory to hold created lines
newLyr = QgsVectorLayer("LineString?crs=epsg:4326", "testPaths", "memory")
newProvider = newLyr.dataProvider()
# make sure field names are identical
newProvider.addAttributes(attributeList)
newLyr.updateFields()

# set up feature request so we get the features in the correct order
req = QgsFeatureRequest()
req.addOrderBy('"Operation No"')
req.addOrderBy('"Time Delay (seconds)"')

currentFeat = False
for nextFeat in lyr.getFeatures(req):
    if currentFeat:
        # we now have both current and next feature. Are they same operation?
        if nextFeat['Operation No'] == currentFeat['Operation No']:
            # if so create a line between them
            pLine = QgsGeometry.fromPolyline([currentFeat.geometry().asPoint(),nextFeat.geometry().asPoint()])
        else:
            # if not, both points in line from current Feature
            pLine = QgsGeometry.fromPolyline([currentFeat.geometry().asPoint(),currentFeat.geometry().asPoint()])
        newFeat = QgsFeature()
        newFeat.setGeometry(pLine)
        newFeat.setAttributes(currentFeat.attributes())
        newProvider.addFeatures([newFeat])
    currentFeat = nextFeat

# because we're always working with previous feature to iteratable
# we will miss the last feature so manually process it:
pLine = QgsGeometry.fromPolyline([currentFeat.geometry().asPoint(),currentFeat.geometry().asPoint()])
newFeat = QgsFeature()
newFeat.setGeometry(pLine)
newFeat.setAttributes(currentFeat.attributes())
newProvider.addFeatures([newFeat])

newLyr.updateExtents()
QgsMapLayerRegistry.instance().addMapLayer(newLyr)

endtime = time.time()
print 'done in {} seconds'.format(endtime - starttime)

---

The old approach:

# To avoid 'QVariant' is not defined error
from PyQt4.QtCore import *

# update these:
lyrName = 'test'
attributeList = [QgsField("Operation No", QVariant.String),
                        QgsField("Time Delay (seconds)", QVariant.Int),
                        QgsField("Latitude", QVariant.Double),
                        QgsField("Longitude", QVariant.Double),
                        QgsField("Altitude(ft)",QVariant.Double),
                        QgsField("Velocity(knots)",QVariant.Double)]

# get layer
lyr = QgsMapLayerRegistry.instance().mapLayersByName(lyrName)[0]

# load into dictionary:
# points {operation : { timedelay : point }}
operationDict = {}
for feat in lyr.getFeatures():
    if feat['Operation No'] in operationDict:
        operationDict[feat['Operation No']][feat['Time Delay (seconds)']] = feat
    else:
        operationDict[feat['Operation No']] = {feat['Time Delay (seconds)'] : feat}
# create new layer in memory to hold created lines
newLyr = QgsVectorLayer("LineString?crs=epsg:4326", "testPaths", "memory")
newProvider = newLyr.dataProvider()
# make sure field names are identical
newProvider.addAttributes(attributeList)
newLyr.updateFields()

# iterate over dictionary and add features to new layer.
for key in operationDict:
    op = operationDict[key]
    sortedTimes = sorted(op.iterkeys())
    print 'sortedTimes:'
    print sortedTimes
    for tstamp in sortedTimes:
        oldFeat = op[tstamp]
        tIndex = sortedTimes.index(tstamp)
        print 'time: {} index: {}'.format(tstamp,tIndex)
        # if not on the last one
        if tIndex + 1 < len(sortedTimes):
            nextFeat = op[sortedTimes[tIndex + 1]]
        else:
            # last feature, next geometry will just be itself
            nextFeat = oldFeat
        # build new feature
        print oldFeat.geometry().asPoint()
        print nextFeat.geometry().asPoint()
        pLine = QgsGeometry.fromPolyline([oldFeat.geometry().asPoint(),nextFeat.geometry().asPoint()])
        newFeat = QgsFeature()
        newFeat.setGeometry(pLine)
        newFeat.setAttributes(oldFeat.attributes())
        newProvider.addFeatures([newFeat])

newLyr.updateExtents()
QgsMapLayerRegistry.instance().addMapLayer(newLyr)

Some info on how the script works: First it sorts the points into a nested dictionary. A python dictionary is a list of key:value pairs. Like this: {'color:'red','model':'corvette'}. In this case we have {'operation': {time: point, time: point}}

That allows us to sort through them easily. Next, the script iterates over the operations (so each op is kept separate) and within the operation iterates over a sorted list of the points. For each point it checks if there's a 'next' point and if there is creates a line to it, saving to a new layer.

Answer 2

This thread was very useful for me - thought I would update based on 3.0 + release with a few changes required (I was using QGIS 3.2).

It is now PyQt5, not 4:

from PyQt5.QtCore import

QGSMaplayerRegistry has been replaced with QGSProject.instance()

lyr = QgsProject.instance().mapLayersByName(lyrName)[0]

QgsGeometry.fromPolyline has been replaced with the following:

QgsGeometry.fromPolylineXY