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)