Add gtfs alg

Author: anitagraser

qgis_processing/gtfsAlgorithm.py

@@ -0,0 +1,154 @@
+import os
+import sys
+
+from qgis.PyQt.QtCore import QCoreApplication, QVariant
+from qgis.PyQt.QtGui import QIcon
+from qgis.core import (
+    QgsProcessing,
+    QgsProcessingAlgorithm,
+    QgsProcessingParameterFeatureSink,
+    QgsProcessingParameterFile,
+    QgsProcessingParameterField,
+    QgsProcessingUtils,
+    QgsCoordinateReferenceSystem,
+    QgsWkbTypes,
+    QgsProcessingParameterString,
+    QgsProcessingParameterBoolean,
+    QgsField,
+    QgsFields,
+    QgsFeature,
+    QgsGeometry,
+    QgsFeatureSink,
+)
+
+try:
+    from gtfs_functions import Feed
+except ImportError as error:
+    raise ImportError(
+        "Missing optional dependencies. To use the GTFS algorithms please "
+        "install gtfs_functions. For details see: "
+        "https://github.com/Bondify/gtfs_functions."
+    ) from error
+
+sys.path.append("..")
+
+from .qgisUtils import tc_from_pt_layer, feature_from_gdf_row, df_from_pt_layer
+
+pluginPath = os.path.dirname(__file__)
+
+
+class GtfsAlgorithm(QgsProcessingAlgorithm):
+    INPUT = "INPUT"
+    SPEED_OPTION = "SPEED"
+    OUTPUT = "OUTPUT"
+
+    def __init__(self):
+        super().__init__()
+
+    def name(self):
+        return "gtfs_segments"
+
+    def displayName(self):
+        return self.tr("Extract segments")
+
+    def group(self):
+        return self.tr("GTFS")
+
+    def groupId(self):
+        return "Gtfs"
+
+    def tr(self, text):
+        return QCoreApplication.translate("trajectools", text)
+
+    def helpUrl(self):
+        return "https://github.com/Bondify/gtfs_functions"
+
+    def shortHelpString(self):
+        return self.tr(
+            "<p>Extracts segments from a GTFS ZIP file using "
+            "gtfs_functions.Feed.segments</p>"
+            "<p>Optionally adds scheduled average speeds using"
+            "gtfs_functions.Feed.avg_speeds</p>"
+        )
+
+    def createInstance(self):
+        return type(self)()
+
+    def initAlgorithm(self, config=None):
+        self.addParameter(
+            QgsProcessingParameterFile(
+                name=self.INPUT,
+                description=self.tr("Input GTFS file"),
+            )
+        )
+        self.addParameter(
+            QgsProcessingParameterBoolean(
+                name=self.SPEED_OPTION,
+                description=self.tr("Add scheduled speeds"),
+            )
+        )
+        self.addParameter(
+            QgsProcessingParameterFeatureSink(
+                name=self.OUTPUT,
+                description=self.tr("GTFS segments"),
+                type=QgsProcessing.TypeVectorLine,
+            )
+        )
+
+    def processAlgorithm(self, parameters, context, feedback):
+        gtfs_file = self.parameterAsFile(parameters, self.INPUT, context)
+        add_avg_speed = self.parameterAsBool(parameters, self.SPEED_OPTION, context)
+        (self.sink_segments, self.dest_segments) = self.parameterAsSink(
+            parameters,
+            self.OUTPUT,
+            context,
+            self.get_fields(add_avg_speed),
+            QgsWkbTypes.LineStringM,
+            QgsCoordinateReferenceSystem("EPSG:4326"),
+        )
+
+        feed = Feed(gtfs_file)
+        segments = self.get_segments(feed, add_avg_speed)
+        for _, segment in segments.iterrows():
+            line = QgsGeometry.fromWkt(segment.geometry.wkt)
+            f = QgsFeature()
+            f.setGeometry(line)
+            attrs = [segment.shape_id, segment.route_id, segment.route_name, segment.direction_id, segment.stop_sequence, segment.segment_name,
+                     segment.start_stop_name, segment.end_stop_name, segment.segment_id, segment.start_stop_id, segment.end_stop_id, segment.distance_m]
+            if add_avg_speed:
+                attrs = attrs + [segment.window, segment.speed_kmh, segment.avg_route_speed_kmh, segment.segment_max_speed_kmh, segment.runtime_sec]
+            f.setAttributes(attrs)
+            self.sink_segments.addFeature(f, QgsFeatureSink.FastInsert)
+
+        return {self.OUTPUT: self.dest_segments}
+
+    def get_segments(self, feed, add_avg_speed=False):
+        if add_avg_speed:
+            segments = feed.avg_speeds
+        else: 
+            segments = feed.segments
+        return segments
+
+    def get_fields(self, add_avg_speed):
+        fields = QgsFields()
+        fields.append(QgsField("shape_id", QVariant.String))
+        fields.append(QgsField("route_id", QVariant.String))
+        fields.append(QgsField("route_name", QVariant.String))
+        fields.append(QgsField("direction_id", QVariant.String))
+        fields.append(QgsField("stop_sequence", QVariant.Int))
+        fields.append(QgsField("segment_name", QVariant.String))
+        fields.append(QgsField("start_stop_name", QVariant.String))
+        fields.append(QgsField("end_stop_name", QVariant.String))
+        fields.append(QgsField("segment_id", QVariant.String))
+        fields.append(QgsField("start_stop_id", QVariant.String))
+        fields.append(QgsField("end_stop_id", QVariant.String))
+        fields.append(QgsField("distance_m", QVariant.Double))
+        if add_avg_speed:
+            fields.append(QgsField("window", QVariant.String))
+            fields.append(QgsField("speed_kmh", QVariant.Double))
+            fields.append(QgsField("avg_route_speed_kmh", QVariant.Double))
+            fields.append(QgsField("segment_max_speed_kmh", QVariant.Double))
+            fields.append(QgsField("runtime_sec", QVariant.Double))
+        return fields
+
+

