From 38d33482109e960c42a0c15090c6641fe1d41e62 Mon Sep 17 00:00:00 2001 From: Kufre Date: Tue, 30 Jun 2020 11:47:02 -0400 Subject: [PATCH 01/14] Use network.sourceCrs() for analysis rather than context.project().crs() for all iso-area algorithms --- algs/IsoAreaAsContoursFromLayer.py | 47 ++++++++++++------------- algs/IsoAreaAsInterpolationFromLayer.py | 43 +++++++++++----------- 2 files changed, 44 insertions(+), 46 deletions(-) diff --git a/algs/IsoAreaAsContoursFromLayer.py b/algs/IsoAreaAsContoursFromLayer.py index bbd301c..401f938 100644 --- a/algs/IsoAreaAsContoursFromLayer.py +++ b/algs/IsoAreaAsContoursFromLayer.py @@ -3,10 +3,10 @@ *************************************************************************** IsoAreaAsContourFromLayer.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : February 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -88,13 +88,13 @@ def group(self): def groupId(self): return 'isoareas' - + def name(self): return 'isoareaascontoursfromlayer' def displayName(self): return self.tr('Iso-Area as Contours (from Layer)') - + def shortHelpString(self): return "General:
"\ "This algorithm implements iso-area contours to return the isochrone areas for a maximum cost level and interval levels on a given network dataset for a layer of points.
"\ @@ -108,7 +108,7 @@ def shortHelpString(self): "Output:
"\ "The output of the algorithm are two layers:"\ "" - + def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -126,7 +126,7 @@ def initAlgorithm(self, config=None): ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - + self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), @@ -199,7 +199,7 @@ def initAlgorithm(self, config=None): self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT_INTERPOLATION, self.tr('Output Interpolation'))) self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT_CONTOURS, self.tr('Output Contours'), QgsProcessing.TypeVectorLine)) - + def processAlgorithm(self, parameters, context, feedback): feedback.pushInfo(self.tr("[QNEAT3Algorithm] This is a QNEAT3 Algorithm: '{}'".format(self.displayName()))) network = self.parameterAsSource(parameters, self.INPUT, context) #QgsProcessingFeatureSource @@ -221,47 +221,46 @@ def processAlgorithm(self, parameters, context, feedback): tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context) #float output_path = self.parameterAsOutputLayer(parameters, self.OUTPUT_INTERPOLATION, context) #string - analysisCrs = context.project().crs() - input_coordinates = getListOfPoints(startPoints) - + analysisCrs = network.sourceCrs() + input_coordinates = getListOfPoints(startPoints) + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - + list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints(list_apoints, max_dist+(max_dist*0.1)) feedback.setProgress(50) - + uri = "Point?crs={}&field=vertex_id:int(254)&field=cost:double(254,7)&field=origin_point_id:string(254)&index=yes".format(analysisCrs.authid()) - + iso_pointcloud_layer = QgsVectorLayer(uri, "iso_pointcloud_layer", "memory") iso_pointcloud_provider = iso_pointcloud_layer.dataProvider() iso_pointcloud_provider.addFeatures(iso_pointcloud, QgsFeatureSink.FastInsert) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Interpolation-Raster using QGIS TIN-Interpolator...") net.calcIsoTinInterpolation(iso_pointcloud_layer, cell_size, output_path) feedback.setProgress(70) - + fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 254, 0)) fields.append(QgsField('cost_level', QVariant.Double, '', 20, 7)) - + (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT_CONTOURS, context, fields, QgsWkbTypes.LineString, network.sourceCrs()) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Contours using numpy and matplotlib...") contour_featurelist = net.calcIsoContours(max_dist, interval, output_path) feedback.setProgress(90) - + sink.addFeatures(contour_featurelist, QgsFeatureSink.FastInsert) - + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") feedback.setProgress(100) - + results = {} results[self.OUTPUT_INTERPOLATION] = output_path results[self.OUTPUT_CONTOURS] = dest_id return results - diff --git a/algs/IsoAreaAsInterpolationFromLayer.py b/algs/IsoAreaAsInterpolationFromLayer.py index 9603886..1ee4eac 100644 --- a/algs/IsoAreaAsInterpolationFromLayer.py +++ b/algs/IsoAreaAsInterpolationFromLayer.py @@ -3,10 +3,10 @@ *************************************************************************** IsoAreaAsInterpolationFromLayer.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : March 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -81,13 +81,13 @@ def group(self): def groupId(self): return 'isoareas' - + def name(self): return 'isoareaasinterpolationfromlayer' def displayName(self): return self.tr('Iso-Area as Interpolation (from Layer)') - + def shortHelpString(self): return "General:
"\ "This algorithm implements iso-area analysis to return the network-distance interpolation for a maximum cost level on a given network dataset for a layer of points.
"\ @@ -101,8 +101,8 @@ def shortHelpString(self): "Output:
"\ "The output of the algorithm is one layer:"\ "" - - + + def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -120,7 +120,7 @@ def initAlgorithm(self, config=None): ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - + self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), @@ -186,7 +186,7 @@ def initAlgorithm(self, config=None): for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(p) - + self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Output Interpolation'))) def processAlgorithm(self, parameters, context, feedback): @@ -209,34 +209,33 @@ def processAlgorithm(self, parameters, context, feedback): tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context) #float output_path = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) - analysisCrs = context.project().crs() + analysisCrs = network.sourceCrs() input_coordinates = getListOfPoints(startPoints) - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") - feedback.setProgress(10) + feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - + list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints(list_apoints, max_dist) feedback.setProgress(70) - + uri = "Point?crs={}&field=vertex_id:int(254)&field=cost:double(254,7)&field=origin_point_id:string(254)&index=yes".format(analysisCrs.authid()) - + iso_pointcloud_layer = QgsVectorLayer(uri, "iso_pointcloud_layer", "memory") iso_pointcloud_provider = iso_pointcloud_layer.dataProvider() iso_pointcloud_provider.addFeatures(iso_pointcloud, QgsFeatureSink.FastInsert) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Interpolation-Raster using QGIS TIN-Interpolator...") net.calcIsoTinInterpolation(iso_pointcloud_layer, cell_size, output_path) feedback.setProgress(99) - + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") - feedback.setProgress(100) - + feedback.setProgress(100) + results = {} results[self.OUTPUT] = output_path return results - From f94e5befec39d7b0dfbd4efaf833e3dc041c578d Mon Sep 17 00:00:00 2001 From: Kufre Date: Tue, 30 Jun 2020 12:27:50 -0400 Subject: [PATCH 02/14] Allowing the unique point identifier fields in OD Matrix to use the original data types of the input points and target points --- algs/OdMatrixFromLayersAsLines.py | 68 +++++++++++++++---------------- algs/OdMatrixFromLayersAsTable.py | 64 ++++++++++++++--------------- 2 files changed, 66 insertions(+), 66 deletions(-) diff --git a/algs/OdMatrixFromLayersAsLines.py b/algs/OdMatrixFromLayersAsLines.py index 1d82d3d..447b058 100644 --- a/algs/OdMatrixFromLayersAsLines.py +++ b/algs/OdMatrixFromLayersAsLines.py @@ -3,10 +3,10 @@ *************************************************************************** OdMatrixFromLayersAsLines.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : February 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -65,7 +65,7 @@ class OdMatrixFromLayersAsLines(QgisAlgorithm): FROM_POINT_LAYER = 'FROM_POINT_LAYER' FROM_ID_FIELD = 'FROM_ID_FIELD' TO_POINT_LAYER = 'TO_POINT_LAYER' - TO_ID_FIELD = 'TO_ID_FIELD' + TO_ID_FIELD = 'TO_ID_FIELD' STRATEGY = 'STRATEGY' ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' @@ -86,13 +86,13 @@ def group(self): def groupId(self): return 'networkbaseddistancematrices' - + def name(self): return 'OdMatrixFromLayersAsLines' def displayName(self): return self.tr('OD Matrix from Layers as Lines (m:n)') - + def shortHelpString(self): return "General:
"\ "This algorithm implements OD-Matrix analysis to return the matrix of origin-destination pairs as lines yielding network based costs on a given network dataset between two layer of points (m:n).
"\ @@ -105,9 +105,9 @@ def shortHelpString(self): "
"\ "Output:
"\ "The output of the algorithm is one layer:"\ - "" - - + "" + + def print_typestring(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -126,31 +126,31 @@ def initAlgorithm(self, config=None): self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), self.tr('Planar (only use with projected CRS)')] - + self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) - + self.addParameter(QgsProcessingParameterFeatureSource(self.FROM_POINT_LAYER, self.tr('From-Point Layer'), [QgsProcessing.TypeVectorPoint])) - + self.addParameter(QgsProcessingParameterField(self.FROM_ID_FIELD, self.tr('Unique Point ID Field'), None, self.FROM_POINT_LAYER, optional=False)) - + self.addParameter(QgsProcessingParameterFeatureSource(self.TO_POINT_LAYER, self.tr('To-Point Layer'), [QgsProcessing.TypeVectorPoint])) - + self.addParameter(QgsProcessingParameterField(self.TO_ID_FIELD, self.tr('Unique Point ID Field'), None, self.TO_POINT_LAYER, optional=False)) - + self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, self.tr('Optimization Criterion'), self.STRATEGIES, @@ -217,9 +217,9 @@ def processAlgorithm(self, parameters, context, feedback): speedFieldName = self.parameterAsString(parameters, self.SPEED_FIELD, context) #str defaultSpeed = self.parameterAsDouble(parameters, self.DEFAULT_SPEED, context) #float tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context) #float - + analysisCrs = network.sourceCrs() - + #Points of both layers have to be merged into one layer --> then tied to the Qneat3Network #get point list of from layer from_coord_list = getListOfPoints(from_points) @@ -227,34 +227,35 @@ def processAlgorithm(self, parameters, context, feedback): to_coord_list = getListOfPoints(to_points) merged_coords = from_coord_list + to_coord_list - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, merged_coords, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) - + #read the merged point-list seperately for the two layers --> index at the first element of the second layer begins at len(firstLayer) and gets added the index of the current point of layer b. list_from_apoints = [Qneat3AnalysisPoint("from", feature, from_id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(from_points))] list_to_apoints = [Qneat3AnalysisPoint("to", feature, to_id_field, net, net.list_tiedPoints[from_coord_list_length+i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(to_points))] - + feat = QgsFeature() fields = QgsFields() - output_id_field_data_type = getFieldDatatype(from_points, from_id_field) - fields.append(QgsField('origin_id', output_id_field_data_type, '', 254, 0)) - fields.append(QgsField('destination_id', output_id_field_data_type, '', 254, 0)) + orig_id_field_data_type = getFieldDatatype(from_points, from_id_field) + dest_id_field_data_type = getFieldDatatype(to_points, to_id_field) + fields.append(QgsField('origin_id', orig_id_field_data_type, '', 254, 0)) + fields.append(QgsField('destination_id', dest_id_field_data_type, '', 254, 0)) fields.append(QgsField('entry_cost', QVariant.Double, '', 20,7)) fields.append(QgsField('network_cost', QVariant.Double, '', 20, 7)) fields.append(QgsField('exit_cost', QVariant.Double, '', 20,7)) fields.append(QgsField('total_cost', QVariant.Double, '', 20,7)) feat.setFields(fields) - + (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.LineString, network.sourceCrs()) - + total_workload = float(len(from_coord_list)*len(to_coord_list)) feedback.pushInfo("[QNEAT3Algorithm] Expecting total workload of {} iterations".format(int(total_workload))) - - + + current_workstep_number = 0 - + for start_point in list_from_apoints: #optimize in case of undirected (not necessary to call calcDijkstra as it has already been calculated - can be replaced by reading from list) dijkstra_query = net.calcDijkstra(start_point.network_vertex_id, 0) @@ -271,7 +272,7 @@ def processAlgorithm(self, parameters, context, feedback): network_cost = dijkstra_query[1][query_point.network_vertex_id] exit_cost = query_point.entry_cost total_cost = network_cost + entry_cost + exit_cost - + feat.setGeometry(QgsGeometry.fromPolylineXY([start_point.point_geom, query_point.point_geom])) feat['origin_id'] = start_point.point_id feat['destination_id'] = query_point.point_id @@ -279,15 +280,14 @@ def processAlgorithm(self, parameters, context, feedback): feat['network_cost'] = network_cost feat['exit_cost'] = exit_cost feat['total_cost'] = total_cost - sink.addFeature(feat, QgsFeatureSink.FastInsert) + sink.addFeature(feat, QgsFeatureSink.FastInsert) current_workstep_number=current_workstep_number+1 feedback.setProgress((current_workstep_number/total_workload)*100) - + feedback.pushInfo("[QNEAT3Algorithm] Total number of OD-pairs processed: {}".format(current_workstep_number)) - + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") results = {} results[self.OUTPUT] = dest_id return results - diff --git a/algs/OdMatrixFromLayersAsTable.py b/algs/OdMatrixFromLayersAsTable.py index 0ed6b5f..e016b7f 100644 --- a/algs/OdMatrixFromLayersAsTable.py +++ b/algs/OdMatrixFromLayersAsTable.py @@ -3,10 +3,10 @@ *************************************************************************** OdMatrixFromLayersAsTable.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : February 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -64,7 +64,7 @@ class OdMatrixFromLayersAsTable(QgisAlgorithm): FROM_POINT_LAYER = 'FROM_POINT_LAYER' FROM_ID_FIELD = 'FROM_ID_FIELD' TO_POINT_LAYER = 'TO_POINT_LAYER' - TO_ID_FIELD = 'TO_ID_FIELD' + TO_ID_FIELD = 'TO_ID_FIELD' STRATEGY = 'STRATEGY' ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' @@ -85,7 +85,7 @@ def group(self): def groupId(self): return 'networkbaseddistancematrices' - + def name(self): return 'OdMatrixFromLayersAsTable' @@ -104,8 +104,8 @@ def shortHelpString(self): "
"\ "Output:
"\ "The output of the algorithm is one table:"\ - "" - + "" + def print_typestring(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -120,34 +120,34 @@ def initAlgorithm(self, config=None): self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), self.tr('Fastest Path (time optimization)')] - + self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), self.tr('Planar (only use with projected CRS)')] self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network layer'), [QgsProcessing.TypeVectorLine])) - + self.addParameter(QgsProcessingParameterFeatureSource(self.FROM_POINT_LAYER, self.tr('From-Point Layer'), [QgsProcessing.TypeVectorPoint])) - + self.addParameter(QgsProcessingParameterField(self.FROM_ID_FIELD, self.tr('Unique Point ID Field'), None, self.FROM_POINT_LAYER, optional=False)) - + self.addParameter(QgsProcessingParameterFeatureSource(self.TO_POINT_LAYER, self.tr('To-Point Layer'), [QgsProcessing.TypeVectorPoint])) - + self.addParameter(QgsProcessingParameterField(self.TO_ID_FIELD, self.tr('Unique Point ID Field'), None, self.TO_POINT_LAYER, optional=False)) - + self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, self.tr('Optimization Criterion'), self.STRATEGIES, @@ -204,7 +204,7 @@ def processAlgorithm(self, parameters, context, feedback): to_points = self.parameterAsSource(parameters, self.TO_POINT_LAYER, context) to_id_field = self.parameterAsString(parameters, self.TO_ID_FIELD, context) strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - + entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str @@ -214,9 +214,9 @@ def processAlgorithm(self, parameters, context, feedback): speedFieldName = self.parameterAsString(parameters, self.SPEED_FIELD, context) #str defaultSpeed = self.parameterAsDouble(parameters, self.DEFAULT_SPEED, context) #float tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context) #float - + analysisCrs = network.sourceCrs() - + #Points of both layers have to be merged into one layer --> then tied to the Qneat3Network #get point list of from layer from_coord_list = getListOfPoints(from_points) @@ -224,35 +224,36 @@ def processAlgorithm(self, parameters, context, feedback): to_coord_list = getListOfPoints(to_points) merged_coords = from_coord_list + to_coord_list - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, merged_coords, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) - + #read the merged point-list seperately for the two layers --> index at the first element of the second layer begins at len(firstLayer) and gets added the index of the current point of layer b. list_from_apoints = [Qneat3AnalysisPoint("from", feature, from_id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(from_points))] list_to_apoints = [Qneat3AnalysisPoint("to", feature, to_id_field, net, net.list_tiedPoints[from_coord_list_length+i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(to_points))] - + feat = QgsFeature() fields = QgsFields() - output_id_field_data_type = getFieldDatatype(from_points, from_id_field) - fields.append(QgsField('origin_id', output_id_field_data_type, '', 254, 0)) - fields.append(QgsField('destination_id', output_id_field_data_type, '', 254, 0)) + orig_id_field_data_type = getFieldDatatype(from_points, from_id_field) + dest_id_field_data_type = getFieldDatatype(to_points, to_id_field) + fields.append(QgsField('origin_id', orig_id_field_data_type, '', 254, 0)) + fields.append(QgsField('destination_id', dest_id_field_data_type, '', 254, 0)) fields.append(QgsField('entry_cost', QVariant.Double, '', 20,7)) fields.append(QgsField('network_cost', QVariant.Double, '', 20, 7)) fields.append(QgsField('exit_cost', QVariant.Double, '', 20,7)) fields.append(QgsField('total_cost', QVariant.Double, '', 20,7)) feat.setFields(fields) - + (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.NoGeometry, network.sourceCrs()) - + total_workload = float(len(from_coord_list)*len(to_coord_list)) feedback.pushInfo("[QNEAT3Algorithm] Expecting total workload of {} iterations".format(int(total_workload))) - - + + current_workstep_number = 0 - + for start_point in list_from_apoints: #optimize in case of undirected (not necessary to call calcDijkstra as it has already been calculated - can be replaced by reading from list) dijkstra_query = net.calcDijkstra(start_point.network_vertex_id, 0) @@ -272,15 +273,14 @@ def processAlgorithm(self, parameters, context, feedback): feat['network_cost'] = network_cost feat['exit_cost'] = query_point.entry_cost feat['total_cost'] = network_cost + start_point.entry_cost + query_point.entry_cost - sink.addFeature(feat, QgsFeatureSink.FastInsert) + sink.addFeature(feat, QgsFeatureSink.FastInsert) current_workstep_number=current_workstep_number+1 feedback.setProgress((current_workstep_number/total_workload)*100) - + feedback.pushInfo("[QNEAT3Algorithm] Total number of OD-pairs processed: {}".format(current_workstep_number)) - + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") results = {} results[self.OUTPUT] = dest_id return results - From dc51e6accbe2fd329491d03fc6785e4237d76cb6 Mon Sep 17 00:00:00 2001 From: Kufre Date: Tue, 30 Jun 2020 21:30:23 -0400 Subject: [PATCH 03/14] Making origin and destination field names consistent with QGIS Distance Matrix tool --- algs/OdMatrixFromLayersAsLines.py | 34 +++++++------- algs/OdMatrixFromLayersAsTable.py | 30 ++++++------- algs/OdMatrixFromPointsAsCsv.py | 63 +++++++++++++------------- algs/OdMatrixFromPointsAsLines.py | 73 +++++++++++++++--------------- algs/OdMatrixFromPointsAsTable.py | 75 +++++++++++++++---------------- 5 files changed, 136 insertions(+), 139 deletions(-) diff --git a/algs/OdMatrixFromLayersAsLines.py b/algs/OdMatrixFromLayersAsLines.py index 447b058..925f530 100644 --- a/algs/OdMatrixFromLayersAsLines.py +++ b/algs/OdMatrixFromLayersAsLines.py @@ -95,17 +95,17 @@ def displayName(self): def shortHelpString(self): return "General:
"\ - "This algorithm implements OD-Matrix analysis to return the matrix of origin-destination pairs as lines yielding network based costs on a given network dataset between two layer of points (m:n).
"\ + "This algorithm implements OD Matrix analysis to return the matrix of origin-destination pairs as lines yielding network based costs on a given network dataset between two layer of points (m:n).
"\ "It accounts for points outside of the network (eg. non-network-elements). Distances are measured accounting for ellipsoids, entry-, exit-, network- and total costs are listed in the result attribute-table.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • From-Point Layer
  • Unique From-Point ID Field (numerical)
  • To-Point Layer
  • Unique To-Point ID Field (numerical)
  • Cost Strategy

"\ + "
  • Network layer
  • Input point layer (origin points)
  • Input unique ID field
  • Target point layer
  • Target unique ID field (destination points)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one layer:"\ - "
  • OD-Matrix as lines with network based distances as attributes
" + "
  • OD Matrix as lines with network based distances as attributes
