def inlezen(self):
"""import the file after all settings wehere made"""
targetLayerName = self.import_laag.currentText()
if targetLayerName == "Ruimten":
typeLayer = UC.getlayer_byname('ruimten_type')
targetFeature = QC.QgsFeature()
targetLayer = UC.getlayer_byname(targetLayerName)
targetFields = targetLayer.fields()
targetFeature.initAttributes(targetFields.count())
identifier = CH.get_identifier_bl(targetLayerName)
targetFeature.setFields(targetFields)
self.iface.setActiveLayer(self.importLayer)
dummy, progressBar = self.progressdialog(0)
progressBar.setValue(0)
progressBar.setMaximum(100)
count = 0
cntFeat = self.importLayer.featureCount()
invalidCount = 0
for feature in self.importLayer.getFeatures():
count += 1
if self.mappingDict[feature[self.type.currentText(
)]] != 'niet importeren' and feature.geometry():
if self.importTypeFile == 'DXF':
if self.importLayer.geometryType(
) == QC.QgsWkbTypes.PolygonGeometry:
geom = QC.QgsGeometry.fromPolygonXY(
feature.geometry().asPolygon())
elif self.importLayer.wkbType(
) == QC.QgsWkbTypes.MultiLineString:
geom = QC.QgsGeometry.fromMultiPolylineXY(
feature.geometry().asMultiPolyline())
else:
geom = QC.QgsGeometry.fromPolylineXY(
feature.geometry().asPolyline())
elif self.importTypeFile in ('GPKG', 'SHP'):
geom = feature.geometry()
targetFeature.setGeometry(geom)
targetFeature["bouwlaag_id"] = int(self.bouwlaag_id.text())
if targetLayerName == "Ruimten":
request = QC.QgsFeatureRequest().setFilterExpression(
'"naam" = ' + "'" +
self.mappingDict[feature[self.type.currentText()]] +
"'")
tempFeature = next(typeLayer.getFeatures(request))
targetFeature[identifier] = tempFeature["id"]
else:
targetFeature[identifier] = self.mappingDict[feature[
self.type.currentText()]]
invalidCheck = UC.write_layer(targetLayer, targetFeature,
True)
if invalidCheck == 'invalid':
invalidCount += 1
progress = (float(count) / float(cntFeat)) * 100
progressBar.setValue(progress)
if invalidCount > 0:
MSG.showMsgBox('importpartiallysuccesfull',
'{}'.format(invalidCount))
else:
MSG.showMsgBox('importsuccesfull')
QC.QgsProject.instance().removeMapLayers([self.importLayer.id()])
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"
self.drawLayer = UC.getlayer_byname("Objecten")
if ilayer is None:
self.run_new_object('wordt gekoppeld in de database', 'BGT',
'wordt gekoppeld in de database')
elif ilayer.name() == PC.PAND["bagpandlayername"]:
objectId = str(ifeature["identificatie"])
bron = ifeature["bron"]
bron_tabel = ifeature["bron_tbl"]
self.run_new_object(objectId, bron, bron_tabel)
elif ilayer.name() == PC.OBJECT["objectlayername"]:
objectId = ifeature["id"]
self.run_object(ifeature, objectId)
elif ilayer.name() == PC.OBJECT["terreinlayername"]:
objectId = ifeature["object_id"]
request = QC.QgsFeatureRequest().setFilterExpression('"id" = ' +
str(objectId))
ifeature = next(self.drawLayer.getFeatures(request))
self.run_object(ifeature, 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 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 import_bouwlaag(self, bouwlaagFeature):
"""after the checks the import of the floor can start"""
childFeature = QC.QgsFeature()
layerName = 'Bouwlagen'
layer = UC.getlayer_byname(layerName)
#get necessary attributes from config file
foreignKey = CH.get_foreign_key_bl(layerName)
#construct QgsFeature to save
childFeature.setGeometry(bouwlaagFeature.geometry())
fields = layer.fields()
childFeature.initAttributes(fields.count())
childFeature.setFields(fields)
childFeature[foreignKey] = str(self.object_id.text())
childFeature["bouwlaag"] = int(self.bouwlaag.text())
newFeatureId = UC.write_layer(layer, childFeature)
self.bouwlaag_id.setText(str(newFeatureId))
self.iface.actionPan().trigger()
self.label2.setVisible(False)
self.selectId.setVisible(False)
self.label3.setVisible(True)
self.label4.setVisible(True)
self.label5a.setVisible(True)
self.label5b.setVisible(True)
self.import_laag.setVisible(True)
self.check.setVisible(True)
self.type.setVisible(True)
def ask_user_for_feature(self, idLayer, allFeatures):
"""if more features are identified ask user which one to choose"""
targetFeature = None
query = "SELECT identifier, type_layer_name FROM {} WHERE child_layer = '{}'".format(
self.whichConfig, idLayer.name())
attrs = UC.read_settings(query, False)
sortList = []
for feat in allFeatures:
if len(attrs) > 1:
request = QC.QgsFeatureRequest().setFilterExpression(
'"id" = ' + str(feat[attrs[0]]))
type_layer = UC.getlayer_byname(attrs[1])
tempFeature = next(type_layer.getFeatures(request))
sortList.append([feat["id"], tempFeature["naam"]])
elif attrs:
sortList.append([feat["id"], feat[attrs[0]]])
else:
sortList = None
if sortList:
AskFeatureDialog.askList = sortList
chosen, dummy = AskFeatureDialog.askFeature()
for feat in allFeatures:
if feat["id"] == int(chosen):
targetFeature = feat
return targetFeature
def run_move_point(self):
"""om te verschuiven/roteren moeten de betreffende lagen op bewerken worden gezet"""
for lyrName in self.moveLayerNames:
moveLayer = UC.getlayer_byname(lyrName)
moveLayer.startEditing()
self.parent.moveTool.onMoved = self.stop_moveTool
self.canvas.setMapTool(self.parent.moveTool)
def run_tekenen(self, _dummy, runLayer, featureId):
#welke pictogram is aangeklikt en wat is de bijbehorende tekenlaag
self.identifier = featureId
self.drawLayer = UC.getlayer_byname(runLayer)
self.drawLayerType = UC.check_layer_type(self.drawLayer)
self.parentLayerName = CH.get_parentlayer_ob(runLayer)
objectId = self.object_id.text()
possibleSnapFeatures = UC.get_possible_snapFeatures_object(DH.ROSNAPLAYERS, objectId)
if self.drawLayerType == "Point":
pointTool = self.parent.pointTool
pointTool.snapPt = None
pointTool.snapping = False
pointTool.startRotate = False
pointTool.possibleSnapFeatures = possibleSnapFeatures
if self.identifier in DH.ROSNAPSYMBOLS:
pointTool.snapping = True
pointTool.layer = self.drawLayer
self.canvas.setMapTool(pointTool)
UG.set_lengte_oppervlakte_visibility(self, False, False, False, False)
pointTool.onGeometryAdded = self.place_feature
else:
drawTool = self.parent.drawTool
if self.drawLayerType == "LineString":
drawTool.captureMode = 1
UG.set_lengte_oppervlakte_visibility(self, True, True, False, True)
else:
drawTool.captureMode = 2
UG.set_lengte_oppervlakte_visibility(self, True, True, True, True)
drawTool.layer = self.drawLayer
drawTool.possibleSnapFeatures = possibleSnapFeatures
drawTool.canvas = self.canvas
drawTool.onGeometryAdded = self.place_feature
self.canvas.setMapTool(drawTool)
drawTool.parent = self
def stop_moveTool(self):
"""na de actie verschuiven/bewerken moeten de betreffende lagen opgeslagen worden en bewerken moet worden uitgezet"""
for lyrName in self.moveLayerNames:
moveLayer = UC.getlayer_byname(lyrName)
moveLayer.commitChanges()
moveLayer.reload()
self.activatePan()
def bouwlagen_to_combobox(self, objectId, actieveBouwlaag):
"""fill combobox with existing floors"""
runLayer = PC.PAND["bouwlaaglayername"]
tempLayer = UC.getlayer_byname(runLayer)
objectId = self.pand_id.text()
foreignKey = CH.get_foreign_key_bl(runLayer)
tempLayer.setSubsetString('')
#request all existing floors of object feature
request = QC.QgsFeatureRequest().setFilterExpression(foreignKey + " = '" + str(objectId) + "'")
tempFeatureIt = tempLayer.getFeatures(request)
#create unique list of existing floors and sort it from small to big
bouwlaagList = [it["bouwlaag"] for it in tempFeatureIt]
self.sortedList = UC.create_unique_sorted_list(bouwlaagList)
#block signal of combobox to add existing floors
self.comboBox.blockSignals(True)
self.comboBox.clear()
for bouwlaag in reversed(self.sortedList):
self.comboBox.addItem(str(bouwlaag))
#if there are existing floors "tekenen" can be enabled
if self.sortedList:
self.tekenen.setEnabled(True)
if actieveBouwlaag is None:
actieveBouwlaag = min(reversed(self.sortedList), key=abs)
else:
self.tekenen.setEnabled(False)
actieveBouwlaag = 1
self.comboBox.blockSignals(False)
#set substring of childlayers
subString = "bouwlaag = " + str(actieveBouwlaag)
UG.set_layer_substring(subString)
index = self.comboBox.findText(str(actieveBouwlaag), PQtC.Qt.MatchFixedString)
if index >= 0:
self.comboBox.setCurrentIndex(index)
self.iface.actionPan().trigger()
def create_kaartblad(self, withGrid):
gridUUID = uuid.uuid4()
geom = self.rubberBand.asGeometry()
geom.convertToMultiType()
layerName = PC.OBJECT["gridlayername"]
layer = UC.getlayer_byname(layerName)
targetFeature = QC.QgsFeature()
targetFields = layer.fields()
targetFeature.initAttributes(targetFields.count())
targetFeature.setFields(targetFields)
targetFeature.setGeometry(geom)
targetFeature["type"] = 'Kaartblad'
if self.scale_25000.isChecked():
targetFeature["scale"] = GH.DEFAULTSCALE
else:
targetFeature["scale"] = self.scale_custom.value()
targetFeature["papersize"] = self.format_combo.currentText()
if self.orient_landscape.isChecked():
targetFeature["orientation"] = 'landscape'
else:
targetFeature["orientation"] = 'portrait'
targetFeature["uuid"] = str(gridUUID)
foreignKey = CH.get_foreign_key_ob(layerName)
targetFeature[foreignKey] = self.objectId
UC.write_layer(layer, targetFeature)
bbox = geom.boundingBox()
dist = self.distance_grid.value()
if withGrid:
self.create_grid(gridUUID, dist, bbox, 'Kaartblad')
self.canvas.scene().removeItem(self.rubberBand)
def place_feature(self, point):
childFeature = QC.QgsFeature()
newFeatureId = None
self.iface.setActiveLayer(self.drawLayer)
objectLayer = UC.getlayer_byname(PC.OBJECT["objectlayername"])
#set geometry from the point clicked on the canvas
childFeature.setGeometry(QC.QgsGeometry.fromPointXY(point))
foreignKey = self.identificatienummer.text()
buttonCheck, formeleNaam = self.get_attributes(foreignKey,
childFeature)
#return of new created feature id
if buttonCheck != 'Cancel':
newFeatureId = UC.write_layer(self.drawLayer, childFeature)
objectLayer.reload()
if not newFeatureId:
idx = objectLayer.fields().indexFromName('id')
maxObjectId = objectLayer.maximumValue(idx)
request = QC.QgsFeatureRequest().setFilterExpression(
'"id" > {}'.format(maxObjectId))
self.drawLayer.reload()
tempFeatureIt = objectLayer.getFeatures(request)
for feat in tempFeatureIt:
if feat["formelenaam"] == formeleNaam:
newFeatureId = feat["id"]
#with new created feature run existing object widget
if newFeatureId:
self.run_objectgegevens(formeleNaam, newFeatureId)
else:
MSG.showMsgBox('newobjectslowanswer')
else:
self.iface.actionPan().trigger()
def run_bouwlaag_bewerken(self):
runLayer = PC.PAND["bouwlaaglayername"]
ilayer = UC.getlayer_byname(runLayer)
objectId = self.pand_id.text()
foreignKey = CH.get_foreign_key_bl(runLayer)
request = QC.QgsFeatureRequest().setFilterExpression(foreignKey + " = '" + str(objectId) + "'")
ifeature = next(ilayer.getFeatures(request))
self.run_edit_bouwlagen(ilayer, ifeature)
def run_tekenen(self):
if self.bron.text() == 'BAG':
runLayer = PC.OBJECT["objectlayername"]
else:
runLayer = PC.OBJECT["objectbgtlayername"]
self.drawLayer = UC.getlayer_byname(runLayer)
self.canvas.setMapTool(self.pointTool)
self.pointTool.canvasClicked.connect(self.place_feature)
def run_bag_overnemen(self):
"""copy polygon of bag feature"""
UG.set_lengte_oppervlakte_visibility(self, False, False, False, False)
layerName = PC.PAND["bagpandlayername"]
ilayer = UC.getlayer_byname(layerName)
request = QC.QgsFeatureRequest().setFilterExpression(
'"identificatie" = ' + "'{}'".format(self.objectId))
ifeature = next(ilayer.getFeatures(request))
self.copy_bag_bouwlaag(ilayer, ifeature)
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 copy_selected_layers(self, ifeature, newFeatureId, bouwlaag):
"""copy related selected features"""
bouwlaagID = ifeature["id"]
for var in vars(self):
typeVar = type(vars(self)[var])
if typeVar == PQtW.QCheckBox:
if vars(self)[var].isChecked():
copyLayer = UC.getlayer_byname(vars(self)[var].text())
self.copy_layers(bouwlaagID, newFeatureId, copyLayer,
bouwlaag)
def run_terrein_toevoegen(self):
objectId = self.object_id.text()
possibleSnapFeatures = UC.get_possible_snapFeatures_object(self.snapLayerNames, objectId)
self.drawTool.parent = self
self.drawTool.layer = UC.getlayer_byname(PC.OBJECT["terreinlayername"])
UG.set_lengte_oppervlakte_visibility(self, True, True, True, True)
self.drawTool.possibleSnapFeatures = possibleSnapFeatures
self.drawTool.canvas = self.canvas
self.drawTool.onGeometryAdded = self.place_object_terrein
self.drawTool.captureMode = 2
self.canvas.setMapTool(self.drawTool)
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 place_object_terrein(self, points, _dummy):
"""save drawn terrain"""
layer = UC.getlayer_byname(PC.OBJECT["terreinlayername"])
if points:
parentId, childFeature = UC.construct_feature('Polygon', PC.OBJECT["objectlayername"], points, self.object_id.text(), self.iface)
if parentId is not None:
buttonCheck = UC.get_attributes(parentId, childFeature, None, None, layer, PC.OBJECT["configtable"])
if buttonCheck != 'Cancel':
UC.write_layer(layer, childFeature)
layer.commitChanges()
layer.triggerRepaint()
self.activatePan()
def run_objectgegevens(self, formeleNaam, objectId):
"""continue to existing object woth the newly created feature and already searched address"""
self.objectwidget.drawLayer = UC.getlayer_byname(
PC.OBJECT["objectlayername"])
self.objectwidget.object_id.setText(str(objectId))
self.objectwidget.formelenaam.setText(formeleNaam)
self.iface.addDockWidget(QH.getWidgetType(), self.objectwidget)
self.objectwidget.initActions()
self.objectwidget.show()
self.iface.actionPan().trigger()
self.close()
del self.objectwidget
del self
def copy_bag_bouwlaag(self, ilayer, ifeature):
"""copy the floor drom the BAG features"""
if ilayer.name() == PC.PAND["bouwlaaglayername"] or ilayer.name(
) == PC.PAND["bagpandlayername"]:
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 run_bouwlaag_tekenen(self):
"""draw a floor with the basic functionality of QGIS"""
drawTool = self.parent.drawTool
possibleSnapFeatures = UC.get_possible_snapFeatures_bouwlaag(
self.snapLayerNames, self.objectId)
layer = UC.getlayer_byname(PC.PAND["bouwlaaglayername"])
drawTool.layer = layer
drawTool.possibleSnapFeatures = possibleSnapFeatures
drawTool.canvas = self.canvas
drawTool.onGeometryAdded = self.draw_feature
drawTool.captureMode = 2
self.canvas.setMapTool(drawTool)
UG.set_lengte_oppervlakte_visibility(self, True, True, True, True)
drawTool.parent = self
def initUI(self):
"""fill the lineedits with values"""
#Get the related BAG attributes from BAG API
ilayer = UC.getlayer_byname('BAG panden')
foreignKey = 'identificatie'
objectId = self.pand_id.text()
request = QC.QgsFeatureRequest().setFilterExpression(foreignKey + " = '" + objectId + "'")
tempFeature = next(ilayer.getFeatures(request))
bagGebruiksdoel = str(tempFeature['gebruiksdoel'])
if self.adres_1.text() == "":
bagAdres1, bagAdres2, bagGebruiksdoel = QB.ask_bag_adress(objectId, bagGebruiksdoel)
self.adres_1.setText(bagAdres1)
self.adres_2.setText(bagAdres2)
self.gebruiksdoel.setText(bagGebruiksdoel)
self.bouwlagen_to_combobox(objectId, None)
def read_types(self):
types = {}
actionList, dummy, dummy = UG.get_actions('config_object')
for lst in actionList:
tempList = []
for action in lst:
layerName = action[0]
layer = UC.getlayer_byname(layerName)
layerType = UC.check_layer_type(layer)
tempList.append(action[1])
tempList.append("niet importeren")
if layerType in types:
types[layerType].update({layerName: tempList})
else:
types.update({layerType: {layerName: tempList}})
return types
def set_object_filter(wdgt):
filters = []
if wdgt.checkVanaf.isChecked():
filters.append("(datum_geldig_vanaf >= '{}' OR datum_geldig_vanaf IS NULL)".format(wdgt.datum_vanaf.date().toPyDate()))
if wdgt.checkTot.isChecked():
filters.append("(datum_geldig_tot < '{}' OR datum_geldig_tot IS NULL)".format(wdgt.datum_tot.date().toPyDate()))
if wdgt.checkSoort.isChecked():
filters.append("typeobject = '{}'".format(wdgt.objecttype.currentText()))
layerNames = CH.get_chidlayers_ob()
if filters:
subString = ' AND '.join(filters)
else:
subString = ''
for layerName in layerNames:
if layerName[0] != 'Alternatief bluswater':#TO_DO:alle lagen die geen objecten als parent hebben
layer = UC.getlayer_byname(layerName[0])
layer.setSubsetString(subString)
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(self):
layerName = PC.PAND["bouwlaaglayername"]
ilayer = UC.getlayer_byname(layerName)
self.iface.setActiveLayer(ilayer)
objectId = self.pand_id.text()
request = QC.QgsFeatureRequest().setFilterExpression('"pand_id" = ' + "'{}'".format(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.setSelectedFeatures([])
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)
#set actieve bouwlaag to 1 and fill combobox
self.bouwlagen_to_combobox(ifeature.id(), 1)
def get_actions(whichConfig):
"""connect buttons and signals to the real action run"""
#skip first line because of header
editableLayerNames = []
moveLayerNames = []
actionList = []
query = "SELECT child_layer, bestand, config_table FROM '{}'".format(
whichConfig)
layers = UC.read_settings(query, True)
for layer in layers:
layerName = layer[0]
csvPath = layer[1]
configTable = layer[2]
if csvPath:
editableLayerNames.append(layerName)
layer = UC.getlayer_byname(layerName)
layerType = UC.check_layer_type(layer)
if layerType == "Point":
moveLayerNames.append(layerName)
if configTable:
query = "SELECT '{}', type_id, button_name FROM {}".format(
layerName, configTable)
actionList.append(UC.read_settings(query, True))
return actionList, editableLayerNames, moveLayerNames
def stop_moveTool(self):
for lyrName in self.moveLayerNames:
moveLayer = UC.getlayer_byname(lyrName)
moveLayer.commitChanges()
moveLayer.reload()
self.activatePan()
def read_types(self, layername):
types = []
layer = UC.getlayer_byname(layername)
for feat in layer.getFeatures():
types.append(feat["naam"])
return types
