def draw_feature(self, points, _dummy):
"""create the floor feature and save to the floors layer"""
minBouwlaag = int(self.bouwlaag_min.text())
maxBouwlaag = int(self.bouwlaag_max.text())
childFeature = QC.QgsFeature()
layerName = PC.PAND["bouwlaaglayername"]
layer = UC.getlayer_byname(layerName)
foreignKey = CH.get_foreign_key_bl(layerName)
# construct QgsFeature to save
for i in range(minBouwlaag, maxBouwlaag + 1):
if i != 0:
childFeature.setGeometry(QC.QgsGeometry.fromPolygonXY([points
]))
fields = layer.fields()
childFeature.initAttributes(fields.count())
childFeature.setFields(fields)
childFeature[foreignKey] = self.objectId
childFeature["bouwlaag"] = i
UC.write_layer(layer, childFeature)
# block the signals of changing the comboBox to add the new floor
self.bouwlaag.blockSignals(True)
self.bouwlaag.clear()
if i not in self.bouwlaagList:
self.bouwlaagList.append(i)
self.bouwlaagList.sort()
self.bouwlagen_to_combobox()
self.bouwlaag.blockSignals(False)
self.iface.actionPan().trigger()
# set all layers substring to the right floor
sub_string = "bouwlaag = " + str(minBouwlaag)
UG.set_layer_substring(sub_string)
if maxBouwlaag != minBouwlaag:
MSG.showMsgBox('bouwlaagcreated')
def get_identified_terrein(self, ilayer, ifeature):
"""Return of identified layer and feature and get related object"""
#the identified layer must be "Object" or "Object terrein"
drawLayer = UC.getlayer_byname(OBJECT["objectlayername"])
if ilayer is None:
self.run_new_object('wordt gekoppeld in de database', 'BGT',
'wordt gekoppeld in de database')
elif ilayer.name() == bagpand_layername() and "PDOK" in ilayer.name():
objectId = str(ifeature["identificatie"])
bron = "BAG"
bron_tabel = "Pand"
self.run_new_object(objectId, bron, bron_tabel)
elif ilayer.name() == bagpand_layername():
objectId = str(ifeature["identificatie"])
bron = ifeature["bron"]
bron_tabel = ifeature["bron_tbl"]
self.run_new_object(objectId, bron, bron_tabel)
elif ilayer.name() == OBJECT["objectlayername"]:
objectId = ifeature["id"]
formeleNaam = ifeature["formelenaam"]
self.run_object(formeleNaam, objectId)
elif ilayer.name() == OBJECT["terreinlayername"]:
objectId = ifeature["object_id"]
request = QC.QgsFeatureRequest().setFilterExpression('"id" = ' +
str(objectId))
ifeature = next(drawLayer.getFeatures(request))
formeleNaam = ifeature["formelenaam"]
self.run_object(formeleNaam, objectId)
#if another layer is identified there is no object that can be determined, so a message is send to the user
else:
MSG.showMsgBox('noidentifiedobject')
self.identifyTool.geomIdentified.disconnect()
def construct_feature(layerType, parentLayerName, points, objectId, iface):
tempFeature = QC.QgsFeature()
parentId = None
#converteer lijst van punten naar QgsGeometry, afhankelijk van soort geometrie
if layerType == "Point":
tempFeature.setGeometry(QC.QgsGeometry.fromPointXY(points))
geom = points
elif layerType == "LineString":
tempFeature.setGeometry(QC.QgsGeometry.fromPolylineXY(points))
geom = points[0]
elif layerType == "Polygon":
tempFeature.setGeometry(QC.QgsGeometry.fromPolygonXY([points]))
geom = points[0]
if parentLayerName != '' and parentLayerName == PC.OBJECT[
"objectlayername"]:
parentlayer = getlayer_byname(parentLayerName)
parentId = int(objectId)
elif parentLayerName != '' and parentLayerName is not None:
parentlayer = getlayer_byname(parentLayerName)
dummy, parentId = nearest_neighbor(iface, parentlayer, geom)
elif parentLayerName is None:
parentId = ''
else:
parentId = None
#foutafhandeling ivm als er geen parentId is
if parentId is None and parentLayerName != '':
MSG.showMsgBox('noparentfeature')
return None, None
else:
return parentId, tempFeature
def run(self):
"""run the plugin, if project is not OIV object, deactivate plugin when clicked on icon"""
project = QC.QgsProject.instance()
projectTest = str(
QC.QgsExpressionContextUtils.projectScope(project).variable(
'project_title'))
try:
layer = UC.getlayer_byname('applicatie')
request = QC.QgsFeatureRequest().setFilterExpression('"id" = 1')
dbVersion = next(layer.getFeatures(request))["db_versie"]
except:
dbVersion = 0
if 'Objecten' not in projectTest:
self.toolbar.setEnabled(False)
self.action.setEnabled(False)
elif PLUGIN["compatibleDbVersion"]["max"] < dbVersion < PLUGIN[
"compatibleDbVersion"]["min"]:
MSG.showMsgBox('invaliddatabaseversion')
self.toolbar.setEnabled(False)
self.action.setEnabled(False)
else:
# always start from floor 1
self.basewidget = OB.oivBaseWidget(self)
subString = "bouwlaag = 1"
UG.set_layer_substring(subString)
index = self.projCombo.findText('1', PQtC.Qt.MatchFixedString)
if index >= 0:
self.projCombo.setCurrentIndex(index)
self.iface.addDockWidget(QT.getWidgetType(), self.basewidget)
self.basewidget.show()
self.toolbar.setEnabled(False)
self.projCombo.setEnabled(False)
self.checkVisibility = True
def inlezen(self):
"""import the file after all settings wehere made"""
importAttr = self.type.currentText()
invalidCount = 0
for importType in self.mappingDict:
if self.mappingDict[importType]["targetType"] != 'niet importeren':
checkConv = False
expr = QC.QgsExpression('"{}"= \'{}\''.format(
importAttr, importType))
featureIt = self.importLayer.getFeatures(
QC.QgsFeatureRequest(expr))
targetFeature = QC.QgsFeature()
targetLayerName = self.mappingDict[importType]["layerName"]
if 'Labels' in targetLayerName:
LabelDialog.attributes = [
self.type.itemText(i) for i in range(self.type.count())
]
LabelDialog.importType = importType
labelField, dummy = LabelDialog.getLabelAtrribute()
targetLayer = UC.getlayer_byname(targetLayerName)
targetFields = targetLayer.fields()
targetFeature.initAttributes(targetFields.count())
targetFeature.setFields(targetFields)
if self.mappingDict[importType][
"convType"] != self.layerImportType:
checkConv = True
query = "SELECT foreign_key, identifier, input_label FROM config_object WHERE child_layer = '{}'".format(
targetLayerName)
attrs = UC.read_settings(query, False)[0]
targetFeature[
attrs[1]] = self.mappingDict[importType]["targetType"]
targetFeature[attrs[0]] = self.object_id.text()
targetLayer.startEditing()
for feat in featureIt:
geom = None
if not checkConv:
geom = EF.getfeature_geometry(feat.geometry(),
self.layerImportType)
if 'Labels' in targetLayerName:
if feat[labelField]:
targetFeature[attrs[2]] = feat[labelField]
else:
targetFeature[attrs[2]] = 'geen label'
if geom:
targetFeature.setGeometry(geom)
invalidCheck = UC.write_layer(targetLayer,
targetFeature, True)
if invalidCheck == 'invalid':
invalidCount += 1
targetLayer.commitChanges()
if invalidCount > 0:
MSG.showMsgBox('importpartiallysuccesfull',
'{}'.format(invalidCount))
else:
MSG.showMsgBox('importsuccesfull')
QC.QgsProject.instance().removeMapLayers([self.importLayer.id()])
def delete(self, ilayer, ifeature):
"""delete a feature"""
if ilayer.name() == PC.OBJECT["gridlayername"]:
gridUUID = ifeature["uuid"]
self.delete_existing_grid(gridUUID, ilayer)
else:
MSG.showMsgBox('nogridselected')
self.run_delete_tool()
self.parent.identifyTool.geomIdentified.disconnect(self.delete)
self.iface.actionPan().trigger()
def run_objectgegevens_bewerken(self):
"""select bouwlaag on canvas to edit the atrribute form"""
objectId = self.object_id.text()
request = QC.QgsFeatureRequest().setFilterExpression('"id" = ' + str(objectId))
tempLayer = UC.getlayer_byname(PC.OBJECT["objectlayername"])
objectFeatIt = tempLayer.getFeatures(request)
try:
objectFeature = next(objectFeatIt)
self.edit_attribute(tempLayer, objectFeature)
except StopIteration:
MSG.showMsgBox('no_objectid')
def inlezen(self):
targetLayerName = self.import_laag.currentText()
targetLayer = UC.getlayer_byname(targetLayerName)
sourceLayerName = 'tempImport'
sourceLayer = UC.getlayer_byname(sourceLayerName)
features = []
for feature in sourceLayer.getFeatures():
features.append(feature)
UC.write_layer(targetLayer, features, False, False)
MSG.showMsgBox('importsuccesfull')
QC.QgsProject.instance().removeMapLayers([sourceLayer.id()])
def copy_bag_bouwlaag(self, ilayer, ifeature):
"""copy the floor drom the BAG features"""
if ilayer.name() == PC.PAND["bouwlaaglayername"] or ilayer.name(
) == PC.bagpand_layername():
childFeature = QC.QgsFeature()
layerName = PC.PAND["bouwlaaglayername"]
# get active floor from dockwidget
minBouwlaag = int(self.bouwlaag_min.text())
maxBouwlaag = int(self.bouwlaag_max.text())
layer = UC.getlayer_byname(layerName)
# get necessary attributes from config file
foreignKey = CH.get_foreign_key_bl(layerName)
# construct QgsFeature to save
for i in range(minBouwlaag, maxBouwlaag + 1):
if i != 0:
childFeature.setGeometry(ifeature.geometry())
fields = layer.fields()
childFeature.initAttributes(fields.count())
childFeature.setFields(fields)
childFeature[foreignKey] = self.objectId
childFeature["bouwlaag"] = i
newFeatureId = UC.write_layer(layer, childFeature)
# copy also the selected layers
if ilayer.name() == PC.PAND["bouwlaaglayername"]:
self.copy_selected_layers(ifeature, newFeatureId, i)
# block the signals of changing the comboBox to add the new floor
self.bouwlaag.blockSignals(True)
self.bouwlaag.clear()
if i not in self.bouwlaagList:
self.bouwlaagList.append(i)
self.bouwlaagList.sort()
self.bouwlagen_to_combobox()
self.bouwlaag.blockSignals(False)
self.iface.actionPan().trigger()
# set all layers substring to the right floor
sub_string = "bouwlaag = " + str(minBouwlaag)
UG.set_layer_substring(sub_string)
try:
self.parent.selectTool.geomSelected.disconnect()
except: # pylint: disable=bare-except
pass
if maxBouwlaag >= minBouwlaag:
MSG.showMsgBox('bouwlaagcreated')
else:
MSG.showMsgBox('nobouwlaagselected')
try:
self.parent.selectTool.geomSelected.disconnect()
except: # pylint: disable=bare-except
pass
self.parent.selectTool.geomSelected.connect(self.copy_bag_bouwlaag)
def get_identified_pand(self, ilayer, ifeature):
"""Return of identified layer and feature and get related object"""
#the identified layer must be "Bouwlagen" or "BAG panden"
if isinstance(ilayer, QC.QgsVectorLayer):
if ilayer.name() == PAND["bouwlaaglayername"]:
objectId = str(ifeature["pand_id"])
self.run_bouwlagen(objectId)
elif ilayer.name() == bagpand_layername():
objectId = str(ifeature["identificatie"])
self.run_bouwlagen(objectId)
#if another layer is identified there is no object that can be determined, so a message is send to the user
else:
MSG.showMsgBox('noidentifiedobject')
self.identifyTool.geomIdentified.disconnect()
def run_bouwlaag(self):
while True:
bouwlaag, bouwlaagMax, ok = BouwlaagDialog.getBouwlagen()
if (bouwlaag != 0 and bouwlaagMax >= bouwlaag and ok is True):
bouwlaagwidget = oivBouwlaagWidget(self, bouwlaag, bouwlaagMax)
self.iface.addDockWidget(QT.getWidgetType(), bouwlaagwidget)
subString = "bouwlaag = " + str(bouwlaag)
UG.set_layer_substring(subString)
bouwlaagwidget.show()
self.close()
break
elif bouwlaagMax < bouwlaag:
MSG.showMsgBox('bouwlaagvolgorde')
elif ok is False:
break
def canvasReleaseEvent(self, mouseEvent):
"""handle mouse release event and return indetified feature"""
results = self.identify(mouseEvent.x(), mouseEvent.y(), self.TopDownStopAtFirst, self.VectorLayer)
if not results == []:
idlayer = results[0].mLayer
if self.expectedLayerName and idlayer.name() != self.expectedLayerName:
MSG.showMsgBox('wronglayeridentified')
else:
allFeatures = []
if len(results) > 1:
for result in results:
allFeatures.append(result.mFeature)
tempfeature = self.ask_user_for_feature(idlayer, allFeatures)
else:
tempfeature = results[0].mFeature
self.geomSelected.emit(idlayer, tempfeature)
else:
MSG.showMsgBox('noidentifiedobject')
def create_grid(self,
gridUUID=None,
dist=None,
extent=None,
gridType='Grid'):
if not gridUUID:
gridUUID = uuid.uuid4()
if not dist and not extent:
extent = self.canvas.extent()
dist = self.distance.value()
layerName = PC.OBJECT["gridlayername"]
layer = UC.getlayer_byname(layerName)
targetFeature = QC.QgsFeature()
targetFields = layer.fields()
targetFeature.initAttributes(targetFields.count())
targetFeature.setFields(targetFields)
foreignKey = CH.get_foreign_key_ob(layerName)
xmin, dummy, ymin, dummy, xIt, yIt = self.calculate_extent(
dist, extent, gridType)
objectId = self.objectId
targetFeature[foreignKey] = objectId
targetFeature["type"] = 'Grid'
for x in range(0, xIt):
for y in range(0, yIt):
yLabel = str(y + 1)
if xIt < 26:
xLabel = chr(x + 97).upper()
elif xIt >= 26:
xLabel = chr(int(math.floor(x / 26)) +
97).upper() + chr(x % 26 + 97).upper()
geom = self.calculate_geometry(dist, xmin, ymin, x, y,
gridType)
targetFeature['vaknummer'] = xLabel + yLabel
if x != 0:
yLabel = ''
if y != 0:
xLabel = ''
targetFeature.setGeometry(geom)
targetFeature['y_as_label'] = yLabel
targetFeature['x_as_label'] = xLabel
targetFeature['afstand'] = dist
targetFeature["uuid"] = str(gridUUID)
UC.write_layer(layer, targetFeature)
MSG.showMsgBox('gridcreated')
def run_delete_object(self):
"""delete repressief object"""
ilayer = UC.getlayer_byname(PC.OBJECT["objectlayername"])
objectId = self.object_id.text()
request = QC.QgsFeatureRequest().setFilterExpression('"id" = ' + str(objectId))
ifeature = next(ilayer.getFeatures(request))
ilayer.startEditing()
ilayer.selectByIds([ifeature.id()])
reply = MSG.showMsgBox('deleteobject')
if not reply:
#als "nee" deselecteer alle geselecteerde features
ilayer.selectByIds([])
elif reply:
#als "ja" -> verwijder de feature op basis van het unieke feature id
ilayer.deleteFeature(ifeature.id())
ilayer.commitChanges()
reply = MSG.showMsgBox('deletedobject')
UC.refresh_layers(self.iface)
self.close_repressief_object_show_base()
def write_layer(layer, features, count=False, check=True):
"""write the attributes to layer"""
checkGeomValidity = True
if check:
checkGeomValidity = features.geometry().isGeosValid()
if checkGeomValidity:
layer.startEditing()
if not isinstance(features, list):
features = [features]
dummy, newFeatures = layer.dataProvider().addFeatures(features)
layer.commitChanges()
layer.reload()
layer.triggerRepaint()
return newFeatures[0].id()
else:
layer.commitChanges()
if count:
return 'invalid'
else:
MSG.showMsgBox('invalidgeometry')
def delete_feature(ilayer, ifeature, rightLayerNames, _iface):
"""delete a feature"""
if ilayer.name() in rightLayerNames:
ids = []
ids.append(ifeature.id())
ilayer.selectByIds(ids)
ilayer.startEditing()
reply = MSG.showMsgBox('deleteobject')
if not reply:
ilayer.selectByIds([])
elif reply:
ilayer.deleteFeature(ifeature.id())
ilayer.commitChanges()
return "Done"
else:
reply = MSG.showMsgBox('noselectedtodelete')
if reply:
ilayer.selectByIds([])
return "Done"
return "Retry"
def run_delete(self):
layerName = PC.PAND["bouwlaaglayername"]
ilayer = UC.getlayer_byname(layerName)
objectId = self.pand_id.text()
request = QC.QgsFeatureRequest().setFilterExpression(
'"pand_id" = ' + "'{}'".format(objectId))
ifeature = next(ilayer.getFeatures(request))
ilayer.selectByIds([ifeature.id()])
reply = MSG.showMsgBox('deleteobject')
if not reply:
#als "nee" deselecteer alle geselecteerde features
ilayer.deselect(ifeature.id())
elif reply:
#als "ja" -> verwijder de feature op basis van het unieke feature id
ilayer.startEditing()
ilayer.deleteFeature(ifeature.id())
ilayer.commitChanges()
reply = MSG.showMsgBox('deletedobject')
UC.refresh_layers(self.iface)
#set actieve bouwlaag to 1 and fill combobox
self.bouwlagen_to_combobox(ifeature.id(), 1)
def delete_existing_grid(self, gridUUID, layer):
request = QC.QgsFeatureRequest().setFilterExpression(
'"uuid" = ' + "'{}'".format(gridUUID))
featureIt = layer.getFeatures(request)
reply = MSG.showMsgBox('deletegrid')
if reply:
layer.startEditing()
for feat in featureIt:
layer.deleteFeature(feat.id())
layer.commitChanges()
return "Done"
return "Exit"
def check_importlayer(self):
"""perform geometric checks on importlayer"""
checks = [None, None]
crsCheck = self.importLayer.crs().authid()
if crsCheck == 'EPSG:28992':
checks[0] = 'RD'
if self.import_laag.currentText(
) == "Bouwkundige veiligheidsvoorzieningen":
if self.importLayer.geometryType() == QC.QgsWkbTypes.LineGeometry:
checks[1] = 'passed'
else:
checks[1] = None
elif self.import_laag.currentText() == "Ruimten":
if self.importLayer.geometryType(
) == QC.QgsWkbTypes.PolygonGeometry:
checks[1] = 'passed'
else:
checks[1] = None
if checks[0] is not None and checks[1] is not None:
MSG.showMsgBox('importchecksok')
self.label6.setVisible(True)
self.mapping.setVisible(True)
else:
if checks[0] != 'RD':
MSG.showMsgBox('importerrorrdstelsel')
if checks[1] is None:
MSG.showMsgBox('importerrorgeometrie')
def set_layer_substring(subString):
"""set layer subset according (you can check the subset under properties of the layer)"""
layersInEditMode = []
layerNames = CH.get_chidlayers_bl()
for layerName in layerNames:
layer = UC.getlayer_byname(layerName[0])
if layer.isModified():
saveChanges = MSG.showMsgBox('unsavedchanges', layerName[0])
if saveChanges:
layer.commitChanges()
else:
layer.rollBack()
elif layer.isEditable():
layersInEditMode.append(layer)
layer.commitChanges()
for layerName in layerNames:
lyr = UC.getlayer_byname(layerName[0])
lyr.setSubsetString(subString)
if lyr in layersInEditMode:
lyr.startEditing()
return "succes"
def inlezen_validatie(self):
"""import the file after all settings wehere made"""
targetLayerName = self.import_laag.currentText()
targetLayer = UC.getlayer_byname(targetLayerName)
targetFields = targetLayer.fields()
if targetLayerName == "Ruimten":
typeLayer = UC.getlayer_byname('ruimten_type')
tempImportLayer = self.init_layer_fields(
targetFields,
["MultiPolygon?crs=epsg:28992", "tempImport", "memory"])
tempImportLayerInvalid = self.init_layer_fields(
targetFields, [
"MultiPolygon?crs=epsg:28992", "tempImport_invalid",
"memory"
])
else:
tempImportLayer = self.init_layer_fields(
targetFields,
["MultiLinestring?crs=epsg:28992", "tempImport", "memory"])
tempImportLayerInvalid = self.init_layer_fields(
targetFields, [
"MultiLinestring?crs=epsg:28992", "tempImport_invalid",
"memory"
])
identifier = CH.get_identifier_bl(targetLayerName)
bouwlaagGeomCentroid = self.get_centroid()
dummy, progressBar = self.progressdialog(0)
count = 0
cntFeat = self.importLayer.featureCount()
invalidCount = 0
validFeatures = []
invalidFeatures = []
geomCheck = True
for feature in self.importLayer.getFeatures():
targetFeature = QC.QgsFeature()
targetFeature.initAttributes(targetFields.count())
targetFeature.setFields(targetFields)
count += 1
if self.mappingDict[feature[self.type.currentText(
)]] != 'niet importeren' and feature.geometry():
if self.importTypeFile == 'DXF':
geom, geomCheck = self.check_feature_validity(
feature, bouwlaagGeomCentroid)
elif self.importTypeFile in ('GPKG', 'SHP'):
geom = feature.geometry()
targetFeature.setGeometry(geom)
targetFeature["bouwlaag_id"] = int(self.bouwlaag_id.text())
if targetLayerName == "Ruimten":
req = '"naam" = ' + "'" + self.mappingDict[feature[
self.type.currentText()]] + "'"
request = QC.QgsFeatureRequest().setFilterExpression(req)
tempFeature = next(typeLayer.getFeatures(request))
targetFeature[identifier] = tempFeature["id"]
else:
targetFeature[identifier] = self.mappingDict[feature[
self.type.currentText()]]
if geomCheck:
validFeatures.append(targetFeature)
else:
invalidFeatures.append(targetFeature)
invalidCount += 1
progress = (float(count) / float(cntFeat)) * 100
progressBar.setValue(progress)
if validFeatures:
UC.write_layer(tempImportLayer, validFeatures, False, False)
if invalidFeatures:
UC.write_layer(tempImportLayerInvalid, invalidFeatures, False,
False)
QC.QgsProject.instance().addMapLayer(tempImportLayer, True)
QC.QgsProject.instance().addMapLayer(tempImportLayerInvalid, True)
if invalidCount > 0:
MSG.showMsgBox('importpartiallysuccesfull',
'{}'.format(invalidCount))
else:
MSG.showMsgBox('importsuccesfull')
QC.QgsProject.instance().removeMapLayers([self.importLayer.id()])
self.label8.setVisible(True)
self.import_file.setVisible(True)
def run_delete_tool(self):
MSG.showMsgBox('selectgrid')
self.canvas.setMapTool(self.parent.identifyTool)
self.parent.identifyTool.geomIdentified.connect(self.delete)