" def print_typestring(self, var): @@ -120,39 +120,39 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), self.tr('Planar (only use with projected CRS)')] self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, - self.tr('Network Layer'), + self.tr('Network layer'), [QgsProcessing.TypeVectorLine])) self.addParameter(QgsProcessingParameterFeatureSource(self.FROM_POINT_LAYER, - self.tr('From-Point Layer'), + self.tr('Input point layer (origin points)'), [QgsProcessing.TypeVectorPoint])) self.addParameter(QgsProcessingParameterField(self.FROM_ID_FIELD, - self.tr('Unique Point ID Field'), + self.tr('Input unique ID field'), None, self.FROM_POINT_LAYER, optional=False)) self.addParameter(QgsProcessingParameterFeatureSource(self.TO_POINT_LAYER, - self.tr('To-Point Layer'), + self.tr('Target point layer (destination points)'), [QgsProcessing.TypeVectorPoint])) self.addParameter(QgsProcessingParameterField(self.TO_ID_FIELD, - self.tr('Unique Point ID Field'), + self.tr('Target unique ID field'), None, self.TO_POINT_LAYER, optional=False)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) @@ -239,8 +239,8 @@ def processAlgorithm(self, parameters, context, feedback): fields = QgsFields() orig_id_field_data_type = getFieldDatatype(from_points, from_id_field) dest_id_field_data_type = getFieldDatatype(to_points, to_id_field) - fields.append(QgsField('origin_id', orig_id_field_data_type, '', 254, 0)) - fields.append(QgsField('destination_id', dest_id_field_data_type, '', 254, 0)) + fields.append(QgsField('InputID', orig_id_field_data_type, '', 254, 0)) + fields.append(QgsField('TargetID', dest_id_field_data_type, '', 254, 0)) fields.append(QgsField('entry_cost', QVariant.Double, '', 20,7)) fields.append(QgsField('network_cost', QVariant.Double, '', 20, 7)) fields.append(QgsField('exit_cost', QVariant.Double, '', 20,7)) @@ -263,8 +263,8 @@ def processAlgorithm(self, parameters, context, feedback): if (current_workstep_number%1000)==0: feedback.pushInfo("[QNEAT3Algorithm] {} OD-pairs processed...".format(current_workstep_number)) if dijkstra_query[0][query_point.network_vertex_id] == -1: - feat['origin_id'] = start_point.point_id - feat['destination_id'] = query_point.point_id + feat['InputID'] = start_point.point_id + feat['TargetID'] = query_point.point_id #do not populate cost field so that it defaults to null sink.addFeature(feat, QgsFeatureSink.FastInsert) else: @@ -274,8 +274,8 @@ def processAlgorithm(self, parameters, context, feedback): total_cost = network_cost + entry_cost + exit_cost feat.setGeometry(QgsGeometry.fromPolylineXY([start_point.point_geom, query_point.point_geom])) - feat['origin_id'] = start_point.point_id - feat['destination_id'] = query_point.point_id + feat['InputID'] = start_point.point_id + feat['TargetID'] = query_point.point_id feat['entry_cost'] = entry_cost feat['network_cost'] = network_cost feat['exit_cost'] = exit_cost diff --git a/algs/OdMatrixFromLayersAsTable.py b/algs/OdMatrixFromLayersAsTable.py index e016b7f..acbd040 100644 --- a/algs/OdMatrixFromLayersAsTable.py +++ b/algs/OdMatrixFromLayersAsTable.py @@ -98,13 +98,13 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements). Distances are measured accounting for ellipsoids, entry-, exit-, network- and total costs are listed in the result attribute-table.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • From-Point Layer
  • Unique From-Point ID Field (numerical)
  • To-Point Layer
  • Unique To-Point ID Field (numerical)
  • Cost Strategy

"\ + "
  • Network layer
  • Input point layer (origin points)
  • Input unique ID field
  • Target point layer (destination points)
  • Target unique ID field
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one table:"\ - "
  • OD-Matrix as table with network based distances as attributes
" + "
  • OD Matrix as table with network based distances as attributes
" def print_typestring(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -118,8 +118,8 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)')] + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time')] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), self.tr('Planar (only use with projected CRS)')] @@ -129,27 +129,27 @@ def initAlgorithm(self, config=None): [QgsProcessing.TypeVectorLine])) self.addParameter(QgsProcessingParameterFeatureSource(self.FROM_POINT_LAYER, - self.tr('From-Point Layer'), + self.tr('Input point layer (origin points)'), [QgsProcessing.TypeVectorPoint])) self.addParameter(QgsProcessingParameterField(self.FROM_ID_FIELD, - self.tr('Unique Point ID Field'), + self.tr('Input unique ID field'), None, self.FROM_POINT_LAYER, optional=False)) self.addParameter(QgsProcessingParameterFeatureSource(self.TO_POINT_LAYER, - self.tr('To-Point Layer'), + self.tr('Target point layer (destination points)'), [QgsProcessing.TypeVectorPoint])) self.addParameter(QgsProcessingParameterField(self.TO_ID_FIELD, - self.tr('Unique Point ID Field'), + self.tr('Target unique ID field'), None, self.TO_POINT_LAYER, optional=False)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) @@ -236,8 +236,8 @@ def processAlgorithm(self, parameters, context, feedback): fields = QgsFields() orig_id_field_data_type = getFieldDatatype(from_points, from_id_field) dest_id_field_data_type = getFieldDatatype(to_points, to_id_field) - fields.append(QgsField('origin_id', orig_id_field_data_type, '', 254, 0)) - fields.append(QgsField('destination_id', dest_id_field_data_type, '', 254, 0)) + fields.append(QgsField('InputID', orig_id_field_data_type, '', 254, 0)) + fields.append(QgsField('TargetID', dest_id_field_data_type, '', 254, 0)) fields.append(QgsField('entry_cost', QVariant.Double, '', 20,7)) fields.append(QgsField('network_cost', QVariant.Double, '', 20, 7)) fields.append(QgsField('exit_cost', QVariant.Double, '', 20,7)) @@ -261,14 +261,14 @@ def processAlgorithm(self, parameters, context, feedback): if (current_workstep_number%1000)==0: feedback.pushInfo("[QNEAT3Algorithm] {} OD-pairs processed...".format(current_workstep_number)) if dijkstra_query[0][query_point.network_vertex_id] == -1: - feat['origin_id'] = start_point.point_id - feat['destination_id'] = query_point.point_id + feat['InputID'] = start_point.point_id + feat['TargetID'] = query_point.point_id #do not populate cost field so that it defaults to null sink.addFeature(feat, QgsFeatureSink.FastInsert) else: network_cost = dijkstra_query[1][query_point.network_vertex_id] - feat['origin_id'] = start_point.point_id - feat['destination_id'] = query_point.point_id + feat['InputID'] = start_point.point_id + feat['TargetID'] = query_point.point_id feat['entry_cost'] = start_point.entry_cost feat['network_cost'] = network_cost feat['exit_cost'] = query_point.entry_cost diff --git a/algs/OdMatrixFromPointsAsCsv.py b/algs/OdMatrixFromPointsAsCsv.py index e4439ba..c00bfa4 100644 --- a/algs/OdMatrixFromPointsAsCsv.py +++ b/algs/OdMatrixFromPointsAsCsv.py @@ -3,10 +3,10 @@ *************************************************************************** OdMatrixFromPointsAsCsv.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : February 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -57,7 +57,7 @@ class OdMatrixFromPointsAsCsv(QgisAlgorithm): INPUT = 'INPUT' POINTS = 'POINTS' - ID_FIELD = 'ID_FIELD' + ID_FIELD = 'ID_FIELD' STRATEGY = 'STRATEGY' ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' @@ -78,27 +78,27 @@ def group(self): def groupId(self): return 'networkbaseddistancematrices' - + def name(self): return 'OdMatrixFromPointsAsCsv' def displayName(self): - return self.tr('OD-Matrix from Points as CSV (n:n)') - + return self.tr('OD Matrix from Points as CSV (n:n)') + def shortHelpString(self): return "General:
"\ - "This algorithm implements OD-Matrix analysis to return the matrix of origin-destination pairs as csv-file yielding network based costs on a given network dataset between the elements of one point layer(n:n).
"\ + "This algorithm implements OD Matrix analysis to return the matrix of origin-destination pairs as csv-file yielding network based costs on a given network dataset between the elements of one point layer(n:n).
"\ "It accounts for points outside of the network (eg. non-network-elements). Distances are measured accounting for ellipsoids, entry-, exit-, network- and total costs are listed in the result attribute-table.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Point Layer
  • Unique Point ID Field (numerical)
  • Cost Strategy

"\ + "
  • Network layer
  • Input point layer (origin points)
  • Input unique ID field
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one file:"\ - "
  • OD-Matrix as csv-file with network based distances as attributes
" - + "
  • OD Matrix as csv-file with network based distances as attributes
" + def print_typestring(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -111,27 +111,27 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), self.tr('Planar (only use with projected CRS)')] - + self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, - self.tr('Network Layer'), + self.tr('Network layer'), [QgsProcessing.TypeVectorLine])) self.addParameter(QgsProcessingParameterFeatureSource(self.POINTS, - self.tr('Point Layer'), + self.tr('Input point layer (origin points)'), [QgsProcessing.TypeVectorPoint])) self.addParameter(QgsProcessingParameterField(self.ID_FIELD, - self.tr('Unique Point ID Field'), + self.tr('Input unique ID field'), None, self.POINTS, optional=False)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) @@ -185,7 +185,7 @@ def processAlgorithm(self, parameters, context, feedback): id_field = self.parameterAsString(parameters, self.ID_FIELD, context) #str strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int + entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -196,26 +196,26 @@ def processAlgorithm(self, parameters, context, feedback): tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context) #float output_path = self.parameterAsFileOutput(parameters, self.OUTPUT, context) #str (filepath) feedback.pushInfo(pluginPath) - + analysisCrs = network.sourceCrs() - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, points, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) - + list_analysis_points = [Qneat3AnalysisPoint("point", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(net.input_points))] - + total_workload = float(pow(len(list_analysis_points),2)) feedback.pushInfo("[QNEAT3Algorithm] Expecting total workload of {} iterations".format(int(total_workload))) - + with open(output_path, 'w', newline='') as csvfile: csv_writer = csv.writer(csvfile, delimiter=';', - quotechar='|', + quotechar='|', quoting=csv.QUOTE_MINIMAL) #write header - csv_writer.writerow(["origin_id","destination_id","entry_cost", "network_cost", "exit_cost", "total_cost"]) - + csv_writer.writerow(["InputID","TargetID","entry_cost", "network_cost", "exit_cost", "total_cost"]) + current_workstep_number = 0 - + for start_point in list_analysis_points: #optimize in case of undirected (not necessary to call calcDijkstra as it has already been calculated - can be replaced by reading from list) dijkstra_query = net.calcDijkstra(start_point.network_vertex_id, 0) @@ -234,11 +234,10 @@ def processAlgorithm(self, parameters, context, feedback): csv_writer.writerow([start_point.point_id, query_point.point_id, entry_cost, network_cost, exit_cost, total_cost]) current_workstep_number=current_workstep_number+1 feedback.setProgress((current_workstep_number/total_workload)*100) - + feedback.pushInfo("[QNEAT3Algorithm] Total number of OD-pairs processed: {}".format(current_workstep_number)) - + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") results = {self.OUTPUT: output_path} return results - diff --git a/algs/OdMatrixFromPointsAsLines.py b/algs/OdMatrixFromPointsAsLines.py index ae72a99..8d9c287 100644 --- a/algs/OdMatrixFromPointsAsLines.py +++ b/algs/OdMatrixFromPointsAsLines.py @@ -3,10 +3,10 @@ *************************************************************************** OdMatrixFromPointsAsLines.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : February 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -63,7 +63,7 @@ class OdMatrixFromPointsAsLines(QgisAlgorithm): INPUT = 'INPUT' POINTS = 'POINTS' - ID_FIELD = 'ID_FIELD' + ID_FIELD = 'ID_FIELD' STRATEGY = 'STRATEGY' ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' @@ -84,27 +84,27 @@ def group(self): def groupId(self): return 'networkbaseddistancematrices' - + def name(self): return 'OdMatrixFromPointsAsLines' def displayName(self): - return self.tr('OD-Matrix from Points as Lines (n:n)') + return self.tr('OD Matrix from Points as Lines (n:n)') def shortHelpString(self): return "General:
"\ - "This algorithm implements OD-Matrix analysis to return the matrix of origin-destination pairs as lines yielding network based costs on a given network dataset between the elements of one point layer(n:n).
"\ + "This algorithm implements OD Matrix analysis to return the matrix of origin-destination pairs as lines yielding network based costs on a given network dataset between the elements of one point layer(n:n).
"\ "It accounts for points outside of the network (eg. non-network-elements). Distances are measured accounting for ellipsoids, entry-, exit-, network- and total costs are listed in the result attribute-table.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Point Layer
  • Unique Point ID Field (numerical)
  • Cost Strategy

"\ + "
  • Network layer
  • Input point layer (origin points)
  • Input unique ID
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one layer:"\ - "
  • OD-Matrix as lines with network based distances as attributes
" - + "
  • OD Matrix as lines with network based distances as attributes
" + def print_typestring(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -118,8 +118,8 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)')] + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time')] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), self.tr('Planar (only use with projected CRS)')] @@ -128,15 +128,15 @@ def initAlgorithm(self, config=None): self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) self.addParameter(QgsProcessingParameterFeatureSource(self.POINTS, - self.tr('Point Layer'), + self.tr('Input point layer (origin points)'), [QgsProcessing.TypeVectorPoint])) self.addParameter(QgsProcessingParameterField(self.ID_FIELD, - self.tr('Unique Point ID Field'), + self.tr('Unique point ID field'), None, self.POINTS, optional=False)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) @@ -200,35 +200,35 @@ def processAlgorithm(self, parameters, context, feedback): speedFieldName = self.parameterAsString(parameters, self.SPEED_FIELD, context) #str defaultSpeed = self.parameterAsDouble(parameters, self.DEFAULT_SPEED, context) #float tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context) #float - + analysisCrs = network.sourceCrs() - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, points, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) - + list_analysis_points = [Qneat3AnalysisPoint("point", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(net.input_points))] - + feat = QgsFeature() fields = QgsFields() output_id_field_data_type = getFieldDatatype(points, id_field) - fields.append(QgsField('origin_id', output_id_field_data_type, '', 254, 0)) - fields.append(QgsField('destination_id', output_id_field_data_type, '', 254, 0)) + fields.append(QgsField('InputID', output_id_field_data_type, '', 254, 0)) + fields.append(QgsField('TargetID', output_id_field_data_type, '', 254, 0)) fields.append(QgsField('entry_cost', QVariant.Double, '', 20,7)) fields.append(QgsField('network_cost', QVariant.Double, '', 20, 7)) fields.append(QgsField('exit_cost', QVariant.Double, '', 20,7)) fields.append(QgsField('total_cost', QVariant.Double, '', 20,7)) feat.setFields(fields) - + (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.LineString, network.sourceCrs()) - + total_workload = float(pow(len(list_analysis_points),2)) feedback.pushInfo("[QNEAT3Algorithm] Expecting total workload of {} iterations".format(int(total_workload))) - - + + current_workstep_number = 0 - + for start_point in list_analysis_points: #optimize in case of undirected (not necessary to call calcDijkstra as it has already been calculated - can be replaced by reading from list) dijkstra_query = net.calcDijkstra(start_point.network_vertex_id, 0) @@ -236,35 +236,34 @@ def processAlgorithm(self, parameters, context, feedback): if (current_workstep_number%1000)==0: feedback.pushInfo("[QNEAT3Algorithm] {} OD-pairs processed...".format(current_workstep_number)) if query_point.point_id == start_point.point_id: - feat['origin_id'] = start_point.point_id - feat['destination_id'] = query_point.point_id + feat['InputID'] = start_point.point_id + feat['TargetID'] = query_point.point_id feat['entry_cost'] = 0.0 feat['network_cost'] = 0.0 feat['exit_cost'] = 0.0 feat['total_cost'] = 0.0 sink.addFeature(feat, QgsFeatureSink.FastInsert) elif dijkstra_query[0][query_point.network_vertex_id] == -1: - feat['origin_id'] = start_point.point_id - feat['destination_id'] = query_point.point_id + feat['InputID'] = start_point.point_id + feat['TargetID'] = query_point.point_id #do not populate cost field so that it defaults to null sink.addFeature(feat, QgsFeatureSink.FastInsert) else: network_cost = dijkstra_query[1][query_point.network_vertex_id] feat.setGeometry(QgsGeometry.fromPolylineXY([start_point.point_geom, query_point.point_geom])) - feat['origin_id'] = start_point.point_id - feat['destination_id'] = query_point.point_id + feat['InputID'] = start_point.point_id + feat['TargetID'] = query_point.point_id feat['entry_cost'] = start_point.entry_cost feat['network_cost'] = network_cost feat['exit_cost'] = query_point.entry_cost feat['total_cost'] = network_cost + start_point.entry_cost + query_point.entry_cost - sink.addFeature(feat, QgsFeatureSink.FastInsert) + sink.addFeature(feat, QgsFeatureSink.FastInsert) current_workstep_number=current_workstep_number+1 feedback.setProgress((current_workstep_number/total_workload)*100) - + feedback.pushInfo("[QNEAT3Algorithm] Total number of OD-pairs processed: {}".format(current_workstep_number)) - + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") results = {} results[self.OUTPUT] = dest_id return results - diff --git a/algs/OdMatrixFromPointsAsTable.py b/algs/OdMatrixFromPointsAsTable.py index 0c3a315..c211b26 100644 --- a/algs/OdMatrixFromPointsAsTable.py +++ b/algs/OdMatrixFromPointsAsTable.py @@ -3,10 +3,10 @@ *************************************************************************** OdMatrixFromPointsAsTable.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : February 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -62,7 +62,7 @@ class OdMatrixFromPointsAsTable(QgisAlgorithm): INPUT = 'INPUT' POINTS = 'POINTS' - ID_FIELD = 'ID_FIELD' + ID_FIELD = 'ID_FIELD' STRATEGY = 'STRATEGY' ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' @@ -83,7 +83,7 @@ def group(self): def groupId(self): return 'networkbaseddistancematrices' - + def name(self): return 'OdMatrixFromPointsAsTable' @@ -92,18 +92,18 @@ def displayName(self): def shortHelpString(self): return "General:
"\ - "This algorithm implements OD-Matrix analysis to return the matrix of origin-destination pairs as table yielding network based costs on a given network dataset between the elements of one point layer(n:n).
"\ + "This algorithm implements OD Matrix analysis to return the matrix of origin-destination pairs as table yielding network based costs on a given network dataset between the elements of one point layer(n:n).
"\ "It accounts for points outside of the network (eg. non-network-elements). Distances are measured accounting for ellipsoids, entry-, exit-, network- and total costs are listed in the result attribute-table.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Point Layer
  • Unique Point ID Field (numerical)
  • Cost Strategy

"\ + "
  • Network Layer
  • Input point layer (origin points)
  • Input unique ID field
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one table:"\ - "
  • OD-Matrix as table with network based distances as attributes
" - + "
  • OD Matrix as table with network based distances as attributes
" + def print_typestring(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -116,26 +116,26 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)')] + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time')] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), self.tr('Planar (only use with projected CRS)')] self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, - self.tr('Network Layer'), + self.tr('Network layer'), [QgsProcessing.TypeVectorLine])) self.addParameter(QgsProcessingParameterFeatureSource(self.POINTS, - self.tr('Point Layer'), + self.tr('Input point layer (origin points)'), [QgsProcessing.TypeVectorPoint])) self.addParameter(QgsProcessingParameterField(self.ID_FIELD, - self.tr('Unique Point ID Field'), + self.tr('Input unique ID field'), None, self.POINTS, optional=False)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) @@ -188,7 +188,7 @@ def processAlgorithm(self, parameters, context, feedback): points = self.parameterAsSource(parameters, self.POINTS, context) #QgsProcessingFeatureSource id_field = self.parameterAsString(parameters, self.ID_FIELD, context) #str strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - + entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str @@ -198,35 +198,35 @@ def processAlgorithm(self, parameters, context, feedback): speedFieldName = self.parameterAsString(parameters, self.SPEED_FIELD, context) #str defaultSpeed = self.parameterAsDouble(parameters, self.DEFAULT_SPEED, context) #float tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context) #float - + analysisCrs = network.sourceCrs() - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, points, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) - + list_analysis_points = [Qneat3AnalysisPoint("point", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(net.input_points))] - + feat = QgsFeature() fields = QgsFields() output_id_field_data_type = getFieldDatatype(points, id_field) - fields.append(QgsField('origin_id', output_id_field_data_type, '', 254, 0)) - fields.append(QgsField('destination_id', output_id_field_data_type, '', 254, 0)) + fields.append(QgsField('InputID', output_id_field_data_type, '', 254, 0)) + fields.append(QgsField('TargetID', output_id_field_data_type, '', 254, 0)) fields.append(QgsField('entry_cost', QVariant.Double, '', 20,7)) fields.append(QgsField('network_cost', QVariant.Double, '', 20, 7)) fields.append(QgsField('exit_cost', QVariant.Double, '', 20,7)) fields.append(QgsField('total_cost', QVariant.Double, '', 20,7)) feat.setFields(fields) - + (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.NoGeometry, network.sourceCrs()) - + total_workload = float(pow(len(list_analysis_points),2)) feedback.pushInfo("[QNEAT3Algorithm] Expecting total workload of {} iterations".format(int(total_workload))) - - + + current_workstep_number = 0 - + for start_point in list_analysis_points: #optimize in case of undirected (not necessary to call calcDijkstra as it has already been calculated - can be replaced by reading from list) dijkstra_query = net.calcDijkstra(start_point.network_vertex_id, 0) @@ -234,32 +234,31 @@ def processAlgorithm(self, parameters, context, feedback): if (current_workstep_number%1000)==0: feedback.pushInfo("[QNEAT3Algorithm] {} OD-pairs processed...".format(current_workstep_number)) if query_point.point_id == start_point.point_id: - feat['origin_id'] = start_point.point_id - feat['destination_id'] = query_point.point_id + feat['InputID'] = start_point.point_id + feat['TargetID'] = query_point.point_id feat['network_cost'] = 0.0 sink.addFeature(feat, QgsFeatureSink.FastInsert) elif dijkstra_query[0][query_point.network_vertex_id] == -1: - feat['origin_id'] = start_point.point_id - feat['destination_id'] = query_point.point_id + feat['InputID'] = start_point.point_id + feat['TargetID'] = query_point.point_id #do not populate cost field so that it defaults to null sink.addFeature(feat, QgsFeatureSink.FastInsert) else: network_cost = dijkstra_query[1][query_point.network_vertex_id] - feat['origin_id'] = start_point.point_id - feat['destination_id'] = query_point.point_id + feat['InputID'] = start_point.point_id + feat['TargetID'] = query_point.point_id feat['entry_cost'] = start_point.entry_cost feat['network_cost'] = network_cost feat['exit_cost'] = query_point.entry_cost feat['total_cost'] = start_point.entry_cost + network_cost + query_point.entry_cost - sink.addFeature(feat, QgsFeatureSink.FastInsert) + sink.addFeature(feat, QgsFeatureSink.FastInsert) current_workstep_number=current_workstep_number+1 feedback.setProgress(current_workstep_number/total_workload) - + feedback.pushInfo("[QNEAT3Algorithm] Total number of OD-pairs processed: {}".format(current_workstep_number)) - + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") results = {} results[self.OUTPUT] = dest_id return results - From 1efb83038845bf0536bddea6e08cff091d0e463a Mon Sep 17 00:00:00 2001 From: Kufre Date: Wed, 1 Jul 2020 10:44:28 -0400 Subject: [PATCH 04/14] Remove start and end ID from shortest path output --- algs/ShortestPathBetweenPoints.py | 79 +++++++++++++++---------------- 1 file changed, 37 insertions(+), 42 deletions(-) diff --git a/algs/ShortestPathBetweenPoints.py b/algs/ShortestPathBetweenPoints.py index 89e3e6f..d45ff59 100644 --- a/algs/ShortestPathBetweenPoints.py +++ b/algs/ShortestPathBetweenPoints.py @@ -3,10 +3,10 @@ *************************************************************************** ShortestPathPointToPoint.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : February 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -86,13 +86,13 @@ def group(self): def groupId(self): return 'networkanalysis' - + def name(self): return 'shortestpathpointtopoint' def displayName(self): return self.tr('Shortest path (point to point)') - + def shortHelpString(self): return "General:
"\ "This algorithm implements the Dijkstra-Search to return the shortest path between two points on a given network dataset.
"\ @@ -100,14 +100,14 @@ def shortHelpString(self): "separate entry- and exit-costs. Distances are measured accounting for ellipsoids.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint Coordinates
  • Endpoint Coordinates
  • Cost Strategy

"\ + "
  • Network Layer
  • Startpoint Coordinates
  • Endpoint Coordinates
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is a Layer containing a single linestring, the attributes showcase the"\ "
  • Name and coordinates of startpoint
  • Name and coordinates of endpoint
  • Entry-cost to enter network
  • Exit-cost to exit network
  • Cost of shortest path on graph
  • Total cost as sum of all cost elements
" - + def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -120,13 +120,13 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), self.tr('Planar (only use with projected CRS)')] - + self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), @@ -136,7 +136,7 @@ def initAlgorithm(self, config=None): self.addParameter(QgsProcessingParameterPoint(self.END_POINT, self.tr('End point'))) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) @@ -204,43 +204,43 @@ def processAlgorithm(self, parameters, context, feedback): tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context) #float analysisCrs = network.sourceCrs() - + input_qgspointxy_list = [startPoint,endPoint] input_points = [getFeatureFromPointParameter(startPoint),getFeatureFromPointParameter(endPoint)] - + feedback.pushInfo(self.tr('[QNEAT3Algorithm] Building Graph')) feedback.setProgress(10) net = Qneat3Network(network, input_qgspointxy_list, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - + list_analysis_points = [Qneat3AnalysisPoint("point", feature, "point_id", net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(input_points)] - + start_vertex_idx = list_analysis_points[0].network_vertex_id end_vertex_idx = list_analysis_points[1].network_vertex_id - + feedback.pushInfo("[QNEAT3Algorithm] Calculating shortest path...") feedback.setProgress(50) - + dijkstra_query = net.calcDijkstra(start_vertex_idx,0) - + if dijkstra_query[0][end_vertex_idx] == -1: raise QgsProcessingException(self.tr('Could not find a path from start point to end point - Check your graph or alter the input points.')) - + path_elements = [list_analysis_points[1].point_geom] #start route with the endpoint outside the network - path_elements.append(net.network.vertex(end_vertex_idx).point()) #then append the corresponding vertex of the graph - + path_elements.append(net.network.vertex(end_vertex_idx).point()) #then append the corresponding vertex of the graph + count = 1 current_vertex_idx = end_vertex_idx while current_vertex_idx != start_vertex_idx: current_vertex_idx = net.network.edge(dijkstra_query[0][current_vertex_idx]).fromVertex() path_elements.append(net.network.vertex(current_vertex_idx).point()) - - + + count = count + 1 if count%10 == 0: feedback.pushInfo("[QNEAT3Algorithm] Taversed {} Nodes...".format(count)) - - path_elements.append(list_analysis_points[0].point_geom) #end path with startpoint outside the network + + path_elements.append(list_analysis_points[0].point_geom) #end path with startpoint outside the network feedback.pushInfo("[QNEAT3Algorithm] Total number of Nodes traversed: {}".format(count+1)) path_elements.reverse() #reverse path elements because it was built from end to start @@ -248,39 +248,34 @@ def processAlgorithm(self, parameters, context, feedback): end_exit_cost = list_analysis_points[1].entry_cost cost_on_graph = dijkstra_query[1][end_vertex_idx] total_cost = start_entry_cost + cost_on_graph + end_exit_cost - + feedback.pushInfo("[QNEAT3Algorithm] Writing path-feature...") feedback.setProgress(80) feat = QgsFeature() - + fields = QgsFields() - fields.append(QgsField('start_id', QVariant.String, '', 254, 0)) - fields.append(QgsField('start_coordinates', QVariant.String, '', 254, 0)) + fields.append(QgsField('start', QVariant.String, '', 254, 0)) fields.append(QgsField('start_entry_cost', QVariant.Double, '', 20, 7)) - fields.append(QgsField('end_id', QVariant.String, '', 254, 0)) - fields.append(QgsField('end_coordinates', QVariant.String, '', 254, 0)) + fields.append(QgsField('end', QVariant.String, '', 254, 0)) fields.append(QgsField('end_exit_cost', QVariant.Double, '', 20, 7)) fields.append(QgsField('cost_on_graph', QVariant.Double, '', 20, 7)) fields.append(QgsField('total_cost', QVariant.Double, '', 20, 7)) feat.setFields(fields) - + (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.LineString, network.sourceCrs()) - - feat['start_id'] = "A" - feat['start_coordinates'] = startPoint.toString() + + feat['start'] = startPoint.toString() feat['start_entry_cost'] = start_entry_cost - feat['end_id'] = "B" - feat['end_coordinates'] = endPoint.toString() + feat['end'] = endPoint.toString() feat['end_exit_cost'] = end_exit_cost feat['cost_on_graph'] = cost_on_graph - feat['total_cost'] = total_cost + feat['total_cost'] = total_cost geom = QgsGeometry.fromPolylineXY(path_elements) feat.setGeometry(geom) - + sink.addFeature(feat, QgsFeatureSink.FastInsert) - feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") feedback.setProgress(100) results = {} results[self.OUTPUT] = dest_id return results - From 9c8a2f4067c8e3f7c6980c9946fb979a1af99255 Mon Sep 17 00:00:00 2001 From: josephholler Date: Wed, 1 Jul 2020 16:09:52 -0400 Subject: [PATCH 05/14] Update language in Iso-Area algorithms for consistency with core QGIS network algorithms in terms of cost strategy. Update language on maximum cost level. --- algs/IsoAreaAsContoursFromLayer.py | 10 +++++----- algs/IsoAreaAsContoursFromPoint.py | 10 +++++----- algs/IsoAreaAsInterpolationFromLayer.py | 10 +++++----- algs/IsoAreaAsInterpolationFromPoint.py | 10 +++++----- algs/IsoAreaAsPointcloudFromLayer.py | 8 ++++---- algs/IsoAreaAsPointcloudFromPoint.py | 8 ++++---- algs/IsoAreaAsPolygonsFromLayer.py | 8 ++++---- algs/IsoAreaAsPolygonsFromPoint.py | 10 +++++----- algs/IsoAreaAsQneatInterpolationFromPoint.py | 10 +++++----- 9 files changed, 42 insertions(+), 42 deletions(-) diff --git a/algs/IsoAreaAsContoursFromLayer.py b/algs/IsoAreaAsContoursFromLayer.py index 401f938..fb64b68 100644 --- a/algs/IsoAreaAsContoursFromLayer.py +++ b/algs/IsoAreaAsContoursFromLayer.py @@ -101,7 +101,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the iso-areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level for Iso-Area
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Cost Strategy

"\ + "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ @@ -121,8 +121,8 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] @@ -140,7 +140,7 @@ def initAlgorithm(self, config=None): self.START_POINTS, optional=False)) self.addParameter(QgsProcessingParameterNumber(self.MAX_DIST, - self.tr('Size of Iso-Area (distance or time value)'), + self.tr('Maximum cost level of Iso-Area'), QgsProcessingParameterNumber.Double, 2500.0, False, 0, 99999999.99)) self.addParameter(QgsProcessingParameterNumber(self.INTERVAL, @@ -152,7 +152,7 @@ def initAlgorithm(self, config=None): QgsProcessingParameterNumber.Integer, 10, False, 1, 99999999)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) diff --git a/algs/IsoAreaAsContoursFromPoint.py b/algs/IsoAreaAsContoursFromPoint.py index 62dba7a..bf20793 100644 --- a/algs/IsoAreaAsContoursFromPoint.py +++ b/algs/IsoAreaAsContoursFromPoint.py @@ -101,7 +101,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the isochrone areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint
  • Maximum cost level for Iso-Area
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Cost Strategy

"\ + "
  • Network Layer
  • Startpoint
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ @@ -122,8 +122,8 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] @@ -135,7 +135,7 @@ def initAlgorithm(self, config=None): self.addParameter(QgsProcessingParameterPoint(self.START_POINT, self.tr('Start point'))) self.addParameter(QgsProcessingParameterNumber(self.MAX_DIST, - self.tr('Size of Iso-Area (distance or time value)'), + self.tr('Maximum cost level of Iso-Area'), QgsProcessingParameterNumber.Double, 2500.0, False, 0, 99999999.99)) self.addParameter(QgsProcessingParameterNumber(self.INTERVAL, @@ -147,7 +147,7 @@ def initAlgorithm(self, config=None): QgsProcessingParameterNumber.Integer, 10, False, 1, 99999999)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) diff --git a/algs/IsoAreaAsInterpolationFromLayer.py b/algs/IsoAreaAsInterpolationFromLayer.py index 1ee4eac..c856473 100644 --- a/algs/IsoAreaAsInterpolationFromLayer.py +++ b/algs/IsoAreaAsInterpolationFromLayer.py @@ -94,7 +94,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the iso-areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level for Iso-Area
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Cost Strategy

"\ + "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ @@ -115,8 +115,8 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] @@ -134,7 +134,7 @@ def initAlgorithm(self, config=None): self.START_POINTS, optional=False)) self.addParameter(QgsProcessingParameterNumber(self.MAX_DIST, - self.tr('Size of Iso-Area (distance or time value)'), + self.tr('Maximum cost level of Iso-Area'), QgsProcessingParameterNumber.Double, 2500.0, False, 0, 99999999.99)) self.addParameter(QgsProcessingParameterNumber(self.CELL_SIZE, @@ -142,7 +142,7 @@ def initAlgorithm(self, config=None): QgsProcessingParameterNumber.Integer, 10, False, 1, 99999999)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) diff --git a/algs/IsoAreaAsInterpolationFromPoint.py b/algs/IsoAreaAsInterpolationFromPoint.py index 7c90578..0d709d1 100644 --- a/algs/IsoAreaAsInterpolationFromPoint.py +++ b/algs/IsoAreaAsInterpolationFromPoint.py @@ -94,7 +94,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the iso-areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint
  • Maximum cost level for Iso-Area
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Cost Strategy

"\ + "
  • Network Layer
  • Startpoint
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ @@ -114,8 +114,8 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] @@ -127,7 +127,7 @@ def initAlgorithm(self, config=None): self.addParameter(QgsProcessingParameterPoint(self.START_POINT, self.tr('Start point'))) self.addParameter(QgsProcessingParameterNumber(self.MAX_DIST, - self.tr('Size of Iso-Area (distance or time value)'), + self.tr('Maximum cost level of Iso-Area'), QgsProcessingParameterNumber.Double, 2500.0, False, 0, 99999999.99)) self.addParameter(QgsProcessingParameterNumber(self.CELL_SIZE, @@ -135,7 +135,7 @@ def initAlgorithm(self, config=None): QgsProcessingParameterNumber.Integer, 10, False, 1, 99999999)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) diff --git a/algs/IsoAreaAsPointcloudFromLayer.py b/algs/IsoAreaAsPointcloudFromLayer.py index 1e273ff..1315d12 100644 --- a/algs/IsoAreaAsPointcloudFromLayer.py +++ b/algs/IsoAreaAsPointcloudFromLayer.py @@ -96,7 +96,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the iso-areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level for Iso-Area
  • Cost Strategy

"\ + "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ @@ -117,8 +117,8 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), @@ -140,7 +140,7 @@ def initAlgorithm(self, config=None): QgsProcessingParameterNumber.Double, 2500.0, False, 0, 99999999.99)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) diff --git a/algs/IsoAreaAsPointcloudFromPoint.py b/algs/IsoAreaAsPointcloudFromPoint.py index 95e9583..696d56f 100644 --- a/algs/IsoAreaAsPointcloudFromPoint.py +++ b/algs/IsoAreaAsPointcloudFromPoint.py @@ -96,7 +96,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the iso-areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint
  • Unique Point ID Field (numerical)
  • Maximum cost level for Iso-Area
  • Cost Strategy

"\ + "
  • Network Layer
  • Startpoint
  • Unique Point ID Field (numerical)
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ @@ -117,8 +117,8 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), @@ -134,7 +134,7 @@ def initAlgorithm(self, config=None): QgsProcessingParameterNumber.Double, 2500.0, False, 0, 99999999.99)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) diff --git a/algs/IsoAreaAsPolygonsFromLayer.py b/algs/IsoAreaAsPolygonsFromLayer.py index 75b0107..15c0127 100644 --- a/algs/IsoAreaAsPolygonsFromLayer.py +++ b/algs/IsoAreaAsPolygonsFromLayer.py @@ -101,7 +101,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the iso-areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level for Iso-Area
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Cost Strategy

"\ + "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ @@ -121,8 +121,8 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] @@ -140,7 +140,7 @@ def initAlgorithm(self, config=None): self.START_POINTS, optional=False)) self.addParameter(QgsProcessingParameterNumber(self.MAX_DIST, - self.tr('Size of Iso-Area (distance or time value)'), + self.tr('Maximum cost level of Iso-Area'), QgsProcessingParameterNumber.Double, 2500.0, False, 0, 99999999.99)) self.addParameter(QgsProcessingParameterNumber(self.INTERVAL, diff --git a/algs/IsoAreaAsPolygonsFromPoint.py b/algs/IsoAreaAsPolygonsFromPoint.py index 80a6d06..14535fe 100644 --- a/algs/IsoAreaAsPolygonsFromPoint.py +++ b/algs/IsoAreaAsPolygonsFromPoint.py @@ -95,7 +95,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the iso-areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint
  • Maximum cost level for Iso-Area
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Cost Strategy

"\ + "
  • Network Layer
  • Startpoint
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ @@ -121,8 +121,8 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] @@ -134,7 +134,7 @@ def initAlgorithm(self, config=None): self.addParameter(QgsProcessingParameterPoint(self.START_POINT, self.tr('Start Point'))) self.addParameter(QgsProcessingParameterNumber(self.MAX_DIST, - self.tr('Size of Iso-Area (distance or time value)'), + self.tr('Maximum cost level of Iso-Area'), QgsProcessingParameterNumber.Double, 2500.0, False, 0, 99999999.99)) self.addParameter(QgsProcessingParameterNumber(self.INTERVAL, @@ -146,7 +146,7 @@ def initAlgorithm(self, config=None): QgsProcessingParameterNumber.Integer, 10, False, 1, 99999999)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) diff --git a/algs/IsoAreaAsQneatInterpolationFromPoint.py b/algs/IsoAreaAsQneatInterpolationFromPoint.py index 4663d47..2684eff 100644 --- a/algs/IsoAreaAsQneatInterpolationFromPoint.py +++ b/algs/IsoAreaAsQneatInterpolationFromPoint.py @@ -104,7 +104,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the iso-areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint
  • Maximum cost level for Iso-Area
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Cost Strategy

"\ + "
  • Network Layer
  • Startpoint
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ @@ -124,8 +124,8 @@ def initAlgorithm(self, config=None): (self.tr('Backward direction'), QgsVectorLayerDirector.DirectionBackward), (self.tr('Both directions'), QgsVectorLayerDirector.DirectionBoth)]) - self.STRATEGIES = [self.tr('Shortest Path (distance optimization)'), - self.tr('Fastest Path (time optimization)') + self.STRATEGIES = [self.tr('Shortest distance'), + self.tr('Fastest time') ] self.METHODS = [self.tr('QGIS TIN-Interpolation (faster but not exact)'), @@ -141,7 +141,7 @@ def initAlgorithm(self, config=None): self.addParameter(QgsProcessingParameterPoint(self.START_POINT, self.tr('Start point'))) self.addParameter(QgsProcessingParameterNumber(self.MAX_DIST, - self.tr('Size of Iso-Area (distance or time value)'), + self.tr('Maximum cost level of Iso-Area'), QgsProcessingParameterNumber.Double, 2500.0, False, 0, 99999999.99)) self.addParameter(QgsProcessingParameterNumber(self.CELL_SIZE, @@ -149,7 +149,7 @@ def initAlgorithm(self, config=None): QgsProcessingParameterNumber.Integer, 10, False, 1, 99999999)) self.addParameter(QgsProcessingParameterEnum(self.STRATEGY, - self.tr('Optimization Criterion'), + self.tr('Path type to calculate'), self.STRATEGIES, defaultValue=0)) self.addParameter(QgsProcessingParameterEnum(self.METHOD, From dbfe669fcfbb960c5a093b901635f934e71cddaa Mon Sep 17 00:00:00 2001 From: josephholler Date: Wed, 1 Jul 2020 16:17:02 -0400 Subject: [PATCH 06/14] Clarify contour interval units --- algs/IsoAreaAsContoursFromLayer.py | 2 +- algs/IsoAreaAsContoursFromPoint.py | 2 +- algs/IsoAreaAsPolygonsFromLayer.py | 2 +- algs/IsoAreaAsPolygonsFromPoint.py | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/algs/IsoAreaAsContoursFromLayer.py b/algs/IsoAreaAsContoursFromLayer.py index fb64b68..1a9877e 100644 --- a/algs/IsoAreaAsContoursFromLayer.py +++ b/algs/IsoAreaAsContoursFromLayer.py @@ -101,7 +101,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the iso-areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ + "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Contour Intervals in distance (meters) or time (seconds)
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ diff --git a/algs/IsoAreaAsContoursFromPoint.py b/algs/IsoAreaAsContoursFromPoint.py index bf20793..1ae4ba5 100644 --- a/algs/IsoAreaAsContoursFromPoint.py +++ b/algs/IsoAreaAsContoursFromPoint.py @@ -101,7 +101,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the isochrone areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ + "
  • Network Layer
  • Startpoint
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Contour Intervals in distance (meters) or time (seconds)
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ diff --git a/algs/IsoAreaAsPolygonsFromLayer.py b/algs/IsoAreaAsPolygonsFromLayer.py index 15c0127..af954be 100644 --- a/algs/IsoAreaAsPolygonsFromLayer.py +++ b/algs/IsoAreaAsPolygonsFromLayer.py @@ -101,7 +101,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the iso-areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ + "
  • Network Layer
  • Startpoint Layer
  • Unique Point ID Field (numerical)
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Contour Intervals in distance (meters) or time (seconds)
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ diff --git a/algs/IsoAreaAsPolygonsFromPoint.py b/algs/IsoAreaAsPolygonsFromPoint.py index 14535fe..c02dc0b 100644 --- a/algs/IsoAreaAsPolygonsFromPoint.py +++ b/algs/IsoAreaAsPolygonsFromPoint.py @@ -95,7 +95,7 @@ def shortHelpString(self): "It accounts for points outside of the network (eg. non-network-elements) and increments the iso-areas cost regarding to distance/default speed value. Distances are measured accounting for ellipsoids.
Please, only use a projected coordinate system (eg. no WGS84) for this kind of analysis.

"\ "Parameters (required):
"\ "Following Parameters must be set to run the algorithm:"\ - "
  • Network Layer
  • Startpoint
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Cost Intervals for Iso-Area Bands
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ + "
  • Network Layer
  • Startpoint
  • Maximum cost level of Iso-Area in distance (meters) or time (seconds)
  • Contour Intervals in distance (meters) or time (seconds)
  • Cellsize in Meters (increase default when analyzing larger networks)
  • Path type to calculate

"\ "Parameters (optional):
"\ "There are also a number of optional parameters to implement direction dependent shortest paths and provide information on speeds on the networks edges."\ "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ From db7f78aabe1b48b6d5eaab17e4c78a6be839af4d Mon Sep 17 00:00:00 2001 From: Kufre Date: Mon, 6 Jul 2020 18:41:56 -0400 Subject: [PATCH 07/14] Increase default value of topology tolerance to 0.00001 --- algs/IsoAreaAsContoursFromLayer.py | 2 +- algs/IsoAreaAsContoursFromPoint.py | 45 ++++---- algs/IsoAreaAsInterpolationFromLayer.py | 2 +- algs/IsoAreaAsInterpolationFromPoint.py | 39 ++++--- algs/IsoAreaAsPointcloudFromLayer.py | 39 ++++--- algs/IsoAreaAsPointcloudFromPoint.py | 37 ++++--- algs/IsoAreaAsPolygonsFromLayer.py | 48 ++++----- algs/IsoAreaAsPolygonsFromPoint.py | 48 ++++----- algs/IsoAreaAsQneatInterpolationFromPoint.py | 104 +++++++++---------- algs/OdMatrixFromLayersAsLines.py | 2 +- algs/OdMatrixFromLayersAsTable.py | 2 +- algs/OdMatrixFromPointsAsCsv.py | 2 +- algs/OdMatrixFromPointsAsLines.py | 2 +- algs/OdMatrixFromPointsAsTable.py | 2 +- algs/ShortestPathBetweenPoints.py | 2 +- 15 files changed, 184 insertions(+), 192 deletions(-) diff --git a/algs/IsoAreaAsContoursFromLayer.py b/algs/IsoAreaAsContoursFromLayer.py index 1a9877e..c4e94ec 100644 --- a/algs/IsoAreaAsContoursFromLayer.py +++ b/algs/IsoAreaAsContoursFromLayer.py @@ -191,7 +191,7 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) diff --git a/algs/IsoAreaAsContoursFromPoint.py b/algs/IsoAreaAsContoursFromPoint.py index 1ae4ba5..1620582 100644 --- a/algs/IsoAreaAsContoursFromPoint.py +++ b/algs/IsoAreaAsContoursFromPoint.py @@ -3,10 +3,10 @@ *************************************************************************** IsoAreaAsContourFromPoint.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : February 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -88,7 +88,7 @@ def group(self): def groupId(self): return 'isoareas' - + def name(self): return 'isoareaascontoursfrompoint' @@ -108,8 +108,8 @@ def shortHelpString(self): "Output:
"\ "The output of the algorithm are two layers:"\ "
  • TIN-Interpolation Distance Raster
  • Iso-Area Contours with cost levels as attributes
" - - + + def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -127,7 +127,7 @@ def initAlgorithm(self, config=None): ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - + self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), @@ -186,7 +186,7 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) @@ -194,7 +194,7 @@ def initAlgorithm(self, config=None): self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT_INTERPOLATION, self.tr('Output Interpolation'))) self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT_CONTOURS, self.tr('Output Contours'), QgsProcessing.TypeVectorLine)) - + def processAlgorithm(self, parameters, context, feedback): feedback.pushInfo(self.tr("[QNEAT3Algorithm] This is a QNEAT3 Algorithm: '{}'".format(self.displayName()))) network = self.parameterAsSource(parameters, self.INPUT, context) #QgsProcessingFeatureSource @@ -218,44 +218,43 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() input_coordinates = [startPoint] input_point = getFeatureFromPointParameter(startPoint) - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") - feedback.setProgress(10) + feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - + analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], entry_cost_calc_method, feedback) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints([analysis_point], (max_dist+(max_dist*0.1))) feedback.setProgress(50) - + uri = "Point?crs={}&field=vertex_id:int(254)&field=cost:double(254,7)&field=origin_point_id:string(254)&index=yes".format(analysisCrs.authid()) - + iso_pointcloud_layer = QgsVectorLayer(uri, "iso_pointcloud_layer", "memory") iso_pointcloud_provider = iso_pointcloud_layer.dataProvider() iso_pointcloud_provider.addFeatures(iso_pointcloud, QgsFeatureSink.FastInsert) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Interpolation-Raster using QGIS TIN-Interpolator...") net.calcIsoTinInterpolation(iso_pointcloud_layer, cell_size, output_path) feedback.setProgress(70) - + fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 254, 0)) fields.append(QgsField('cost_level', QVariant.Double, '', 20, 7)) - + (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT_CONTOURS, context, fields, QgsWkbTypes.LineString, network.sourceCrs()) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Contours using numpy and matplotlib...") contour_featurelist = net.calcIsoContours(max_dist, interval, output_path) feedback.setProgress(90) - + sink.addFeatures(contour_featurelist, QgsFeatureSink.FastInsert) feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") feedback.setProgress(100) - + results = {} results[self.OUTPUT_INTERPOLATION] = output_path results[self.OUTPUT_CONTOURS] = dest_id return results - diff --git a/algs/IsoAreaAsInterpolationFromLayer.py b/algs/IsoAreaAsInterpolationFromLayer.py index c856473..f352af6 100644 --- a/algs/IsoAreaAsInterpolationFromLayer.py +++ b/algs/IsoAreaAsInterpolationFromLayer.py @@ -181,7 +181,7 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) diff --git a/algs/IsoAreaAsInterpolationFromPoint.py b/algs/IsoAreaAsInterpolationFromPoint.py index 0d709d1..4a872e8 100644 --- a/algs/IsoAreaAsInterpolationFromPoint.py +++ b/algs/IsoAreaAsInterpolationFromPoint.py @@ -3,10 +3,10 @@ *************************************************************************** IsoAreaAsInterpolationPoint.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : March 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -81,7 +81,7 @@ def group(self): def groupId(self): return 'isoareas' - + def name(self): return 'isoareaasinterpolationfrompoint' @@ -101,7 +101,7 @@ def shortHelpString(self): "Output:
"\ "The output of the algorithm is one layer:"\ "
  • TIN-Interpolation Distance Raster