qgis_processing/qgisUtils.py

@@ -55,6 +55,7 @@ def tc_from_df(df, time_field_name, trajectory_id_field, crs):
         y="geom_y",
         t=time_field_name,
         crs=crs,
+        min_length=min_length
     )
     return tc
 

qgis_processing/trajectoolsProvider.py

@@ -20,6 +20,7 @@
 )
 from .extractPtsAlgorithm import ExtractODPtsAlgorithm, ExtractStopsAlgorithm
 from .privacyAttackAlgorithm import HomeWorkAttack
+from .gtfsAlgorithm import GtfsAlgorithm
 
 pluginPath = os.path.dirname(__file__)
 
@@ -62,6 +63,7 @@ def getAlgs(self):
             ExtractODPtsAlgorithm(),
             ExtractStopsAlgorithm(),
             HomeWorkAttack(),
+            GtfsAlgorithm(),
         ]
         return algs
 

qgis_processing/trajectoriesAlgorithm.py

@@ -12,6 +12,7 @@
     QgsProcessingUtils,
     QgsWkbTypes,
     QgsProcessingParameterString,
+    QgsProcessingParameterNumber,
     QgsField,
     QgsFields,
     QgsFeature,
@@ -39,6 +40,7 @@ class TrajectoriesAlgorithm(QgsProcessingAlgorithm):
     TRAJ_ID_FIELD = "TRAJ_ID_FIELD"
     TIMESTAMP_FIELD = "TIME_FIELD"
     SPEED_UNIT = "SPEED_UNIT"
+    MIN_LENGTH = "MIN_LENGTH"
 
     def __init__(self):
         super().__init__()
@@ -93,6 +95,15 @@ def initAlgorithm(self, config=None):
                 optional=False,
             )
         )
+        self.addParameter(
+            QgsProcessingParameterNumber(
+                name=self.MIN_LENGTH,
+                description=self.tr("Minimum trajectory length"),
+                defaultValue=0,
+                #optional=True,
+                minValue=0
+            )
+        )
 
     def create_df(self, parameters, context):
         self.prepare_parameters(parameters, context)
@@ -114,13 +125,16 @@ def prepare_parameters(self, parameters, context):
         self.speed_units = self.parameterAsString(
             parameters, self.SPEED_UNIT, context
         ).split("/")
+        self.min_length = self.parameterAsDouble(
+            parameters, self.MIN_LENGTH, context
+        )
 
     def create_tc(self, parameters, context):
         self.prepare_parameters(parameters, context)
         crs = self.input_layer.sourceCrs()
 
         tc = tc_from_pt_layer(
-            self.input_layer, self.timestamp_field, self.traj_id_field
+            self.input_layer, self.timestamp_field, self.traj_id_field, self.min_length
         )
 
         if len(tc.trajectories) < 1: