def zoomtosel( self ): codcom ="" fpath =os.getenv("HOME")+'/.qgis2/python/plugins/Cxf_in/CTCOMCAT.txt' in_file = open(fpath,"r") testo= in_file.readlines() comune="" if (self.ui.cat_com.currentText()) !=comune: for ctcom in testo: line=ctcom.split(",") if line[3].strip()==self.ui.cat_com.currentText(): print line[0].strip() codcom=line[0].strip() layer = QgsMapLayerRegistry.instance().mapLayersByName("Particelle") [0] iface.setActiveLayer(layer) iter= layer.getFeatures() nfile = layer.fieldNameIndex('Nomefile') map = layer.fieldNameIndex('Mappale') layer.removeSelection () foglio=codcom+"_"+self.ui.cat_fg.currentText().replace ('_','') for feature in iter: if feature.attributes()[nfile]==codcom+"_"+self.ui.cat_fg.currentText().replace ('_','') and feature.attributes()[map]==self.ui.cat_mapp.currentText() : layer.select( feature.id()) iface.actionZoomToSelected().trigger()
def addTiles(self, layer, files): count = 0 layers = [] QApplication.setOverrideCursor( Qt.WaitCursor ) iface.mapCanvas().freeze(True) for fileName in files: print("TileIndex plugin : loading raster file %s" % fileName) fileInfo = QFileInfo(fileName) rlayer = QgsRasterLayer(fileName, fileInfo.baseName()) if rlayer is None: print("TileIndex plugin : raster file %s could not be loaded..." % fileName) continue layers.append(rlayer) count = count + 1 print("TileIndex plugin : adding %d layers to map registry" % count) QgsMapLayerRegistry.instance().addMapLayers(layers) iface.mapCanvas().freeze(False) iface.mapCanvas().refresh() print("TileIndex plugin : done adding layers") QApplication.restoreOverrideCursor() # restore active layer if qgis >= 1.9 if count > 0: if QGis.QGIS_VERSION_INT >= 10900: iface.legendInterface().setCurrentLayer(layer) else: iface.setActiveLayer(layer) return count
def __init__(self, edit_dialog): """Constructor.""" # setup self.edit_dialog = edit_dialog self.parent_frame = self.edit_dialog.parent_frame self.editing_layer = self.edit_dialog.editing_layer iface.setActiveLayer(self.editing_layer)
def nodeSetActive(node): if oeq_global.isStringOrUnicode(node): node = nodeByName(node) if len(node) == 0: return None node = node[0] iface.setActiveLayer(node.layer())
def createCentroidsLayer(self, layer, filt, name): #Dato un layer di tipo poligonale, ne crea una copia utilizzandone i centroidi; #In base al filtro scelto utilizza solo le features selezionate (o tutte le features se non esiste un filtro): #aggiunge i campi prob, ruolo e probRuolo if filt: QueryLayer().selectionByExpr(layer, filt) else: layer.selectAll() context = dataobjects.createContext() context.setInvalidGeometryCheck(QgsFeatureRequest.GeometryNoCheck) params = { 'INPUT': QgsProcessingFeatureSourceDefinition(layer.id(), True), 'ALL_PARTS': False, 'OUTPUT': 'memory:' } newLayer = processing.run("native:centroids", params, context=context) layerOutput = newLayer['OUTPUT'] data_provider = layerOutput.dataProvider() data_provider.addAttributes([QgsField('prob', QVariant.Int)]) data_provider.addAttributes([QgsField('ruolo', QVariant.String)]) data_provider.addAttributes([QgsField('probRuolo', QVariant.String)]) layerOutput.updateFields() layerOutput.setName(name) QgsProject.instance().addMapLayer(layerOutput) QgsProject.instance().layerTreeRoot().findLayer( layerOutput.id()).setItemVisibilityChecked(False) layer.removeSelection() iface.setActiveLayer(layerOutput) return layerOutput
def add_ext_layer(self, geom_str, idx): crs = QgsCoordinateReferenceSystem('EPSG:4326').toWkt() vlayer = self._init_ext_layer(geom_str, idx, crs) self._add_layer(geom_str, vlayer, idx) dom = QDomDocument() dom.setContent(LAYER_QML, True) # xyz_id non editable vlayer.importNamedStyle(dom) QgsProject.instance().addMapLayer(vlayer, False) group = self.add_empty_group() geom = self._group_geom_name(geom_str) order = self.GEOM_ORDER.get(geom) group_geom = self.qgroups.get(geom) group_geom = group_geom or ( group.insertGroup(order,geom) if order is not None else group.addGroup(geom) ) self.qgroups[geom] = group_geom group_geom.addLayer(vlayer) if iface: iface.setActiveLayer(vlayer) return vlayer
def display_pipe(self, pipe_id): """Show the pipe_id attributes on the pipe-tab""" pipe = self.pipes.getFeatures(QgsFeatureRequest(pipe_id)).next() hestelmaatregel = self.field_combobox_pipes.findText( str(pipe["Herstelmaa"])) if hestelmaatregel: self.field_combobox_pipes.setCurrentIndex(hestelmaatregel) else: self.field_combobox_pipes.setCurrentIndex(0) opmerking = pipe['Opmerking'] if opmerking: self.value_plaintextedit_pipes.setPlainText(opmerking) else: self.value_plaintextedit_pipes.setPlainText("") for index, field in enumerate(PIPE_FIELDS): value = pipe[field] if type( pipe[field]) is not QPyNullVariant else "" self.tablewidget_pipes.setItem(0, index, QTableWidgetItem(value)) iface.setActiveLayer(self.pipes) self.pipes.triggerRepaint() # Go to the pipe tab self.tabWidget.setCurrentIndex(2) self.selected_pipe_id = pipe.id()
def show_measuring_point(self): """Show the measuring point that belongs to a certain pipe.""" if not self.measuring_points: iface.messageBar().pushMessage( "Error", "There is no measuring points layer.", level=QgsMessageBar.CRITICAL, duration=0) return expr = QgsExpression("\"PIPE_ID\" IS '{}'".format( self.selected_pipe_id)) measuring_points = self.measuring_points.getFeatures( QgsFeatureRequest(expr)) ids = [measuring_point.id() for measuring_point in measuring_points] if len(ids) == 0: iface.messageBar().pushMessage( "Warning", "There are no measuring points connected to this pipe.", level=QgsMessageBar.WARNING, duration=0) return # Setting the selected measure points causes the measure_points onchange to trigger # which calls get_selected_measuring_point() to display the measure point. self.measuring_points.setSelectedFeatures(ids) iface.setActiveLayer(self.measuring_points) self.measuring_points.triggerRepaint() # Go to measuring points tab self.tabWidget.setCurrentIndex(3)
def create_count(self): layer = self.layers['section'] selected_count = layer.selectedFeatureCount() if selected_count == 0: push_info("Veuillez sélectionner un tronçon") return elif selected_count > 1: push_info("Veuillez ne sélectionner qu'un tronçon") return else: selected_feature = next(layer.getSelectedFeatures()) lanes = self.get_lanes_of_section(selected_feature.attribute('id')) installation = self.get_installation_of_lane( next(lanes).attribute('id')) # Save the id of the installation related to the selected section # so we can use in the count form to automatically select the # installation in the combobox QgsExpressionContextUtils.setProjectVariable( QgsProject.instance(), 'selected_installation', installation.attribute('id')) self.layers['count'].startEditing() iface.setActiveLayer(self.layers['count']) iface.actionAddFeature().trigger()
def show_shapefile_layers(directory): """ Show the manholes, pipes and measuring points layer. Set the manholes layer as active layer to be the same layer as the active tab. Arguments: (string) directory: Directory where the shapefiles are. These shapefiles are shown as layers. """ # Manholes manholes_filename = "{}.shp".format(SHP_NAME_MANHOLES) manholes_path = os.path.join(directory, manholes_filename) manholes_layer = iface.addVectorLayer(manholes_path, SHP_NAME_MANHOLES, "ogr") # Pipes pipes_filename = "{}.shp".format(SHP_NAME_PIPES) pipes_path = os.path.join(directory, pipes_filename) pipes_layer = iface.addVectorLayer(pipes_path, SHP_NAME_PIPES, "ogr") # Measuring stations measuring_points_filename = "{}.shp".format(SHP_NAME_MEASURING_POINTS) measuring_points_path = os.path.join(directory, measuring_points_filename) measuring_points_layer = iface.addVectorLayer(measuring_points_path, SHP_NAME_MEASURING_POINTS, "ogr") # Set manholes layer as active layer iface.setActiveLayer(manholes_layer)
def run_delete_action(self): self.layer_selector() assert self.link_layer != None, "self.link_layer != None" if self.delete_link_action.isChecked() == True: self.changeTool(self.delete_link_action) print("link 삭제 작업이 시작되었습니다.") # deselect all self.deselectAll() # selection 버튼 call iface.actionSelect().trigger() #link_layer 활성화 iface.setActiveLayer(self.link_layer) # # delete a feature with specified ID # layer.deleteFeature(fid) # selection 이벤트 함수 연결 self.link_layer.selectionChanged.connect(self.deleteLink) else: self.link_layer.selectionChanged.disconnect(self.deleteLink) print("link 삭제 작업이 종료되었습니다.")
def run_add_action(self): # layer 설정 self.layer_selector() # assert문으로 layer가 설정되었는지 검증 assert self.node_layer != None, "self.node_layer != None" # checked 상태 확인 # print("self.add_link_action.isChecked()=", self.add_link_action.isChecked()) # checked 상태이면 node레이어에 selectionChanged 이벤트를 connect if self.add_link_action.isChecked() == True: # 버튼 change self.changeTool(self.add_link_action) print("Link 추가 작업이 시작되었습니다.") # 기존에 선택됐던 피쳐 선택 취소하기 위해 deselect action trigger self.deselectAll() # selection 버튼 call iface.actionSelect().trigger() # node_layer 활성화 iface.setActiveLayer(self.node_layer) # selectionChanged 이벤트함수 연결 self.node_layer.selectionChanged.connect(self.onNodeSelected) # checked 아니면 disconnect else: self.node_layer.selectionChanged.disconnect(self.onNodeSelected) print("Link 추가 작업이 종료되었습니다.")
def add_ext_layer(self, geom_str, idx): """Add layer group structure qgroups: dict["main"] = group dict[geom] = list([vlayer1, vlayer2,...]) map_vlayer: dict[geom_str] = list([vlayer1, vlayer2,...]) vlayer order in list shall always be fixed, deleted vlayer hall be set to None map_fields: dict[geom_str] = list([fields1, fields2,...]) fields order in list shall always be fixed and not be deleted geom_str: QgsWkbTypes.displayString (detailed geometry, e.g. Multi-) geom: QgsWkbTypes.geometryDisplayString (generic geometry,) """ group = self.add_empty_group() geom = self._group_geom_name(geom_str) order = self.GEOM_ORDER.get(geom) group_geom = group.findGroup(geom) or (group.insertGroup( order, geom) if order is not None else group.addGroup(geom)) crs = QgsCoordinateReferenceSystem("EPSG:4326").toWkt() vlayer = self._init_ext_layer(geom_str, idx, crs) self._add_layer(geom_str, vlayer, idx) self._connect_cb_vlayer(vlayer, geom_str, idx) dom = QDomDocument() dom.setContent(LAYER_QML, True) # xyz_id non editable vlayer.importNamedStyle(dom) QgsProject.instance().addMapLayer(vlayer, False) group_geom.addLayer(vlayer) if iface: iface.setActiveLayer(vlayer) return vlayer
def run(self): """Run method that loads and starts the plugin""" manholes_layerList = QgsMapLayerRegistry.instance().mapLayersByName( SHP_NAME_MANHOLES) pipes_layerList = QgsMapLayerRegistry.instance().mapLayersByName( SHP_NAME_PIPES) measuring_points_layerList = QgsMapLayerRegistry.instance( ).mapLayersByName(SHP_NAME_MEASURING_POINTS) if not self.pluginIsActive: #print "** STARTING Beoordelingstool" # dockwidget may not exist if: # first run of plugin # removed on close (see self.onClosePlugin method) # Check if the layers manholes, pipes and measuring_points are active if not manholes_layerList or not pipes_layerList or not measuring_points_layerList: iface.messageBar().pushMessage( "Warning", "You don't have a manholes, pipes and measuring_points layer. \n Upload a json.", level=QgsMessageBar.WARNING, duration=20) self.download_dialog = BeoordelingstoolDownloadDialog() self.download_dialog.show() else: # Create the dockwidget (after translation) and keep reference self.dockwidget = BeoordelingstoolDockWidget( manhole_layer=manholes_layerList[0], pipe_layer=pipes_layerList[0], measuring_point_layer=measuring_points_layerList[0]) # DOWNLOAD # connect to provide cleanup on closing of dockwidget self.dockwidget.closingPlugin.connect(self.onClosePlugin) # show the dockwidget # TODO: fix to allow choice of dock location self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockwidget) self.dockwidget.show() self.pluginIsActive = True # Set the active layer to the manholes layer to be in # compliance with the Manholes tab of the dockwidget. iface.setActiveLayer(manholes_layerList[0]) # Show a message if not all layers are active elif self.pluginIsActive: if not manholes_layerList or not pipes_layerList or not measuring_points_layerList: self.iface.removeDockWidget(self.dockwidget) self.dockwidget = None self.pluginIsActive = False iface.messageBar().pushMessage( "Warning", "You don't have a manholes, pipes and measuring_points layer. \n Upload a json.", level=QgsMessageBar.WARNING, duration=20) self.download_dialog = BeoordelingstoolDownloadDialog() self.download_dialog.show()
def set_active_layer(self): layer = tools_qt.get_combo_value(self.dlg, self.dlg.cmb_layers, 0) if type(layer) != QgsVectorLayer: msg = "Invalid layer" tools_gw.show_warning(msg) return iface.setActiveLayer(layer)
def initLayerNavigation(self): self.layerName = str(self.ui.layersCombo.currentText()) self.layer = layer_helper.get_layer(self.layerName) iface.setActiveLayer(self.layer) self.features = [] for f in self.layer.getFeatures(): self.features.append(f) self.ui.maxLabel.setText(" of " + str(len(self.features))) self.currentFeatureIdx = 0
def createArea(self): l = self.proj.mapLayersByName('Beräkningsområde') if l: l = l[0] iface.setActiveLayer(l) iface.actionToggleEditing().trigger() iface.actionAddFeature().trigger() #l.featureAdded.connect(lambda fid: self.areaAdded(fid, l)) l.featureAdded.connect(lambda fid: self.showSaveDialog(fid, l))
def testImportFeature(self): '''Simulate user moves and check results.''' # Open python console iface.actionShowPythonDialog().trigger() # Get map tool action that is activated previousActivatedMapToolActionName = iface.mapCanvas().mapTool().action().text() #Add test layers to map registry layerDest = self.addTestVectorLayer() layerSource = self.addTestVectorLayer('test/data/segment2.shp') iface.setActiveLayer(layerDest) # Simulate click on edit mode button self.clickOnWidgetByActionName(iface.actionToggleEditing().text()) # Simulate click on plugin fusion button self.clickOnWidgetByActionName('Import Feature') # Move and click on the feature to import self.clickOnMapPoint(QgsPoint(785519,6528705)) # Feature must have been added if not self.printTest(38, self.featuresCount(layerDest), 'Import feature', 'Features count'): return # End of test ? if self.TESTS_TO_CHECK == 'up_to_import_feature': return # Test undo action self.ctrlZ() if not self.printTest(37, self.featuresCount(layerDest), 'Undo Import feature(Ctrl + z)', 'Features count'): return # End of test ? if self.TESTS_TO_CHECK == 'up_to_undo_import_feat': return # Quit edit mode self.clickOnWidgetByActionName(iface.actionToggleEditing().text()) # Fusion button must be enabled if not self.printTest(False, self.findButtonByActionName('Import Feature').isEnabled(), 'Disable fusion button', 'Fusion button status'): return # Previous map tool button must be re-checked if not self.printTest(True, self.findButtonByActionName(previousActivatedMapToolActionName).isChecked(), 'Check previous map tool button ('+previousActivatedMapToolActionName+')', 'Previous map tool button ('+previousActivatedMapToolActionName+') status'): return # End of test ? if self.TESTS_TO_CHECK == 'up_to_quit_edit_import_feat': return # Clear layers #QgsMapLayerRegistry.instance().removeAllMapLayers() iface.mapCanvas().refresh()
def restore_user_layer(layer_name, user_current_layer=None): """ Set active layer, preferably @user_current_layer else @layer_name """ if user_current_layer: iface.setActiveLayer(user_current_layer) else: layer = get_layer_by_tablename(layer_name) if layer: iface.setActiveLayer(layer)
def set_active_layer(self): print("activar seleccion sobre la capa seleccionada") layer = tools_qt.get_combo_value(self.dlg_btn1, self.dlg_btn1.cmb_layers, 0) if type(layer) != QgsVectorLayer: msg = "Invalid layer" tools_gw.show_warning(msg) return iface.setActiveLayer(layer)
def updateLink(self, fid, new_geom): # print("fid: ", fid, "geom: ", new_geom, "노드가 변경되었습니다.") ## link_layer 수정, node 따라서 geometry만 수정 # changeGeometry 함수가 적용되기 위해 레이어의 edit 모드가 활성화 되어야 한다. iface.setActiveLayer(self.link_layer) # self.link_layer.startEditing() # link_layer의 모든 feature 확인 for feat in self.link_layer.getFeatures(): # 이동한 node와 같은 id의 fr, to 노드를 가진 link 찾기 # from 노드가 수정된 경우 if fid == feat["node_fr"]: link_id = feat["link_id"] # to 노드는 기존에 있는 값 그대로 사용 toPoint = self.node_layer.getFeature(feat["node_to"]) # frGeom, toGeom = new_geom, feat.geometry().get()[-1] # feature의 geometry에 바로 접근하는 방법 frGeom, toGeom = new_geom, toPoint.geometry() new_link_geom = QgsGeometry.fromPolyline( [QgsPoint(frGeom.asPoint()), QgsPoint(toGeom.asPoint())]) # link geometry 수정 try: with edit(self.link_layer): ok = self.link_layer.changeGeometry( link_id, new_link_geom) # feat.setGeometry(new_link_geom) # 결과 출력 print("Changed?: ", ok, "link id: ", link_id) except Exception as err: print(repr(err)) # to 노드가 수정된 경우 if fid == feat["node_to"]: link_id = feat["link_id"] frPoint = self.node_layer.getFeature(feat["node_fr"]) frGeom, toGeom = frPoint.geometry(), new_geom new_link_geom = QgsGeometry.fromPolyline( [QgsPoint(frGeom.asPoint()), QgsPoint(toGeom.asPoint())]) try: with edit(self.link_layer): ok = self.link_layer.changeGeometry( link_id, new_link_geom) print("Changed?: ", ok, "link id: ", link_id) except Exception as err: print(repr(err)) ## node수정작업 연속으로 하기위해 다시 node_layer 활성화 self.moveNode()
def moveNode(self): self.deselectAll() ## node_layer 활성화 iface.setActiveLayer(self.node_layer) ## edit mode 시작 self.node_layer.startEditing() # move feature 버튼 call # https://gis.stackexchange.com/questions/141371/implementing-add-feature-action-using-pyqgis?rq=1 iface.actionMoveFeature().trigger()
def move_active_vector_layer_to_top(): layer = iface.activeLayer() if isinstance(layer, QgsVectorLayer): root = QgsProject.instance().layerTreeRoot() my_layer = root.findLayer(layer) clone = my_layer.clone() parent = my_layer.parent() parent.insertChildNode(0, clone) parent.removeChildNode(my_layer) layer = QgsProject.instance().mapLayersByName(layer.name())[0] iface.setActiveLayer(layer)
def selectArea(self): for a in iface.attributesToolBar().actions(): if a.objectName() == 'mActionDeselectAll': a.trigger() break l = self.proj.mapLayersByName('Beräkningsområde') if l: l = l[0] iface.setActiveLayer(l) iface.actionSelect().trigger()
def add_capture_source_area_layer(self): """Called on opening of frame to add capture source area layer""" path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "styles/") # add layer self.capture_source_area = self.layer_registry.add_postgres_layer( "capture_source_area", "capture_source_area", "shape", "buildings_reference", "", "") # set style self.capture_source_area.loadNamedStyle(path + "capture_source.qml") # make capture source area the active layer iface.setActiveLayer(self.capture_source_area)
def load_layers(self): settings = Settings() group_comptages = QgsProject.instance().layerTreeRoot().findGroup( 'Comptages') group_extra = QgsProject.instance().layerTreeRoot().findGroup('Extra') if group_comptages is None: group_comptages = QgsProject.instance().layerTreeRoot().addGroup( 'Comptages') if group_extra is None and settings.value("extra_layers"): group_extra = group_comptages.addGroup('Extra') for key in LAYER_DEFINITIONS: layer_definition = LAYER_DEFINITIONS[key] if not QgsProject.instance().mapLayersByName( layer_definition['display_name']): layer = self.load_layer( 'comptages', # Schema layer_definition['table'], layer_definition['geometry'], layer_definition['sql'], layer_definition['display_name'], layer_definition['id'], layer_definition['epsg'], ) if layer_definition['legend']: group_comptages.addLayer(layer) elif settings.value("extra_layers"): group_extra.addLayer(layer) self.layers[key] = layer self.apply_qml_styles() self.add_layer_actions() self.create_virtual_fields() self.create_joins() self.create_relations() iface.setActiveLayer(self.layers['section']) self.populate_list_of_highlighted_sections() self.layers['count'].featureAdded.connect(self.on_count_added) from qgis.core import QgsExpressionContextUtils QgsExpressionContextUtils.setProjectVariable( QgsProject.instance(), 'highlighted_installation', '')
def currentRowChanged(self, selected, deselected): indexes = self.annotationView.selectedIndexes() if len(indexes) == 0: return rowIndex = indexes[0].row() targetLayer = None for node in QgsProject.instance().layerTreeRoot().findLayers(): layer = node.layer() if isinstance(layer, QgsRasterLayer) and layer.dataProvider( ).dataSourceUri() == self.model.item(rowIndex, 2).text(): targetLayer = layer break root = QgsProject.instance().layerTreeRoot() if targetLayer is None: file = QFileInfo(self.model.item(rowIndex, 2).text()) path = file.filePath() base = file.baseName() targetLayer = QgsRasterLayer(path, base) QgsProject.instance().addMapLayer(targetLayer, False) root.insertLayer(0, targetLayer) else: clonedLayer = targetLayer.clone() QgsProject.instance().removeMapLayer(targetLayer.id()) QgsProject.instance().addMapLayer(clonedLayer) targetLayer = clonedLayer iface.setActiveLayer(targetLayer) crs = QgsCoordinateReferenceSystem(self.model.item(rowIndex, 3).text()) QgsProject.instance().setCrs(crs) iface.mapCanvas().setExtent(targetLayer.extent()) point1 = QgsPointXY(float(self.model.item(rowIndex, 8).text()), float(self.model.item(rowIndex, 9).text())) point2 = QgsPointXY(float(self.model.item(rowIndex, 8).text()), float(self.model.item(rowIndex, 11).text())) point3 = QgsPointXY(float(self.model.item(rowIndex, 10).text()), float(self.model.item(rowIndex, 11).text())) point4 = QgsPointXY(float(self.model.item(rowIndex, 10).text()), float(self.model.item(rowIndex, 9).text())) self.resetSelectionBand() self.selectionBand.addPoint(point1, False) self.selectionBand.addPoint(point2, False) self.selectionBand.addPoint(point3, False) self.selectionBand.addPoint(point4, True) self.selectionBand.setOpacity(0.5) self.selectionBand.show()
def run(self): """Run method that performs all the real work""" from qgis.core import QgsMarkerSymbol, QgsProject, QgsSymbol from qgis.utils import iface import pandas as pd import time data = pd.read_pickle('C:\\projectData\\blackforest\\data.pickle') # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False self.dlg = FloatingWasteDialog() # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: stationLayer = QgsProject.instance().mapLayersByName("SensorStations")[0] stationLayer.setAutoRefreshInterval(500) stationLayer.setAutoRefreshEnabled(True) iface.setActiveLayer(stationLayer) FloatingWaste.setRenderer(layer = stationLayer) iface.layerTreeView().refreshLayerSymbology(stationLayer.id()) stationLayer.startEditing() for i in range(len(data)): print(i) for c in data.columns: index = c - 1 value = data.loc[i,c] wlevel = FloatingWaste.getWasteClass(value) # (ID, 0=id; 1=wlevel; 2=wastecount, value) stationLayer.changeAttributeValue(index, 1, wlevel) stationLayer.changeAttributeValue(index, 2, str(value)) print(f"Station:{index}, Vaule:{value}, Class:{wlevel}") #iface.layerTreeView().refreshLayerSymbology(iface.activeLayer().id()) #iface.layerTreeView().refreshLayerSymbology(stationLayer.id()) FloatingWaste.spin(3)
def populateProject(self, _feedback=None): """Populates the project.""" project = QgsProject.instance() root = project.layerTreeRoot() layersToAdd = self._config.layers savedICAO = project.metadata().keywords().get('icao') # Clear the project if a ICAO if is present and it's not the apt being loaded if savedICAO is not None and savedICAO[0] != self._airport.getIcao(): project.clear() airportGroup = root.findGroup( LayerName.Airport.value) or self.addGroup(LayerName.Airport.value) mapsGroup = root.findGroup(LayerName.Maps.value) or self.addGroup( LayerName.Maps.value) terrainGroup = root.findGroup( LayerName.Terrain.value) or self.addGroup(LayerName.Terrain.value) airspaceGroup = root.findGroup( LayerName.Airspace.value) or self.addGroup( LayerName.Airspace.value) airspace = None if LayerType.Fixes in layersToAdd: self._generateFixes(airportGroup) if LayerType.Restricted in layersToAdd: self._generateRestricted(airportGroup) if LayerType.Airspace in layersToAdd: airspace = self._generateAirspace(airspaceGroup) if LayerType.AirspaceHidden in layersToAdd: self._generateAirspace(airspaceGroup, True) if LayerType.Maps in layersToAdd: self._generateMaps(mapsGroup) if LayerType.ExistingTerrain in layersToAdd: self.loadExistingTerrain(terrainGroup) if not project.mapLayersByName('OpenStreetMap'): osm = QgsRasterLayer(_XYZ_OSM, 'OpenStreetMap', 'wms') self.addLayerToGroup(osm, root) if airspace: iface.setActiveLayer(airspace) self.zoomToGroup(airspaceGroup)
def zoomToSelectedFeature(self, layer): #Dato un layer lo attiva e zoomma sulle features attive #In base al numero di features attive setta la scala per lo zoom iface.setActiveLayer(layer) iface.mapCanvas().zoomToSelected() scale = iface.mapCanvas().scale() if len(layer.selectedFeatures()) > 5: newScale = scale + 0.5 * scale if len(layer.selectedFeatures()) <= 5: newScale = scale + 1.5 * scale if len(layer.selectedFeatures()) <= 3: newScale = scale + 2 * scale if len(layer.selectedFeatures()) == 1: newScale = scale + 10 * scale iface.mapCanvas().zoomScale(newScale)
def selectLinePushButton_clicked(self): #self.hide() vectorDraftLyr = QgsVectorLayer('LineString?crs=epsg:4326', 'Please Draw A Line for Planning', "memory") QgsProject().instance().addMapLayer(vectorDraftLyr) # set layer active self.hide() iface.setActiveLayer(vectorDraftLyr) # start edit iface.actionToggleEditing().trigger() # enable tool iface.actionAddFeature().trigger() #self.show() iface.actionToggleEditing().triggered.connect(self.endDrawLine)
def show_feature(self, nr): '''Show selected feature on map''' try: featureID = eval('self.featureID' + str(nr)) feature_data = featureID.text().split('\n') layer_name = feature_data[0] layer = QgsProject.instance().mapLayersByName(layer_name)[0] iface.setActiveLayer(layer) layer.removeSelection() # if result contains features id select it if len(feature_data) == 2: layer.select(int(feature_data[1])) box = layer.boundingBoxOfSelected() iface.mapCanvas().setExtent(box) iface.mapCanvas().refresh() except Exception as e: print('Something happened at delete_rule [%s]' % (e))
def add_outlines(self): """ Add building outlines to canvas """ path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "styles/") self.layer_registry.remove_layer(self.building_layer) self.building_historic = self.layer_registry.add_postgres_layer( "historic_outlines", "building_outlines", "shape", "buildings", "", "end_lifespan is not NULL") self.building_historic.loadNamedStyle(path + "building_historic.qml") self.building_layer = None self.building_layer = self.layer_registry.add_postgres_layer( "building_outlines", "building_outlines", "shape", "buildings", "", "end_lifespan is NULL") self.building_layer.loadNamedStyle(path + "building_blue.qml") iface.setActiveLayer(self.building_layer)
def addToMap(csvfile, selectedLayer): # A little windows path trickery if csvfile[0] is not "/": csvfile = "/" + csvfile uri = "file://{0}?delimiter={1}&crs={2}&wktField={3}".format( csvfile, ",", selectedLayer.crs().authid(), "Wkt") rOutput = QgsVectorLayer(uri, "ProfileLayer_{}".format(selectedLayer.name()), "delimitedtext") symbolize(rOutput, selectedLayer) QgsMapLayerRegistry.instance().addMapLayer(rOutput) # Make sure this doesn't change the active layer selection iface.setActiveLayer(selectedLayer)
def setActiveLayer(*args): """Makes layer with the given name active. NOTE: layer should be loaded into project. """ layer = layerFromName(args[0]) iface.setActiveLayer(layer)
def set_active_layer(layer): """ Set the active layer in the current session """ layer = layer_by_name(layer) iface.setActiveLayer(layer)
def _selectLayer(): layer = layerFromName("points") iface.setActiveLayer(layer)
for dRange in rangeList: canvas = iface.mapCanvas() myLayer=NULL #note: take all this out of loop myPolyLayer=NULL #set current layer to the main malnutrition one, edit it for layer in canvas.layers(): if NAMEOFPOINTLAYER.lower() in layer.name().lower(): myLayer=layer if NAMEOFPOLYLAYER.lower() in layer.name().lower(): myPolyLayer=layer if myLayer==NULL: print 'point layer name has changed' if myPolyLayer==NULL: print 'polygon layer has changed' iface.setActiveLayer(myLayer) layer=myLayer #dRange in form [min,max] of date objects [city_dict]=malHat.getCityDict(dRange,visitKey,cityKey,inQgis=True) #city dict in form {city:(mild,moderate,severe)} #now place malnut values into QGIS for map export layer.startEditing() if not ruleBased: #renders all city points symbol= QgsSymbolV2.defaultSymbol(layer.geometryType()) #make the points all just green renderer = QgsSingleSymbolRendererV2(symbol) # create a new simple marker symbol layer, a green circle with a black border properties = {'color': 'green', 'color_border': 'black','scale_method':'Map unit','size':'2'}