" - + def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -119,7 +119,7 @@ def initAlgorithm(self, config=None): ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - + self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), @@ -174,12 +174,12 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(p) - + self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Output Interpolation'))) def processAlgorithm(self, parameters, context, feedback): @@ -204,32 +204,31 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() input_coordinates = [startPoint] input_point = getFeatureFromPointParameter(startPoint) - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") - feedback.setProgress(10) + feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - + analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], entry_cost_calc_method, feedback) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints([analysis_point], max_dist) feedback.setProgress(70) - + uri = "Point?crs={}&field=vertex_id:int(254)&field=cost:double(254,7)&field=origin_point_id:string(254)&index=yes".format(analysisCrs.authid()) - + iso_pointcloud_layer = QgsVectorLayer(uri, "iso_pointcloud_layer", "memory") iso_pointcloud_provider = iso_pointcloud_layer.dataProvider() iso_pointcloud_provider.addFeatures(iso_pointcloud, QgsFeatureSink.FastInsert) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Interpolation-Raster using QGIS TIN-Interpolator...") net.calcIsoTinInterpolation(iso_pointcloud_layer, cell_size, output_path) feedback.setProgress(99) - + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") - feedback.setProgress(100) - + feedback.setProgress(100) + results = {} results[self.OUTPUT] = output_path return results - diff --git a/algs/IsoAreaAsPointcloudFromLayer.py b/algs/IsoAreaAsPointcloudFromLayer.py index 1315d12..819e70d 100644 --- a/algs/IsoAreaAsPointcloudFromLayer.py +++ b/algs/IsoAreaAsPointcloudFromLayer.py @@ -3,10 +3,10 @@ *************************************************************************** IsoAreaAsPointcloudFromLayer.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : February 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -83,7 +83,7 @@ def group(self): def groupId(self): return 'isoareas' - + def name(self): return 'isoareaaspointcloudfromlayer' @@ -104,7 +104,7 @@ def shortHelpString(self): "The output of the algorithm is one layer:"\ "
  • Point layer of reachable network nodes

"\ "You may use the output pointcloud as input for further analyses." - + def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -123,7 +123,7 @@ def initAlgorithm(self, config=None): self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), self.tr('Planar (only use with projected CRS)')] - + self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) @@ -179,12 +179,12 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(p) - + self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Output Pointcloud'), QgsProcessing.TypeVectorPoint)) @@ -209,31 +209,30 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() input_coordinates = getListOfPoints(startPoints) - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") - feedback.setProgress(10) + feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - + list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] - + fields = QgsFields() fields.append(QgsField('vertex_id', QVariant.Int, '', 254, 0)) fields.append(QgsField('cost', QVariant.Double, '', 254, 7)) fields.append(QgsField('origin_point_id', getFieldDatatype(startPoints, id_field))) - + (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.Point, network.sourceCrs()) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints(list_apoints, max_dist) feedback.setProgress(90) - + sink.addFeatures(iso_pointcloud, QgsFeatureSink.FastInsert) - + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") - feedback.setProgress(100) - + feedback.setProgress(100) + results = {} results[self.OUTPUT] = dest_id return results - diff --git a/algs/IsoAreaAsPointcloudFromPoint.py b/algs/IsoAreaAsPointcloudFromPoint.py index 696d56f..b1c4322 100644 --- a/algs/IsoAreaAsPointcloudFromPoint.py +++ b/algs/IsoAreaAsPointcloudFromPoint.py @@ -3,10 +3,10 @@ *************************************************************************** IsoAreaAsPointcloudFromPoint.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : February 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -83,13 +83,13 @@ def group(self): def groupId(self): return 'isoareas' - + def name(self): return 'isoareaaspointcloudfrompoint' def displayName(self): return self.tr('Iso-Area as Pointcloud (from Point)') - + def shortHelpString(self): return "General:
"\ "This algorithm implements iso-pointcloud analysis to return all network nodes reachable within a maximum cost level as pointcloud on a given network dataset for a manually chosen point.
"\ @@ -104,7 +104,7 @@ def shortHelpString(self): "The output of the algorithm is one layer:"\ "
  • Point layer of reachable network nodes

"\ "You may use the output pointcloud as input for further analyses." - + def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -173,12 +173,12 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(p) - + self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Output Pointcloud'), QgsProcessing.TypeVectorPoint)) @@ -203,31 +203,30 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() input_coordinates = [startPoint] input_point = getFeatureFromPointParameter(startPoint) - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") - feedback.setProgress(10) + feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], entry_cost_calc_method, feedback) - + fields = QgsFields() fields.append(QgsField('vertex_id', QVariant.Int, '', 254, 0)) fields.append(QgsField('cost', QVariant.Double, '', 254, 7)) fields.append(QgsField('origin_point_id',QVariant.String, '', 254, 7)) - + (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.Point, network.sourceCrs()) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints([analysis_point], max_dist) feedback.setProgress(90) - + sink.addFeatures(iso_pointcloud, QgsFeatureSink.FastInsert) - + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") - feedback.setProgress(100) - + feedback.setProgress(100) + results = {} results[self.OUTPUT] = dest_id return results - diff --git a/algs/IsoAreaAsPolygonsFromLayer.py b/algs/IsoAreaAsPolygonsFromLayer.py index af954be..a1328b2 100644 --- a/algs/IsoAreaAsPolygonsFromLayer.py +++ b/algs/IsoAreaAsPolygonsFromLayer.py @@ -3,10 +3,10 @@ *************************************************************************** IsoAreaAsPolygonFromLayer.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : April 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -88,13 +88,13 @@ def group(self): def groupId(self): return 'isoareas' - + def name(self): return 'isoareaaspolygonsfromlayer' def displayName(self): return self.tr('Iso-Area as Polygons (from Layer)') - + def shortHelpString(self): return "General:
"\ "This algorithm implements iso-area analysis to return the iso-area polygons for a maximum cost level and interval levels on a given network dataset for a layer of points.
"\ @@ -107,8 +107,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm are two layers:"\ - "
  • TIN-Interpolation Distance Raster
  • Iso-Area Polygons with cost levels as attributes
" - + "
  • TIN-Interpolation Distance Raster
  • Iso-Area Polygons with cost levels as attributes
" + def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -126,7 +126,7 @@ def initAlgorithm(self, config=None): ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - + self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Vector layer representing network'), @@ -191,7 +191,7 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) @@ -199,7 +199,7 @@ def initAlgorithm(self, config=None): self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT_INTERPOLATION, self.tr('Output Interpolation'))) self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT_POLYGONS, self.tr('Output Polygon'), QgsProcessing.TypeVectorPolygon)) - + def processAlgorithm(self, parameters, context, feedback): feedback.pushInfo(self.tr("[QNEAT3Algorithm] This is a QNEAT3 Algorithm: '{}'".format(self.displayName()))) network = self.parameterAsSource(parameters, self.INPUT, context) #QgsProcessingFeatureSource @@ -223,45 +223,43 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() input_coordinates = getListOfPoints(startPoints) - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - + list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints(list_apoints, max_dist+(max_dist*0.1)) feedback.setProgress(50) - + uri = "Point?crs={}&field=vertex_id:int(254)&field=cost:double(254,7)&field=origin_point_id:string(254)&index=yes".format(analysisCrs.authid()) - + iso_pointcloud_layer = QgsVectorLayer(uri, "iso_pointcloud_layer", "memory") iso_pointcloud_provider = iso_pointcloud_layer.dataProvider() iso_pointcloud_provider.addFeatures(iso_pointcloud, QgsFeatureSink.FastInsert) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Interpolation-Raster using QGIS TIN-Interpolator...") net.calcIsoTinInterpolation(iso_pointcloud_layer, cell_size, output_path) feedback.setProgress(70) - + fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 254, 0)) fields.append(QgsField('cost_level', QVariant.Double, '', 20, 7)) - - (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT_POLYGONS, context, fields, QgsWkbTypes.Polygon, network.sourceCrs()) - + + (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT_POLYGONS, context, fields, QgsWkbTypes.Polygon, network.sourceCrs()) + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Polygons using numpy and matplotlib...") polygon_featurelist = net.calcIsoPolygons(max_dist, interval, output_path) feedback.setProgress(90) - + sink.addFeatures(polygon_featurelist, QgsFeatureSink.FastInsert) feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") feedback.setProgress(100) - + results = {} results[self.OUTPUT_INTERPOLATION] = output_path results[self.OUTPUT_POLYGONS] = dest_id return results - - diff --git a/algs/IsoAreaAsPolygonsFromPoint.py b/algs/IsoAreaAsPolygonsFromPoint.py index c02dc0b..0e96396 100644 --- a/algs/IsoAreaAsPolygonsFromPoint.py +++ b/algs/IsoAreaAsPolygonsFromPoint.py @@ -3,10 +3,10 @@ *************************************************************************** IsoAreaAsPolygonFromPoint.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : April 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -88,7 +88,7 @@ def group(self): def groupId(self): return 'isoareas' - + def shortHelpString(self): return "General:
"\ "This algorithm implements iso-area analysis to return the iso-area polygons for a maximum cost level and interval levels on a given network dataset for a manually chosen point.
"\ @@ -101,14 +101,14 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm are two layers:"\ - "
  • TIN-Interpolation Distance Raster
  • Iso-Area Polygons with cost levels as attributes
" - + "
  • TIN-Interpolation Distance Raster
  • Iso-Area Polygons with cost levels as attributes
" + def name(self): return 'isoareaaspolygonsfrompoint' def displayName(self): return self.tr('Iso-Area as Polygons (from Point)') - + def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -126,7 +126,7 @@ def initAlgorithm(self, config=None): ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - + self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), @@ -185,7 +185,7 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) @@ -193,7 +193,7 @@ def initAlgorithm(self, config=None): self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT_INTERPOLATION, self.tr('Output Interpolation'))) self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT_POLYGONS, self.tr('Output Polygon'), QgsProcessing.TypeVectorPolygon)) - + def processAlgorithm(self, parameters, context, feedback): feedback.pushInfo(self.tr("[QNEAT3Algorithm] This is a QNEAT3 Algorithm: '{}'".format(self.displayName()))) network = self.parameterAsSource(parameters, self.INPUT, context) #QgsProcessingFeatureSource @@ -217,45 +217,43 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() input_coordinates = [startPoint] input_point = getFeatureFromPointParameter(startPoint) - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - + analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], entry_cost_calc_method, feedback) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints([analysis_point], max_dist+(max_dist*0.1)) feedback.setProgress(50) - + uri = "Point?crs={}&field=vertex_id:int(254)&field=cost:double(254,7)&field=origin_point_id:string(254)&index=yes".format(analysisCrs.authid()) - + iso_pointcloud_layer = QgsVectorLayer(uri, "iso_pointcloud_layer", "memory") iso_pointcloud_provider = iso_pointcloud_layer.dataProvider() iso_pointcloud_provider.addFeatures(iso_pointcloud, QgsFeatureSink.FastInsert) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Interpolation-Raster using QGIS TIN-Interpolator...") net.calcIsoTinInterpolation(iso_pointcloud_layer, cell_size, output_path) feedback.setProgress(70) - + fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 254, 0)) fields.append(QgsField('cost_level', QVariant.Double, '', 20, 7)) - - (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT_POLYGONS, context, fields, QgsWkbTypes.Polygon, network.sourceCrs()) - + + (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT_POLYGONS, context, fields, QgsWkbTypes.Polygon, network.sourceCrs()) + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Polygons using numpy and matplotlib...") polygon_featurelist = net.calcIsoPolygons(max_dist, interval, output_path) feedback.setProgress(90) - + sink.addFeatures(polygon_featurelist, QgsFeatureSink.FastInsert) feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") feedback.setProgress(100) - + results = {} results[self.OUTPUT_INTERPOLATION] = output_path results[self.OUTPUT_POLYGONS] = dest_id return results - - diff --git a/algs/IsoAreaAsQneatInterpolationFromPoint.py b/algs/IsoAreaAsQneatInterpolationFromPoint.py index 2684eff..9318695 100644 --- a/algs/IsoAreaAsQneatInterpolationFromPoint.py +++ b/algs/IsoAreaAsQneatInterpolationFromPoint.py @@ -3,10 +3,10 @@ *************************************************************************** IsoAreaAsQneatInterpolationPoint.py --------------------- - - Partially based on QGIS3 network analysis algorithms. - Copyright 2016 Alexander Bruy - + + Partially based on QGIS3 network analysis algorithms. + Copyright 2016 Alexander Bruy + Date : July 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -91,7 +91,7 @@ def group(self): def groupId(self): return 'isoareas' - + def name(self): return 'isoareaasqneatinterpolationfrompoint' @@ -111,7 +111,7 @@ def shortHelpString(self): "Output:
"\ "The output of the algorithm is one layer:"\ "
  • TIN-Interpolation Distance Raster
