def get_possible_snapFeatures_bouwlaag(layerNamesList, objectId):
possibleSnapFeatures = []
bouwlaagIds = []
for name in layerNamesList:
lyr = getlayer_byname(name)
if lyr:
if name == PC.bagpand_layername():
request = QC.QgsFeatureRequest().setFilterExpression(
'"identificatie" = ' + "'{}'".format(objectId))
tempFeature = next(lyr.getFeatures(request))
possibleSnapFeatures.append(tempFeature.geometry())
elif name == PC.PAND["bouwlaaglayername"]:
request = QC.QgsFeatureRequest().setFilterExpression(
'"pand_id" = ' + "'{}'".format(objectId))
featureIt = lyr.getFeatures(request)
for feat in featureIt:
bouwlaagIds.append(feat["id"])
possibleSnapFeatures.append(feat.geometry())
elif bouwlaagIds:
for bid in bouwlaagIds:
request = QC.QgsFeatureRequest().setFilterExpression(
'"bouwlaag_id" = ' + str(bid))
featureIt = lyr.getFeatures(request)
for feat in featureIt:
possibleSnapFeatures.append(feat.geometry())
return possibleSnapFeatures
def nearest_neighbor(iface, layer, point):
"""search the nearest parent feature id"""
index = None
parentId = None
parentFeature = None
extent = iface.mapCanvas().extent()
# veroorzaakt foutmelding als er niets in het kaartvenster staat, daarom in try/except statement
index = QC.QgsSpatialIndex(layer.getFeatures(QC.QgsFeatureRequest(extent)))
try:
parentId = index.nearestNeighbor(point, 1)[0]
parentFeature = next(layer.getFeatures(QC.QgsFeatureRequest(parentId)))
parentId = parentFeature["id"]
except: # pylint: disable=bare-except
pass
return parentFeature, parentId
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(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 _cb_featureAdded(self, fid):
"""Pixelise the feature drawn.
Align the polygon to the raster grid by creating a RasterBlockWrapper
and updating the geometry of the feature. Also add the average
(arithmetic mean) value of the cells of the newly created geometry as
a label.
Parameters
----------
fid : int
Feature id of the added feature.
"""
ft = self.getFeatures(QGisCore.QgsFeatureRequest(fid)).next()
block = RasterBlockWrapper(self.rasterLayer, 1, ft.geometry())
if not block.isEmpty():
self.changeGeometry(fid, block.getRasterizedGeometry())
self.setCustomProperty("labeling/fieldName",
"%0.2f" % block.getStats()['avg'])
else:
self.editBuffer().deleteFeature(fid)
self.commitChanges()
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 = self.drawLayer
objectFeature = next(tempLayer.getFeatures(request))
self.edit_attribute(tempLayer, objectFeature)
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:
typeValue = feat[attrs[0]]
if isinstance(typeValue, (int, float)):
req = '"id" = {}'.format(typeValue)
request = QC.QgsFeatureRequest().setFilterExpression(req)
type_layer = UC.getlayer_byname(attrs[1])
tempFeature = next(type_layer.getFeatures(request))
sortList.append([feat["id"], tempFeature["naam"]])
else:
sortList.append([feat["id"], typeValue])
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 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 query(self, sql, attributes=None):
"""Execute a SQL query and return the results as QGis Features.
Parameters
----------
sql : str
Query to execute.
attributes : list, optional
Subset of attributes to include in the returned QgsFeature's.
Defaults to all attributes.
Returns
-------
list of QgsFeature
List of QgsFeatures matching the query.
"""
fids = [i[0] for i in self.rawQuery(sql)]
if len(fids) < 1:
return []
fr = QGisCore.QgsFeatureRequest()
fts = []
if attributes is not None:
fr.setSubsetOfAttributes(attributes)
for fid in fids:
fr.setFilterFid(fid)
fts.append(self.layer.getFeatures(fr).next())
return fts
def openForm(self):
layer = self.legendInterface.currentLayer()
id_table = layer.customProperty('id_table')
layers_table = [
l for l in self.legendInterface.layers() if id_table == l.id()
]
if len(layers_table) == 0:
msg = "Layer used for create this image not found."
arg = (self.pluginName, msg, QgsGui.QgsMessageBar.WARNING, 4)
self.msgBar.pushMessage(*arg)
return
table = layers_table[0]
id_image = layer.customProperty('id_image')
request = QgsCore.QgsFeatureRequest().setFilterExpression(
u'"id" = \'{0}\''.format(id_image))
request.setFlags(QgsCore.QgsFeatureRequest.NoGeometry)
feats = [f for f in table.getFeatures(request)]
if len(feats) == 0:
msg = "Image '{}' not found in '{}'.".format(
id_image, table.name())
arg = (self.pluginName, msg, QgsGui.QgsMessageBar.WARNING, 4)
self.msgBar.pushMessage(*arg)
return
form = QgsUtils.iface.getFeatureForm(table, feats[0])
form.show()
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 copy_layers(self, parentID, newID, layer, bouwlaag):
"""select the features"""
fields = layer.fields()
newFeature = QC.QgsFeature()
newFeature.initAttributes(fields.count())
newFeature.setFields(fields)
attrs = CH.get_allkeys_bl(layer.name())
# get features by bouwlaag ID
it = layer.getFeatures(
QC.QgsFeatureRequest().setFilterExpression(attrs[0] + '=' +
str(parentID)))
for feat in it:
newFeature.setGeometry(feat.geometry())
if attrs[1]:
if str(feat[attrs[1]]).isdigit():
newFeature[attrs[1]] = int(feat[attrs[1]])
else:
newFeature[attrs[1]] = feat[attrs[1]]
if attrs[2]:
newFeature[attrs[2]] = feat[attrs[2]]
if attrs[3]:
newFeature[attrs[3]] = feat[attrs[3]]
newFeature[attrs[0]] = int(newID)
newFeature["bouwlaag"] = bouwlaag
UC.write_layer(layer, newFeature)
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 catchJSevents(self,status):
try:
tmpPOV = json.JSONDecoder().decode(status)
except:
tmpPOV = None
if tmpPOV:
if tmpPOV["transport"] == "drag":
self.refreshWidget(tmpPOV['lon'], tmpPOV['lat'])
elif tmpPOV["transport"] == "view":
self.httpConnecting = True
if self.actualPOV["lat"] != tmpPOV["lat"] or self.actualPOV["lon"] != tmpPOV["lon"]:
self.actualPOV = tmpPOV
actualPoint = core.QgsPointXY(float(self.actualPOV['lon']),float(self.actualPOV['lat']))
if self.infoBoxManager.isEnabled():
#self.view.SV.settings().clearMemoryCaches()
#self.view.BE.settings().clearMemoryCaches()
self.writeInfoBuffer(self.transformToCurrentSRS(actualPoint))
else:
self.actualPOV = tmpPOV
self.setPosition()
elif tmpPOV["transport"] == "mapCommand":
feat = self.infoBoxManager.getInfolayer().getFeatures(core.QgsFeatureRequest(tmpPOV["fid"])).__next__()
if tmpPOV["type"] == "edit":
self.iface.openFeatureForm(self.infoBoxManager.getInfolayer(),feat,True)
if tmpPOV["type"] == "select":
self.infoBoxManager.getInfolayer().select(feat.id())
elif tmpPOV["transport"] == "SVLocation":
if tmpPOV["status"] == 'OK':
self.SVLocationResponse = core.QgsPointXY(tmpPOV["lon"],tmpPOV["lat"])
else:
self.SVLocationResponse = "cucu" #core.QgsPointXY()
def request_feature(ifeature, layer_feature_id, layer_name):
"""get feature from specific id"""
objectId = ifeature[layer_feature_id]
request = QC.QgsFeatureRequest().setFilterExpression('"id" = ' +
str(objectId))
tempLayer = getlayer_byname(layer_name)
tempFeature = next(tempLayer.getFeatures(request))
return tempFeature, objectId
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 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 run_bag_overnemen(self):
"""copy polygon of bag feature"""
UG.set_lengte_oppervlakte_visibility(self, False, False, False, False)
layerName = PC.bagpand_layername()
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 canvasReleaseEvent(self, mouseEvent):
"""Identify parcels at the point the user clicked the map canvas.
Called when the user clicks the map canvas. Identify parcels at this
location and select one on them (prefer the ones that have a
complaint).
Marks the selected parcel in a distinctive color by selecting it using
the polygon selection manager, and show the information about the
selected parcel in the parcelinfowidget.
Parameters
----------
mouseEvent : QGisGui.QgsMapMouseEvent
Event describing the point on the map canvas the user clicked.
"""
table = self.main.utils.getLayerByName('percelenkaart_table')
view = self.main.utils.getLayerByName('percelenkaart_view')
if table and view:
self.main.iface.setActiveLayer(table)
results = self.identify(mouseEvent.x(), mouseEvent.y(),
self.ActiveLayer, self.VectorLayer)
resultFid = None
# Check for overlapping features:
# - if one of them is an objection, select that
# - if none of them is an objection, sort them to always select
# the same feature
if len(results) == 1:
resultFid = results[0].mFeature.id()
elif len(results) > 1:
fts = sorted([r.mFeature for r in results],
key=lambda x: x.attribute('uniek_id'))
fts_objections = [
ft for ft in fts if ft.attribute('datum_bezwaar')
]
if len(fts_objections) == 1:
resultFid = fts_objections[0].id()
elif len(fts_objections) == 0:
resultFid = fts[0].id()
if resultFid:
fr = QGisCore.QgsFeatureRequest()
fr.setFilterFid(resultFid)
feature = view.getFeatures(fr).next()
self.main.parcelInfoWidget.setLayer(view)
self.main.parcelInfoWidget.setFeature(feature)
self.main.parcelInfoWidget.parent.show()
else:
self.main.parcelInfoWidget.clear()
if self.previousActiveLayer:
self.main.iface.setActiveLayer(self.previousActiveLayer)
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 get_possible_snapFeatures_object(layerNamesList, objectId):
possibleSnapFeatures = []
for name in layerNamesList:
lyr = getlayer_byname(name)
request = QC.QgsFeatureRequest().setFilterExpression('"object_id" = ' +
str(objectId))
featureIt = lyr.getFeatures(request)
for feat in featureIt:
if feat.hasGeometry():
possibleSnapFeatures.append(feat.geometry())
return possibleSnapFeatures
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 pointBuffer(self,p):
infoLayer = self.infoBoxManager.getInfolayer()
toInfoLayerProjection = core.QgsCoordinateTransform(self.iface.mapCanvas().mapSettings().destinationCrs(),infoLayer.crs(), core.QgsProject.instance())
toWGS84 = core.QgsCoordinateTransform(infoLayer.crs(),core.QgsCoordinateReferenceSystem(4326), core.QgsProject.instance())
# create layer and replicate fields
bufferLayer = core.QgsVectorLayer("Point?crs="+infoLayer.crs().toWkt(), "temporary_points", "memory")
#bufferLayer.setCrs(infoLayer.crs()) #This generates alert message
bufferLayer.startEditing()
bufferLayer.addAttribute(core.QgsField("id",QtCore.QVariant.String))
bufferLayer.addAttribute(core.QgsField("html",QtCore.QVariant.String))
bufferLayer.addAttribute(core.QgsField("icon",QtCore.QVariant.String))
bufferLayer.addAttribute(core.QgsField("fid",QtCore.QVariant.Int))
self.enableControlShape(toInfoLayerProjection.transform(core.QgsPointXY(p)))
fetched = 0
self.featsId = self.infoBoxManager.getContextFeatures(toInfoLayerProjection.transform(p))
for featId in self.featsId:
feat = infoLayer.getFeatures(core.QgsFeatureRequest(featId)).__next__()
if fetched < 200:
if infoLayer.geometryType() == core.QgsWkbTypes.PolygonGeometry:
fGeom = feat.geometry().pointOnSurface()
elif infoLayer.geometryType() == core.QgsWkbTypes.PointGeometry:
fGeom = feat.geometry()
if fGeom.isMultipart():
multipoint = fGeom.asMultiPoint()
point = multipoint[0]
else:
point = fGeom.asPoint()
fetched += 1
newGeom = core.QgsGeometry.fromPointXY(core.QgsPointXY(point))
newFeat = core.QgsFeature()
newFeat.setGeometry(newGeom)
newFeat.setAttributes([self.infoBoxManager.getInfoField(feat),self.infoBoxManager.getHtml(feat),self.infoBoxManager.getIconPath(feat),self.infoBoxManager.getFeatId(feat)])
bufferLayer.addFeature(newFeat)
else:
core.QgsMessageLog.logMessage("fetched too much features..... 200 max", tag="go2streetview", level=core.Qgis.Warning)
break
bufferLayer.commitChanges()
core.QgsMessageLog.logMessage("markers context rebuilt", tag="go2streetview", level=core.Qgis.Info)
#StreetView markers
tmpfile = os.path.join(self.dirPath,"tmp","tmp_markers.geojson")
core.QgsVectorFileWriter.writeAsVectorFormat (bufferLayer, tmpfile,"UTF8",toWGS84,"GeoJSON")
with open(tmpfile) as f:
geojson = f.read().replace('\n','')
os.remove(tmpfile)
#js = geojson.replace("'",'')
#js = js.replace("\n",'\n')
js = """this.markersJson = %s""" % json.dumps(geojson)
self.view.SV.page().mainFrame().evaluateJavaScript(js)
self.view.BE.page().mainFrame().evaluateJavaScript(js)
js = """this.readJson() """
self.view.SV.page().mainFrame().evaluateJavaScript(js)
self.view.BE.page().mainFrame().evaluateJavaScript(js)
core.QgsMessageLog.logMessage("webview markers refreshed", tag="go2streetview", level=core.Qgis.Info)
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 run_delete_object(self):
"""delete repressief object"""
ilayer = self.drawLayer
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 __populate(self):
"""Find all previous objections for the parcel and add them."""
if not self.previousObjectionsLayer:
return
expr = '"perceel_2019" like \'%%%s%%\'' % (self.uniek_id)
objectionList = []
for i in self.previousObjectionsLayer.getFeatures(
QGisCore.QgsFeatureRequest(QGisCore.QgsExpression(expr))):
objectionList.append(i)
filteredObjectionList = []
for i in objectionList:
perceel_2019 = i.attribute('perceel_2019').split(',')
if self.uniek_id in perceel_2019:
filteredObjectionList.append(i)
for i in sorted(filteredObjectionList,
key=lambda x: int(x.attribute('jaar'))):
self.addObjection(i)
def reshapeSimplify(self, reshapeLine):
canvas = self.getIface().mapCanvas()
layer = canvas.currentLayer()
tolerance = self.getTolerance(layer)
rsLine = self.simplifyGeometry(reshapeLine, tolerance)
request = core.QgsFeatureRequest().setFilterRect(rsLine.boundingBox())
for feat in layer.getFeatures(request):
geom = feat.geometry() # geometria que receberá o reshape.
if geom.intersects(
rsLine
): # Se intersecta e transforma frompolyline em geometria.
geom.reshapeGeometry(rsLine.asPolyline(
)) # realiza o reshape entre a linha e a geometria.
layer.changeGeometry(feat.id(), geom)
canvas.refresh(
) # Refresh para atualizar, mas não salvar as alterações.
def close_stacked(self, ilayer, ifeature):
"""close feature form and save changes"""
self.attributeForm.save()
self.terug.clicked.disconnect()
ilayer.commitChanges()
self.attributeForm.close()
del self.attributeForm
self.attributeForm = None
if ilayer.name() == PC.OBJECT["objectlayername"]:
request = QC.QgsFeatureRequest().setFilterExpression("id = " \
+ str(ifeature["id"]))
objectFeature = next(ilayer.getFeatures(request))
self.parentWidget.formelenaam.setText(objectFeature["formelenaam"])
self.close()
try:
self.parentWidget.show()
self.iface.actionPan().trigger()
except: # pylint: disable=bare-except
pass
del self
def clearWithMode(self, mode, toggleRendering=True):
"""Clear the selected geometry that have the given mode.
Parameters
----------
mode : int
Clear the geometries that have been selected using this mode.
toggleRendering : boolean, optional
Redraw the map after changing the tempLayer. Defaults to True.
When making multiple changes to the selection set only the last
change to toggleRendering=`True` for improved performance.
"""
if not self.__getLayer():
return
self.main.iface.mapCanvas().setRenderFlag(False)
for feature in self.layer.getFeatures(QGisCore.QgsFeatureRequest(
QGisCore.QgsExpression('mode = %i' % mode))):
self.layer.deleteFeature(feature.id())
if toggleRendering:
self.main.iface.mapCanvas().setRenderFlag(True)
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)
