Merge pull request #28 from movingpandas/emeralds

Add Emeralds contributions

Author: anitagraser

README.md

@@ -2,18 +2,34 @@
 
 The Trajectools plugin adds trajectory analysis algorithms to the QGIS Processing toolbox. 
 
-![Trajectools screenshot](screenshots/trajectools.PNG)
-![Trajectools clipping screenshot](screenshots/trajectools2.PNG)
 
 
-**Note: This plugin depends on MovingPandas!** You will need to install MovingPandas in your QGIS Python environment. I recommend installing both QGIS and MovingPandas from conda-forge:
+## Requirements
+
+Trajectools requires [MovingPandas](https://github.com/movingpandas/movingpandas) (a Python library for movement data analysis) and optionally integrates [scikit-mobility](https://scikit-mobility.github.io/scikit-mobility/) and [gtfs_functions](https://github.com/Bondify/gtfs_functions). 
+
+The recommended way to install these dependencies is through conda/mamba:
 
 ```
 (base) conda create -n qgis -c conda-forge python=3.9 
 (base) conda activate qgis
-(qgis) mamba install -c conda-forge qgis movingpandas
+(qgis) mamba install -c conda-forge qgis movingpandas scikit-mobility
+(qgis) pip install gtfs_functions
 ```
 
-More details: https://anitagraser.com/2023/01/21/pyqgis-jupyter-notebooks-on-windows-using-conda/
+(More details: https://anitagraser.com/2023/01/21/pyqgis-jupyter-notebooks-on-windows-using-conda/)
+
+The Trajectools plugin can be installed directly in QGIS using the built-in Plugin Manager:
+
+![image](https://github.com/emeralds-horizon/UC3-traveltime-analytics/assets/590385/9f6cdb53-f2b3-4f2f-82cf-923d3b61341f)
 
+**Figure 1: QGIS Plugin Manager with Trajectools plugin installed.**
 
+
+
+## Examples
+
+The individual Trajectools algorithms are flexible and modular and can therefore be used on a wide array on input datasets, including, for example, the open [Microsoft Geolife dataset](http://research.microsoft.com/en-us/downloads/b16d359d-d164-469e-9fd4-daa38f2b2e13/) a [sample](https://github.com/emeralds-horizon/trajectools-qgis/tree/main/sample_data) of which is included in the plugin repo:
+
+![Trajectools screenshot](screenshots/trajectools.PNG)
+![Trajectools clipping screenshot](screenshots/trajectools2.PNG)

icons/skmob.png

@@ -1,7 +1,5 @@
 import sys
 
-from qgis.PyQt.QtCore import QCoreApplication
-
 sys.path.append("..")
 
 from .trajectoriesAlgorithm import TrajectoryManipulationAlgorithm

qgis_processing/createTrajectoriesAlgorithm.py

@@ -0,0 +1,253 @@
+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 GtfsShapesAlgorithm(QgsProcessingAlgorithm):
+    INPUT = "INPUT"
+    SPEED_OPTION = "SPEED"
+    OUTPUT = "OUTPUT"
+
+    def __init__(self):
+        super().__init__()
+
+    def name(self):
+        return "gtfs_shapes"
+
+    def displayName(self):
+        return self.tr("Extract shapes")
+
+    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 shapes from a GTFS ZIP file using "
+            "gtfs_functions.Feed.shapes</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(
+            QgsProcessingParameterFeatureSink(
+                name=self.OUTPUT,
+                description=self.tr("GTFS shapes"),
+                type=QgsProcessing.TypeVectorLine,
+            )
+        )
+
+    def processAlgorithm(self, parameters, context, feedback):
+        gtfs_file = self.parameterAsFile(parameters, self.INPUT, context)
+        (self.sink_shapes, self.dest_shapes) = self.parameterAsSink(
+            parameters,
+            self.OUTPUT,
+            context,
+            self.get_fields(),
+            QgsWkbTypes.LineStringM,
+            QgsCoordinateReferenceSystem("EPSG:4326"),
+        )
+
+        feed = Feed(gtfs_file)
+        segments = feed.shapes
+        for _, shape in segments.iterrows():
+            line = QgsGeometry.fromWkt(shape.geometry.wkt)
+            f = QgsFeature()
+            f.setGeometry(line)
+            attrs = [
+                shape.shape_id
+            ]
+            f.setAttributes(attrs)
+            self.sink_shapes.addFeature(f, QgsFeatureSink.FastInsert)
+
+        return {self.OUTPUT: self.dest_shapes}
+
+    def get_fields(self):
+        fields = QgsFields()
+        fields.append(QgsField("shape_id", QVariant.String))
+        return fields
+
+
+
+class GtfsSegmentsAlgorithm(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