" - + def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -127,13 +127,13 @@ def initAlgorithm(self, config=None): self.STRATEGIES = [self.tr('Shortest distance'), self.tr('Fastest time') ] - + self.METHODS = [self.tr('QGIS TIN-Interpolation (faster but not exact)'), self.tr('QNEAT-Interpolation (slower but more exact') ] self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - + self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), @@ -192,12 +192,12 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) self.addParameter(p) - + self.addParameter(QgsProcessingParameterRasterDestination(self.OUTPUT, self.tr('Output Interpolation'))) def processAlgorithm(self, parameters, context, feedback): @@ -223,24 +223,24 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() input_coordinates = [startPoint] input_point = getFeatureFromPointParameter(startPoint) - + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") - feedback.setProgress(10) + feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - + analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], entry_cost_calc_method, feedback) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints([analysis_point], max_dist) feedback.setProgress(70) - + uri = "Point?crs={}&field=vertex_id:int(254)&field=cost:double(254,7)&field=origin_point_id:string(254)&index=yes".format(analysisCrs.authid()) - + iso_pointcloud_layer = QgsVectorLayer(uri, "iso_pointcloud_layer", "memory") iso_pointcloud_provider = iso_pointcloud_layer.dataProvider() iso_pointcloud_provider.addFeatures(iso_pointcloud, QgsFeatureSink.FastInsert) - + feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Interpolation-Raster using QGIS TIN-Interpolator...") if interpolation_method == 0: feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Interpolation-Raster using QGIS TIN-Interpolator...") @@ -252,84 +252,84 @@ def processAlgorithm(self, parameters, context, feedback): #prepare numpy coordinate grids NoData_value = -9999 raster_rectangle = iso_pointcloud_layer.extent() - + #implement spatial index for lines (closest line, etc...) spt_idx = QgsSpatialIndex(iso_pointcloud_layer.getFeatures(QgsFeatureRequest()), feedback) - + #top left point xmin = raster_rectangle.xMinimum() ymin = raster_rectangle.yMinimum() xmax = raster_rectangle.xMaximum() ymax = raster_rectangle.yMaximum() - + cols = int((xmax - xmin) / cell_size) rows = int((ymax - ymin) / cell_size) - + output_interpolation_raster = gdal.GetDriverByName('GTiff').Create(output_path, cols, rows, 1, gdal.GDT_Float64 ) output_interpolation_raster.SetGeoTransform((xmin, cell_size, 0, ymax, 0, -cell_size)) - + band = output_interpolation_raster.GetRasterBand(1) band.SetNoDataValue(NoData_value) - + #initialize zero array with 2 dimensions (according to rows and cols) raster_routingcost_data = zeros(shape=(rows, cols)) - + #compute raster cell MIDpoints x_pos = linspace(xmin+(cell_size/2), xmax -(cell_size/2), raster_routingcost_data.shape[1]) y_pos = linspace(ymax-(cell_size/2), ymin + (cell_size/2), raster_routingcost_data.shape[0]) - x_grid, y_grid = meshgrid(x_pos, y_pos) - + x_grid, y_grid = meshgrid(x_pos, y_pos) + feedback.pushInfo('[QNEAT3Network][calcQneatInterpolation] Beginning with interpolation') total_work = rows * cols counter = 0 - + feedback.pushInfo('[QNEAT3Network][calcQneatInterpolation] Total workload: {} cells'.format(total_work)) feedback.setProgress(0) for i in range(rows): for j in range(cols): current_pixel_midpoint = QgsPointXY(x_grid[i,j],y_grid[i,j]) - + nearest_vertex_fid = spt_idx.nearestNeighbor(current_pixel_midpoint, 1)[0] - + nearest_feature = iso_pointcloud_layer.getFeature(nearest_vertex_fid) - + nearest_vertex = net.network.vertex(nearest_feature['vertex_id']) - - #yields a list of all incoming and outgoing edges - edges = nearest_vertex.incomingEdges() + nearest_vertex.outgoingEdges() - + + #yields a list of all incoming and outgoing edges + edges = nearest_vertex.incomingEdges() + nearest_vertex.outgoingEdges() + vertex_found = False nearest_counter = 2 while vertex_found == False: #find the second nearest vertex (eg, the vertex with least cost of all edges incoming to the first nearest vertex) - second_nearest_feature_fid = spt_idx.nearestNeighbor(current_pixel_midpoint, nearest_counter)[nearest_counter-1] + second_nearest_feature_fid = spt_idx.nearestNeighbor(current_pixel_midpoint, nearest_counter)[nearest_counter-1] second_nearest_feature = iso_pointcloud_layer.getFeature(second_nearest_feature_fid) second_nearest_vertex_id = second_nearest_feature['vertex_id'] - + for edge_id in edges: from_vertex_id = net.network.edge(edge_id).fromVertex() to_vertex_id = net.network.edge(edge_id).toVertex() - - if second_nearest_vertex_id == from_vertex_id: + + if second_nearest_vertex_id == from_vertex_id: vertex_found = True vertex_type = "from_vertex" from_point = second_nearest_feature.geometry().asPoint() from_vertex_cost = second_nearest_feature['cost'] - + if second_nearest_vertex_id == to_vertex_id: vertex_found = True vertex_type = "to_vertex" to_point = second_nearest_feature.geometry().asPoint() to_vertex_cost = second_nearest_feature['cost'] - - + + nearest_counter = nearest_counter + 1 """ if nearest_counter == 5: vertex_found = True vertex_type = "end_vertex" """ - + if vertex_type == "from_vertex": nearest_edge_geometry = QgsGeometry().fromPolylineXY([from_point, nearest_vertex.point()]) res = nearest_edge_geometry.closestSegmentWithContext(current_pixel_midpoint) @@ -354,34 +354,34 @@ def processAlgorithm(self, parameters, context, feedback): raster_routingcost_data[i,j] = pixel_cost else: pixel_cost = -99999#nearest_feature['cost'] + (nearest_vertex.point().distance(current_pixel_midpoint)) - - + + """ nearest_feature_pointxy = nearest_feature.geometry().asPoint() nearest_feature_cost = nearest_feature['cost'] - + dist_to_vertex = current_pixel_midpoint.distance(nearest_feature_pointxy) #implement time cost pixel_cost = dist_to_vertex + nearest_feature_cost - + raster_data[i,j] = pixel_cost """ counter = counter+1 if counter%1000 == 0: feedback.pushInfo("[QNEAT3Network][calcQneatInterpolation] Interpolated {} cells...".format(counter)) feedback.setProgress((counter/total_work)*100) - - + + band.WriteArray(raster_routingcost_data) outRasterSRS = osr.SpatialReference() outRasterSRS.ImportFromWkt(net.AnalysisCrs.toWkt()) output_interpolation_raster.SetProjection(outRasterSRS.ExportToWkt()) band.FlushCache() - + feedback.pushInfo("[QNEAT3Algorithm] Ending Algorithm") - feedback.setProgress(100) - + feedback.setProgress(100) + results = {} results[self.OUTPUT] = output_path - return results \ No newline at end of file + return results diff --git a/algs/OdMatrixFromLayersAsLines.py b/algs/OdMatrixFromLayersAsLines.py index 925f530..01d4ad1 100644 --- a/algs/OdMatrixFromLayersAsLines.py +++ b/algs/OdMatrixFromLayersAsLines.py @@ -191,7 +191,7 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) diff --git a/algs/OdMatrixFromLayersAsTable.py b/algs/OdMatrixFromLayersAsTable.py index acbd040..9b15437 100644 --- a/algs/OdMatrixFromLayersAsTable.py +++ b/algs/OdMatrixFromLayersAsTable.py @@ -188,7 +188,7 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) diff --git a/algs/OdMatrixFromPointsAsCsv.py b/algs/OdMatrixFromPointsAsCsv.py index c00bfa4..038ee6c 100644 --- a/algs/OdMatrixFromPointsAsCsv.py +++ b/algs/OdMatrixFromPointsAsCsv.py @@ -170,7 +170,7 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) diff --git a/algs/OdMatrixFromPointsAsLines.py b/algs/OdMatrixFromPointsAsLines.py index 8d9c287..8c1767f 100644 --- a/algs/OdMatrixFromPointsAsLines.py +++ b/algs/OdMatrixFromPointsAsLines.py @@ -175,7 +175,7 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) diff --git a/algs/OdMatrixFromPointsAsTable.py b/algs/OdMatrixFromPointsAsTable.py index c211b26..7d20b35 100644 --- a/algs/OdMatrixFromPointsAsTable.py +++ b/algs/OdMatrixFromPointsAsTable.py @@ -174,7 +174,7 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) diff --git a/algs/ShortestPathBetweenPoints.py b/algs/ShortestPathBetweenPoints.py index d45ff59..afda8a3 100644 --- a/algs/ShortestPathBetweenPoints.py +++ b/algs/ShortestPathBetweenPoints.py @@ -175,7 +175,7 @@ def initAlgorithm(self, config=None): params.append(QgsProcessingParameterNumber(self.TOLERANCE, self.tr('Topology tolerance'), QgsProcessingParameterNumber.Double, - 0.0, False, 0, 99999999.99)) + 0.00001, False, 0, 99999999.99)) for p in params: p.setFlags(p.flags() | QgsProcessingParameterDefinition.FlagAdvanced) From 2c7e4ac17ea99957b5932f1c906ad72f78291422 Mon Sep 17 00:00:00 2001 From: Kufre Date: Wed, 8 Jul 2020 13:11:04 -0400 Subject: [PATCH 08/14] creating exceptions for geographic CRS and CRS mismatch --- algs/IsoAreaAsContoursFromLayer.py | 7 +++++++ algs/IsoAreaAsContoursFromPoint.py | 7 +++++++ algs/IsoAreaAsInterpolationFromLayer.py | 7 +++++++ algs/IsoAreaAsInterpolationFromPoint.py | 7 +++++++ algs/IsoAreaAsPointcloudFromLayer.py | 7 +++++++ algs/IsoAreaAsPointcloudFromPoint.py | 7 +++++++ algs/IsoAreaAsPolygonsFromLayer.py | 7 +++++++ algs/IsoAreaAsPolygonsFromPoint.py | 7 +++++++ algs/IsoAreaAsQneatInterpolationFromPoint.py | 7 +++++++ algs/OdMatrixFromLayersAsLines.py | 7 +++++++ algs/OdMatrixFromLayersAsTable.py | 7 +++++++ algs/OdMatrixFromPointsAsCsv.py | 8 ++++++++ algs/OdMatrixFromPointsAsLines.py | 7 +++++++ algs/OdMatrixFromPointsAsTable.py | 7 +++++++ algs/ShortestPathBetweenPoints.py | 6 ++++++ 15 files changed, 105 insertions(+) diff --git a/algs/IsoAreaAsContoursFromLayer.py b/algs/IsoAreaAsContoursFromLayer.py index c4e94ec..2149cf6 100644 --- a/algs/IsoAreaAsContoursFromLayer.py +++ b/algs/IsoAreaAsContoursFromLayer.py @@ -40,6 +40,7 @@ QgsFields, QgsField, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterField, QgsProcessingParameterNumber, @@ -224,6 +225,12 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() input_coordinates = getListOfPoints(startPoints) + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != startPoints.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/IsoAreaAsContoursFromPoint.py b/algs/IsoAreaAsContoursFromPoint.py index 1620582..679d616 100644 --- a/algs/IsoAreaAsContoursFromPoint.py +++ b/algs/IsoAreaAsContoursFromPoint.py @@ -40,6 +40,7 @@ QgsFields, QgsField, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterPoint, QgsProcessingParameterField, @@ -219,6 +220,12 @@ def processAlgorithm(self, parameters, context, feedback): input_coordinates = [startPoint] input_point = getFeatureFromPointParameter(startPoint) + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != startPoint.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/IsoAreaAsInterpolationFromLayer.py b/algs/IsoAreaAsInterpolationFromLayer.py index f352af6..665ca2a 100644 --- a/algs/IsoAreaAsInterpolationFromLayer.py +++ b/algs/IsoAreaAsInterpolationFromLayer.py @@ -36,6 +36,7 @@ from qgis.core import (QgsFeatureSink, QgsVectorLayer, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterField, QgsProcessingParameterNumber, @@ -212,6 +213,12 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() input_coordinates = getListOfPoints(startPoints) + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != startPoints.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/IsoAreaAsInterpolationFromPoint.py b/algs/IsoAreaAsInterpolationFromPoint.py index 4a872e8..01bde61 100644 --- a/algs/IsoAreaAsInterpolationFromPoint.py +++ b/algs/IsoAreaAsInterpolationFromPoint.py @@ -36,6 +36,7 @@ from qgis.core import (QgsFeatureSink, QgsVectorLayer, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterPoint, QgsProcessingParameterField, @@ -205,6 +206,12 @@ def processAlgorithm(self, parameters, context, feedback): input_coordinates = [startPoint] input_point = getFeatureFromPointParameter(startPoint) + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != startPoint.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/IsoAreaAsPointcloudFromLayer.py b/algs/IsoAreaAsPointcloudFromLayer.py index 819e70d..5dfd9ab 100644 --- a/algs/IsoAreaAsPointcloudFromLayer.py +++ b/algs/IsoAreaAsPointcloudFromLayer.py @@ -39,6 +39,7 @@ QgsFields, QgsField, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterField, QgsProcessingParameterNumber, @@ -210,6 +211,12 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() input_coordinates = getListOfPoints(startPoints) + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != startPoints.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/IsoAreaAsPointcloudFromPoint.py b/algs/IsoAreaAsPointcloudFromPoint.py index b1c4322..a96e1e7 100644 --- a/algs/IsoAreaAsPointcloudFromPoint.py +++ b/algs/IsoAreaAsPointcloudFromPoint.py @@ -39,6 +39,7 @@ QgsFields, QgsField, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterPoint, QgsProcessingParameterField, @@ -204,6 +205,12 @@ def processAlgorithm(self, parameters, context, feedback): input_coordinates = [startPoint] input_point = getFeatureFromPointParameter(startPoint) + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != startPoint.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/IsoAreaAsPolygonsFromLayer.py b/algs/IsoAreaAsPolygonsFromLayer.py index a1328b2..32c8583 100644 --- a/algs/IsoAreaAsPolygonsFromLayer.py +++ b/algs/IsoAreaAsPolygonsFromLayer.py @@ -40,6 +40,7 @@ QgsFields, QgsField, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterField, QgsProcessingParameterNumber, @@ -224,6 +225,12 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() input_coordinates = getListOfPoints(startPoints) + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != startPoints.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/IsoAreaAsPolygonsFromPoint.py b/algs/IsoAreaAsPolygonsFromPoint.py index 0e96396..8d0dfbc 100644 --- a/algs/IsoAreaAsPolygonsFromPoint.py +++ b/algs/IsoAreaAsPolygonsFromPoint.py @@ -40,6 +40,7 @@ QgsFields, QgsField, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterPoint, QgsProcessingParameterField, @@ -218,6 +219,12 @@ def processAlgorithm(self, parameters, context, feedback): input_coordinates = [startPoint] input_point = getFeatureFromPointParameter(startPoint) + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != startPoint.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/IsoAreaAsQneatInterpolationFromPoint.py b/algs/IsoAreaAsQneatInterpolationFromPoint.py index 9318695..6f4ff08 100644 --- a/algs/IsoAreaAsQneatInterpolationFromPoint.py +++ b/algs/IsoAreaAsQneatInterpolationFromPoint.py @@ -45,6 +45,7 @@ QgsFeatureRequest, QgsGeometry, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterPoint, QgsProcessingParameterField, @@ -224,6 +225,12 @@ def processAlgorithm(self, parameters, context, feedback): input_coordinates = [startPoint] input_point = getFeatureFromPointParameter(startPoint) + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != startPoint.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/OdMatrixFromLayersAsLines.py b/algs/OdMatrixFromLayersAsLines.py index 01d4ad1..86aa3c1 100644 --- a/algs/OdMatrixFromLayersAsLines.py +++ b/algs/OdMatrixFromLayersAsLines.py @@ -41,6 +41,7 @@ QgsGeometry, QgsFeatureSink, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterFeatureSink, QgsProcessingParameterFeatureSource, @@ -220,6 +221,12 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != from_points.sourceCrs() or from_points.sourceCrs() != to_points.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + #Points of both layers have to be merged into one layer --> then tied to the Qneat3Network #get point list of from layer from_coord_list = getListOfPoints(from_points) diff --git a/algs/OdMatrixFromLayersAsTable.py b/algs/OdMatrixFromLayersAsTable.py index 9b15437..e50b385 100644 --- a/algs/OdMatrixFromLayersAsTable.py +++ b/algs/OdMatrixFromLayersAsTable.py @@ -40,6 +40,7 @@ QgsFeature, QgsFeatureSink, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterFeatureSink, QgsProcessingParameterFeatureSource, @@ -217,6 +218,12 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != from_points.sourceCrs() or from_points.sourceCrs() != to_points.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + #Points of both layers have to be merged into one layer --> then tied to the Qneat3Network #get point list of from layer from_coord_list = getListOfPoints(from_points) diff --git a/algs/OdMatrixFromPointsAsCsv.py b/algs/OdMatrixFromPointsAsCsv.py index 038ee6c..4dfab1f 100644 --- a/algs/OdMatrixFromPointsAsCsv.py +++ b/algs/OdMatrixFromPointsAsCsv.py @@ -35,6 +35,7 @@ from qgis.PyQt.QtGui import QIcon from qgis.core import (QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterFileDestination, QgsProcessingParameterFeatureSource, @@ -199,6 +200,13 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != points.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, points, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/OdMatrixFromPointsAsLines.py b/algs/OdMatrixFromPointsAsLines.py index 8c1767f..7aeb90f 100644 --- a/algs/OdMatrixFromPointsAsLines.py +++ b/algs/OdMatrixFromPointsAsLines.py @@ -41,6 +41,7 @@ QgsFeature, QgsFeatureSink, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterFeatureSink, QgsProcessingParameterFeatureSource, @@ -203,6 +204,12 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != points.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, points, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/OdMatrixFromPointsAsTable.py b/algs/OdMatrixFromPointsAsTable.py index 7d20b35..c43d92d 100644 --- a/algs/OdMatrixFromPointsAsTable.py +++ b/algs/OdMatrixFromPointsAsTable.py @@ -40,6 +40,7 @@ QgsFeature, QgsFeatureSink, QgsProcessing, + QgsProcessingException, QgsProcessingParameterEnum, QgsProcessingParameterFeatureSink, QgsProcessingParameterFeatureSource, @@ -201,6 +202,12 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != points.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, points, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/ShortestPathBetweenPoints.py b/algs/ShortestPathBetweenPoints.py index afda8a3..76230ff 100644 --- a/algs/ShortestPathBetweenPoints.py +++ b/algs/ShortestPathBetweenPoints.py @@ -205,6 +205,12 @@ def processAlgorithm(self, parameters, context, feedback): analysisCrs = network.sourceCrs() + if analysisCrs.isGeographic(): + raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') + + if analysisCrs != startPoint.sourceCrs() | startPoint.sourceCrs() != endPoint.sourceCrs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + input_qgspointxy_list = [startPoint,endPoint] input_points = [getFeatureFromPointParameter(startPoint),getFeatureFromPointParameter(endPoint)] From 319e05fc85c66425bd5d09b0c8a734c63fa92151 Mon Sep 17 00:00:00 2001 From: Kufre Date: Wed, 8 Jul 2020 15:20:13 -0400 Subject: [PATCH 09/14] clarifying units of outputs --- algs/IsoAreaAsContoursFromLayer.py | 5 +++-- algs/IsoAreaAsContoursFromPoint.py | 5 +++-- algs/IsoAreaAsInterpolationFromLayer.py | 5 +++-- algs/IsoAreaAsInterpolationFromPoint.py | 5 +++-- algs/IsoAreaAsPointcloudFromLayer.py | 5 +++-- algs/IsoAreaAsPointcloudFromPoint.py | 5 +++-- algs/IsoAreaAsPolygonsFromLayer.py | 5 +++-- algs/IsoAreaAsPolygonsFromPoint.py | 5 +++-- algs/IsoAreaAsQneatInterpolationFromPoint.py | 5 +++-- algs/OdMatrixFromLayersAsLines.py | 5 +++-- algs/OdMatrixFromLayersAsTable.py | 5 +++-- algs/OdMatrixFromPointsAsCsv.py | 5 +++-- algs/OdMatrixFromPointsAsLines.py | 5 +++-- algs/OdMatrixFromPointsAsTable.py | 5 +++-- algs/ShortestPathBetweenPoints.py | 5 +++-- 15 files changed, 45 insertions(+), 30 deletions(-) diff --git a/algs/IsoAreaAsContoursFromLayer.py b/algs/IsoAreaAsContoursFromLayer.py index 2149cf6..ca1ff39 100644 --- a/algs/IsoAreaAsContoursFromLayer.py +++ b/algs/IsoAreaAsContoursFromLayer.py @@ -108,7 +108,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm are two layers:"\ - "
  • TIN-Interpolation Distance Raster
  • Iso-Area Contours with cost levels as attributes
" + "
  • TIN-Interpolation Distance Raster
  • Iso-Area Contours with cost levels as attributes
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -181,7 +182,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/IsoAreaAsContoursFromPoint.py b/algs/IsoAreaAsContoursFromPoint.py index 679d616..94755db 100644 --- a/algs/IsoAreaAsContoursFromPoint.py +++ b/algs/IsoAreaAsContoursFromPoint.py @@ -108,7 +108,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm are two layers:"\ - "
  • TIN-Interpolation Distance Raster
  • Iso-Area Contours with cost levels as attributes
" + "
  • TIN-Interpolation Distance Raster
  • Iso-Area Contours with cost levels as attributes
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def msg(self, var): @@ -176,7 +177,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/IsoAreaAsInterpolationFromLayer.py b/algs/IsoAreaAsInterpolationFromLayer.py index 665ca2a..b13d298 100644 --- a/algs/IsoAreaAsInterpolationFromLayer.py +++ b/algs/IsoAreaAsInterpolationFromLayer.py @@ -101,7 +101,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one layer:"\ - "
  • TIN-Interpolation Distance Raster
" + "
  • TIN-Interpolation Distance Raster
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def msg(self, var): @@ -171,7 +172,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/IsoAreaAsInterpolationFromPoint.py b/algs/IsoAreaAsInterpolationFromPoint.py index 01bde61..665d78c 100644 --- a/algs/IsoAreaAsInterpolationFromPoint.py +++ b/algs/IsoAreaAsInterpolationFromPoint.py @@ -101,7 +101,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one layer:"\ - "
  • TIN-Interpolation Distance Raster
" + "
  • TIN-Interpolation Distance Raster
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -164,7 +165,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/IsoAreaAsPointcloudFromLayer.py b/algs/IsoAreaAsPointcloudFromLayer.py index 5dfd9ab..e77adf6 100644 --- a/algs/IsoAreaAsPointcloudFromLayer.py +++ b/algs/IsoAreaAsPointcloudFromLayer.py @@ -104,7 +104,8 @@ def shortHelpString(self): "Output:
"\ "The output of the algorithm is one layer:"\ "
  • Point layer of reachable network nodes

"\ - "You may use the output pointcloud as input for further analyses." + "You may use the output pointcloud as input for further analyses."\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -169,7 +170,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/IsoAreaAsPointcloudFromPoint.py b/algs/IsoAreaAsPointcloudFromPoint.py index a96e1e7..b1c49ee 100644 --- a/algs/IsoAreaAsPointcloudFromPoint.py +++ b/algs/IsoAreaAsPointcloudFromPoint.py @@ -104,7 +104,8 @@ def shortHelpString(self): "Output:
"\ "The output of the algorithm is one layer:"\ "
  • Point layer of reachable network nodes

"\ - "You may use the output pointcloud as input for further analyses." + "You may use the output pointcloud as input for further analyses."\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -163,7 +164,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/IsoAreaAsPolygonsFromLayer.py b/algs/IsoAreaAsPolygonsFromLayer.py index 32c8583..74fe854 100644 --- a/algs/IsoAreaAsPolygonsFromLayer.py +++ b/algs/IsoAreaAsPolygonsFromLayer.py @@ -108,7 +108,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm are two layers:"\ - "
  • TIN-Interpolation Distance Raster
  • Iso-Area Polygons with cost levels as attributes
" + "
  • TIN-Interpolation Distance Raster
  • Iso-Area Polygons with cost levels as attributes
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -181,7 +182,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/IsoAreaAsPolygonsFromPoint.py b/algs/IsoAreaAsPolygonsFromPoint.py index 8d0dfbc..9999b7b 100644 --- a/algs/IsoAreaAsPolygonsFromPoint.py +++ b/algs/IsoAreaAsPolygonsFromPoint.py @@ -102,7 +102,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm are two layers:"\ - "
  • TIN-Interpolation Distance Raster
  • Iso-Area Polygons with cost levels as attributes
