def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
fields = source.fields()
x_field_index = fields.lookupField(self.parameterAsString(parameters, self.XFIELD, context))
y_field_index = fields.lookupField(self.parameterAsString(parameters, self.YFIELD, context))
z_field_index = -1
if self.parameterAsString(parameters, self.ZFIELD, context):
z_field_index = fields.lookupField(self.parameterAsString(parameters, self.ZFIELD, context))
m_field_index = -1
if self.parameterAsString(parameters, self.MFIELD, context):
m_field_index = fields.lookupField(self.parameterAsString(parameters, self.MFIELD, context))
wkb_type = QgsWkbTypes.Point
if z_field_index >= 0:
wkb_type = QgsWkbTypes.addZ(wkb_type)
if m_field_index >= 0:
wkb_type = QgsWkbTypes.addM(wkb_type)
target_crs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, wkb_type, target_crs)
request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry)
features = source.getFeatures()
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, feature in enumerate(features):
if feedback.isCanceled():
break
feedback.setProgress(int(current * total))
attrs = feature.attributes()
try:
x = float(attrs[x_field_index])
y = float(attrs[y_field_index])
point = QgsPoint(x, y)
if z_field_index >= 0:
try:
point.addZValue(float(attrs[z_field_index]))
except:
point.addZValue(0.0)
if m_field_index >= 0:
try:
point.addMValue(float(attrs[m_field_index]))
except:
point.addMValue(0.0)
feature.setGeometry(QgsGeometry(point))
except:
pass # no geometry
sink.addFeature(feature)
return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
fields = source.fields()
x_field_index = fields.lookupField(self.parameterAsString(parameters, self.XFIELD, context))
y_field_index = fields.lookupField(self.parameterAsString(parameters, self.YFIELD, context))
z_field_index = -1
if self.parameterAsString(parameters, self.ZFIELD, context):
z_field_index = fields.lookupField(self.parameterAsString(parameters, self.ZFIELD, context))
m_field_index = -1
if self.parameterAsString(parameters, self.MFIELD, context):
m_field_index = fields.lookupField(self.parameterAsString(parameters, self.MFIELD, context))
wkb_type = QgsWkbTypes.Point
if z_field_index >= 0:
wkb_type = QgsWkbTypes.addZ(wkb_type)
if m_field_index >= 0:
wkb_type = QgsWkbTypes.addM(wkb_type)
target_crs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, wkb_type, target_crs)
request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry)
features = source.getFeatures()
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, feature in enumerate(features):
if feedback.isCanceled():
break
feedback.setProgress(int(current * total))
attrs = feature.attributes()
try:
x = float(attrs[x_field_index])
y = float(attrs[y_field_index])
point = QgsPoint(x, y)
if z_field_index >= 0:
try:
point.addZValue(float(attrs[z_field_index]))
except:
point.addZValue(0.0)
if m_field_index >= 0:
try:
point.addMValue(float(attrs[m_field_index]))
except:
point.addMValue(0.0)
feature.setGeometry(QgsGeometry(point))
except:
pass # no geometry
sink.addFeature(feature)
return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback):
source = self.getParameterValue(self.INPUT)
vlayer = QgsProcessingUtils.mapLayerFromString(source, context)
output = self.getOutputFromName(self.OUTPUT)
fields = vlayer.fields()
x_field_index = fields.lookupField(self.getParameterValue(self.XFIELD))
y_field_index = fields.lookupField(self.getParameterValue(self.YFIELD))
z_field_index = None
if self.getParameterValue(self.ZFIELD):
z_field_index = fields.lookupField(self.getParameterValue(self.ZFIELD))
m_field_index = None
if self.getParameterValue(self.MFIELD):
m_field_index = fields.lookupField(self.getParameterValue(self.MFIELD))
wkb_type = QgsWkbTypes.Point
if z_field_index is not None:
wkb_type = QgsWkbTypes.addZ(wkb_type)
if m_field_index is not None:
wkb_type = QgsWkbTypes.addM(wkb_type)
crsId = self.getParameterValue(self.TARGET_CRS)
target_crs = QgsCoordinateReferenceSystem()
target_crs.createFromUserInput(crsId)
writer = output.getVectorWriter(fields, wkb_type, target_crs, context)
features = QgsProcessingUtils.getFeatures(vlayer, context)
total = 100.0 / QgsProcessingUtils.featureCount(vlayer, context)
for current, feature in enumerate(features):
feedback.setProgress(int(current * total))
attrs = feature.attributes()
try:
x = float(attrs[x_field_index])
y = float(attrs[y_field_index])
point = QgsPoint(x, y)
if z_field_index is not None:
try:
point.addZValue(float(attrs[z_field_index]))
except:
point.addZValue(0.0)
if m_field_index is not None:
try:
point.addMValue(float(attrs[m_field_index]))
except:
point.addMValue(0.0)
feature.setGeometry(QgsGeometry(point))
except:
pass # no geometry
writer.addFeature(feature)
del writer
def processAlgorithm(self, parameters, context, feedback):
source = self.getParameterValue(self.INPUT)
vlayer = QgsProcessingUtils.mapLayerFromString(source, context)
output = self.getOutputFromName(self.OUTPUT)
fields = vlayer.fields()
x_field_index = fields.lookupField(self.getParameterValue(self.XFIELD))
y_field_index = fields.lookupField(self.getParameterValue(self.YFIELD))
z_field_index = None
if self.getParameterValue(self.ZFIELD):
z_field_index = fields.lookupField(self.getParameterValue(self.ZFIELD))
m_field_index = None
if self.getParameterValue(self.MFIELD):
m_field_index = fields.lookupField(self.getParameterValue(self.MFIELD))
wkb_type = QgsWkbTypes.Point
if z_field_index is not None:
wkb_type = QgsWkbTypes.addZ(wkb_type)
if m_field_index is not None:
wkb_type = QgsWkbTypes.addM(wkb_type)
crsId = self.getParameterValue(self.TARGET_CRS)
target_crs = QgsCoordinateReferenceSystem()
target_crs.createFromUserInput(crsId)
writer = output.getVectorWriter(fields, wkb_type, target_crs, context)
features = QgsProcessingUtils.getFeatures(vlayer, context)
total = 100.0 / QgsProcessingUtils.featureCount(vlayer, context)
for current, feature in enumerate(features):
feedback.setProgress(int(current * total))
attrs = feature.attributes()
try:
x = float(attrs[x_field_index])
y = float(attrs[y_field_index])
point = QgsPoint(x, y)
if z_field_index is not None:
try:
point.addZValue(float(attrs[z_field_index]))
except:
point.addZValue(0.0)
if m_field_index is not None:
try:
point.addMValue(float(attrs[m_field_index]))
except:
point.addMValue(0.0)
feature.setGeometry(QgsGeometry(point))
except:
pass # no geometry
writer.addFeature(feature)
del writer
def btn_ok_clicked(self):
new_zs = self.static_canvas.pipe_line.get_ydata()
pipe_geom_v2 = self.pipe_ft.geometry().get()
for p in range(pipe_geom_v2.vertexCount(0, 0)):
vertex_id = QgsVertexId(0, 0, p, QgsVertexId.SegmentVertex)
vertex = pipe_geom_v2.vertexAt(vertex_id)
new_pos_pt = QgsPoint(vertex.x(), vertex.y())
new_pos_pt.addZValue(new_zs[p])
LinkHandler.move_link_vertex(self.params, self.params.pipes_vlay,
self.pipe_ft, new_pos_pt, p)
# Update delta z for nodes
(start_node_ft, end_node_ft) = NetworkUtils.find_start_end_nodes(
self.params, self.pipe_ft.geometry())
start_node_elev = start_node_ft.attribute(Junction.field_name_elev)
# end_node_deltaz = end_node_ft.attribute(Junction.field_name_delta_z)
end_node_elev = end_node_ft.attribute(Junction.field_name_elev)
start_node_new_deltaz = new_zs[0] - start_node_elev
end_node_new_deltaz = new_zs[-1] - end_node_elev
start_node_ft.setAttribute(
start_node_ft.fieldNameIndex(Junction.field_name_delta_z),
start_node_new_deltaz)
end_node_ft.setAttribute(
end_node_ft.fieldNameIndex(Junction.field_name_delta_z),
end_node_new_deltaz)
# Update start node elevation attribute
start_node_lay = NetworkUtils.find_node_layer(self.params,
start_node_ft.geometry())
vector_utils.update_attribute(start_node_lay, start_node_ft,
Junction.field_name_delta_z,
float(start_node_new_deltaz))
# Update end node elevation attribute
end_node_lay = NetworkUtils.find_node_layer(self.params,
end_node_ft.geometry())
vector_utils.update_attribute(end_node_lay, end_node_ft,
Junction.field_name_delta_z,
float(end_node_new_deltaz))
# Update pipe length
# Calculate 3D length
pipe_geom_2 = self.pipe_ft.geometry()
if self.params.dem_rlay is not None:
length_3d = LinkHandler.calc_3d_length(self.params, pipe_geom_2)
else:
length_3d = pipe_geom_2.length()
vector_utils.update_attribute(self.params.pipes_vlay, self.pipe_ft,
Pipe.field_name_length, length_3d)
self.setVisible(False)
def point_from_event(event: QgsMapMouseEvent, snapping: bool) -> QgsPoint:
"""
Returns the point from the mouse canvas event. If snapping is enabled it will be
snapped using the settings.
:param event: The map mouse event.
:return: Point for the map canvas event.
"""
if snapping:
point = QgsPoint(event.snapPoint())
point.addZValue(0)
else:
point = QgsPoint(event.originalMapPoint())
point.addZValue(0)
return point
def addZtoPointFeatures(self,
inputPoints,
inputCrs,
fieldIdWithZVals=-1,
override=True):
#pointsListZ=[] #list of QgsFeature()
featuresWithZ = []
try:
#check if pointsLayer is emty
#if inputPoints.featureCount!=0:
for feat in inputPoints:
#if geom.hasZ==False or geom.hasZ==True and override==True:
# get Raster Values for each point feature
featZ = QgsFeature(feat.fields()) #Copy of the Feature
geom = feat.geometry()
#create a copy of the geometry for temporary transform to the project.crs()
wkb = feat.geometry().asWkb()
#self.feedback.pushInfo("addZtoPointFeatures1 " + geom.asWkt())
geom2CRS = QgsGeometry()
geom2CRS.fromWkb(wkb)
#transform geom to rasterLayer.crs() if crs a different
if not inputCrs.authid() == self.rasterLayer.crs().authid():
trafo = QgsCoordinateTransform(inputCrs,
self.rasterLayer.crs(),
QgsProject.instance())
#transform clip Geom to SrcLayer.crs Reverse
geom2CRS.transform(trafo,
QgsCoordinateTransform.ForwardTransform,
False)
pinPoint = None
if geom.isMultipart():
pinPoint = geom.vertexAt(
0) #nimm den ersten Punkt, wenn es ein MultiPoint ist
pin2Crs = geom2CRS.vertexAt(0)
else:
pinPoint = geom.asPoint()
pin2Crs = geom2CRS.asPoint()
rastVal = None
if fieldIdWithZVals > -1:
rastVal = feat[fieldIdWithZVals]
if rastVal is None or str(rastVal) == 'NULL':
felder = feat.fields()
feld = felder.field(fieldIdWithZVals)
self.feedback.reportError('Error on Feature ' +
str(feat.id()))
self.feedback.reportError('Feature Attributes :' +
str(feat.attributes()))
raise QgsProcessingException('Z value on field ' +
feld.name() +
' is empty!')
else: #hole Z-Wert von DGM
rastVal = self.interpolator.linear(
pin2Crs) #QgsPointXY(4459566.0, 5613959.0))
#self.feedback.pushInfo("addZtoPointFeatures2 " + geom.asWkt() + " 2Crs: " + geom2CRS.asWkt())
#self.feedback.pushInfo("rastVal " + str(pinPoint)+ " = in RasterCrs:"+ str(pin2Crs)+ " = "+ str(rastVal))
#rastSample = rasterLayer.dataProvider().identify(pin2Crs, QgsRaster.IdentifyFormatValue).results()
if not rastVal is None or str(
rastVal
) != 'NULL': # ToDo der Leerwert muss noch beruecksichtigt werden
wkt = "PointZ(" + str(pinPoint.x()) + " " + str(
pinPoint.y()) + " " + str(rastVal) + ")"
#self.feedback.reportError(wkt)
#construct new Feature in source Crs
ptZ = QgsPoint(pinPoint.x(), pinPoint.y())
ptZ.addZValue(rastVal)
geomZ = QgsGeometry.fromWkt(wkt)
featZ.setGeometry(geomZ)
featZ.setAttributes(feat.attributes())
featuresWithZ.append(featZ)
else:
self.feedback.reportError('Point Feature: ' + feat.id() +
' ' + wkt + ' ' +
feat.attributes())
raise QgsProcessingException(
"No valid RasterValue for this position: " +
str(round(pinPoint.x(), 1)) + " " +
str(round(pinPoint.y(), 1)) + ' raster value: ' +
str(rastVal))
#self.feedback.pushInfo("addZtoPointFeatures " + str(len(featuresWithZ))+ " Objekte")
except Exception as err:
msg = "Error: add Z to Point Features {0} \n {1}".format(
err.args, repr(err))
self.feedback.reportError(msg)
featuresWithZ = []
raise QgsProcessingException(msg)
#print("Error addZtoPointFeatures")#,str(err.args) + ";" + str(repr(err)))
#raise QgsProcessingException("Error addZtoPointFeatures " + str(err.args))# + ";" + str(repr(err)))
return featuresWithZ
def canvasReleaseEvent(self, event):
mouse_pt = self.toMapCoordinates(event.pos())
if not self.mouse_clicked:
return
if event.button() == 1:
self.mouse_clicked = False
if self.snap_results is not None:
snap_results = self.snap_results
selected_node_ft = self.selected_node_ft
selected_node_ft_lay = self.selected_node_ft_lay
# Check elev
if self.elev is None and self.params.dem_rlay is not None:
self.iface.messageBar().pushMessage(
Parameters.plug_in_name,
'Elevation value not available: element elevation set to 0.',
Qgis.Warning, 5) # TODO: softcode
# It's just a pipe vertex
if selected_node_ft is None:
feat = vector_utils.get_feats_by_id(
snap_results.layer(), snap_results.featureId())
vertex_id = QgsVertexId(0, 0, snap_results.vertexIndex(),
QgsVertexId.SegmentVertex)
vertex_v2 = feat[0].geometry().get().vertexAt(vertex_id)
new_pos_pt_v2 = QgsPoint(mouse_pt.x(), mouse_pt.y())
new_pos_pt_v2.addZValue(vertex_v2.z())
LinkHandler.move_link_vertex(self.params,
self.params.pipes_vlay,
feat[0], new_pos_pt_v2,
snap_results.vertexIndex())
# There are adjacent links: it's a node
else:
# Not pump or valve: plain junction
if not self.pump_valve_selected:
# Update junction geometry
NodeHandler.move_element(selected_node_ft_lay,
self.params.dem_rlay,
selected_node_ft, mouse_pt)
# Update pipes
for feat, (vertex_index,
layer) in self.adj_links_fts_d.items():
vertex_id = QgsVertexId(0, 0, vertex_index,
QgsVertexId.SegmentVertex)
vertex_v2 = feat.geometry().get().vertexAt(
vertex_id)
new_pos_pt_v2 = QgsPoint(mouse_pt.x(),
mouse_pt.y())
new_pos_pt_v2.addZValue(vertex_v2.z())
LinkHandler.move_link_vertex(
self.params, layer, feat, new_pos_pt_v2,
vertex_index)
# Pump or valve
else:
# Update junctions geometry
NodeHandler.move_element(
self.adj_junctions[0][1], self.params.dem_rlay,
self.adj_junctions[0][0],
QgsPointXY(
self.adj_junctions[0]
[0].geometry().asPoint().x() +
self.delta_vec.x(), self.adj_junctions[0]
[0].geometry().asPoint().y() +
self.delta_vec.y()))
NodeHandler.move_element(
self.adj_junctions[1][1], self.params.dem_rlay,
self.adj_junctions[1][0],
QgsPointXY(
self.adj_junctions[1]
[0].geometry().asPoint().x() +
self.delta_vec.x(), self.adj_junctions[1]
[0].geometry().asPoint().y() +
self.delta_vec.y()))
# in 2.16: NodeHandler.move_element(Parameters.junctions_vlay, self.adj_links_fts[0], self.adj_links_fts[0].geometry().asPoint() + self.delta_vec)
if self.pump_or_valve == 'pump':
lay = self.params.pumps_vlay
elif self.pump_or_valve == 'valve':
lay = self.params.valves_vlay
# Move the pump/valve
LinkHandler.move_pump_valve(lay, self.pump_valve_ft,
self.delta_vec)
# Move the adjacent pipes' vertices
for feat, (vertex_index,
layer) in self.adj_links_fts_d.items():
vertex_id = QgsVertexId(0, 0, vertex_index,
QgsVertexId.SegmentVertex)
vertex_v2 = feat.geometry().get().vertexAt(
vertex_id)
new_pos_pt_v2 = QgsPoint(
feat.geometry().vertexAt(vertex_index).x() +
self.delta_vec.x(),
feat.geometry().vertexAt(vertex_index).y() +
self.delta_vec.y())
new_pos_pt_v2.addZValue(vertex_v2.z())
LinkHandler.move_link_vertex(
self.params, layer, feat, new_pos_pt_v2,
vertex_index)
# In 2.16: LinkHandler.move_pipe_vertex(feat, feat.geometry().vertexAt(vertex_index) + self.delta_vec, vertex_index)
self.adj_links_fts_d.clear()
symbology.refresh_layer(self.iface.mapCanvas(),
self.params.junctions_vlay)
symbology.refresh_layer(self.iface.mapCanvas(),
self.params.reservoirs_vlay)
symbology.refresh_layer(self.iface.mapCanvas(),
self.params.tanks_vlay)
symbology.refresh_layer(self.iface.mapCanvas(),
self.params.pipes_vlay)
symbology.refresh_layer(self.iface.mapCanvas(),
self.params.pumps_vlay)
symbology.refresh_layer(self.iface.mapCanvas(),
self.params.valves_vlay)
# Remove vertex marker and rubber band
self.vertex_marker.hide()
self.iface.mapCanvas().scene().removeItem(self.rubber_band)
