def __init__(self, table, parent=None):
TableDataModel.__init__(self, table, parent)
self.layer = None
if isinstance(table, LVectorTable):
self.layer = VLayerRegistry.instance().getLayer(table.name)
else:
self.layer = VLayerRegistry.instance().getLayer(table)
if not self.layer:
return
# populate self.resdata
self.resdata = []
for f in self.layer.getFeatures():
a = f.attributes()
# add the geometry type
if f.geometry():
a.append(QgsWKBTypes.displayString(QGis.fromOldWkbType(f.geometry().wkbType())))
else:
a.append('None')
self.resdata.append(a)
self.fetchedFrom = 0
self.fetchedCount = len(self.resdata)
def get_wkb_type(cls, wkb_type):
if COMPAT_QGIS_VERSION == 2:
return QGis.fromOldWkbType(wkb_type) # get new (not deprecated) WKB type for e.g. QgsVectorLayer::wkbType(), QgsGeometry::wkbType(), etc
elif COMPAT_QGIS_VERSION == 3:
return wkb_type
else:
raise NotImplementedError(COMPAT_QGIS_UNSUPPORTED_MSG)
def setEnable(self, layer):
"""
To check if we can enable the action for the selected layer
:param layer: selected layer
"""
if layer is not None\
and isinstance(layer, QgsVectorLayer)\
and QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.LineStringZ:
if layer == self.__layer:
return
if self.__layer is not None:
if self.__layer.isEditable():
self.__layer.editingStopped.disconnect(self.stopEditing)
else:
self.__layer.editingStarted.disconnect(self.startEditing)
self.__layer = layer
if self.__layer.isEditable():
self.action().setEnabled(True)
self.__updateList()
self.__layer.editingStopped.connect(self.stopEditing)
else:
self.action().setEnabled(False)
self.__layer.editingStarted.connect(self.startEditing)
if self.__canvas.mapTool == self:
self.__iface.actionPan().trigger()
# self.__canvas.setMapTool(self.__oldTool)
return
self.action().setEnabled(False)
self.removeLayer()
def setEnable(self, layer):
"""
To check if we can enable the action for the selected layer
:param layer: selected layer
"""
if layer is not None and layer.type() == QgsMapLayer.VectorLayer\
and QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.LineStringZ:
if layer == self.__layer:
return
if self.__layer is not None:
if self.__layer.isEditable():
Signal.safelyDisconnect(self.__layer.editingStopped,
self.stopEditing)
else:
Signal.safelyDisconnect(self.__layer.editingStarted,
self.startEditing)
self.__layer = layer
if self.__layer.isEditable():
self.action().setEnabled(True)
self.__layer.editingStopped.connect(self.stopEditing)
else:
self.action().setEnabled(False)
self.__layer.editingStarted.connect(self.startEditing)
if self.canvas().mapTool() == self:
self.__iface.actionPan().trigger()
return
self.action().setEnabled(False)
self.__removeLayer()
def canvasReleaseEvent(self, event):
"""
When the mouse is clicked
:param event: mouse event
"""
types = [QgsWKBTypes.PointZ, QgsWKBTypes.LineStringZ, QgsWKBTypes.CircularStringZ, QgsWKBTypes.CompoundCurveZ,
QgsWKBTypes.CurvePolygonZ, QgsWKBTypes.PolygonZ]
display = ""
for layer in self.canvas().layers():
if layer.type() == QgsMapLayer.VectorLayer and QGis.fromOldWkbType(layer.wkbType()) in types:
layerConfig = QgsSnappingUtils.LayerConfig(layer, QgsPointLocator.Vertex, 10, QgsTolerance.Pixels)
features = Finder.findFeaturesAt(event.mapPoint(), layerConfig, self)
if len(features) > 0:
display += layer.name() + " : \n"
for f in features:
if f.geometry().type() == QGis.Point:
alt = f.geometry().geometry().z()
elif f.geometry().type() == QGis.Line:
closest = f.geometry().closestVertex(event.mapPoint())
alt = f.geometry().geometry().zAt(closest[1])
elif f.geometry().type() == QGis.Polygon:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "Polygon not yet implemented"),
level=QgsMessageBar.WARNING)
continue
else:
continue
display += " " + str(f.id()) + " | " + str(alt) + " m.\n"
if display != "":
QMessageBox.information(None, QCoreApplication.translate("VDLTools", "Id | Elevation"), display)
def setEnable(self, layer):
"""
To check if we can enable the action for the selected layer
:param layer: selected layer
"""
if layer is not None and layer.type() == QgsMapLayer.VectorLayer\
and QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.LineStringZ:
if layer == self.__layer:
return
if self.__layer is not None:
if self.__layer.isEditable():
Signal.safelyDisconnect(self.__layer.editingStopped, self.stopEditing)
else:
Signal.safelyDisconnect(self.__layer.editingStarted, self.startEditing)
self.__layer = layer
if self.__layer.isEditable():
self.action().setEnabled(True)
self.__layer.editingStopped.connect(self.stopEditing)
else:
self.action().setEnabled(False)
self.__layer.editingStarted.connect(self.startEditing)
if self.canvas().mapTool() == self:
self.__iface.actionPan().trigger()
return
self.action().setEnabled(False)
self.__removeLayer()
def processAlgorithm(self, progress):
layerA = dataobjects.getObjectFromUri(
self.getParameterValue(Difference.INPUT))
layerB = dataobjects.getObjectFromUri(
self.getParameterValue(Difference.OVERLAY))
ignoreInvalid = self.getParameterValue(Difference.IGNORE_INVALID)
geomType = QgsWKBTypes.multiType(QGis.fromOldWkbType(layerA.wkbType()))
writer = self.getOutputFromName(
Difference.OUTPUT).getVectorWriter(layerA.pendingFields(),
geomType,
layerA.crs())
outFeat = QgsFeature()
index = vector.spatialindex(layerB)
selectionA = vector.features(layerA)
total = 100.0 / len(selectionA) if len(selectionA) > 0 else 1
for current, inFeatA in enumerate(selectionA):
add = True
geom = QgsGeometry(inFeatA.geometry())
diff_geom = QgsGeometry(geom)
attrs = inFeatA.attributes()
intersections = index.intersects(geom.boundingBox())
for i in intersections:
request = QgsFeatureRequest().setFilterFid(i)
inFeatB = layerB.getFeatures(request).next()
tmpGeom = QgsGeometry(inFeatB.geometry())
if diff_geom.intersects(tmpGeom):
diff_geom = QgsGeometry(diff_geom.difference(tmpGeom))
if diff_geom.isGeosEmpty():
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Feature with NULL geometry found.'))
if not diff_geom.isGeosValid():
if ignoreInvalid:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('GEOS geoprocessing error: One or more input features have invalid geometry.'))
add = False
else:
raise GeoAlgorithmExecutionException(self.tr('Features with invalid geometries found. Please fix these errors or specify the "Ignore invalid input features" flag'))
break
if add:
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING,
self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
continue
progress.setPercentage(int(current * total))
del writer
def __getPointLayers(self):
"""
To get all points layers that can be used
:return: layers list
"""
layerList = []
for layer in self.__iface.mapCanvas().layers():
if layer.type() == QgsMapLayer.VectorLayer and QGis.fromOldWkbType(
layer.wkbType()) == QgsWKBTypes.PointZ:
layerList.append(layer)
return layerList
def __getOtherLayers(self):
"""
To get all points layers that can be used
:return: layers list
"""
layerList = []
types = [QgsWKBTypes.PointZ, QgsWKBTypes.LineStringZ, QgsWKBTypes.CircularStringZ, QgsWKBTypes.CompoundCurveZ,
QgsWKBTypes.CurvePolygonZ, QgsWKBTypes.PolygonZ]
for layer in self.canvas().layers():
if layer.type() == QgsMapLayer.VectorLayer and QGis.fromOldWkbType(layer.wkbType()) in types:
layerList.append(layer)
return layerList
def setEnable(self, layer):
"""
To check if we can enable the action for the selected layer
:param layer: selected layer
"""
if layer is not None and layer.type() == QgsMapLayer.VectorLayer and QGis.fromOldWkbType(layer.wkbType()) == \
QgsWKBTypes.LineStringZ:
self.__lineLayer = layer
self.action().setEnabled(True)
return
self.action().setEnabled(False)
if self.canvas().mapTool() == self:
self.__iface.actionPan().trigger()
if self.__dockWdg is not None:
self.__dockWdg.close()
self.__lineLayer = None
def setEnable(self, layer):
"""
To check if we can enable the action for the selected layer
:param layer: selected layer
"""
if layer is not None and layer.type() == QgsMapLayer.VectorLayer and \
QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.LineStringZ:
self.__lineLayer = layer
self.action().setEnabled(True)
return
self.action().setEnabled(False)
if self.__canvas.mapTool == self:
self.__iface.actionPan().trigger()
# self.__canvas.setMapTool(self.__oldTool)
if self.__dockWdg is not None:
self.__dockWdg.close()
self.__lineLayer = None
def processAlgorithm(self, progress):
layerA = dataobjects.getObjectFromUri(
self.getParameterValue(Difference.INPUT))
layerB = dataobjects.getObjectFromUri(
self.getParameterValue(Difference.OVERLAY))
ignoreInvalid = self.getParameterValue(Difference.IGNORE_INVALID)
geomType = QgsWKBTypes.multiType(QGis.fromOldWkbType(layerA.wkbType()))
writer = self.getOutputFromName(Difference.OUTPUT).getVectorWriter(
layerA.pendingFields(), geomType, layerA.crs())
outFeat = QgsFeature()
index = vector.spatialindex(layerB)
selectionA = vector.features(layerA)
total = 100.0 / len(selectionA)
for current, inFeatA in enumerate(selectionA):
add = True
geom = QgsGeometry(inFeatA.geometry())
diff_geom = QgsGeometry(geom)
attrs = inFeatA.attributes()
intersections = index.intersects(geom.boundingBox())
for i in intersections:
request = QgsFeatureRequest().setFilterFid(i)
inFeatB = layerB.getFeatures(request).next()
tmpGeom = QgsGeometry(inFeatB.geometry())
if diff_geom.intersects(tmpGeom):
diff_geom = QgsGeometry(diff_geom.difference(tmpGeom))
if diff_geom.isGeosEmpty():
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr('Feature with NULL geometry found.'))
if not diff_geom.isGeosValid():
if ignoreInvalid:
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
self.
tr('GEOS geoprocessing error: One or more input features have invalid geometry.'
))
add = False
else:
raise GeoAlgorithmExecutionException(
self.
tr('Features with invalid geometries found. Please fix these errors or specify the "Ignore invalid input features" flag'
))
break
if add:
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_WARNING,
self.
tr('Feature geometry error: One or more output features ignored due to invalid geometry.'
))
continue
progress.setPercentage(int(current * total))
del writer
def __init__(self, iface, memoryPointsLayer, memoryLinesLayer, ctllDb, configTable, uriDb, schemaDb, mntUrl,
refLayers, adjLayers, levelAtt, levelVal, drawdowmLayer, pipeDiam, moreTools):
"""
Constructor
:param iface: interface
:param memoryPointsLayer: working memory points layer
:param memoryLinesLayer: working memory lines layer
:param configTable: config table selected for import
"""
QDialog.__init__(self)
self.__iface = iface
self.__memoryPointsLayer = memoryPointsLayer
self.__memoryLinesLayer = memoryLinesLayer
self.__ctlDb = ctllDb
self.__configTable = configTable
self.__uriDb = uriDb
self.__schemaDb = schemaDb
self.__mntUrl = mntUrl
self.__refLayers = refLayers
self.__adjLayers = adjLayers
self.__levelAtt = levelAtt
self.__levelVal = levelVal
self.__drawdowmLayer = drawdowmLayer
self.__pipeDiam = pipeDiam
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Settings"))
self.__pointsLayers = []
self.__linesLayers = []
self.__refAvailableLayers = []
self.__drawdownLayers = []
self.__tables = []
self.__schemas = []
self.__pipeDiamFields = []
self.__levelAttFields = []
self.__dbs = DBConnector.getUsedDatabases()
self.__refLabels = []
self.__refChecks = []
self.__adjChecks = []
for layer in list(QgsMapLayerRegistry.instance().mapLayers().values()):
if layer is not None and layer.type() == QgsMapLayer.VectorLayer:
if layer.providerType() == "memory":
if layer.geometryType() == QGis.Point:
self.__pointsLayers.append(layer)
if layer.geometryType() == QGis.Line:
self.__linesLayers.append(layer)
if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.LineStringZ:
self.__drawdownLayers.append(layer)
if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.PointZ:
self.__refAvailableLayers.append(layer)
# self.resize(450, 400)
self.__layout = QGridLayout()
line = 0
intersectLabel = QLabel(QCoreApplication.translate("VDLTools", "Intersect "))
self.__layout.addWidget(intersectLabel, line, 0)
line += 1
pointLabel = QLabel(QCoreApplication.translate("VDLTools", "Working points layer : "))
self.__layout.addWidget(pointLabel, line, 1)
self.__pointCombo = QComboBox()
self.__pointCombo.setMinimumHeight(20)
self.__pointCombo.setMinimumWidth(50)
self.__pointCombo.addItem("")
for layer in self.__pointsLayers:
self.__pointCombo.addItem(layer.name())
self.__layout.addWidget(self.__pointCombo, line, 2)
self.__pointCombo.currentIndexChanged.connect(self.__pointComboChanged)
if self.__memoryPointsLayer is not None:
if self.__memoryPointsLayer in self.__pointsLayers:
self.__pointCombo.setCurrentIndex(self.__pointsLayers.index(self.__memoryPointsLayer)+1)
line += 1
lineLabel = QLabel(QCoreApplication.translate("VDLTools", "Working lines layer : "))
self.__layout.addWidget(lineLabel, line, 1)
self.__lineCombo = QComboBox()
self.__lineCombo.setMinimumHeight(20)
self.__lineCombo.setMinimumWidth(50)
self.__lineCombo.addItem("")
for layer in self.__linesLayers:
self.__lineCombo.addItem(layer.name())
self.__layout.addWidget(self.__lineCombo, line, 2)
self.__lineCombo.currentIndexChanged.connect(self.__lineComboChanged)
if self.__memoryLinesLayer is not None:
if self.__memoryLinesLayer in self.__linesLayers:
self.__lineCombo.setCurrentIndex(self.__linesLayers.index(self.__memoryLinesLayer)+1)
line += 1
profilesLabel = QLabel(QCoreApplication.translate("VDLTools", "Profiles "))
self.__layout.addWidget(profilesLabel, line, 0)
line += 1
mntLabel = QLabel(QCoreApplication.translate("VDLTools", "Url for MNT : "))
self.__layout.addWidget(mntLabel, line, 1)
self.__mntText = QLineEdit()
if self.__mntUrl is None or self.__mntUrl == "None":
self.__mntText.insert('https://map.lausanne.ch/prod/wsgi/profile.json')
else:
self.__mntText.insert(self.__mntUrl)
self.__mntText.setMinimumHeight(20)
self.__mntText.setMinimumWidth(100)
self.__layout.addWidget(self.__mntText, line, 2)
line += 1
ddLabel = QLabel(QCoreApplication.translate("VDLTools", "Drawdown "))
self.__layout.addWidget(ddLabel, line, 0)
line += 1
self.__layout.addWidget(QLabel(QCoreApplication.translate("VDLTools", "Layer")), line, 1)
namesLayout = QHBoxLayout()
namesWidget = QWidget()
namesLayout.addWidget(QLabel(QCoreApplication.translate("VDLTools", "Reference")))
namesLayout.addWidget(QLabel(QCoreApplication.translate("VDLTools", "Adjustable")))
namesLayout.setContentsMargins(0,0,0,0)
namesWidget.setLayout(namesLayout)
self.__layout.addWidget(namesWidget, line, 2)
line += 1
for layer in self.__refAvailableLayers:
refLabel = QLabel(" - " + layer.name())
self.__refLabels.append(refLabel)
self.__layout.addWidget(refLabel, line, 1)
checksLayout = QHBoxLayout()
checksLayout.setContentsMargins(0,0,0,0)
checksWidget = QWidget()
refCheck = QCheckBox()
self.__refChecks.append(refCheck)
refCheck.stateChanged.connect(self.__refBoxesChanged)
checksLayout.addWidget(refCheck)
adjCheck = QCheckBox()
self.__adjChecks.append(adjCheck)
checksLayout.addWidget(adjCheck)
checksWidget.setLayout(checksLayout)
self.__layout.addWidget(checksWidget, line, 2)
line += 1
levelAttLabel = QLabel(QCoreApplication.translate("VDLTools", "Code(s) on pipe : "))
self.__layout.addWidget(levelAttLabel, line, 1)
self.__levelAttCombo = QComboBox()
self.__levelAttCombo.setMinimumHeight(20)
self.__levelAttCombo.setMinimumWidth(50)
self.__levelAttCombo.addItem("")
self.__layout.addWidget(self.__levelAttCombo, line, 2)
self.__levelAttCombo.currentIndexChanged.connect(self.__levelAttComboChanged)
i = 0
for layer in self.__refAvailableLayers:
if layer in self.__refLayers:
self.__refChecks[i].setChecked(True)
if layer in self.__adjLayers:
self.__adjChecks[i].setChecked(True)
i += 1
line += 1
levelValLabel = QLabel(QCoreApplication.translate("VDLTools", "Point code attribute : "))
self.__layout.addWidget(levelValLabel, line, 1)
self.__levelValText = QLineEdit()
if self.__levelVal is not None and self.__levelVal != "None":
self.__levelValText.insert(self.__levelVal)
self.__levelValText.setMinimumHeight(20)
self.__levelValText.setMinimumWidth(100)
self.__layout.addWidget(self.__levelValText, line, 2)
line += 1
drawdownLabel = QLabel(QCoreApplication.translate("VDLTools", "drawdown layer : "))
self.__layout.addWidget(drawdownLabel, line, 1)
self.__drawdownCombo = QComboBox()
self.__drawdownCombo.setMinimumHeight(20)
self.__drawdownCombo.setMinimumWidth(50)
self.__drawdownCombo.addItem("")
for layer in self.__drawdownLayers:
self.__drawdownCombo.addItem(layer.name())
self.__layout.addWidget(self.__drawdownCombo, line, 2)
line += 1
pipeDiamLabel = QLabel(QCoreApplication.translate("VDLTools", "Pipe diameter attribute [cm] : "))
self.__layout.addWidget(pipeDiamLabel, line, 1)
self.__pipeDiamCombo = QComboBox()
self.__pipeDiamCombo.setMinimumHeight(20)
self.__pipeDiamCombo.setMinimumWidth(50)
self.__pipeDiamCombo.addItem("")
self.__layout.addWidget(self.__pipeDiamCombo, line, 2)
self.__drawdownCombo.currentIndexChanged.connect(self.__drawdownComboChanged)
self.__pipeDiamCombo.currentIndexChanged.connect(self.__pipeDiamComboChanged)
if self.__drawdowmLayer is not None:
if self.__drawdowmLayer in self.__drawdownLayers:
self.__drawdownCombo.setCurrentIndex(self.__drawdownLayers.index(self.__drawdowmLayer)+1)
if moreTools:
line += 1
importLabel = QLabel(QCoreApplication.translate("VDLTools", "Import "))
self.__layout.addWidget(importLabel, line, 0)
line += 1
dbLabel = QLabel(QCoreApplication.translate("VDLTools", "Import database : "))
self.__layout.addWidget(dbLabel, line, 1)
self.__dbCombo = QComboBox()
self.__dbCombo.setMinimumHeight(20)
self.__dbCombo.setMinimumWidth(50)
self.__dbCombo.addItem("")
for db in list(self.__dbs.keys()):
self.__dbCombo.addItem(db)
self.__layout.addWidget(self.__dbCombo, line, 2)
line += 1
schemaLabel = QLabel(QCoreApplication.translate("VDLTools", "Database schema : "))
self.__layout.addWidget(schemaLabel, line, 1)
self.__schemaCombo = QComboBox()
self.__schemaCombo.setMinimumHeight(20)
self.__schemaCombo.setMinimumWidth(50)
self.__schemaCombo.addItem("")
self.__layout.addWidget(self.__schemaCombo, line, 2)
line += 1
tableLabel = QLabel(QCoreApplication.translate("VDLTools", "Config table : "))
self.__layout.addWidget(tableLabel, line, 1)
self.__tableCombo = QComboBox()
self.__tableCombo.setMinimumHeight(20)
self.__tableCombo.setMinimumWidth(50)
self.__tableCombo.addItem("")
self.__layout.addWidget(self.__tableCombo, line, 2)
line += 1
controlLabel = QLabel(QCoreApplication.translate("VDLTools", "Control "))
self.__layout.addWidget(controlLabel, line, 0)
line += 1
ctlLabel = QLabel(QCoreApplication.translate("VDLTools", "Control database : "))
self.__layout.addWidget(ctlLabel, line, 1)
self.__ctlCombo = QComboBox()
self.__ctlCombo.setMinimumHeight(20)
self.__ctlCombo.setMinimumWidth(50)
self.__ctlCombo.addItem("")
for db in list(self.__dbs.keys()):
self.__ctlCombo.addItem(db)
self.__layout.addWidget(self.__ctlCombo, line, 2)
self.__dbCombo.currentIndexChanged.connect(self.__dbComboChanged)
self.__schemaCombo.currentIndexChanged.connect(self.__schemaComboChanged)
self.__tableCombo.currentIndexChanged.connect(self.__tableComboChanged)
self.__ctlCombo.currentIndexChanged.connect(self.__ctlComboChanged)
if self.__uriDb is not None:
if self.__uriDb.database() in list(self.__dbs.keys()):
self.__dbCombo.setCurrentIndex(list(self.__dbs.keys()).index(self.__uriDb.database()) + 1)
if self.__ctlDb is not None:
if self.__ctlDb.database() in list(self.__dbs.keys()):
self.__ctlCombo.setCurrentIndex(list(self.__dbs.keys()).index(self.__ctlDb.database()) + 1)
else:
self.__dbCombo = None
self.__schemaCombo = None
self.__tableCombo = None
self.__ctlCombo = None
self.__okButton = QPushButton(QCoreApplication.translate("VDLTools", "OK"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(100)
self.__cancelButton = QPushButton(QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, 100, 1)
self.__layout.addWidget(self.__cancelButton, 100, 2)
self.setLayout(self.__layout)
def processAlgorithm(self, progress):
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
vlayerB = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT2))
ignoreNull = self.getParameterValue(Intersection.IGNORE_NULL)
geomType = QgsWKBTypes.multiType(QGis.fromOldWkbType(vlayerA.wkbType()))
fields = vector.combineVectorFields(vlayerA, vlayerB)
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
geomType, vlayerA.crs())
outFeat = QgsFeature()
index = vector.spatialindex(vlayerB)
selectionA = vector.features(vlayerA)
total = 100.0 / len(selectionA) if len(selectionA) > 0 else 1
for current, inFeatA in enumerate(selectionA):
progress.setPercentage(int(current * total))
geom = inFeatA.geometry()
if not geom:
if ignoreNull:
continue
else:
raise GeoAlgorithmExecutionException(
self.tr('Input layer A contains NULL geometries. '
'Please check "Ignore NULL geometries" '
'if you want to run this algorithm anyway.'))
if not geom.isGeosValid():
raise GeoAlgorithmExecutionException(
self.tr('Input layer A contains invalid geometries '
'(feature {}). Unable to complete intersection '
'algorithm.'.format(inFeatA.id())))
atMapA = inFeatA.attributes()
intersects = index.intersects(geom.boundingBox())
for inFeatB in vlayerB.getFeatures(QgsFeatureRequest().setFilterFids(intersects)):
tmpGeom = QgsGeometry(inFeatB.geometry())
if not geom:
if ignoreNull:
continue
else:
raise GeoAlgorithmExecutionException(
self.tr('Input layer B contains NULL geometries. '
'Please check "Ignore NULL geometries" '
'if you want to run this algorithm anyway.'))
if not geom.isGeosValid():
raise GeoAlgorithmExecutionException(
self.tr('Input layer B contains invalid geometries '
'(feature {}). Unable to complete intersection '
'algorithm.'.format(inFeatB.id())))
if geom.intersects(tmpGeom):
atMapB = inFeatB.attributes()
int_geom = QgsGeometry(geom.intersection(tmpGeom))
if int_geom.wkbType() == QGis.WKBUnknown or QgsWKBTypes.flatType(int_geom.geometry().wkbType()) == QgsWKBTypes.GeometryCollection:
int_com = geom.combine(tmpGeom)
int_geom = QgsGeometry()
if int_com is not None:
int_sym = geom.symDifference(tmpGeom)
if int_sym:
diff_geom = int_com.difference(int_sym)
int_geom = QgsGeometry(diff_geom)
if int_geom.isGeosEmpty() or not int_geom.isGeosValid():
raise GeoAlgorithmExecutionException(
self.tr('GEOS geoprocessing error: One or '
'more input features have invalid '
'geometry.'))
try:
if int_geom.wkbType() in wkbTypeGroups[wkbTypeGroups[int_geom.wkbType()]]:
outFeat.setGeometry(int_geom)
attrs = []
attrs.extend(atMapA)
attrs.extend(atMapB)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
except:
raise GeoAlgorithmExecutionException(
self.tr('Feature geometry error: one or '
'more output features ignored due '
'to invalid geometry.'))
del writer
def processAlgorithm(self, progress):
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
vlayerB = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT2))
ignoreNull = self.getParameterValue(Intersection.IGNORE_NULL)
geomType = QgsWKBTypes.multiType(QGis.fromOldWkbType(
vlayerA.wkbType()))
fields = vector.combineVectorFields(vlayerA, vlayerB)
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, geomType, vlayerA.crs())
outFeat = QgsFeature()
index = vector.spatialindex(vlayerB)
selectionA = vector.features(vlayerA)
total = 100.0 / len(selectionA)
for current, inFeatA in enumerate(selectionA):
progress.setPercentage(int(current * total))
geom = inFeatA.geometry()
if not geom:
if ignoreNull:
continue
else:
raise GeoAlgorithmExecutionException(
self.tr('Input layer A contains NULL geometries. '
'Please check "Ignore NULL geometries" '
'if you want to run this algorithm anyway.'))
if not geom.isGeosValid():
raise GeoAlgorithmExecutionException(
self.tr('Input layer A contains invalid geometries '
'(feature {}). Unable to complete intersection '
'algorithm.'.format(inFeatA.id())))
atMapA = inFeatA.attributes()
intersects = index.intersects(geom.boundingBox())
for inFeatB in vlayerB.getFeatures(
QgsFeatureRequest().setFilterFids(intersects)):
tmpGeom = QgsGeometry(inFeatB.geometry())
if not geom:
if ignoreNull:
continue
else:
raise GeoAlgorithmExecutionException(
self.tr(
'Input layer B contains NULL geometries. '
'Please check "Ignore NULL geometries" '
'if you want to run this algorithm anyway.'))
if not geom.isGeosValid():
raise GeoAlgorithmExecutionException(
self.tr(
'Input layer B contains invalid geometries '
'(feature {}). Unable to complete intersection '
'algorithm.'.format(inFeatB.id())))
if geom.intersects(tmpGeom):
atMapB = inFeatB.attributes()
int_geom = QgsGeometry(geom.intersection(tmpGeom))
if int_geom.wkbType(
) == QGis.WKBUnknown or QgsWKBTypes.flatType(
int_geom.geometry().wkbType(
)) == QgsWKBTypes.GeometryCollection:
int_com = geom.combine(tmpGeom)
int_geom = QgsGeometry()
if int_com is not None:
int_sym = geom.symDifference(tmpGeom)
if int_sym:
diff_geom = int_com.difference(int_sym)
int_geom = QgsGeometry(diff_geom)
if int_geom.isGeosEmpty() or not int_geom.isGeosValid():
raise GeoAlgorithmExecutionException(
self.tr('GEOS geoprocessing error: One or '
'more input features have invalid '
'geometry.'))
try:
if int_geom.wkbType() in wkbTypeGroups[wkbTypeGroups[
int_geom.wkbType()]]:
outFeat.setGeometry(int_geom)
attrs = []
attrs.extend(atMapA)
attrs.extend(atMapB)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
except:
raise GeoAlgorithmExecutionException(
self.tr('Feature geometry error: one or '
'more output features ignored due '
'to invalid geometry.'))
del writer
def processAlgorithm(self, progress):
source_layer = dataobjects.getObjectFromUri(
self.getParameterValue(Clip.INPUT))
mask_layer = dataobjects.getObjectFromUri(
self.getParameterValue(Clip.OVERLAY))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
source_layer.fields(),
QgsWKBTypes.multiType(QGis.fromOldWkbType(source_layer.wkbType())),
source_layer.crs())
# first build up a list of clip geometries
clip_geoms = []
for maskFeat in vector.features(mask_layer, QgsFeatureRequest().setSubsetOfAttributes([])):
clip_geoms.append(QgsGeometry(maskFeat.constGeometry()))
# are we clipping against a single feature? if so, we can show finer progress reports
if len(clip_geoms) > 1:
combined_clip_geom = QgsGeometry.unaryUnion(clip_geoms)
single_clip_feature = False
else:
combined_clip_geom = clip_geoms[0]
single_clip_feature = True
# use prepared geometries for faster intersection tests
engine = QgsGeometry.createGeometryEngine(combined_clip_geom.geometry())
engine.prepareGeometry()
tested_feature_ids = set()
for i, clip_geom in enumerate(clip_geoms):
input_features = [f for f in vector.features(source_layer, QgsFeatureRequest().setFilterRect(clip_geom.boundingBox()))]
if not input_features:
continue
if single_clip_feature:
total = 100.0 / len(input_features) if len(input_features) > 0 else 1
else:
total = 0
for current, in_feat in enumerate(input_features):
if not in_feat.constGeometry():
continue
if in_feat.id() in tested_feature_ids:
# don't retest a feature we have already checked
continue
tested_feature_ids.add(in_feat.id())
if not engine.intersects(in_feat.constGeometry().geometry()):
continue
if not engine.contains(in_feat.constGeometry().geometry()):
cur_geom = QgsGeometry(in_feat.constGeometry())
new_geom = combined_clip_geom.intersection(cur_geom)
if new_geom.wkbType() == QGis.WKBUnknown or QgsWKBTypes.flatType(new_geom.geometry().wkbType()) == QgsWKBTypes.GeometryCollection:
int_com = in_feat.constGeometry().combine(new_geom)
int_sym = in_feat.constGeometry().symDifference(new_geom)
if not int_com or not int_sym:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('GEOS geoprocessing error: One or more '
'input features have invalid geometry.'))
else:
new_geom = int_com.difference(int_sym)
if new_geom.isGeosEmpty() or not new_geom.isGeosValid():
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('GEOS geoprocessing error: One or more '
'input features have invalid geometry.'))
else:
# clip geometry totally contains feature geometry, so no need to perform intersection
new_geom = QgsGeometry(in_feat.constGeometry())
try:
out_feat = QgsFeature()
out_feat.setGeometry(new_geom)
out_feat.setAttributes(in_feat.attributes())
writer.addFeature(out_feat)
except:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('Feature geometry error: One or more '
'output features ignored due to '
'invalid geometry.'))
continue
if single_clip_feature:
progress.setPercentage(int(current * total))
if not single_clip_feature:
# coarse progress report for multiple clip geometries
progress.setPercentage(100.0 * i / len(clip_geoms))
del writer
def processAlgorithm(self, progress):
layerA = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
layerB = dataobjects.getObjectFromUri(
self.getParameterValue(self.OVERLAY))
geomType = QgsWKBTypes.multiType(QGis.fromOldWkbType(layerA.wkbType()))
fields = vector.combineVectorFields(layerA, layerB)
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, geomType, layerA.crs())
featB = QgsFeature()
outFeat = QgsFeature()
indexA = vector.spatialindex(layerB)
indexB = vector.spatialindex(layerA)
featuresA = vector.features(layerA)
featuresB = vector.features(layerB)
total = 100.0 / (len(featuresA) * len(featuresB))
count = 0
for featA in featuresA:
add = True
geom = QgsGeometry(featA.geometry())
diffGeom = QgsGeometry(geom)
attrs = featA.attributes()
intersects = indexA.intersects(geom.boundingBox())
for i in intersects:
layerB.getFeatures(
QgsFeatureRequest().setFilterFid(i)).nextFeature(featB)
tmpGeom = QgsGeometry(featB.geometry())
if diffGeom.intersects(tmpGeom):
diffGeom = QgsGeometry(diffGeom.difference(tmpGeom))
if not diffGeom.isGeosValid():
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
self.tr('GEOS geoprocessing error: One or '
'more input features have invalid '
'geometry.'))
add = False
break
if add:
try:
outFeat.setGeometry(diffGeom)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_WARNING,
self.
tr('Feature geometry error: One or more output features ignored due to invalid geometry.'
))
continue
count += 1
progress.setPercentage(int(count * total))
length = len(layerA.fields())
for featA in featuresB:
add = True
geom = QgsGeometry(featA.geometry())
diffGeom = QgsGeometry(geom)
attrs = featA.attributes()
attrs = [NULL] * length + attrs
intersects = indexB.intersects(geom.boundingBox())
for i in intersects:
layerA.getFeatures(
QgsFeatureRequest().setFilterFid(i)).nextFeature(featB)
tmpGeom = QgsGeometry(featB.geometry())
if diffGeom.intersects(tmpGeom):
diffGeom = QgsGeometry(diffGeom.difference(tmpGeom))
if not diffGeom.isGeosValid():
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
self.tr('GEOS geoprocessing error: One or '
'more input features have invalid '
'geometry.'))
add = False
break
if add:
try:
outFeat.setGeometry(diffGeom)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_WARNING,
self.
tr('Feature geometry error: One or more output features ignored due to invalid geometry.'
))
continue
count += 1
progress.setPercentage(int(count * total))
del writer
def __project_loaded(self):
"""
Get saved settings on load
"""
""" Reference point layers for drawdown tool """
str_ids = QgsProject.instance().readEntry("VDLTools", "ref_layers", "None")[0]
ref_ids = str_ids.split(',')
""" Adjustable point layers for drawdown tool """
str_ids = QgsProject.instance().readEntry("VDLTools", "adj_layers", "None")[0]
adj_ids = str_ids.split(',')
""" Level attribute for drawdown tool """
self.__levelAtt = QgsProject.instance().readEntry("VDLTools", "level_att", "None")[0]
""" Level value for drawdown tool """
value = QgsProject.instance().readEntry("VDLTools", "level_val", "None")[0]
self.__levelVals = value.split(",")
""" Drawdown line layer """
dd_id = QgsProject.instance().readEntry("VDLTools", "drawdown_layer", "None")[0]
""" Pipe diameter attribute for drawdown line layer """
self.__pipeDiam = QgsProject.instance().readEntry("VDLTools", "pipe_diam", "None")[0]
""" Url used to get mnt values on a line """
self.__mntUrl = QgsProject.instance().readEntry("VDLTools", "mnt_url", "None")[0]
""" Config table in Database for importing new Lausanne data """
self.__configTable = QgsProject.instance().readEntry("VDLTools", "config_table", None)[0]
""" Database used for importing new Lausanne data """
dbName = QgsProject.instance().readEntry("VDLTools", "db_name", None)[0]
""" Table in Database containing control values for importing new Lausanne data """
ctlDbName = QgsProject.instance().readEntry("VDLTools", "ctl_db_name", None)[0]
""" Schema of the Database used for importing new Lausanne data """
self.__schemaDb = QgsProject.instance().readEntry("VDLTools", "schema_db", None)[0]
""" Temporarly points layer for the project """
mpl_id = QgsProject.instance().readEntry("VDLTools", "memory_points_layer", None)[0]
""" Temporarly lines layer for the project """
mll_id = QgsProject.instance().readEntry("VDLTools", "memory_lines_layer", None)[0]
for layer in list(QgsMapLayerRegistry.instance().mapLayers().values()):
if layer and layer.type() == QgsMapLayer.VectorLayer:
if layer.providerType() == "memory":
if layer.geometryType() == QGis.Point:
if layer.id() == mpl_id:
self.__memoryPointsLayer = layer
if layer.geometryType() == QGis.Line:
if layer.id() == mll_id:
self.__memoryLinesLayer = layer
if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.LineStringZ:
if layer.id() == dd_id:
self.__drawdownLayer = layer
if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.PointZ:
if layer.id() in ref_ids:
self.__refLayers.append(layer)
if layer.id() in adj_ids:
self.__adjLayers.append(layer)
if dbName != "":
usedDbs = DBConnector.getUsedDatabases()
if dbName in list(usedDbs.keys()):
self.__uriDb = usedDbs[dbName]
if ctlDbName != "":
usedDbs = DBConnector.getUsedDatabases()
if ctlDbName in list(usedDbs.keys()):
self.__ctlDb = usedDbs[ctlDbName]
self.changedSignal.emit()
def __init__(self, iface, memoryPointsLayer, memoryLinesLayer,
importConfigTable, importUriDb, importSchemaDb,
controlConfigTable, controlUriDb, controlSchemaDb, mntUrl,
refLayers, adjLayers, levelAtt, levelVal, drawdowmLayer,
pipeDiam, moreTools):
"""
Constructor
:param iface: interface
:param memoryPointsLayer: working memory points layer
:param memoryLinesLayer: working memory lines layer
:param importConfigTable: config table selected for import
:param importUriDb: database for import
:param importSchemaDb: db schema for import
:param controlConfigTable: config table selected for control
:param controlUriDb: database for control
:param controlSchemaDb: db schema for control
:param mntUrl: url to get mnt
:param refLayers: reference layers for drawdown
:param adjLayers: adjustement layers for drawdown
:param levelAtt: level attribute for drawdown
:param levelVal: level value for drawdown
:param drawdowmLayer: line layer for drawdown
:param pipeDiam: pipe diameter for drawdown
:param moreTools: if more tools or not
"""
QDialog.__init__(self)
self.__iface = iface
self.__memoryPointsLayer = memoryPointsLayer
self.__memoryLinesLayer = memoryLinesLayer
self.__importConfigTable = importConfigTable
self.__importUriDb = importUriDb
self.__importSchemaDb = importSchemaDb
self.__controlConfigTable = controlConfigTable
self.__controlUriDb = controlUriDb
self.__controlSchemaDb = controlSchemaDb
self.__mntUrl = mntUrl
self.__refLayers = refLayers
self.__adjLayers = adjLayers
self.__levelAtt = levelAtt
self.__levelVal = levelVal
self.__drawdowmLayer = drawdowmLayer
self.__pipeDiam = pipeDiam
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Settings"))
self.__pointsLayers = []
self.__linesLayers = []
self.__refAvailableLayers = []
self.__drawdownLayers = []
self.__tables = []
self.__schemas = []
self.__pipeDiamFields = []
self.__levelAttFields = []
self.__dbs = DBConnector.getUsedDatabases()
self.__refLabels = []
self.__refChecks = []
self.__adjChecks = []
for layer in list(QgsMapLayerRegistry.instance().mapLayers().values()):
if layer is not None and layer.type() == QgsMapLayer.VectorLayer:
if layer.providerType() == "memory":
if layer.geometryType() == QGis.Point:
self.__pointsLayers.append(layer)
if layer.geometryType() == QGis.Line:
self.__linesLayers.append(layer)
if QGis.fromOldWkbType(
layer.wkbType()) == QgsWKBTypes.LineStringZ:
self.__drawdownLayers.append(layer)
if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.PointZ:
self.__refAvailableLayers.append(layer)
self.resize(600, 500)
self.__layout = QGridLayout()
self.__scrollLayout = QGridLayout()
line = 0
intersectLabel = QLabel(
QCoreApplication.translate("VDLTools", "Intersect "))
self.__scrollLayout.addWidget(intersectLabel, line, 0)
line += 1
pointLabel = QLabel(
QCoreApplication.translate("VDLTools", "Working points layer : "))
self.__scrollLayout.addWidget(pointLabel, line, 1)
self.__pointCombo = QComboBox()
self.__pointCombo.setMinimumHeight(20)
self.__pointCombo.setMinimumWidth(50)
self.__pointCombo.addItem("")
for layer in self.__pointsLayers:
self.__pointCombo.addItem(layer.name())
self.__scrollLayout.addWidget(self.__pointCombo, line, 2)
self.__pointCombo.currentIndexChanged.connect(self.__pointComboChanged)
if self.__memoryPointsLayer is not None:
if self.__memoryPointsLayer in self.__pointsLayers:
self.__pointCombo.setCurrentIndex(
self.__pointsLayers.index(self.__memoryPointsLayer) + 1)
line += 1
lineLabel = QLabel(
QCoreApplication.translate("VDLTools", "Working lines layer : "))
self.__scrollLayout.addWidget(lineLabel, line, 1)
self.__lineCombo = QComboBox()
self.__lineCombo.setMinimumHeight(20)
self.__lineCombo.setMinimumWidth(50)
self.__lineCombo.addItem("")
for layer in self.__linesLayers:
self.__lineCombo.addItem(layer.name())
self.__scrollLayout.addWidget(self.__lineCombo, line, 2)
self.__lineCombo.currentIndexChanged.connect(self.__lineComboChanged)
if self.__memoryLinesLayer is not None:
if self.__memoryLinesLayer in self.__linesLayers:
self.__lineCombo.setCurrentIndex(
self.__linesLayers.index(self.__memoryLinesLayer) + 1)
line += 1
profilesLabel = QLabel(
QCoreApplication.translate("VDLTools", "Profiles "))
self.__scrollLayout.addWidget(profilesLabel, line, 0)
line += 1
mntLabel = QLabel(
QCoreApplication.translate("VDLTools", "Url for MNT : "))
self.__scrollLayout.addWidget(mntLabel, line, 1)
self.__mntText = QLineEdit()
if self.__mntUrl is None or self.__mntUrl == "None":
self.__mntText.insert(
'https://map.lausanne.ch/prod/wsgi/profile.json')
else:
self.__mntText.insert(self.__mntUrl)
self.__mntText.setMinimumHeight(20)
self.__mntText.setMinimumWidth(100)
self.__scrollLayout.addWidget(self.__mntText, line, 2)
line += 1
ddLabel = QLabel(QCoreApplication.translate("VDLTools", "Drawdown "))
self.__scrollLayout.addWidget(ddLabel, line, 0)
line += 1
self.__scrollLayout.addWidget(
QLabel(QCoreApplication.translate("VDLTools", "Layer")), line, 1)
namesLayout = QHBoxLayout()
namesWidget = QWidget()
namesLayout.addWidget(
QLabel(QCoreApplication.translate("VDLTools", "Reference")))
namesLayout.addWidget(
QLabel(QCoreApplication.translate("VDLTools", "Adjustable")))
namesLayout.setContentsMargins(0, 0, 0, 0)
namesWidget.setLayout(namesLayout)
self.__scrollLayout.addWidget(namesWidget, line, 2)
line += 1
for layer in self.__refAvailableLayers:
refLabel = QLabel(" - " + layer.name())
self.__refLabels.append(refLabel)
self.__scrollLayout.addWidget(refLabel, line, 1)
checksLayout = QHBoxLayout()
checksLayout.setContentsMargins(0, 0, 0, 0)
checksWidget = QWidget()
refCheck = QCheckBox()
self.__refChecks.append(refCheck)
refCheck.stateChanged.connect(self.__refBoxesChanged)
checksLayout.addWidget(refCheck)
adjCheck = QCheckBox()
self.__adjChecks.append(adjCheck)
checksLayout.addWidget(adjCheck)
checksWidget.setLayout(checksLayout)
self.__scrollLayout.addWidget(checksWidget, line, 2)
line += 1
levelAttLabel = QLabel(
QCoreApplication.translate("VDLTools", "Code(s) on pipe : "))
self.__scrollLayout.addWidget(levelAttLabel, line, 1)
self.__levelAttCombo = QComboBox()
self.__levelAttCombo.setMinimumHeight(20)
self.__levelAttCombo.setMinimumWidth(50)
self.__levelAttCombo.addItem("")
self.__scrollLayout.addWidget(self.__levelAttCombo, line, 2)
self.__levelAttCombo.currentIndexChanged.connect(
self.__levelAttComboChanged)
i = 0
for layer in self.__refAvailableLayers:
if layer in self.__refLayers:
self.__refChecks[i].setChecked(True)
if layer in self.__adjLayers:
self.__adjChecks[i].setChecked(True)
i += 1
line += 1
levelValLabel = QLabel(
QCoreApplication.translate("VDLTools", "Point code attribute : "))
self.__scrollLayout.addWidget(levelValLabel, line, 1)
self.__levelValText = QLineEdit()
if self.__levelVal is not None and self.__levelVal != "None":
self.__levelValText.insert(self.__levelVal)
self.__levelValText.setMinimumHeight(20)
self.__levelValText.setMinimumWidth(100)
self.__scrollLayout.addWidget(self.__levelValText, line, 2)
line += 1
drawdownLabel = QLabel(
QCoreApplication.translate("VDLTools", "drawdown layer : "))
self.__scrollLayout.addWidget(drawdownLabel, line, 1)
self.__drawdownCombo = QComboBox()
self.__drawdownCombo.setMinimumHeight(20)
self.__drawdownCombo.setMinimumWidth(50)
self.__drawdownCombo.addItem("")
for layer in self.__drawdownLayers:
self.__drawdownCombo.addItem(layer.name())
self.__scrollLayout.addWidget(self.__drawdownCombo, line, 2)
line += 1
pipeDiamLabel = QLabel(
QCoreApplication.translate("VDLTools",
"Pipe diameter attribute [cm] : "))
self.__scrollLayout.addWidget(pipeDiamLabel, line, 1)
self.__pipeDiamCombo = QComboBox()
self.__pipeDiamCombo.setMinimumHeight(20)
self.__pipeDiamCombo.setMinimumWidth(50)
self.__pipeDiamCombo.addItem("")
self.__scrollLayout.addWidget(self.__pipeDiamCombo, line, 2)
self.__drawdownCombo.currentIndexChanged.connect(
self.__drawdownComboChanged)
self.__pipeDiamCombo.currentIndexChanged.connect(
self.__pipeDiamComboChanged)
if self.__drawdowmLayer is not None:
if self.__drawdowmLayer in self.__drawdownLayers:
self.__drawdownCombo.setCurrentIndex(
self.__drawdownLayers.index(self.__drawdowmLayer) + 1)
line += 1
controlLabel = QLabel(
QCoreApplication.translate("VDLTools", "Control "))
self.__scrollLayout.addWidget(controlLabel, line, 0)
line += 1
controlDbLabel = QLabel(
QCoreApplication.translate("VDLTools", "Control database : "))
self.__scrollLayout.addWidget(controlDbLabel, line, 1)
self.__controlDbCombo = QComboBox()
self.__controlDbCombo.setMinimumHeight(20)
self.__controlDbCombo.setMinimumWidth(50)
self.__controlDbCombo.addItem("")
for db in list(self.__dbs.keys()):
self.__controlDbCombo.addItem(db)
self.__scrollLayout.addWidget(self.__controlDbCombo, line, 2)
line += 1
controlSchemaLabel = QLabel(
QCoreApplication.translate("VDLTools",
"Control database schema : "))
self.__scrollLayout.addWidget(controlSchemaLabel, line, 1)
self.__controlSchemaCombo = QComboBox()
self.__controlSchemaCombo.setMinimumHeight(20)
self.__controlSchemaCombo.setMinimumWidth(50)
self.__controlSchemaCombo.addItem("")
self.__scrollLayout.addWidget(self.__controlSchemaCombo, line, 2)
line += 1
controlTableLabel = QLabel(
QCoreApplication.translate("VDLTools", "Control config table : "))
self.__scrollLayout.addWidget(controlTableLabel, line, 1)
self.__controlTableCombo = QComboBox()
self.__controlTableCombo.setMinimumHeight(20)
self.__controlTableCombo.setMinimumWidth(50)
self.__controlTableCombo.addItem("")
self.__scrollLayout.addWidget(self.__controlTableCombo, line, 2)
self.__controlDbCombo.currentIndexChanged.connect(
self.__controlDbComboChanged)
self.__controlSchemaCombo.currentIndexChanged.connect(
self.__controlSchemaComboChanged)
self.__controlTableCombo.currentIndexChanged.connect(
self.__controlTableComboChanged)
if self.__controlUriDb is not None:
if self.__controlUriDb.database() in list(self.__dbs.keys()):
self.__controlDbCombo.setCurrentIndex(
list(self.__dbs.keys()).index(
self.__controlUriDb.database()) + 1)
if moreTools:
line += 1
importLabel = QLabel(
QCoreApplication.translate("VDLTools", "Import "))
self.__scrollLayout.addWidget(importLabel, line, 0)
line += 1
importDbLabel = QLabel(
QCoreApplication.translate("VDLTools", "Import database : "))
self.__scrollLayout.addWidget(importDbLabel, line, 1)
self.__importDbCombo = QComboBox()
self.__importDbCombo.setMinimumHeight(20)
self.__importDbCombo.setMinimumWidth(50)
self.__importDbCombo.addItem("")
for db in list(self.__dbs.keys()):
self.__importDbCombo.addItem(db)
self.__scrollLayout.addWidget(self.__importDbCombo, line, 2)
line += 1
importSchemaLabel = QLabel(
QCoreApplication.translate("VDLTools",
"Import database schema : "))
self.__scrollLayout.addWidget(importSchemaLabel, line, 1)
self.__importSchemaCombo = QComboBox()
self.__importSchemaCombo.setMinimumHeight(20)
self.__importSchemaCombo.setMinimumWidth(50)
self.__importSchemaCombo.addItem("")
self.__scrollLayout.addWidget(self.__importSchemaCombo, line, 2)
line += 1
importTableLabel = QLabel(
QCoreApplication.translate("VDLTools",
"Import config table : "))
self.__scrollLayout.addWidget(importTableLabel, line, 1)
self.__importTableCombo = QComboBox()
self.__importTableCombo.setMinimumHeight(20)
self.__importTableCombo.setMinimumWidth(50)
self.__importTableCombo.addItem("")
self.__scrollLayout.addWidget(self.__importTableCombo, line, 2)
self.__importDbCombo.currentIndexChanged.connect(
self.__importDbComboChanged)
self.__importSchemaCombo.currentIndexChanged.connect(
self.__importSchemaComboChanged)
self.__importTableCombo.currentIndexChanged.connect(
self.__importTableComboChanged)
if self.__importUriDb is not None:
if self.__importUriDb.database() in list(self.__dbs.keys()):
self.__importDbCombo.setCurrentIndex(
list(self.__dbs.keys()).index(
self.__importUriDb.database()) + 1)
else:
self.__importDbCombo = None
self.__importSchemaCombo = None
self.__importTableCombo = None
widget = QWidget()
widget.setLayout(self.__scrollLayout)
scroll = QScrollArea()
scroll.setWidgetResizable(True)
scroll.setWidget(widget)
self.__layout.addWidget(scroll, 1, 0, 1, 2)
self.__okButton = QPushButton(
QCoreApplication.translate("VDLTools", "OK"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(100)
self.__cancelButton = QPushButton(
QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, 100, 0)
self.__layout.addWidget(self.__cancelButton, 100, 1)
self.setLayout(self.__layout)
def __project_loaded(self):
"""
Get saved settings on load
"""
""" Reference point layers for drawdown tool """
str_ids = QgsProject.instance().readEntry("VDLTools", "ref_layers",
"None")[0]
ref_ids = str_ids.split(',')
""" Adjustable point layers for drawdown tool """
str_ids = QgsProject.instance().readEntry("VDLTools", "adj_layers",
"None")[0]
adj_ids = str_ids.split(',')
""" Level attribute for drawdown tool """
self.__levelAtt = QgsProject.instance().readEntry(
"VDLTools", "level_att", "None")[0]
""" Level value for drawdown tool """
value = QgsProject.instance().readEntry("VDLTools", "level_val",
"None")[0]
self.__levelVals = value.split(",")
""" Drawdown line layer """
dd_id = QgsProject.instance().readEntry("VDLTools", "drawdown_layer",
"None")[0]
""" Pipe diameter attribute for drawdown line layer """
self.__pipeDiam = QgsProject.instance().readEntry(
"VDLTools", "pipe_diam", "None")[0]
""" Url used to get mnt values on a line """
self.__mntUrl = QgsProject.instance().readEntry(
"VDLTools", "mnt_url", "None")[0]
""" Config table in Database for importing new Lausanne data """
self.__importConfigTable = QgsProject.instance().readEntry(
"VDLTools", "import_config_table", None)[0]
""" Config table in Database for controling """
self.__controlConfigTable = QgsProject.instance().readEntry(
"VDLTools", "control_config_table", None)[0]
""" Database used for importing new Lausanne data """
importDbName = QgsProject.instance().readEntry("VDLTools",
"import_db_name",
None)[0]
""" Database used for controling """
controlDbName = QgsProject.instance().readEntry(
"VDLTools", "control_db_name", None)[0]
""" Schema of the Database used for importing new Lausanne data """
self.__importSchemaDb = QgsProject.instance().readEntry(
"VDLTools", "import_schema_db", None)[0]
""" Schema of the Database used for controling """
self.__controlSchemaDb = QgsProject.instance().readEntry(
"VDLTools", "control_schema_db", None)[0]
""" Temporarly points layer for the project """
mpl_id = QgsProject.instance().readEntry("VDLTools",
"memory_points_layer",
None)[0]
""" Temporarly lines layer for the project """
mll_id = QgsProject.instance().readEntry("VDLTools",
"memory_lines_layer", None)[0]
for layer in list(QgsMapLayerRegistry.instance().mapLayers().values()):
if layer and layer.type() == QgsMapLayer.VectorLayer:
if layer.providerType() == "memory":
if layer.geometryType() == QGis.Point:
if layer.id() == mpl_id:
self.__memoryPointsLayer = layer
if layer.geometryType() == QGis.Line:
if layer.id() == mll_id:
self.__memoryLinesLayer = layer
if QGis.fromOldWkbType(
layer.wkbType()) == QgsWKBTypes.LineStringZ:
if layer.id() == dd_id:
self.__drawdownLayer = layer
if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.PointZ:
if layer.id() in ref_ids:
self.__refLayers.append(layer)
if layer.id() in adj_ids:
self.__adjLayers.append(layer)
if importDbName != "" or controlDbName != "":
usedDbs = DBConnector.getUsedDatabases()
if importDbName != "" and importDbName in list(usedDbs.keys()):
self.__importUriDb = usedDbs[importDbName]
if controlDbName != "" and controlDbName in list(usedDbs.keys()):
self.__controlUriDb = usedDbs[controlDbName]
self.changedSignal.emit()