" + "
  • TIN-Interpolation Distance Raster
  • Iso-Area Polygons with cost levels as attributes
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def name(self): return 'isoareaaspolygonsfrompoint' @@ -175,7 +176,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/IsoAreaAsQneatInterpolationFromPoint.py b/algs/IsoAreaAsQneatInterpolationFromPoint.py index 6f4ff08..d9eb3d6 100644 --- a/algs/IsoAreaAsQneatInterpolationFromPoint.py +++ b/algs/IsoAreaAsQneatInterpolationFromPoint.py @@ -111,7 +111,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one layer:"\ - "
  • TIN-Interpolation Distance Raster
" + "
  • TIN-Interpolation Distance Raster
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -182,7 +183,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/OdMatrixFromLayersAsLines.py b/algs/OdMatrixFromLayersAsLines.py index 86aa3c1..b853983 100644 --- a/algs/OdMatrixFromLayersAsLines.py +++ b/algs/OdMatrixFromLayersAsLines.py @@ -106,7 +106,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one layer:"\ - "
  • OD Matrix as lines with network based distances as attributes
" + "
  • OD Matrix as lines with network based distances as attributes
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def print_typestring(self, var): @@ -181,7 +182,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/OdMatrixFromLayersAsTable.py b/algs/OdMatrixFromLayersAsTable.py index e50b385..c07c9e6 100644 --- a/algs/OdMatrixFromLayersAsTable.py +++ b/algs/OdMatrixFromLayersAsTable.py @@ -105,7 +105,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one table:"\ - "
  • OD Matrix as table with network based distances as attributes
" + "
  • OD Matrix as table with network based distances as attributes
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def print_typestring(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -178,7 +179,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/OdMatrixFromPointsAsCsv.py b/algs/OdMatrixFromPointsAsCsv.py index 4dfab1f..450aee3 100644 --- a/algs/OdMatrixFromPointsAsCsv.py +++ b/algs/OdMatrixFromPointsAsCsv.py @@ -98,7 +98,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one file:"\ - "
  • OD Matrix as csv-file with network based distances as attributes
" + "
  • OD Matrix as csv-file with network based distances as attributes
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def print_typestring(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -160,7 +161,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/OdMatrixFromPointsAsLines.py b/algs/OdMatrixFromPointsAsLines.py index 7aeb90f..3088607 100644 --- a/algs/OdMatrixFromPointsAsLines.py +++ b/algs/OdMatrixFromPointsAsLines.py @@ -104,7 +104,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one layer:"\ - "
  • OD Matrix as lines with network based distances as attributes
" + "
  • OD Matrix as lines with network based distances as attributes
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def print_typestring(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -165,7 +166,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/OdMatrixFromPointsAsTable.py b/algs/OdMatrixFromPointsAsTable.py index c43d92d..c67a659 100644 --- a/algs/OdMatrixFromPointsAsTable.py +++ b/algs/OdMatrixFromPointsAsTable.py @@ -103,7 +103,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is one table:"\ - "
  • OD Matrix as table with network based distances as attributes
" + "
  • OD Matrix as table with network based distances as attributes
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def print_typestring(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -164,7 +165,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) diff --git a/algs/ShortestPathBetweenPoints.py b/algs/ShortestPathBetweenPoints.py index 76230ff..fd4f3aa 100644 --- a/algs/ShortestPathBetweenPoints.py +++ b/algs/ShortestPathBetweenPoints.py @@ -106,7 +106,8 @@ def shortHelpString(self): "
  • Direction Field
  • Value for forward direction
  • Value for backward direction
  • Value for both directions
  • Default direction
  • Speed Field
  • Default Speed (affects entry/exit costs)
  • Topology tolerance

"\ "Output:
"\ "The output of the algorithm is a Layer containing a single linestring, the attributes showcase the"\ - "
  • Name and coordinates of startpoint
  • Name and coordinates of endpoint
  • Entry-cost to enter network
  • Exit-cost to exit network
  • Cost of shortest path on graph
  • Total cost as sum of all cost elements
" + "
  • Name and coordinates of startpoint
  • Name and coordinates of endpoint
  • Entry-cost to enter network
  • Exit-cost to exit network
  • Cost of shortest path on graph
  • Total cost as sum of all cost elements
"\ + "Shortest distance cost units are meters and Fastest time cost units are seconds." def msg(self, var): return "Type:"+str(type(var))+" repr: "+var.__str__() @@ -164,7 +165,7 @@ def initAlgorithm(self, config=None): list(self.DIRECTIONS.keys()), defaultValue=2)) params.append(QgsProcessingParameterField(self.SPEED_FIELD, - self.tr('Speed field'), + self.tr('Speed field (km/h)'), None, self.INPUT, optional=True)) From 6cc455a9e4f3b063dc30cbbe05847176abc7a1ef Mon Sep 17 00:00:00 2001 From: Kufre Date: Thu, 9 Jul 2020 12:28:32 -0400 Subject: [PATCH 10/14] removing distUnit and unit_to_meter_factor --- Qneat3Framework.py | 228 +++++++++++++++++++++------------------------ 1 file changed, 108 insertions(+), 120 deletions(-) diff --git a/Qneat3Framework.py b/Qneat3Framework.py index f531caa..3e6a20d 100644 --- a/Qneat3Framework.py +++ b/Qneat3Framework.py @@ -3,7 +3,7 @@ *************************************************************************** Qneat3Framework.py --------------------- - + Date : January 2018 Copyright : (C) 2018 by Clemens Raffler Email : clemens dot raffler at gmail dot com @@ -24,7 +24,7 @@ from numpy import arange, meshgrid, linspace, nditer, zeros from osgeo import osr -from qgis.core import QgsProject, QgsPoint, QgsVectorLayer, QgsRasterLayer, QgsFeature, QgsFeatureSink, QgsFeatureRequest, QgsFields, QgsField, QgsGeometry, QgsPointXY, QgsLineString, QgsProcessingException, QgsDistanceArea, QgsUnitTypes +from qgis.core import QgsProject, QgsPoint, QgsVectorLayer, QgsRasterLayer, QgsFeature, QgsFeatureSink, QgsFeatureRequest, QgsFields, QgsField, QgsGeometry, QgsPointXY, QgsLineString, QgsProcessingException, QgsDistanceArea, QgsUnitTypes from qgis.analysis import QgsVectorLayerDirector, QgsNetworkDistanceStrategy, QgsNetworkSpeedStrategy, QgsGraphAnalyzer, QgsGraphBuilder, QgsInterpolator, QgsTinInterpolator, QgsGridFileWriter from qgis.PyQt.QtCore import QVariant @@ -38,7 +38,7 @@ class Qneat3Network(): Provides basic logic for more advanced network analysis algorithms """ - def __init__(self, + def __init__(self, input_network, #QgsProcessingParameterFeatureSource input_points, #[QgsPointXY] or QgsProcessingParameterFeatureSource or QgsVectorLayer --> Implement List of QgsFeatures [QgsFeatures] input_strategy, #int @@ -52,12 +52,12 @@ def __init__(self, input_defaultSpeed, #float input_tolerance, #float feedback #feedback object from processing (log window) - ): - + ): + """ Constructor for a Qneat3Network object. @type input_network: QgsProcessingParameterFeatureSource - @param input_network: input network dataset from processing algorithm + @param input_network: input network dataset from processing algorithm @type input_points: QgsProcessingParameterFeatureSource/QgsVectorLayer/[QgsPointXY] @param input_points: input point dataset from processing algorithm @type input_strategy: int @@ -81,17 +81,13 @@ def __init__(self, @type feedback: QgsProcessingFeedback @param feedback: feedback object from processing algorithm """ - + #initialize feedback self.feedback = feedback - + self.feedback.pushInfo("[QNEAT3Network][__init__] Setting up parameters") self.AnalysisCrs = input_analysisCrs - - #enable polygon calculation in geographic coordinate systems - distUnit = self.AnalysisCrs.mapUnits() - self.meter_to_unit_factor = QgsUnitTypes.fromUnitToUnitFactor(QgsUnitTypes.DistanceMeters, distUnit) - + #init direction fields self.feedback.pushInfo("[QNEAT3Network][__init__] Setting up network direction parameters") self.directedAnalysis = self.setNetworkDirection((input_directionFieldName, input_forwardValue, input_backwardValue, input_bothValue, input_defaultDirection)) @@ -109,18 +105,18 @@ def __init__(self, else: self.list_input_points = getListOfPoints(input_points) #[QgsPointXY] self.input_points = input_points - + #Setup cost-strategy pattern. self.feedback.pushInfo("[QNEAT3Network][__init__] Setting analysis strategy: {}".format(input_strategy)) self.default_speed = input_defaultSpeed - + self.setNetworkStrategy(input_strategy, input_network, input_speedField, input_defaultSpeed) #add the strategy to the QgsGraphDirector self.director.addStrategy(self.strategy) self.builder = QgsGraphBuilder(self.AnalysisCrs, True, input_tolerance) #tell the graph-director to make the graph using the builder object and tie the start point geometry to the graph - + self.feedback.pushInfo("[QNEAT3Network][__init__] Start tying analysis points to the graph and building it.") self.feedback.pushInfo("[QNEAT3Network][__init__] This is a compute intensive task and may take some time depending on network size") start_local_time = time.localtime() @@ -134,25 +130,22 @@ def __init__(self, self.feedback.pushInfo("[QNEAT3Network][__init__] End Time: {}".format(time.strftime(":%Y-%m-%d %H:%M:%S", end_local_time))) self.feedback.pushInfo("[QNEAT3Network][__init__] Total Build Time: {}".format(end_time-start_time)) self.feedback.pushInfo("[QNEAT3Network][__init__] Analysis setup complete") - - - def setNetworkDirection(self, directionArgs): + + + def setNetworkDirection(self, directionArgs): if directionArgs.count("") == 0: self.directedAnalysis = True self.directionFieldId, self.input_forwardValue, self.input_backwardValue, self.input_bothValue, self.input_defaultDirection = directionArgs else: self.directedAnalysis = False - + def setNetworkStrategy(self, input_strategy, input_network, input_speedField, input_defaultSpeed): - distUnit = self.AnalysisCrs.mapUnits() - unit_to_meter_factor = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters) - speedFieldId = getFieldIndexFromQgsProcessingFeatureSource(input_network, input_speedField) if input_strategy == 0: self.strategy = QgsNetworkDistanceStrategy() self.strategy_int = 0 else: - self.strategy = QgsNetworkSpeedStrategy(speedFieldId, float(input_defaultSpeed), unit_to_meter_factor * 1000.0 / 3600.0) + self.strategy = QgsNetworkSpeedStrategy(speedFieldId, float(input_defaultSpeed), 1000.0 / 3600.0) self.strategy_int = 1 self.multiplier = 3600 @@ -163,11 +156,11 @@ def calcDijkstra(self, startpoint_id, criterion): dijkstra_query.insert(0, tree) dijkstra_query.insert(1, cost) return dijkstra_query - + def calcShortestTree(self, startpoint_id, criterion): tree = QgsGraphAnalyzer.shortestTree(self.network, startpoint_id, criterion) return tree - + def calcIsoPoints(self, analysis_point_list, max_dist): iso_pointcloud = dict() @@ -176,13 +169,13 @@ def calcIsoPoints(self, analysis_point_list, max_dist): dijkstra_query = self.calcDijkstra(point.network_vertex_id, 0) tree = dijkstra_query[0] cost = dijkstra_query[1] - + current_start_point_id = point.point_id #id of the input point current_vertex_id = point.network_vertex_id entry_cost = point.entry_cost - + field_type = getFieldDatatypeFromPythontype(current_start_point_id) - + #startpoints are not part of the Query so they have to be added manually before #dikstra is called. start_vertex_feat = QgsFeature() @@ -198,12 +191,12 @@ def calcIsoPoints(self, analysis_point_list, max_dist): pt_m.addMValue(entry_cost) geom = QgsGeometry(pt_m) start_vertex_feat.setGeometry(geom) - + iso_pointcloud.update({current_vertex_id: start_vertex_feat}) - + i = 0 while i < len(cost): - #as long as costs at vertex i is greater than iso_distance and there exists an incoming edge (tree[i]!=-1) + #as long as costs at vertex i is greater than iso_distance and there exists an incoming edge (tree[i]!=-1) #consider it as a possible catchment polygon element if tree[i] != -1: fromVertexId = self.network.edge(tree[i]).toVertex() @@ -211,7 +204,7 @@ def calcIsoPoints(self, analysis_point_list, max_dist): #if the costs of the current vertex are lower than the radius, append the vertex id to results. if real_cost <= max_dist: #build feature - + feat = QgsFeature() fields = QgsFields() fields.append(QgsField('vertex_id', QVariant.Int, '', 254, 0)) @@ -226,7 +219,7 @@ def calcIsoPoints(self, analysis_point_list, max_dist): pt_m.addMValue((500-cost[fromVertexId])*2) geom = QgsGeometry(pt_m) feat.setGeometry(geom) - + if fromVertexId not in iso_pointcloud: #ERROR: FIRST POINT IN POINTCLOUD WILL NEVER BE ADDED iso_pointcloud.update({fromVertexId: feat}) @@ -236,80 +229,80 @@ def calcIsoPoints(self, analysis_point_list, max_dist): #iso_pointcloud.pop(toVertexId) iso_pointcloud.update({fromVertexId: feat}) #count up to next vertex - i = i + 1 + i = i + 1 if (i%10000)==0: self.feedback.pushInfo("[QNEAT3Network][calcIsoPoints] Added {} Nodes to iso pointcloud...".format(i)) - + return iso_pointcloud.values() #list of QgsFeature (=QgsFeatureList) - - def calcQneatInterpolation(self,iso_pointcloud_featurelist, resolution, interpolation_raster_path): + + def calcQneatInterpolation(self,iso_pointcloud_featurelist, resolution, interpolation_raster_path): #prepare spatial index uri = 'PointM?crs={}&field=vertex_id:int(254)&field=cost:double(254,7)&key=vertex_id&index=yes'.format(self.AnalysisCrs.authid()) - + mIsoPointcloud = QgsVectorLayer(uri, "mIsoPointcloud_layer", "memory") mIsoPointcloud_provider = mIsoPointcloud.dataProvider() mIsoPointcloud_provider.addFeatures(iso_pointcloud_featurelist, QgsFeatureSink.FastInsert) - + #implement spatial index for lines (closest line, etc...) spt_idx = QgsSpatialIndex(mIsoPointcloud.getFeatures(QgsFeatureRequest()), self.feedback) - + #prepare numpy coordinate grids NoData_value = -9999 raster_rectangle = mIsoPointcloud.extent() - + #top left point xmin = raster_rectangle.xMinimum() ymin = raster_rectangle.yMinimum() xmax = raster_rectangle.xMaximum() ymax = raster_rectangle.yMaximum() - + cols = int((xmax - xmin) / resolution) rows = int((ymax - ymin) / resolution) - + output_interpolation_raster = gdal.GetDriverByName('GTiff').Create(interpolation_raster_path, cols, rows, 1, gdal.GDT_Float64 ) output_interpolation_raster.SetGeoTransform((xmin, resolution, 0, ymax, 0, -resolution)) - + band = output_interpolation_raster.GetRasterBand(1) band.SetNoDataValue(NoData_value) - + #initialize zero array with 2 dimensions (according to rows and cols) raster_data = zeros(shape=(rows, cols)) - + #compute raster cell MIDpoints x_pos = linspace(xmin+(resolution/2), xmax -(resolution/2), raster_data.shape[1]) y_pos = linspace(ymax-(resolution/2), ymin + (resolution/2), raster_data.shape[0]) - x_grid, y_grid = meshgrid(x_pos, y_pos) - + x_grid, y_grid = meshgrid(x_pos, y_pos) + self.feedback.pushInfo('[QNEAT3Network][calcQneatInterpolation] Beginning with interpolation') total_work = rows * cols counter = 0 - + self.feedback.pushInfo('[QNEAT3Network][calcQneatInterpolation] Total workload: {} cells'.format(total_work)) self.feedback.setProgress(0) for i in range(rows): for j in range(cols): current_pixel_midpoint = QgsPointXY(x_grid[i,j],y_grid[i,j]) - + nearest_vertex_fid = spt_idx.nearestNeighbor(current_pixel_midpoint, 1)[0] - + nearest_feature = mIsoPointcloud.getFeature(nearest_vertex_fid) - + nearest_vertex = self.network.vertex(nearest_feature['vertex_id']) - + edges = nearest_vertex.incomingEdges() + nearest_vertex.outgoingEdges() - + vertex_found = False nearest_counter = 2 while vertex_found == False: n_nearest_feature_fid = spt_idx.nearestNeighbor(current_pixel_midpoint, nearest_counter)[nearest_counter-1] n_nearest_feature = mIsoPointcloud.getFeature(n_nearest_feature_fid) n_nearest_vertex_id = n_nearest_feature['vertex_id'] - + for edge_id in edges: from_vertex_id = self.network.edge(edge_id).fromVertex() to_vertex_id = self.network.edge(edge_id).toVertex() - - if n_nearest_vertex_id == from_vertex_id: + + if n_nearest_vertex_id == from_vertex_id: vertex_found = True vertex_type = "from_vertex" from_point = n_nearest_feature.geometry().asPoint() @@ -319,14 +312,14 @@ def calcQneatInterpolation(self,iso_pointcloud_featurelist, resolution, interpol vertex_type = "to_vertex" to_point = n_nearest_feature.geometry().asPoint() to_vertex_cost = n_nearest_feature['cost'] - + nearest_counter = nearest_counter + 1 """ if nearest_counter == 5: vertex_found = True vertex_type = "end_vertex" """ - + if vertex_type == "from_vertex": nearest_edge_geometry = QgsGeometry().fromPolylineXY([from_point, nearest_vertex.point()]) res = nearest_edge_geometry.closestSegmentWithContext(current_pixel_midpoint) @@ -351,98 +344,98 @@ def calcQneatInterpolation(self,iso_pointcloud_featurelist, resolution, interpol raster_data[i,j] = pixel_cost else: pixel_cost = -99999#nearest_feature['cost'] + (nearest_vertex.point().distance(current_pixel_midpoint)) - - + + """ nearest_feature_pointxy = nearest_feature.geometry().asPoint() nearest_feature_cost = nearest_feature['cost'] - + dist_to_vertex = current_pixel_midpoint.distance(nearest_feature_pointxy) #implement time cost pixel_cost = dist_to_vertex + nearest_feature_cost - + raster_data[i,j] = pixel_cost """ counter = counter+1 if counter%1000 == 0: self.feedback.pushInfo("[QNEAT3Network][calcQneatInterpolation] Interpolated {} cells...".format(counter)) self.feedback.setProgress((counter/total_work)*100) - - + + band.WriteArray(raster_data) outRasterSRS = osr.SpatialReference() outRasterSRS.ImportFromWkt(self.AnalysisCrs.toWkt()) output_interpolation_raster.SetProjection(outRasterSRS.ExportToWkt()) band.FlushCache() - - + + def calcIsoTinInterpolation(self, iso_point_layer, resolution, interpolation_raster_path): if self.AnalysisCrs.isGeographic(): raise QgsProcessingException('The TIN-Interpolation algorithm in QGIS is designed to work with projected coordinate systems.Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') - + layer_data = QgsInterpolator.LayerData() QgsInterpolator.LayerData - + layer_data.source = iso_point_layer #in QGIS2: vectorLayer layer_data.valueSource = QgsInterpolator.ValueAttribute layer_data.interpolationAttribute = 1 #take second field to get costs layer_data.sourceType = QgsInterpolator.SourcePoints tin_interpolator = QgsTinInterpolator([layer_data], QgsTinInterpolator.Linear) - + rect = iso_point_layer.extent() ncol = int((rect.xMaximum() - rect.xMinimum()) / resolution) nrows = int((rect.yMaximum() - rect.yMinimum()) / resolution) - + writer = QgsGridFileWriter(tin_interpolator, interpolation_raster_path, rect, ncol, nrows) writer.writeFile(self.feedback) # Creating .asc raste return QgsRasterLayer(interpolation_raster_path, "temp_qneat3_interpolation_raster") def calcIsoContours(self, max_dist, interval, interpolation_raster_path): featurelist = [] - + try: import matplotlib.pyplot as plt except: return featurelist - + ds_in = gdal.Open(interpolation_raster_path) band_in = ds_in.GetRasterBand(1) xsize_in = band_in.XSize ysize_in = band_in.YSize - + geotransform_in = ds_in.GetGeoTransform() - + srs = osr.SpatialReference() srs.ImportFromWkt( ds_in.GetProjectionRef() ) raster_values = band_in.ReadAsArray(0, 0, xsize_in, ysize_in) raster_values[raster_values < 0] = max_dist + 1000 #necessary to produce rectangular array from raster #nodata values get replaced by the maximum value + 1 - + x_pos = linspace(geotransform_in[0], geotransform_in[0] + geotransform_in[1] * raster_values.shape[1], raster_values.shape[1]) y_pos = linspace(geotransform_in[3], geotransform_in[3] + geotransform_in[5] * raster_values.shape[0], raster_values.shape[0]) - x_grid, y_grid = meshgrid(x_pos, y_pos) - + x_grid, y_grid = meshgrid(x_pos, y_pos) + start = interval end = interval * ceil(max_dist/interval) +interval - + levels = arange(start, end, interval) - + fid = 0 for current_level in nditer(levels): self.feedback.pushInfo("[QNEAT3Network][calcIsoContours] Calculating {}-level contours".format(current_level)) contours = plt.contourf(x_grid, y_grid, raster_values, [0, current_level], antialiased=True) - + for collection in contours.collections: - for contour_paths in collection.get_paths(): + for contour_paths in collection.get_paths(): for polygon in contour_paths.to_polygons(): x = polygon[:,0] y = polygon[:,1] polylinexy_list = [QgsPointXY(i[0], i[1]) for i in zip(x,y)] - + feat = QgsFeature() fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 254, 0)) @@ -453,61 +446,61 @@ def calcIsoContours(self, max_dist, interval, interpolation_raster_path): feat['id'] = fid feat['cost_level'] = float(current_level) featurelist.insert(0, feat) - - fid=fid+1 + + fid=fid+1 return featurelist - - + + def calcIsoPolygons(self, max_dist, interval, interpolation_raster_path): featurelist = [] - + try: import matplotlib.pyplot as plt except: return featurelist - + ds_in = gdal.Open(interpolation_raster_path) band_in = ds_in.GetRasterBand(1) xsize_in = band_in.XSize ysize_in = band_in.YSize - + geotransform_in = ds_in.GetGeoTransform() - + srs = osr.SpatialReference() srs.ImportFromWkt( ds_in.GetProjectionRef() ) raster_values = band_in.ReadAsArray(0, 0, xsize_in, ysize_in) raster_values[raster_values < 0] = max_dist + 1000 #necessary to produce rectangular array from raster #nodata values get replaced by the maximum value + 1 - + x_pos = linspace(geotransform_in[0], geotransform_in[0] + geotransform_in[1] * raster_values.shape[1], raster_values.shape[1]) y_pos = linspace(geotransform_in[3], geotransform_in[3] + geotransform_in[5] * raster_values.shape[0], raster_values.shape[0]) - x_grid, y_grid = meshgrid(x_pos, y_pos) - + x_grid, y_grid = meshgrid(x_pos, y_pos) + start = interval end = interval * ceil(max_dist/interval) +interval - + levels = arange(start, end, interval) fid = 0 for current_level in nditer(levels): self.feedback.pushInfo("[QNEAT3Network][calcIsoPolygons] calculating {}-level contours".format(current_level)) contours = plt.contourf(x_grid, y_grid, raster_values, [0, current_level], antialiased=True) - - + + for collection in contours.collections: - for contour_path in collection.get_paths(): - + for contour_path in collection.get_paths(): + polygon_list = [] - + for vertex in contour_path.to_polygons(): x = vertex[:,0] y = vertex[:,1] polylinexy_list = [QgsPointXY(i[0], i[1]) for i in zip(x,y)] polygon_list.append(polylinexy_list) - + feat = QgsFeature() fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 254, 0)) @@ -517,21 +510,21 @@ def calcIsoPolygons(self, max_dist, interval, interpolation_raster_path): feat.setGeometry(geom) feat['id'] = fid feat['cost_level'] = float(current_level) - + featurelist.insert(0, feat) - fid=fid+1 + fid=fid+1 """Maybe move to algorithm""" #featurelist = featurelist[::-1] #reverse self.feedback.pushInfo("[QNEAT3Network][calcIsoPolygons] number of elements in contour_featurelist: {}".format(len(featurelist))) return featurelist - + class Qneat3AnalysisPoint(): - + def __init__(self, layer_name, feature, point_id_field_name, net, vertex_geom, entry_cost_calculation_method, feedback): self.layer_name = layer_name self.point_feature = feature - self.point_id = feature[point_id_field_name] + self.point_id = feature[point_id_field_name] self.point_geom = feature.geometry().asPoint() self.network_vertex_id = self.getNearestVertexId(net.network, vertex_geom) self.network_vertex = self.getNearestVertex(net.network, vertex_geom) @@ -544,7 +537,7 @@ def __init__(self, layer_name, feature, point_id_field_name, net, vertex_geom, e self.entry_cost = self.calcEntryCostPlanar(feedback) else: self.entry_cost = self.calcEntryCostEllipsoidal(feedback) - + def calcEntryCostEllipsoidal(self, feedback): dist_calculator = QgsDistanceArea() dist_calculator.setSourceCrs(QgsProject().instance().crs(), QgsProject().instance().transformContext()) @@ -554,30 +547,25 @@ def calcEntryCostEllipsoidal(self, feedback): if self.strategy == 0: return dist else: - distUnit = self.crs.mapUnits() - unit_to_meter_factor = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters) - return dist/(self.entry_speed*(unit_to_meter_factor * 1000.0 / 3600.0)) #length/(m/s) todo: Make dynamic - + return dist/(self.entry_speed*(1000.0 / 3600.0)) #length/(m/s) todo: Make dynamic + def calcEntryCostPlanar(self, feedback): dist = self.calcEntryLinestring().length() feedback.pushInfo("[QNEAT3Network][calcEntryCostPlanar] Planar entry cost to vertex {} = {}".format(self.network_vertex_id, dist)) if self.strategy == 0: return dist else: - distUnit = self.crs.mapUnits() - unit_to_meter_factor = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters) - return dist/(self.entry_speed*(unit_to_meter_factor * 1000.0 / 3600.0)) #length/(m/s) todo: Make dynamic + return dist/(self.entry_speed*(1000.0 / 3600.0)) #length/(m/s) todo: Make dynamic def calcEntryLinestring(self): return QgsGeometry.fromPolylineXY([self.point_geom, self.network_vertex.point()]) - + def getNearestVertexId(self, network, vertex_geom): return network.findVertex(vertex_geom) - + def getNearestVertex(self, network, vertex_geom): return network.vertex(self.getNearestVertexId(network, vertex_geom)) - + def __str__(self): - return u"Qneat3AnalysisPoint: {} analysis_id: {:30} FROM {:30} TO {:30} network_id: {:d}".format(self.layer_name, self.point_id, self.point_geom.__str__(), self.network_vertex.point().__str__(), self.network_vertex_id) - + return u"Qneat3AnalysisPoint: {} analysis_id: {:30} FROM {:30} TO {:30} network_id: {:d}".format(self.layer_name, self.point_id, self.point_geom.__str__(), self.network_vertex.point().__str__(), self.network_vertex_id) From 29c00172bafddae1c370cd2b30ea867c69b55e58 Mon Sep 17 00:00:00 2001 From: Kufre Date: Thu, 9 Jul 2020 12:49:34 -0400 Subject: [PATCH 11/14] adding self.meter_to_unit_factor --- Qneat3Framework.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/Qneat3Framework.py b/Qneat3Framework.py index 3e6a20d..94c8997 100644 --- a/Qneat3Framework.py +++ b/Qneat3Framework.py @@ -87,7 +87,11 @@ def __init__(self, self.feedback.pushInfo("[QNEAT3Network][__init__] Setting up parameters") self.AnalysisCrs = input_analysisCrs - + + #enable polygon calculation in geographic coordinate systems + distUnit = self.AnalysisCrs.mapUnits() + self.meter_to_unit_factor = QgsUnitTypes.fromUnitToUnitFactor(QgsUnitTypes.DistanceMeters, distUnit) + #init direction fields self.feedback.pushInfo("[QNEAT3Network][__init__] Setting up network direction parameters") self.directedAnalysis = self.setNetworkDirection((input_directionFieldName, input_forwardValue, input_backwardValue, input_bothValue, input_defaultDirection)) From da94606e964c2952034b7d373786e9158ae5f8cc Mon Sep 17 00:00:00 2001 From: Kufre Date: Fri, 10 Jul 2020 10:52:44 -0400 Subject: [PATCH 12/14] remove planar calculations and meter_to_unit_factor --- Qneat3Framework.py | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/Qneat3Framework.py b/Qneat3Framework.py index 94c8997..6f3d4d9 100644 --- a/Qneat3Framework.py +++ b/Qneat3Framework.py @@ -89,8 +89,8 @@ def __init__(self, self.AnalysisCrs = input_analysisCrs #enable polygon calculation in geographic coordinate systems - distUnit = self.AnalysisCrs.mapUnits() - self.meter_to_unit_factor = QgsUnitTypes.fromUnitToUnitFactor(QgsUnitTypes.DistanceMeters, distUnit) + # distUnit = self.AnalysisCrs.mapUnits() + # self.meter_to_unit_factor = QgsUnitTypes.fromUnitToUnitFactor(QgsUnitTypes.DistanceMeters, distUnit) #init direction fields self.feedback.pushInfo("[QNEAT3Network][__init__] Setting up network direction parameters") @@ -118,8 +118,11 @@ def __init__(self, #add the strategy to the QgsGraphDirector self.director.addStrategy(self.strategy) - self.builder = QgsGraphBuilder(self.AnalysisCrs, True, input_tolerance) + self.builder = QgsGraphBuilder(self.AnalysisCrs, False, input_tolerance) #tell the graph-director to make the graph using the builder object and tie the start point geometry to the graph + #switched the transformation option to False because we're already checking that all inputs use the same CRS + #consistent with the Entry & Exit cost portion of this plugin, which was not handling coordinate transformations + #by default this is using WGS84 ellipsoidal distance calculations by not passing a 4th parameter for an ellipsoid acronym, resulting in linear units of METERS self.feedback.pushInfo("[QNEAT3Network][__init__] Start tying analysis points to the graph and building it.") self.feedback.pushInfo("[QNEAT3Network][__init__] This is a compute intensive task and may take some time depending on network size") @@ -151,7 +154,7 @@ def setNetworkStrategy(self, input_strategy, input_network, input_speedField, in else: self.strategy = QgsNetworkSpeedStrategy(speedFieldId, float(input_defaultSpeed), 1000.0 / 3600.0) self.strategy_int = 1 - self.multiplier = 3600 + # self.multiplier = 3600 def calcDijkstra(self, startpoint_id, criterion): """Calculates Dijkstra on whole network beginning from one startPoint. Returns a list containing a TreeId-Array and Cost-Array that match up with their indices [[tree],[cost]] """ @@ -535,24 +538,29 @@ def __init__(self, layer_name, feature, point_id_field_name, net, vertex_geom, e self.crs = net.AnalysisCrs self.strategy = net.strategy_int self.entry_speed = net.default_speed + #BETTER TO ALWAYS USE ELLIPSOIDAL for consistency with the NETWORK COST calculation by the NETWORK BUILDER + ''' if entry_cost_calculation_method == 0: self.entry_cost = self.calcEntryCostEllipsoidal(feedback) elif entry_cost_calculation_method == 1: self.entry_cost = self.calcEntryCostPlanar(feedback) else: self.entry_cost = self.calcEntryCostEllipsoidal(feedback) + ''' + self.entry_cost = self.calcEntryCostEllipsoidal(feedback) def calcEntryCostEllipsoidal(self, feedback): dist_calculator = QgsDistanceArea() - dist_calculator.setSourceCrs(QgsProject().instance().crs(), QgsProject().instance().transformContext()) - dist_calculator.setEllipsoid(QgsProject().instance().crs().ellipsoidAcronym()) + dist_calculator.setSourceCrs(self.crs, QgsProject().instance().transformContext()) #set distance calculator CRS to that of the input network + dist_calculator.setEllipsoid("WGS84") #always use WGS84 for distance calculations for consistency with the QgsNetworkBuilder dist = dist_calculator.measureLine([self.point_geom, self.network_vertex.point()]) feedback.pushInfo("[QNEAT3Network][calcEntryCostEllipsoidal] Ellipsoidal entry cost to vertex {} = {}".format(self.network_vertex_id, dist)) if self.strategy == 0: return dist else: return dist/(self.entry_speed*(1000.0 / 3600.0)) #length/(m/s) todo: Make dynamic - + + # I THINK THIS FUNCITON AND ITS OPTIONS IN EACH ALGORITHM SHOULD BE REMOVED. ALWAYS USE ELLIPSOIDAL def calcEntryCostPlanar(self, feedback): dist = self.calcEntryLinestring().length() feedback.pushInfo("[QNEAT3Network][calcEntryCostPlanar] Planar entry cost to vertex {} = {}".format(self.network_vertex_id, dist)) From 41bcc6261d33110df1cc7a00f4b8bc475dbcde3b Mon Sep 17 00:00:00 2001 From: Kufre Date: Fri, 10 Jul 2020 11:19:39 -0400 Subject: [PATCH 13/14] change error message for crs and fix crs check for from-point algorithms --- algs/IsoAreaAsContoursFromLayer.py | 2 +- algs/IsoAreaAsContoursFromPoint.py | 4 ++-- algs/IsoAreaAsInterpolationFromLayer.py | 2 +- algs/IsoAreaAsInterpolationFromPoint.py | 4 ++-- algs/IsoAreaAsPointcloudFromLayer.py | 2 +- algs/IsoAreaAsPointcloudFromPoint.py | 4 ++-- algs/IsoAreaAsPolygonsFromLayer.py | 2 +- algs/IsoAreaAsPolygonsFromPoint.py | 4 ++-- algs/IsoAreaAsQneatInterpolationFromPoint.py | 2 +- algs/OdMatrixFromLayersAsLines.py | 2 +- algs/OdMatrixFromLayersAsTable.py | 2 +- algs/OdMatrixFromPointsAsCsv.py | 2 +- algs/OdMatrixFromPointsAsLines.py | 2 +- algs/OdMatrixFromPointsAsTable.py | 2 +- algs/ShortestPathBetweenPoints.py | 4 ++-- 15 files changed, 20 insertions(+), 20 deletions(-) diff --git a/algs/IsoAreaAsContoursFromLayer.py b/algs/IsoAreaAsContoursFromLayer.py index ca1ff39..1f51a2f 100644 --- a/algs/IsoAreaAsContoursFromLayer.py +++ b/algs/IsoAreaAsContoursFromLayer.py @@ -230,7 +230,7 @@ def processAlgorithm(self, parameters, context, feedback): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') if analysisCrs != startPoints.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) diff --git a/algs/IsoAreaAsContoursFromPoint.py b/algs/IsoAreaAsContoursFromPoint.py index 94755db..9aba57a 100644 --- a/algs/IsoAreaAsContoursFromPoint.py +++ b/algs/IsoAreaAsContoursFromPoint.py @@ -224,8 +224,8 @@ def processAlgorithm(self, parameters, context, feedback): if analysisCrs.isGeographic(): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') - if analysisCrs != startPoint.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + if analysisCrs != context.project().crs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) diff --git a/algs/IsoAreaAsInterpolationFromLayer.py b/algs/IsoAreaAsInterpolationFromLayer.py index b13d298..e94c629 100644 --- a/algs/IsoAreaAsInterpolationFromLayer.py +++ b/algs/IsoAreaAsInterpolationFromLayer.py @@ -218,7 +218,7 @@ def processAlgorithm(self, parameters, context, feedback): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') if analysisCrs != startPoints.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) diff --git a/algs/IsoAreaAsInterpolationFromPoint.py b/algs/IsoAreaAsInterpolationFromPoint.py index 665d78c..4a82aac 100644 --- a/algs/IsoAreaAsInterpolationFromPoint.py +++ b/algs/IsoAreaAsInterpolationFromPoint.py @@ -210,8 +210,8 @@ def processAlgorithm(self, parameters, context, feedback): if analysisCrs.isGeographic(): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') - if analysisCrs != startPoint.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + if analysisCrs != context.project().crs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) diff --git a/algs/IsoAreaAsPointcloudFromLayer.py b/algs/IsoAreaAsPointcloudFromLayer.py index e77adf6..6f85594 100644 --- a/algs/IsoAreaAsPointcloudFromLayer.py +++ b/algs/IsoAreaAsPointcloudFromLayer.py @@ -216,7 +216,7 @@ def processAlgorithm(self, parameters, context, feedback): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') if analysisCrs != startPoints.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) diff --git a/algs/IsoAreaAsPointcloudFromPoint.py b/algs/IsoAreaAsPointcloudFromPoint.py index b1c49ee..5493e62 100644 --- a/algs/IsoAreaAsPointcloudFromPoint.py +++ b/algs/IsoAreaAsPointcloudFromPoint.py @@ -209,8 +209,8 @@ def processAlgorithm(self, parameters, context, feedback): if analysisCrs.isGeographic(): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') - if analysisCrs != startPoint.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + if analysisCrs != context.project().crs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) diff --git a/algs/IsoAreaAsPolygonsFromLayer.py b/algs/IsoAreaAsPolygonsFromLayer.py index 74fe854..246699e 100644 --- a/algs/IsoAreaAsPolygonsFromLayer.py +++ b/algs/IsoAreaAsPolygonsFromLayer.py @@ -230,7 +230,7 @@ def processAlgorithm(self, parameters, context, feedback): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') if analysisCrs != startPoints.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) diff --git a/algs/IsoAreaAsPolygonsFromPoint.py b/algs/IsoAreaAsPolygonsFromPoint.py index 9999b7b..7d84a0c 100644 --- a/algs/IsoAreaAsPolygonsFromPoint.py +++ b/algs/IsoAreaAsPolygonsFromPoint.py @@ -223,8 +223,8 @@ def processAlgorithm(self, parameters, context, feedback): if analysisCrs.isGeographic(): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') - if analysisCrs != startPoint.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + if analysisCrs != context.project().crs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) diff --git a/algs/IsoAreaAsQneatInterpolationFromPoint.py b/algs/IsoAreaAsQneatInterpolationFromPoint.py index d9eb3d6..8c452a0 100644 --- a/algs/IsoAreaAsQneatInterpolationFromPoint.py +++ b/algs/IsoAreaAsQneatInterpolationFromPoint.py @@ -230,7 +230,7 @@ def processAlgorithm(self, parameters, context, feedback): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') if analysisCrs != startPoint.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") feedback.setProgress(10) diff --git a/algs/OdMatrixFromLayersAsLines.py b/algs/OdMatrixFromLayersAsLines.py index b853983..36e203c 100644 --- a/algs/OdMatrixFromLayersAsLines.py +++ b/algs/OdMatrixFromLayersAsLines.py @@ -226,7 +226,7 @@ def processAlgorithm(self, parameters, context, feedback): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') if analysisCrs != from_points.sourceCrs() or from_points.sourceCrs() != to_points.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') #Points of both layers have to be merged into one layer --> then tied to the Qneat3Network #get point list of from layer diff --git a/algs/OdMatrixFromLayersAsTable.py b/algs/OdMatrixFromLayersAsTable.py index c07c9e6..d307727 100644 --- a/algs/OdMatrixFromLayersAsTable.py +++ b/algs/OdMatrixFromLayersAsTable.py @@ -223,7 +223,7 @@ def processAlgorithm(self, parameters, context, feedback): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') if analysisCrs != from_points.sourceCrs() or from_points.sourceCrs() != to_points.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') #Points of both layers have to be merged into one layer --> then tied to the Qneat3Network #get point list of from layer diff --git a/algs/OdMatrixFromPointsAsCsv.py b/algs/OdMatrixFromPointsAsCsv.py index 450aee3..6724380 100644 --- a/algs/OdMatrixFromPointsAsCsv.py +++ b/algs/OdMatrixFromPointsAsCsv.py @@ -205,7 +205,7 @@ def processAlgorithm(self, parameters, context, feedback): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') if analysisCrs != points.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") diff --git a/algs/OdMatrixFromPointsAsLines.py b/algs/OdMatrixFromPointsAsLines.py index 3088607..1823443 100644 --- a/algs/OdMatrixFromPointsAsLines.py +++ b/algs/OdMatrixFromPointsAsLines.py @@ -209,7 +209,7 @@ def processAlgorithm(self, parameters, context, feedback): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') if analysisCrs != points.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, points, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/OdMatrixFromPointsAsTable.py b/algs/OdMatrixFromPointsAsTable.py index c67a659..5cee088 100644 --- a/algs/OdMatrixFromPointsAsTable.py +++ b/algs/OdMatrixFromPointsAsTable.py @@ -207,7 +207,7 @@ def processAlgorithm(self, parameters, context, feedback): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') if analysisCrs != points.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, points, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) diff --git a/algs/ShortestPathBetweenPoints.py b/algs/ShortestPathBetweenPoints.py index fd4f3aa..8813ee1 100644 --- a/algs/ShortestPathBetweenPoints.py +++ b/algs/ShortestPathBetweenPoints.py @@ -209,8 +209,8 @@ def processAlgorithm(self, parameters, context, feedback): if analysisCrs.isGeographic(): raise QgsProcessingException('QNEAT3 algorithms are designed to work with projected coordinate systems. Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!') - if analysisCrs != startPoint.sourceCrs() | startPoint.sourceCrs() != endPoint.sourceCrs(): - raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system.') + if analysisCrs != context.project().crs(): + raise QgsProcessingException('QNEAT3 algorithms require that all inputs to be the same projected coordinate reference system (including project coordinate system).') input_qgspointxy_list = [startPoint,endPoint] input_points = [getFeatureFromPointParameter(startPoint),getFeatureFromPointParameter(endPoint)] From 17e192db71189f9dabe25978e8853591b15a7842 Mon Sep 17 00:00:00 2001 From: Kufre Date: Fri, 10 Jul 2020 14:07:22 -0400 Subject: [PATCH 14/14] remove entry cost calculation method parameter --- Qneat3Framework.py | 6 +++--- algs/IsoAreaAsContoursFromLayer.py | 11 +---------- algs/IsoAreaAsContoursFromPoint.py | 11 +---------- algs/IsoAreaAsInterpolationFromLayer.py | 11 +---------- algs/IsoAreaAsInterpolationFromPoint.py | 11 +---------- algs/IsoAreaAsPointcloudFromLayer.py | 11 +---------- algs/IsoAreaAsPointcloudFromPoint.py | 11 +---------- algs/IsoAreaAsPolygonsFromLayer.py | 11 +---------- algs/IsoAreaAsPolygonsFromPoint.py | 11 +---------- algs/IsoAreaAsQneatInterpolationFromPoint.py | 11 +---------- algs/OdMatrixFromLayersAsLines.py | 13 ++----------- algs/OdMatrixFromLayersAsTable.py | 13 ++----------- algs/OdMatrixFromPointsAsCsv.py | 12 +----------- algs/OdMatrixFromPointsAsLines.py | 11 +---------- algs/OdMatrixFromPointsAsTable.py | 12 +----------- algs/ShortestPathBetweenPoints.py | 12 +----------- 16 files changed, 20 insertions(+), 158 deletions(-) diff --git a/Qneat3Framework.py b/Qneat3Framework.py index 6f3d4d9..8d3eba7 100644 --- a/Qneat3Framework.py +++ b/Qneat3Framework.py @@ -87,7 +87,7 @@ def __init__(self, self.feedback.pushInfo("[QNEAT3Network][__init__] Setting up parameters") self.AnalysisCrs = input_analysisCrs - + #enable polygon calculation in geographic coordinate systems # distUnit = self.AnalysisCrs.mapUnits() # self.meter_to_unit_factor = QgsUnitTypes.fromUnitToUnitFactor(QgsUnitTypes.DistanceMeters, distUnit) @@ -528,7 +528,7 @@ def calcIsoPolygons(self, max_dist, interval, interpolation_raster_path): class Qneat3AnalysisPoint(): - def __init__(self, layer_name, feature, point_id_field_name, net, vertex_geom, entry_cost_calculation_method, feedback): + def __init__(self, layer_name, feature, point_id_field_name, net, vertex_geom, feedback): self.layer_name = layer_name self.point_feature = feature self.point_id = feature[point_id_field_name] @@ -559,7 +559,7 @@ def calcEntryCostEllipsoidal(self, feedback): return dist else: return dist/(self.entry_speed*(1000.0 / 3600.0)) #length/(m/s) todo: Make dynamic - + # I THINK THIS FUNCITON AND ITS OPTIONS IN EACH ALGORITHM SHOULD BE REMOVED. ALWAYS USE ELLIPSOIDAL def calcEntryCostPlanar(self, feedback): dist = self.calcEntryLinestring().length() diff --git a/algs/IsoAreaAsContoursFromLayer.py b/algs/IsoAreaAsContoursFromLayer.py index 1f51a2f..35b948a 100644 --- a/algs/IsoAreaAsContoursFromLayer.py +++ b/algs/IsoAreaAsContoursFromLayer.py @@ -69,7 +69,6 @@ class IsoAreaAsContoursFromLayer(QgisAlgorithm): CELL_SIZE = "CELL_SIZE" INTERVAL = "INTERVAL" STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -127,9 +126,6 @@ def initAlgorithm(self, config=None): self.tr('Fastest time') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) @@ -159,10 +155,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -212,7 +204,6 @@ def processAlgorithm(self, parameters, context, feedback): cell_size = self.parameterAsInt(parameters, self.CELL_SIZE, context)#int strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -237,7 +228,7 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] + list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints(list_apoints, max_dist+(max_dist*0.1)) diff --git a/algs/IsoAreaAsContoursFromPoint.py b/algs/IsoAreaAsContoursFromPoint.py index 9aba57a..3f394d7 100644 --- a/algs/IsoAreaAsContoursFromPoint.py +++ b/algs/IsoAreaAsContoursFromPoint.py @@ -69,7 +69,6 @@ class IsoAreaAsContoursFromPoint(QgisAlgorithm): CELL_SIZE = "CELL_SIZE" INTERVAL = "INTERVAL" STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -128,9 +127,6 @@ def initAlgorithm(self, config=None): self.tr('Fastest time') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) @@ -154,10 +150,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -206,7 +198,6 @@ def processAlgorithm(self, parameters, context, feedback): cell_size = self.parameterAsInt(parameters, self.CELL_SIZE, context)#int strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -232,7 +223,7 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], entry_cost_calc_method, feedback) + analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], feedback) feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints([analysis_point], (max_dist+(max_dist*0.1))) diff --git a/algs/IsoAreaAsInterpolationFromLayer.py b/algs/IsoAreaAsInterpolationFromLayer.py index e94c629..5ee59c3 100644 --- a/algs/IsoAreaAsInterpolationFromLayer.py +++ b/algs/IsoAreaAsInterpolationFromLayer.py @@ -63,7 +63,6 @@ class IsoAreaAsInterpolationFromLayer(QgisAlgorithm): MAX_DIST = "MAX_DIST" CELL_SIZE = "CELL_SIZE" STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -121,9 +120,6 @@ def initAlgorithm(self, config=None): self.tr('Fastest time') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) @@ -149,10 +145,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -200,7 +192,6 @@ def processAlgorithm(self, parameters, context, feedback): cell_size = self.parameterAsInt(parameters, self.CELL_SIZE, context)#int strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -225,7 +216,7 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] + list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints(list_apoints, max_dist) diff --git a/algs/IsoAreaAsInterpolationFromPoint.py b/algs/IsoAreaAsInterpolationFromPoint.py index 4a82aac..a28b372 100644 --- a/algs/IsoAreaAsInterpolationFromPoint.py +++ b/algs/IsoAreaAsInterpolationFromPoint.py @@ -63,7 +63,6 @@ class IsoAreaAsInterpolationFromPoint(QgisAlgorithm): MAX_DIST = "MAX_DIST" CELL_SIZE = "CELL_SIZE" STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -120,9 +119,6 @@ def initAlgorithm(self, config=None): self.tr('Fastest time') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) @@ -142,10 +138,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -192,7 +184,6 @@ def processAlgorithm(self, parameters, context, feedback): cell_size = self.parameterAsInt(parameters, self.CELL_SIZE, context)#int strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -218,7 +209,7 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], entry_cost_calc_method, feedback) + analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], feedback) feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints([analysis_point], max_dist) diff --git a/algs/IsoAreaAsPointcloudFromLayer.py b/algs/IsoAreaAsPointcloudFromLayer.py index 6f85594..98f7e4d 100644 --- a/algs/IsoAreaAsPointcloudFromLayer.py +++ b/algs/IsoAreaAsPointcloudFromLayer.py @@ -65,7 +65,6 @@ class IsoAreaAsPointcloudFromLayer(QgisAlgorithm): ID_FIELD = 'ID_FIELD' MAX_DIST = "MAX_DIST" STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -123,9 +122,6 @@ def initAlgorithm(self, config=None): self.tr('Fastest time') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), - self.tr('Planar (only use with projected CRS)')] - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) @@ -147,10 +143,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -199,7 +191,6 @@ def processAlgorithm(self, parameters, context, feedback): max_dist = self.parameterAsDouble(parameters, self.MAX_DIST, context)#float strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -223,7 +214,7 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] + list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] fields = QgsFields() fields.append(QgsField('vertex_id', QVariant.Int, '', 254, 0)) diff --git a/algs/IsoAreaAsPointcloudFromPoint.py b/algs/IsoAreaAsPointcloudFromPoint.py index 5493e62..f81f54a 100644 --- a/algs/IsoAreaAsPointcloudFromPoint.py +++ b/algs/IsoAreaAsPointcloudFromPoint.py @@ -65,7 +65,6 @@ class IsoAreaAsPointcloudFromPoint(QgisAlgorithm): START_POINT = 'START_POINT' MAX_DIST = "MAX_DIST" STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -123,9 +122,6 @@ def initAlgorithm(self, config=None): self.tr('Fastest time') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), - self.tr('Planar (only use with projected CRS)')] - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) @@ -141,10 +137,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -192,7 +184,6 @@ def processAlgorithm(self, parameters, context, feedback): max_dist = self.parameterAsDouble(parameters, self.MAX_DIST, context)#float strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -217,7 +208,7 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], entry_cost_calc_method, feedback) + analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], feedback) fields = QgsFields() fields.append(QgsField('vertex_id', QVariant.Int, '', 254, 0)) diff --git a/algs/IsoAreaAsPolygonsFromLayer.py b/algs/IsoAreaAsPolygonsFromLayer.py index 246699e..e53de54 100644 --- a/algs/IsoAreaAsPolygonsFromLayer.py +++ b/algs/IsoAreaAsPolygonsFromLayer.py @@ -69,7 +69,6 @@ class IsoAreaAsPolygonsFromLayer(QgisAlgorithm): CELL_SIZE = "CELL_SIZE" INTERVAL = "INTERVAL" STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -127,9 +126,6 @@ def initAlgorithm(self, config=None): self.tr('Fastest time') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Vector layer representing network'), [QgsProcessing.TypeVectorLine])) @@ -159,10 +155,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -212,7 +204,6 @@ def processAlgorithm(self, parameters, context, feedback): cell_size = self.parameterAsInt(parameters, self.CELL_SIZE, context)#int strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -237,7 +228,7 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] + list_apoints = [Qneat3AnalysisPoint("from", feature, id_field, net, net.list_tiedPoints[i], feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(startPoints))] feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints(list_apoints, max_dist+(max_dist*0.1)) diff --git a/algs/IsoAreaAsPolygonsFromPoint.py b/algs/IsoAreaAsPolygonsFromPoint.py index 7d84a0c..5aa1ed2 100644 --- a/algs/IsoAreaAsPolygonsFromPoint.py +++ b/algs/IsoAreaAsPolygonsFromPoint.py @@ -69,7 +69,6 @@ class IsoAreaAsPolygonsFromPoint(QgisAlgorithm): CELL_SIZE = "CELL_SIZE" INTERVAL = "INTERVAL" STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -127,9 +126,6 @@ def initAlgorithm(self, config=None): self.tr('Fastest time') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) @@ -153,10 +149,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -205,7 +197,6 @@ def processAlgorithm(self, parameters, context, feedback): cell_size = self.parameterAsInt(parameters, self.CELL_SIZE, context)#int strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -231,7 +222,7 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], entry_cost_calc_method, feedback) + analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], feedback) feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints([analysis_point], max_dist+(max_dist*0.1)) diff --git a/algs/IsoAreaAsQneatInterpolationFromPoint.py b/algs/IsoAreaAsQneatInterpolationFromPoint.py index 8c452a0..a9919e2 100644 --- a/algs/IsoAreaAsQneatInterpolationFromPoint.py +++ b/algs/IsoAreaAsQneatInterpolationFromPoint.py @@ -73,7 +73,6 @@ class IsoAreaAsQneatInterpolationFromPoint(QgisAlgorithm): CELL_SIZE = "CELL_SIZE" STRATEGY = 'STRATEGY' METHOD = 'METHOD' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -134,9 +133,6 @@ def initAlgorithm(self, config=None): self.tr('QNEAT-Interpolation (slower but more exact') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Planar (only use with projected CRS)')] - - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) @@ -160,10 +156,6 @@ def initAlgorithm(self, config=None): defaultValue=1)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=1)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -211,7 +203,6 @@ def processAlgorithm(self, parameters, context, feedback): strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int interpolation_method = self.parameterAsEnum(parameters, self.METHOD, context)#int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -237,7 +228,7 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, input_coordinates, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], entry_cost_calc_method, feedback) + analysis_point = Qneat3AnalysisPoint("point", input_point, "point_id", net, net.list_tiedPoints[0], feedback) feedback.pushInfo("[QNEAT3Algorithm] Calculating Iso-Pointcloud...") iso_pointcloud = net.calcIsoPoints([analysis_point], max_dist) diff --git a/algs/OdMatrixFromLayersAsLines.py b/algs/OdMatrixFromLayersAsLines.py index 36e203c..789fb00 100644 --- a/algs/OdMatrixFromLayersAsLines.py +++ b/algs/OdMatrixFromLayersAsLines.py @@ -68,7 +68,6 @@ class OdMatrixFromLayersAsLines(QgisAlgorithm): TO_POINT_LAYER = 'TO_POINT_LAYER' TO_ID_FIELD = 'TO_ID_FIELD' STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -126,9 +125,6 @@ def initAlgorithm(self, config=None): self.tr('Fastest time') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), - self.tr('Planar (only use with projected CRS)')] - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network layer'), [QgsProcessing.TypeVectorLine])) @@ -159,10 +155,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -210,7 +202,6 @@ def processAlgorithm(self, parameters, context, feedback): to_id_field = self.parameterAsString(parameters, self.TO_ID_FIELD, context) strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -240,8 +231,8 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, merged_coords, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) #read the merged point-list seperately for the two layers --> index at the first element of the second layer begins at len(firstLayer) and gets added the index of the current point of layer b. - list_from_apoints = [Qneat3AnalysisPoint("from", feature, from_id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(from_points))] - list_to_apoints = [Qneat3AnalysisPoint("to", feature, to_id_field, net, net.list_tiedPoints[from_coord_list_length+i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(to_points))] + list_from_apoints = [Qneat3AnalysisPoint("from", feature, from_id_field, net, net.list_tiedPoints[i], feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(from_points))] + list_to_apoints = [Qneat3AnalysisPoint("to", feature, to_id_field, net, net.list_tiedPoints[from_coord_list_length+i], feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(to_points))] feat = QgsFeature() fields = QgsFields() diff --git a/algs/OdMatrixFromLayersAsTable.py b/algs/OdMatrixFromLayersAsTable.py index d307727..320c52c 100644 --- a/algs/OdMatrixFromLayersAsTable.py +++ b/algs/OdMatrixFromLayersAsTable.py @@ -67,7 +67,6 @@ class OdMatrixFromLayersAsTable(QgisAlgorithm): TO_POINT_LAYER = 'TO_POINT_LAYER' TO_ID_FIELD = 'TO_ID_FIELD' STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -123,9 +122,6 @@ def initAlgorithm(self, config=None): self.STRATEGIES = [self.tr('Shortest distance'), self.tr('Fastest time')] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), - self.tr('Planar (only use with projected CRS)')] - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network layer'), [QgsProcessing.TypeVectorLine])) @@ -156,10 +152,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -207,7 +199,6 @@ def processAlgorithm(self, parameters, context, feedback): to_id_field = self.parameterAsString(parameters, self.TO_ID_FIELD, context) strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -237,8 +228,8 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, merged_coords, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) #read the merged point-list seperately for the two layers --> index at the first element of the second layer begins at len(firstLayer) and gets added the index of the current point of layer b. - list_from_apoints = [Qneat3AnalysisPoint("from", feature, from_id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(from_points))] - list_to_apoints = [Qneat3AnalysisPoint("to", feature, to_id_field, net, net.list_tiedPoints[from_coord_list_length+i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(to_points))] + list_from_apoints = [Qneat3AnalysisPoint("from", feature, from_id_field, net, net.list_tiedPoints[i], feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(from_points))] + list_to_apoints = [Qneat3AnalysisPoint("to", feature, to_id_field, net, net.list_tiedPoints[from_coord_list_length+i], feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(to_points))] feat = QgsFeature() fields = QgsFields() diff --git a/algs/OdMatrixFromPointsAsCsv.py b/algs/OdMatrixFromPointsAsCsv.py index 6724380..1bac9d5 100644 --- a/algs/OdMatrixFromPointsAsCsv.py +++ b/algs/OdMatrixFromPointsAsCsv.py @@ -60,7 +60,6 @@ class OdMatrixFromPointsAsCsv(QgisAlgorithm): POINTS = 'POINTS' ID_FIELD = 'ID_FIELD' STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -117,10 +116,6 @@ def initAlgorithm(self, config=None): self.tr('Fastest time') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), - self.tr('Planar (only use with projected CRS)')] - - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network layer'), [QgsProcessing.TypeVectorLine])) @@ -138,10 +133,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -187,7 +178,6 @@ def processAlgorithm(self, parameters, context, feedback): id_field = self.parameterAsString(parameters, self.ID_FIELD, context) #str strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -211,7 +201,7 @@ def processAlgorithm(self, parameters, context, feedback): feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, points, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) - list_analysis_points = [Qneat3AnalysisPoint("point", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(net.input_points))] + list_analysis_points = [Qneat3AnalysisPoint("point", feature, id_field, net, net.list_tiedPoints[i], feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(net.input_points))] total_workload = float(pow(len(list_analysis_points),2)) feedback.pushInfo("[QNEAT3Algorithm] Expecting total workload of {} iterations".format(int(total_workload))) diff --git a/algs/OdMatrixFromPointsAsLines.py b/algs/OdMatrixFromPointsAsLines.py index 1823443..1b77c85 100644 --- a/algs/OdMatrixFromPointsAsLines.py +++ b/algs/OdMatrixFromPointsAsLines.py @@ -66,7 +66,6 @@ class OdMatrixFromPointsAsLines(QgisAlgorithm): POINTS = 'POINTS' ID_FIELD = 'ID_FIELD' STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -123,9 +122,6 @@ def initAlgorithm(self, config=None): self.STRATEGIES = [self.tr('Shortest distance'), self.tr('Fastest time')] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), - self.tr('Planar (only use with projected CRS)')] - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) @@ -143,10 +139,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -193,7 +185,6 @@ def processAlgorithm(self, parameters, context, feedback): id_field = self.parameterAsString(parameters, self.ID_FIELD, context) #str strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -214,7 +205,7 @@ def processAlgorithm(self, parameters, context, feedback): feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, points, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) - list_analysis_points = [Qneat3AnalysisPoint("point", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(net.input_points))] + list_analysis_points = [Qneat3AnalysisPoint("point", feature, id_field, net, net.list_tiedPoints[i], feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(net.input_points))] feat = QgsFeature() fields = QgsFields() diff --git a/algs/OdMatrixFromPointsAsTable.py b/algs/OdMatrixFromPointsAsTable.py index 5cee088..f8c789d 100644 --- a/algs/OdMatrixFromPointsAsTable.py +++ b/algs/OdMatrixFromPointsAsTable.py @@ -65,7 +65,6 @@ class OdMatrixFromPointsAsTable(QgisAlgorithm): POINTS = 'POINTS' ID_FIELD = 'ID_FIELD' STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -121,10 +120,6 @@ def initAlgorithm(self, config=None): self.STRATEGIES = [self.tr('Shortest distance'), self.tr('Fastest time')] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), - self.tr('Planar (only use with projected CRS)')] - - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network layer'), [QgsProcessing.TypeVectorLine])) @@ -142,10 +137,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -191,7 +182,6 @@ def processAlgorithm(self, parameters, context, feedback): id_field = self.parameterAsString(parameters, self.ID_FIELD, context) #str strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -212,7 +202,7 @@ def processAlgorithm(self, parameters, context, feedback): feedback.pushInfo("[QNEAT3Algorithm] Building Graph...") net = Qneat3Network(network, points, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) - list_analysis_points = [Qneat3AnalysisPoint("point", feature, id_field, net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(net.input_points))] + list_analysis_points = [Qneat3AnalysisPoint("point", feature, id_field, net, net.list_tiedPoints[i], feedback) for i, feature in enumerate(getFeaturesFromQgsIterable(net.input_points))] feat = QgsFeature() fields = QgsFields() diff --git a/algs/ShortestPathBetweenPoints.py b/algs/ShortestPathBetweenPoints.py index 8813ee1..d71106b 100644 --- a/algs/ShortestPathBetweenPoints.py +++ b/algs/ShortestPathBetweenPoints.py @@ -67,7 +67,6 @@ class ShortestPathBetweenPoints(QgisAlgorithm): START_POINT = 'START_POINT' END_POINT = 'END_POINT' STRATEGY = 'STRATEGY' - ENTRY_COST_CALCULATION_METHOD = 'ENTRY_COST_CALCULATION_METHOD' DIRECTION_FIELD = 'DIRECTION_FIELD' VALUE_FORWARD = 'VALUE_FORWARD' VALUE_BACKWARD = 'VALUE_BACKWARD' @@ -125,10 +124,6 @@ def initAlgorithm(self, config=None): self.tr('Fastest time') ] - self.ENTRY_COST_CALCULATION_METHODS = [self.tr('Ellipsoidal'), - self.tr('Planar (only use with projected CRS)')] - - self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, self.tr('Network Layer'), [QgsProcessing.TypeVectorLine])) @@ -142,10 +137,6 @@ def initAlgorithm(self, config=None): defaultValue=0)) params = [] - params.append(QgsProcessingParameterEnum(self.ENTRY_COST_CALCULATION_METHOD, - self.tr('Entry Cost calculation method'), - self.ENTRY_COST_CALCULATION_METHODS, - defaultValue=0)) params.append(QgsProcessingParameterField(self.DIRECTION_FIELD, self.tr('Direction field'), None, @@ -194,7 +185,6 @@ def processAlgorithm(self, parameters, context, feedback): endPoint = self.parameterAsPoint(parameters, self.END_POINT, context, network.sourceCrs()) #QgsPointXY strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) #int - entry_cost_calc_method = self.parameterAsEnum(parameters, self.ENTRY_COST_CALCULATION_METHOD, context) #int directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context) #str (empty if no field given) forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context) #str backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context) #str @@ -220,7 +210,7 @@ def processAlgorithm(self, parameters, context, feedback): net = Qneat3Network(network, input_qgspointxy_list, strategy, directionFieldName, forwardValue, backwardValue, bothValue, defaultDirection, analysisCrs, speedFieldName, defaultSpeed, tolerance, feedback) feedback.setProgress(40) - list_analysis_points = [Qneat3AnalysisPoint("point", feature, "point_id", net, net.list_tiedPoints[i], entry_cost_calc_method, feedback) for i, feature in enumerate(input_points)] + list_analysis_points = [Qneat3AnalysisPoint("point", feature, "point_id", net, net.list_tiedPoints[i], feedback) for i, feature in enumerate(input_points)] start_vertex_idx = list_analysis_points[0].network_vertex_id end_vertex_idx = list_analysis_points[1].network_vertex_id