def snap_to_connec_gully(self): """ Set snapping to 'connec' and 'gully' """ QgsProject.instance().blockSignals(True) layer_settings = self.snap_to_layer(self.layer_connec, QgsPointLocator.Vertex, True) if layer_settings: layer_settings.setType(1) layer_settings.setTolerance(15) layer_settings.setEnabled(True) else: layer_settings = QgsSnappingConfig.IndividualLayerSettings(True, 1, 15, 1) self.snapping_config.setIndividualLayerSettings(self.layer_connec, layer_settings) layer_settings = self.snap_to_layer(self.layer_gully, QgsPointLocator.Vertex, True) if layer_settings: layer_settings.setType(1) layer_settings.setTolerance(15) layer_settings.setEnabled(True) else: layer_settings = QgsSnappingConfig.IndividualLayerSettings(True, 1, 15, 1) self.snapping_config.setIndividualLayerSettings(self.layer_gully, layer_settings) QgsProject.instance().blockSignals(False) QgsProject.instance().snappingConfigChanged.emit(self.snapping_config)
def snap_to_connec_gully(): """ Set snapping to 'connec' and 'gully' """ QgsProject.instance().blockSignals(True) snapping_config = get_snapping_options() layer_settings = snap_to_layer(get_layer('v_edit_connec'), QgsPointLocator.Vertex, True) if layer_settings: layer_settings.setType(1) layer_settings.setTolerance(15) layer_settings.setEnabled(True) else: layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, 1, 15, 1) snapping_config.setIndividualLayerSettings(get_layer('v_edit_connec'), layer_settings) layer_settings = snap_to_layer(get_layer('v_edit_gully'), QgsPointLocator.Vertex, True) if layer_settings: layer_settings.setType(1) layer_settings.setTolerance(15) layer_settings.setEnabled(True) else: layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, 1, 15, 1) snapping_config.setIndividualLayerSettings(get_layer('v_edit_gully'), layer_settings) QgsProject.instance().blockSignals(False) QgsProject.instance().snappingConfigChanged.emit(snapping_config)
def __init__(self, iface: QgisInterface, layer): QgepMapToolAddFeature.__init__(self, iface, layer) self.snapping_marker = None self.node_layer = QgepLayerManager.layer('vw_wastewater_node') assert self.node_layer is not None self.reach_layer = QgepLayerManager.layer('vw_qgep_reach') assert self.reach_layer is not None self.setAdvancedDigitizingAllowed(True) self.setAutoSnapEnabled(True) layer_snapping_configs = [{ 'layer': self.node_layer, 'mode': QgsSnappingConfig.Vertex }, { 'layer': self.reach_layer, 'mode': QgsSnappingConfig.VertexAndSegment }] self.snapping_configs = [] self.snapping_utils = QgsMapCanvasSnappingUtils(self.iface.mapCanvas()) for lsc in layer_snapping_configs: config = QgsSnappingConfig() config.setMode(QgsSnappingConfig.AdvancedConfiguration) config.setEnabled(True) settings = QgsSnappingConfig.IndividualLayerSettings( True, lsc['mode'], 10, QgsTolerance.Pixels) config.setIndividualLayerSettings(lsc['layer'], settings) self.snapping_configs.append(config)
def prepare_boundary_creation(self): # Load layers res_layers = self.qgis_utils.get_layers(self._db, { BOUNDARY_TABLE: {'name': BOUNDARY_TABLE, 'geometry': QgsWkbTypes.LineGeometry}, BOUNDARY_POINT_TABLE: {'name': BOUNDARY_POINT_TABLE, 'geometry': QgsWkbTypes.PointGeometry}}, load=True) boundary_layer = res_layers[BOUNDARY_TABLE] if boundary_layer is None: self.iface.messageBar().pushMessage("Asistente LADM_COL", QCoreApplication.translate("CreateBoundariesCadastreWizard", "Boundary layer couldn't be found... {}").format(self._db.get_description()), Qgis.Warning) return boundary_point_layer = res_layers[BOUNDARY_POINT_TABLE] if boundary_point_layer is None: self.iface.messageBar().pushMessage("Asistente LADM_COL", QCoreApplication.translate("CreateBoundariesCadastreWizard", "Boundary point layer couldn't be found... {}").format(self._db.get_description()), Qgis.Warning) return # Disable transactions groups QgsProject.instance().setAutoTransaction(False) # Configure Snapping snapping = QgsProject.instance().snappingConfig() snapping.setEnabled(True) snapping.setMode(QgsSnappingConfig.AdvancedConfiguration) snapping.setIndividualLayerSettings(boundary_point_layer, QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex, 15, QgsTolerance.Pixels)) snapping.setIndividualLayerSettings(boundary_layer, QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex, 15, QgsTolerance.Pixels)) QgsProject.instance().setSnappingConfig(snapping) # Suppress feature form form_config = boundary_layer.editFormConfig() form_config.setSuppress(QgsEditFormConfig.SuppressOn) boundary_layer.setEditFormConfig(form_config) # Enable edition mode self.iface.layerTreeView().setCurrentLayer(boundary_layer) boundary_layer.startEditing() self.iface.actionAddFeature().trigger() self.iface.messageBar().pushMessage("Asistente LADM_COL", QCoreApplication.translate("CreateBoundariesCadastreWizard", "You can now start capturing boundaries clicking on the map..."), Qgis.Info)
def test_signalConnection(self): # remove all layers QgsProject.instance().removeAllMapLayers() # set dependencies and add back layers self.pointsLayer = QgsVectorLayer("dbname='%s' table=\"node\" (geom) sql=" % self.fn, "points", "spatialite") assert (self.pointsLayer.isValid()) self.linesLayer = QgsVectorLayer("dbname='%s' table=\"section\" (geom) sql=" % self.fn, "lines", "spatialite") assert (self.linesLayer.isValid()) self.pointsLayer2 = QgsVectorLayer("dbname='%s' table=\"node2\" (geom) sql=" % self.fn, "_points2", "spatialite") assert (self.pointsLayer2.isValid()) self.pointsLayer.setDependencies([QgsMapLayerDependency(self.linesLayer.id())]) self.pointsLayer2.setDependencies([QgsMapLayerDependency(self.pointsLayer.id())]) # this should update connections between layers QgsProject.instance().addMapLayers([self.pointsLayer]) QgsProject.instance().addMapLayers([self.linesLayer]) QgsProject.instance().addMapLayers([self.pointsLayer2]) ms = QgsMapSettings() ms.setOutputSize(QSize(100, 100)) ms.setExtent(QgsRectangle(0, 0, 1, 1)) self.assertTrue(ms.hasValidSettings()) u = QgsSnappingUtils() u.setMapSettings(ms) cfg = u.config() cfg.setEnabled(True) cfg.setMode(QgsSnappingConfig.AdvancedConfiguration) cfg.setIndividualLayerSettings(self.pointsLayer, QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels)) cfg.setIndividualLayerSettings(self.pointsLayer2, QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels)) u.setConfig(cfg) # add another line f = QgsFeature(self.linesLayer.fields()) f.setId(4) geom = QgsGeometry.fromWkt("LINESTRING(0.5 0.2,0.6 0)") f.setGeometry(geom) self.linesLayer.startEditing() self.linesLayer.addFeatures([f]) self.linesLayer.commitChanges() # check the second snapped point is OK m = u.snapToMap(QPoint(75, 100 - 0)) self.assertTrue(m.isValid()) self.assertTrue(m.hasVertex()) self.assertEqual(m.point(), QgsPointXY(0.8, 0.0)) self.pointsLayer.setDependencies([]) self.pointsLayer2.setDependencies([])
def setSnapLayers(self, snapper, layers): config = QgsSnappingConfig() config.setMode(QgsSnappingConfig.AdvancedConfiguration) config.setEnabled(True) for layer in layers: if layer: ils = QgsSnappingConfig.IndividualLayerSettings( True, QgsSnappingConfig.VertexAndSegment, 16, QgsTolerance.Pixels) config.setIndividualLayerSettings(layer, ils) snapper.setConfig(config)
def init_snapper(self): """ Initialize snapper """ if not self.snapper: self.node_layer = self.network_analyzer.getNodeLayer() self.snapper = QgsMapCanvasSnappingUtils(self.canvas) config = QgsSnappingConfig() config.setMode(QgsSnappingConfig.AdvancedConfiguration) config.setEnabled(True) ils = QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.VertexAndSegment, 16, QgsTolerance.Pixels) config.setIndividualLayerSettings(self.node_layer, ils) self.snapper.setConfig(config)
def setSnapLayers(self, snapper, layers): config = QgsSnappingConfig() config.setMode(QgsSnappingConfig.AdvancedConfiguration) config.setEnabled(True) for layer in layers: if layer: ils = QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.VertexAndSegment, 16, QgsTolerance.Pixels) config.setIndividualLayerSettings(layer, ils) layer.destroyed.connect(self.deactivate) snapper.setConfig(config) snapper.layer_priority = layers
def snap_to_arc(self): """ Set snapping to 'arc' """ QgsProject.instance().blockSignals(True) layer_settings = self.snap_to_layer(self.layer_arc, QgsPointLocator.All, True) if layer_settings: layer_settings.setType(2) layer_settings.setTolerance(15) layer_settings.setEnabled(True) else: layer_settings = QgsSnappingConfig.IndividualLayerSettings(True, 2, 15, 1) self.snapping_config.setIndividualLayerSettings(self.layer_arc, layer_settings) QgsProject.instance().blockSignals(False) QgsProject.instance().snappingConfigChanged.emit(self.snapping_config)
def setAxialSnapping(self): # keep button pressed # un press other buttons # disable previous snapping setting self.resetSnapping() # self.axialButton.setCheckable(True) self.resetIcons() axial_icon = QPixmap(os.path.dirname(__file__) + "/custom_icons/axial.png") self.axialButton.setIcon(QIcon(axial_icon)) self.axialButton.setIconSize(QSize(40, 40)) # snap to nothing if self.settings[0] != '': proj = QgsProject.instance() # fix_print_with_import # fix_print_with_import print(proj, 'ax') proj.writeEntry('Digitizing', 'SnappingMode', 'advanced') layer = lfh.getLayerByName(self.settings[0]) self.iface.setActiveLayer(layer) # if layer.isEditable(): # layer.commitChanges() # else: # layer.startEditing() snapConfig = QgsSnappingConfig() snapConfig.setMode(QgsSnappingConfig.AdvancedConfiguration) layerSnapConfig = QgsSnappingConfig.IndividualLayerSettings(False, QgsSnappingConfig.Vertex, self.settings[2], QgsTolerance.LayerUnits) snapConfig.setIndividualLayerSettings(layer, layerSnapConfig) snapConfig.setEnabled(False) proj.setAvoidIntersectionsLayers([layer]) proj.setSnappingConfig(snapConfig) proj.setTopologicalEditing(False) self.axial_mode = True else: self.iface.messageBar().pushMessage("Network layer not specified!", Qgis.Critical, duration=5) self.axial_mode = False return
def save(self): proj = QgsProject.instance() snapping_config = proj.snappingConfig() snapping_config.clearIndividualLayerSettings() snapping_config.setTolerance(20.0) snapping_config.setMode(QgsSnappingConfig.AllLayers) POLYGON_LYR = [ "Unita' geologico-tecniche", "Instabilita' di versante", "Zone stabili liv 1", "Zone instabili liv 1", "Zone stabili liv 2", "Zone instabili liv 2", "Zone stabili liv 3", "Zone instabili liv 3", ] layer = self.iface.activeLayer() if layer is not None: if layer.name() in POLYGON_LYR: # self.wait_dlg.show() layers = proj.mapLayers().values() snapping_config = proj.snappingConfig() snapping_config.clearIndividualLayerSettings() snapping_config.setIntersectionSnapping(False) for fc in layers: if fc.name() in POLYGON_LYR: layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, QgsSnappingConfig.VertexFlag, 20, QgsTolerance.ProjectUnits, ) snapping_config.setIndividualLayerSettings( fc, layer_settings) layer.commitChanges() # self.wait_dlg.hide() else: layer.commitChanges()
def snap_to_node(self): """ Set snapping to 'node' """ QgsProject.instance().blockSignals(True) layer_settings = self.snap_to_layer(self.layer_node, QgsPointLocator.Vertex, True) if layer_settings: layer_settings.setType(1) layer_settings.setTolerance(15) layer_settings.setEnabled(True) else: layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, 1, 15, 1) self.snapping_config.setIndividualLayerSettings( self.layer_node, layer_settings) self.apply_snapping_options(self.snapping_config)
def config_snap_to_arc(self): """ Set snapping to 'arc' """ QgsProject.instance().blockSignals(True) self.set_snapping_layers() segment_flag = tools_gw.get_segment_flag(2) layer_settings = self.config_snap_to_layer(self.layer_arc, QgsPointLocator.All, True) if layer_settings: tools_gw.set_snapping_type(layer_settings, segment_flag) layer_settings.setTolerance(15) layer_settings.setEnabled(True) else: layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, segment_flag, 15, 1) self.snapping_config.setIndividualLayerSettings( self.layer_arc, layer_settings) self.restore_snap_options(self.snapping_config)
def config_snap_to_node(self): """ Set snapping to 'node' """ QgsProject.instance().blockSignals(True) vertex_flag = tools_gw.get_vertex_flag(1) layer_settings = self.config_snap_to_layer(self.layer_node, QgsPointLocator.Vertex, True) if layer_settings: tools_gw.set_snapping_type(layer_settings, vertex_flag) layer_settings.setTolerance(15) layer_settings.setEnabled(True) else: layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, vertex_flag, 15, 1) self.snapping_config.setIndividualLayerSettings( self.layer_node, layer_settings) self.restore_snap_options(self.snapping_config)
def snap_to_arc(): """ Set snapping to 'arc' """ QgsProject.instance().blockSignals(True) snapping_config = get_snapping_options() layer_settings = snap_to_layer(get_layer('v_edit_arc'), QgsPointLocator.All, True) if layer_settings: layer_settings.setType(2) layer_settings.setTolerance(15) layer_settings.setEnabled(True) else: layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, 2, 15, 1) snapping_config.setIndividualLayerSettings(get_layer('v_edit_arc'), layer_settings) QgsProject.instance().blockSignals(False) QgsProject.instance().snappingConfigChanged.emit(snapping_config)
def config_snap_to_gully(self): """ Set snapping to 'gully' """ QgsProject.instance().blockSignals(True) snapping_config = self.get_snapping_options() vertex_flag = tools_gw.get_vertex_flag(1) layer_settings = self.config_snap_to_layer( tools_qgis.get_layer_by_tablename('v_edit_gully'), QgsPointLocator.Vertex, True) if layer_settings: tools_gw.set_snapping_type(layer_settings, vertex_flag) layer_settings.setTolerance(15) layer_settings.setEnabled(True) else: layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, vertex_flag, 15, 1) snapping_config.setIndividualLayerSettings( tools_qgis.get_layer_by_tablename('v_edit_gully'), layer_settings) self.restore_snap_options(self.snapping_config)
def save(self): proj = QgsProject.instance() POLYGON_LYR = [ "Aree di emergenza", "Aggregati strutturali", "Edifici strategici", "Unita' strutturali", ] snapping_config = proj.snappingConfig() snapping_config.clearIndividualLayerSettings() snapping_config.setTolerance(20.0) snapping_config.setMode(QgsSnappingConfig.AllLayers) layer = self.iface.activeLayer() if layer is not None: if layer.name() in POLYGON_LYR: # self.dlg_wait.show() layers = proj.mapLayers().values() for fc in layers: if fc.name() in POLYGON_LYR: layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, QgsSnappingConfig.VertexFlag, 20, QgsTolerance.ProjectUnits, ) snapping_config.setIndividualLayerSettings( fc, layer_settings) layer.commitChanges() # self.dlg_wait.hide() else: layer.commitChanges()
def activate(self): QgsMapTool.activate(self) # Snapping self.snapper = QgsMapCanvasSnappingUtils(self.iface.mapCanvas()) self.snapper.setMapSettings(self.iface.mapCanvas().mapSettings()) config = QgsSnappingConfig(QgsProject.instance()) config.setType(1) # Vertex config.setMode(2) # All layers config.setTolerance(2) config.setUnits(2) # Pixels config.setEnabled(True) self.snapper.setConfig(config)
def activate(self): cursor = QCursor() cursor.setShape(Qt.ArrowCursor) self.iface.mapCanvas().setCursor(cursor) myLayers = [] # Editing layers = self.getLayers() for layer in layers: openedLayerPath = self.getLayerPath(layer) for name in self.ownMainLayers: layerPath = self.generatePath( self.ProjectDirectory, self.NetworkName + "_" + name + ".shp") if openedLayerPath == layerPath: myLayers.append(layer) if not layer.isEditable(): layer.startEditing() # Snapping self.snapper = QgsMapCanvasSnappingUtils(self.iface.mapCanvas()) self.snapper.setMapSettings(self.iface.mapCanvas().mapSettings()) config = QgsSnappingConfig(QgsProject.instance()) config.setType(2) # Vertex config.setMode(2) # All layers config.setTolerance(10) config.setUnits(1) # Pixels config.setEnabled(True) self.snapper.setConfig(config) self.pipeSnapper = QgsMapCanvasSnappingUtils(self.iface.mapCanvas()) self.pipeSnapper.setMapSettings(self.iface.mapCanvas().mapSettings()) config = QgsSnappingConfig(QgsProject.instance()) config.setType(2) # Vertex config.setMode(2) # All layers config.setTolerance(10) config.setUnits(1) # Pixels config.setEnabled(True) self.pipeSnapper.setConfig(config)
def configure_snapping_settings(): my_snap_config = QgsSnappingConfig() my_snap_config.setEnabled(True) my_snap_config.setMode(QgsSnappingConfig.AllLayers) my_snap_config.setType(QgsSnappingConfig.Vertex) my_snap_config.setUnits(QgsTolerance.Pixels) my_snap_config.setTolerance(10) my_snap_config.setIntersectionSnapping(True) QgsProject.instance().setSnappingConfig(my_snap_config)
def add_feature_or_record(self): proj = QgsProject.instance() snapping_config = proj.instance().snappingConfig() snapping_config.clearIndividualLayerSettings() snapping_config.setTolerance(20.0) snapping_config.setMode(QgsSnappingConfig.AllLayers) DIZIO_LAYER = { "Zone stabili liv 1": "Zone instabili liv 1", "Zone instabili liv 1": "Zone stabili liv 1", "Zone stabili liv 2": "Zone instabili liv 2", "Zone instabili liv 2": "Zone stabili liv 2", "Zone stabili liv 3": "Zone instabili liv 3", "Zone instabili liv 3": "Zone stabili liv 3", } POLY_LYR = [ "Unita' geologico-tecniche", "Instabilita' di versante", "Zone stabili liv 1", "Zone instabili liv 1", "Zone stabili liv 2", "Zone instabili liv 2", "Zone stabili liv 3", "Zone instabili liv 3", ] layer = self.iface.activeLayer() # Configure snapping if layer is not None: if layer.name() in POLY_LYR: # self.wait_dlg.show() for fc in proj.mapLayers().values(): if fc.name() in POLY_LYR: layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, QgsSnappingConfig.VertexFlag, 20, QgsTolerance.ProjectUnits, ) snapping_config.setIndividualLayerSettings( fc, layer_settings) snapping_config.setIntersectionSnapping(False) for chiave, valore in list(DIZIO_LAYER.items()): if layer.name() == chiave: other_layer = proj.mapLayersByName(valore)[0] layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, QgsSnappingConfig.VertexFlag, 20, QgsTolerance.ProjectUnits, ) snapping_config.setIndividualLayerSettings( layer, layer_settings) snapping_config.setIndividualLayerSettings( other_layer, layer_settings) snapping_config.setIntersectionSnapping(True) elif layer.name() == "Unita' geologico-tecniche": layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, QgsSnappingConfig.VertexFlag, 20, QgsTolerance.ProjectUnits, ) snapping_config.setIndividualLayerSettings( layer, layer_settings) snapping_config.setIntersectionSnapping(True) elif layer.name() == "Instabilita' di versante": layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, QgsSnappingConfig.VertexFlag, 20, QgsTolerance.ProjectUnits, ) snapping_config.setIndividualLayerSettings( layer, layer_settings) snapping_config.setIntersectionSnapping(True) layer.startEditing() self.iface.actionAddFeature().trigger() # self.wait_dlg.hide() else: layer.startEditing() self.iface.actionAddFeature().trigger()
def setUnlinkSnapping(self): # disable previous snapping setting if segment self.resetSnapping() # snap to vertex if self.settings[1] != 'no unlinks': self.resetIcons() unlink_icon = QPixmap(os.path.dirname(__file__) + "/custom_icons/unlink.png") self.unlinksButton.setIcon(QIcon(unlink_icon)) self.unlinksButton.setIconSize(QSize(40, 40)) proj = QgsProject.instance() # fix_print_with_import # fix_print_with_import print(proj, 'un') proj.writeEntry('Digitizing', 'SnappingMode', 'advanced') layer = lfh.getLayerByName(self.settings[0]) unlinks_layer = lfh.getLayerByName(self.settings[1]) # if unlinks_layer.isEditable(): # unlinks_layer.commitChanges() # else: # unlinks_layer.startEditing() self.iface.setActiveLayer(unlinks_layer) snapConfig = QgsSnappingConfig() snapConfig.setMode(QgsSnappingConfig.AdvancedConfiguration) layerSnapConfig = QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex, self.settings[2], QgsTolerance.LayerUnits) snapConfig.setIndividualLayerSettings(layer, layerSnapConfig) proj.setAvoidIntersectionsLayers([layer]) snapConfig.setIntersectionSnapping(True) snapConfig.setEnabled(True) QgsProject.instance().setSnappingConfig(snapConfig) proj.setTopologicalEditing(False) self.unlink_mode = True else: self.iface.messageBar().pushMessage("Unlinks layer not specified!", Qgis.Critical, duration=5) self.unlink_mode = False return
def manage_layer_manager(json_result, sql): """ Manage options for layers (active, visible, zoom and indexing) :param json_result: Json result of a query (Json) :return: None """ try: layermanager = json_result['body']['layerManager'] except KeyError: return try: # force visible and in case of does not exits, load it if 'visible' in layermanager: for lyr in layermanager['visible']: layer_name = [key for key in lyr][0] layer = global_vars.controller.get_layer_by_tablename(layer_name) if layer is None: the_geom = lyr[layer_name]['geom_field'] field_id = lyr[layer_name]['pkey_field'] if lyr[layer_name]['group_layer'] is not None: group = lyr[layer_name]['group_layer'] else: group = "GW Layers" style_id = lyr[layer_name]['style_id'] from_postgres_to_toc(layer_name, the_geom, field_id, group=group, style_id=style_id) global_vars.controller.set_layer_visible(layer) # force reload dataProvider in order to reindex. if 'index' in layermanager: for lyr in layermanager['index']: layer_name = [key for key in lyr][0] layer = global_vars.controller.get_layer_by_tablename(layer_name) if layer: global_vars.controller.set_layer_index(layer) # Set active if 'active' in layermanager: layer = global_vars.controller.get_layer_by_tablename(layermanager['active']) if layer: global_vars.iface.setActiveLayer(layer) # Set zoom to extent with a margin if 'zoom' in layermanager: layer = global_vars.controller.get_layer_by_tablename(layermanager['zoom']['layer']) if layer: prev_layer = global_vars.iface.activeLayer() global_vars.iface.setActiveLayer(layer) global_vars.iface.zoomToActiveLayer() margin = layermanager['zoom']['margin'] set_margin(layer, margin) if prev_layer: global_vars.iface.setActiveLayer(prev_layer) # Set snnaping options if 'snnaping' in layermanager: for layer_name in layermanager['snnaping']: layer = global_vars.controller.get_layer_by_tablename(layer_name) if layer: QgsProject.instance().blockSignals(True) layer_settings = snap_to_layer(layer, QgsPointLocator.All, True) if layer_settings: layer_settings.setType(2) layer_settings.setTolerance(15) layer_settings.setEnabled(True) else: layer_settings = QgsSnappingConfig.IndividualLayerSettings(True, 2, 15, 1) snapping_config = get_snapping_options() snapping_config.setIndividualLayerSettings(layer, layer_settings) QgsProject.instance().blockSignals(False) QgsProject.instance().snappingConfigChanged.emit( snapping_config) set_snapping_mode() except Exception as e: global_vars.controller.manage_exception(None, f"{type(e).__name__}: {e}", sql)
def resetSnapping(self): self.unlink_mode = False # disable previous snapping setting proj = QgsProject.instance() snapConfig = QgsSnappingConfig() if self.settings[0] != '' and self.settings[0]: # proj.writeEntry('Digitizing', 'SnappingMode', 'advanced') layer = lfh.getLayerByName(self.settings[0]) if layer: # layer might have been removed snapConfig.setMode(QgsSnappingConfig.AdvancedConfiguration) layerSnapConfig = QgsSnappingConfig.IndividualLayerSettings(False, QgsSnappingConfig.Vertex, self.settings[2], QgsTolerance.LayerUnits) snapConfig.setIndividualLayerSettings(layer, layerSnapConfig) proj.setAvoidIntersectionsLayers([layer]) if self.settings[1] != 'no unlinks' and self.settings[1]: # proj.writeEntry('Digitizing', 'SnappingMode', 'advanced') layer = lfh.getLayerByName(self.settings[1]) if layer: snapConfig.setMode(QgsSnappingConfig.AdvancedConfiguration) layerSnapConfig = QgsSnappingConfig.IndividualLayerSettings(False, QgsSnappingConfig.Vertex, self.settings[2], QgsTolerance.LayerUnits) snapConfig.setIndividualLayerSettings(layer, layerSnapConfig) proj.setAvoidIntersectionsLayers([]) snapConfig.setIntersectionSnapping(False) proj.setSnappingConfig(snapConfig) return
def add_feature_or_record(self): proj = QgsProject.instance() snapping_config = proj.instance().snappingConfig() snapping_config.clearIndividualLayerSettings() snapping_config.setTolerance(20.0) snapping_config.setMode(QgsSnappingConfig.AllLayers) DIZIO_LAYER = { "Aree di emergenza": [ "Aggregati strutturali", "Edifici strategici", "Unita' strutturali", ], "Edifici strategici": ["Aree di emergenza", "Unita' strutturali"], "Aggregati strutturali": ["Aree di emergenza"], "Unita' strutturali": ["Aree di emergenza", "Edifici strategici"], } POLY_LYR = [ "Aree di emergenza", "Aggregati strutturali", "Edifici strategici", "Unita' strutturali", ] layer = self.iface.activeLayer() if layer is not None: if layer.name() in POLY_LYR: # self.dlg_wait.show() for fc in proj.mapLayers().values(): if fc.name() in POLY_LYR: layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, QgsSnappingConfig.VertexFlag, 20, QgsTolerance.ProjectUnits, ) snapping_config.setIndividualLayerSettings( fc, layer_settings) snapping_config.setIntersectionSnapping(False) for chiave, valore in DIZIO_LAYER.items(): if layer.name() == chiave: for layer_name in valore: other_layer = QgsProject.instance( ).mapLayersByName(layer_name)[0] layer_settings = QgsSnappingConfig.IndividualLayerSettings( True, QgsSnappingConfig.VertexFlag, 20, QgsTolerance.ProjectUnits, ) snapping_config.setIndividualLayerSettings( layer, layer_settings) snapping_config.setIndividualLayerSettings( other_layer, layer_settings) snapping_config.setIntersectionSnapping(True) layer.startEditing() self.iface.actionAddFeature().trigger() # self.dlg_wait.hide() else: layer.startEditing() self.iface.actionAddFeature().trigger()
class TOMsNodeTool(MapToolMixin, RestrictionTypeUtilsMixin, NodeTool): def __init__(self, iface, proposalsManager, restrictionTransaction): #def __init__(self, iface, proposalsManager, restrictionTransaction, currFeature, currLayer): QgsMessageLog.logMessage("In TOMsNodeTool:initialising .... ", tag="TOMs panel") self.iface = iface canvas = self.iface.mapCanvas() cadDock = self.iface.cadDockWidget() NodeTool.__init__(self, canvas, cadDock) # set current layer to active layer to avoid any issues in NodeTools cadCanvasReleaseEvent #canvas.setCurrentLayer(self.iface.activeLayer()) self.proposalsManager = proposalsManager self.restrictionTransaction = restrictionTransaction #self.constants = TOMsConstants() #self.origFeature = self.originalFeature() # taken from mapTools.CreateRestrictionTool (not sure if they will make a difference ...) # self.setMode(TOMsNodeTool.CaptureLine) self.snappingConfig = QgsSnappingConfig() self.snappingConfig.setMode(QgsSnappingConfig.AdvancedConfiguration) #RoadCasementLayer = QgsProject.instance().mapLayersByName("rc_nsg_sideofstreet")[0] # get details of the selected feature self.selectedRestriction = self.iface.activeLayer().selectedFeatures()[0] QgsMessageLog.logMessage("In TOMsNodeTool:initialising ... saving original feature + " + self.selectedRestriction.attribute("GeometryID"), tag="TOMs panel") # Create a copy of the feature self.origFeature = originalFeature() self.origFeature.setFeature(self.selectedRestriction) self.origLayer = self.iface.activeLayer() QgsMessageLog.logMessage("In TOMsNodeTool:initialising ... original layer + " + self.origLayer.name(), tag="TOMs panel") #self.origLayer.startEditing() self.origFeature.printFeature() self.origLayer.geometryChanged.connect(self.on_cached_geometry_changed) self.origLayer.featureDeleted.connect(self.on_cached_geometry_deleted) #*** New #RestInProp = self.constants.RESTRICTIONS_IN_PROPOSALS_LAYER() #QgsMessageLog.logMessage("In init: RestInProp: " + str(RestInProp.name()), tag="TOMs panel") #RestInProp.editCommandEnded.connect(self.proposalsManager.updateMapCanvas()) advancedDigitizingPanel = iface.mainWindow().findChild(QDockWidget, 'AdvancedDigitizingTools') advancedDigitizingPanel.setVisible(True) self.setupPanelTabs(self.iface, advancedDigitizingPanel) self.setAdvancedDigitizingAllowed(True) self. setAutoSnapEnabled(True) #QgsMapToolAdvancedDigitizing.deactivate(self) #QgsMapToolAdvancedDigitizing.activate(self) #self.newFeature = None self.finishEdit = False self.iface.mapCanvas().mapToolSet.connect(self.setUnCheck) self.proposalsManager.TOMsToolChanged.connect(functools.partial(self.onGeometryChanged, self.origFeature.getFeature())) # get details of the selected feature #self.selectedRestriction = self.iface.activeLayer().selectedFeatures()[0] #QgsMessageLog.logMessage("In TOMsNodeTool:initialising ... saving original feature + " + self.selectedRestriction.attribute("GeometryID"), tag="TOMs panel") #self.origFeature.setFeature(self.selectedRestriction) #self.currFeature = currFeature #self.currLayer = currLayer #self.origLayer = self.iface.activeLayer() #self.origLayer.startEditing() #self.origFeature.printFeature() #cache = self.cached_geometry(self.currLayer, self.currFeature.id()) #newFeature = self.prepareRestrictionForEdit(self.selectedRestriction, self.origLayer) #QgsMessageLog.logMessage("In TOMsNodeTool:init - fid: " + str(self.newFid), tag="TOMs panel") #self.origLayer.selectByIds([self.newFid]) #self.origLayer.selectByIds([self.newFid]) def setUnCheck(self): pass def deactivate(self): QgsMessageLog.logMessage("In TOMsNodeTool:deactivate .... ", tag="TOMs panel") NodeTool.deactivate(self) def shutDownNodeTool(self): QgsMessageLog.logMessage("In TOMsNodeTool:shutDownNodeTool .... ", tag="TOMs panel") # TODO: May need to disconnect geometryChange and featureDeleted signals self.origLayer.geometryChanged.disconnect(self.on_cached_geometry_changed) self.origLayer.featureDeleted.disconnect(self.on_cached_geometry_deleted) self.proposalsManager.TOMsToolChanged.disconnect() self.set_highlighted_nodes([]) self.remove_temporary_rubber_bands() #currAction = self.iface.mapCanvas().mapTool().action() #currAction.setChecked(False) self.proposalPanel = self.iface.mainWindow().findChild(QDockWidget, 'ProposalPanelDockWidgetBase') self.setupPanelTabs(self.iface, self.proposalPanel) #self.iface.mapCanvas().unsetMapTool(self.mapTool) #NodeTool.deactivate() def onGeometryChanged(self, currRestriction): # Added by TH to deal with RestrictionsInProposals # When a geometry is changed; we need to check whether or not the feature is part of the current proposal QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. fid: " + str(currRestriction.id()) + " GeometryID: " + str(currRestriction.attribute("GeometryID")), tag="TOMs panel") # disconnect signal for geometryChanged #self.origLayer.geometryChanged.disconnect(self.on_cached_geometry_changed) #self.proposalsManager.TOMsToolChanged.disconnect() #self.currLayer = self.iface.activeLayer() QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. Layer: " + str(self.origLayer.name()), tag="TOMs panel") #currLayer.geometryChanged.disconnect(self.onGeometryChanged) #QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. geometryChange signal disconnected.", tag="TOMs panel") idxRestrictionID = self.origLayer.fields().indexFromName("RestrictionID") QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. currProposal: " + str(self.proposalsManager.currentProposal()), tag="TOMs panel") # Now obtain the changed feature (not sure which geometry) #currFeature = self.THgetFeature(fid, currLayer) #self.origFeature.printFeature() #currFeature = currRestriction newGeometry = QgsGeometry(self.feature_band.asGeometry()) QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - newGeom incoming: " + newGeometry.asWkt(), tag="TOMs panel") QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. currRestrictionID: " + str(currRestriction[idxRestrictionID]), tag="TOMs panel") if not self.restrictionInProposal(currRestriction[idxRestrictionID], self.getRestrictionLayerTableID(self.origLayer), self.proposalsManager.currentProposal()): QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - adding details to RestrictionsInProposal", tag="TOMs panel") # This one is not in the current Proposal, so now we need to: # - generate a new ID and assign it to the feature for which the geometry has changed # - switch the geometries arround so that the original feature has the original geometry and the new feature has the new geometry # - add the details to RestrictionsInProposal originalfeature = self.origFeature.getFeature() newFeature = QgsFeature(self.origLayer.fields()) newFeature.setAttributes(currRestriction.attributes()) newFeature.setGeometry(newGeometry) newRestrictionID = str(uuid.uuid4()) newFeature[idxRestrictionID] = newRestrictionID idxOpenDate = self.origLayer.fields().indexFromName("OpenDate") idxGeometryID = self.origLayer.fields().indexFromName("GeometryID") newFeature[idxOpenDate] = None newFeature[idxGeometryID] = None #currLayer.addFeature(newFeature) self.origLayer.addFeatures([newFeature]) QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - attributes: " + str(newFeature.attributes()), tag="TOMs panel") QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - newGeom: " + newFeature.geometry().asWkt(), tag="TOMs panel") originalGeomBuffer = QgsGeometry(originalfeature.geometry()) QgsMessageLog.logMessage( "In TOMsNodeTool:onGeometryChanged - originalGeom: " + originalGeomBuffer.asWkt(), tag="TOMs panel") self.origLayer.changeGeometry(currRestriction.id(), originalGeomBuffer) QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - geometries switched.", tag="TOMs panel") self.addRestrictionToProposal(currRestriction[idxRestrictionID], self.getRestrictionLayerTableID(self.origLayer), self.proposalsManager.currentProposal(), RestrictionAction.OPEN) # close the original feature QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - feature closed.", tag="TOMs panel") self.addRestrictionToProposal(newRestrictionID, self.getRestrictionLayerTableID(self.origLayer), self.proposalsManager.currentProposal(), RestrictionAction.OPEN) # open the new one QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - feature opened.", tag="TOMs panel") #self.proposalsManager.updateMapCanvas() else: # assign the changed geometry to the current feature #currRestriction.setGeometry(newGeometry) pass QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - newGeom (2): " + currRestriction.geometry().asWkt(), tag="TOMs panel") # Trying to unset map tool to force updates ... #self.iface.mapCanvas().unsetMapTool(self.iface.mapCanvas().mapTool()) #currMapTool = self.iface.mapCanvas().mapTool() #currAction = currMapTool.action() #currMapToolAction = self.iface.mapCanvas().mapTool().action().setChecked(False) # uncheck current tool self.restrictionTransaction.commitTransactionGroup(self.origLayer) #self.restrictionTransaction.deleteTransactionGroup() self.origLayer.deselect(self.origFeature.getFeature().id()) self.shutDownNodeTool() # **** New """"#currRestrictionRestrictionID = currFeature[idxRestrictionID] QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. currRestrictionID: " + str(self.currFeature[idxRestrictionID]), tag="TOMs panel") self.currFeature.setGeometry(newGeometry) QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - attributes: " + str(self.currFeature.attributes()), tag="TOMs panel") QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - newGeom: " + self.currFeature.geometry().asWkt(), tag="TOMs panel") # Trying to unset map tool to force updates ... #self.iface.mapCanvas().unsetMapTool(self.iface.mapCanvas().mapTool()) # change active layer status = self.iface.setActiveLayer(None) self.restrictionTransaction.commitTransactionGroup(self.currLayer) #self.restrictionTransaction.deleteTransactionGroup() #QTimer.singleShot(0, functools.partial(RestrictionTypeUtils.commitRestrictionChanges, origLayer)) #QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - geometry saved.", tag="TOMs panel")""" return def cadCanvasPressEvent(self, e): QgsMessageLog.logMessage("In TOMsNodeTool:cadCanvasPressEvent", tag="TOMs panel") NodeTool.cadCanvasPressEvent(self, e) QgsMessageLog.logMessage("In TOMsNodeTool:cadCanvasPressEvent: after NodeTool.cadCanvasPressEvent", tag="TOMs panel") #currLayer = self.iface.activeLayer() if e.button() == Qt.RightButton: QgsMessageLog.logMessage("In TOMsNodeTool:cadCanvasPressEvent: right button pressed", tag="TOMs panel") self.finishEdit = True if self.origLayer.isModified(): QgsMessageLog.logMessage("In TOMsNodeTool:cadCanvasPressEvent: orig layer modified", tag="TOMs panel") self.onGeometryChanged(self.selectedRestriction) #RestrictionTypeUtils.commitRestrictionChanges(self.origLayer) #self.iface.setActiveLayer(None) # returns bool pass return def cadCanvasReleaseEvent(self, e): QgsMessageLog.logMessage("In TOMsNodeTool:cadCanvasReleaseEvent", tag="TOMs panel") if self.finishEdit == True: # unset Tool ?? self.iface.mapCanvas().unsetMapTool(self.iface.mapCanvas().mapTool()) return NodeTool.cadCanvasReleaseEvent(self, e) def snap_to_editable_layer(self, e): """ Temporarily override snapping config and snap to vertices and edges of any editable vector layer, to allow selection of node for editing (if snapped to edge, it would offer creation of a new vertex there). """ QgsMessageLog.logMessage("In TOMsNodeTool:snap_to_editable_layer", tag="TOMs panel") map_point = self.toMapCoordinates(e.pos()) tol = QgsTolerance.vertexSearchRadius(self.canvas().mapSettings()) snap_type = QgsPointLocator.Type(QgsPointLocator.Vertex|QgsPointLocator.Edge) #snap_layers = [] ### TH: Amend to choose only from selected feature (and layer) """snap_layers.append(QgsSnappingUtils.LayerConfig( self.origLayer, snap_type, tol, QgsTolerance.ProjectUnits))""" """for layer in self.canvas().layers(): if not isinstance(layer, QgsVectorLayer) or not layer.isEditable(): continue snap_layers.append(QgsSnappingUtils.LayerConfig( layer, snap_type, tol, QgsTolerance.ProjectUnits))""" snap_util = self.canvas().snappingUtils() old_snap_util = snap_util snap_config = snap_util.config() #snap_util = QgsSnappingUtils() #snap_config = snap_util.config() # old_layers = snap_util.layers() # old_mode = snap_util.mode() # old_intersections = old_snap_config.intersectionSnapping() """ for layer in snap_config.individualLayerSettings().keys(): snap_config.removeLayers([layer]) """ snap_util.setCurrentLayer(self.origLayer) snap_config.setMode(QgsSnappingConfig.ActiveLayer) snap_config.setIntersectionSnapping(False) # only snap to layers #m = snap_util.snapToMap(map_point) snap_config.setTolerance(tol) snap_config.setUnits(QgsTolerance.ProjectUnits) snap_config.setType(QgsSnappingConfig.VertexAndSegment) snap_config.setEnabled(True) """snap_config.setMode(QgsSnappingConfig.AdvancedConfiguration) currLayerSnapSettings = snap_config.individualLayerSettings(self.origLayer) currLayerSnapSettings.setTolerance(tol) currLayerSnapSettings.setUnits(QgsTolerance.ProjectUnits) currLayerSnapSettings.setType(QgsSnappingConfig.VertexAndSegment) currLayerSnapSettings.setEnabled(True) snap_config.setIndividualLayerSettings(self.origLayer, currLayerSnapSettings)""" # try to stay snapped to previously used feature # so the highlight does not jump around at nodes where features are joined ### TH: Amend to choose only from selected feature (and layer) filter_last = OneFeatureFilter(self.origLayer, self.origFeature.getFeature().id()) # m = snap_util.snapToMap(map_point, filter_last) """if m_last.isValid() and m_last.distance() <= m.distance(): m = m_last""" self.origFeature.printFeature() QgsMessageLog.logMessage("In TOMsNodeTool:snap_to_editable_layer: origLayer " + self.origLayer.name(), tag="TOMs panel") """ v3 try to use some other elements of snap_config - snapToCurrentLayer - setCurrentLayer """ QgsMessageLog.logMessage("In TOMsNodeTool:snap_to_editable_layer: pos " + str(e.pos().x()) + "|" + str(e.pos().y()), tag="TOMs panel") m = snap_util.snapToCurrentLayer(e.pos(), snap_type, filter_last) """self.canvas().setSnappingUtils(snap_util) m = snap_util.snapToMap(e.pos(), filter_last)""" #snap_util.setLayers(old_layers) #snap_config.setMode(old_mode) #snap_config.setIntersectionSnapping(old_intersections) self.canvas().setSnappingUtils(old_snap_util) #self.last_snap = m # TODO: Tidy up ... QgsMessageLog.logMessage("In TOMsNodeTool:snap_to_editable_layer: snap point " + str(m.type()) +";" + str(m.isValid()) + "; ", tag="TOMs panel") return m def keyPressEvent(self, e): QgsMessageLog.logMessage("In TOMsNodeTool:keyPressEvent", tag="TOMs panel") # want to pick up "esc" and exit tool if e.key() == Qt.Key_Escape: self.iface.mapCanvas().unsetMapTool(self.iface.mapCanvas().mapTool()) self.restrictionTransaction.rollBackTransactionGroup() self.shutDownNodeTool() return NodeTool.keyPressEvent(self, e)
def configSnapper(self, type): # Snapping self.snapper = QgsMapCanvasSnappingUtils(self.iface.mapCanvas()) self.snapper.setMapSettings(self.iface.mapCanvas().mapSettings()) config = QgsSnappingConfig(QgsProject.instance()) config.setType(type) # 1: Vertex; 2:Segment config.setMode(2) # All layers config.setTolerance(10) config.setUnits(1) # Pixels config.setEnabled(True) self.snapper.setConfig(config)
def __init__(self, iface, proposalsManager, restrictionTransaction): #def __init__(self, iface, proposalsManager, restrictionTransaction, currFeature, currLayer): QgsMessageLog.logMessage("In TOMsNodeTool:initialising .... ", tag="TOMs panel") self.iface = iface canvas = self.iface.mapCanvas() cadDock = self.iface.cadDockWidget() NodeTool.__init__(self, canvas, cadDock) # set current layer to active layer to avoid any issues in NodeTools cadCanvasReleaseEvent #canvas.setCurrentLayer(self.iface.activeLayer()) self.proposalsManager = proposalsManager self.restrictionTransaction = restrictionTransaction #self.constants = TOMsConstants() #self.origFeature = self.originalFeature() # taken from mapTools.CreateRestrictionTool (not sure if they will make a difference ...) # self.setMode(TOMsNodeTool.CaptureLine) self.snappingConfig = QgsSnappingConfig() self.snappingConfig.setMode(QgsSnappingConfig.AdvancedConfiguration) #RoadCasementLayer = QgsProject.instance().mapLayersByName("rc_nsg_sideofstreet")[0] # get details of the selected feature self.selectedRestriction = self.iface.activeLayer().selectedFeatures()[0] QgsMessageLog.logMessage("In TOMsNodeTool:initialising ... saving original feature + " + self.selectedRestriction.attribute("GeometryID"), tag="TOMs panel") # Create a copy of the feature self.origFeature = originalFeature() self.origFeature.setFeature(self.selectedRestriction) self.origLayer = self.iface.activeLayer() QgsMessageLog.logMessage("In TOMsNodeTool:initialising ... original layer + " + self.origLayer.name(), tag="TOMs panel") #self.origLayer.startEditing() self.origFeature.printFeature() self.origLayer.geometryChanged.connect(self.on_cached_geometry_changed) self.origLayer.featureDeleted.connect(self.on_cached_geometry_deleted) #*** New #RestInProp = self.constants.RESTRICTIONS_IN_PROPOSALS_LAYER() #QgsMessageLog.logMessage("In init: RestInProp: " + str(RestInProp.name()), tag="TOMs panel") #RestInProp.editCommandEnded.connect(self.proposalsManager.updateMapCanvas()) advancedDigitizingPanel = iface.mainWindow().findChild(QDockWidget, 'AdvancedDigitizingTools') advancedDigitizingPanel.setVisible(True) self.setupPanelTabs(self.iface, advancedDigitizingPanel) self.setAdvancedDigitizingAllowed(True) self. setAutoSnapEnabled(True) #QgsMapToolAdvancedDigitizing.deactivate(self) #QgsMapToolAdvancedDigitizing.activate(self) #self.newFeature = None self.finishEdit = False self.iface.mapCanvas().mapToolSet.connect(self.setUnCheck) self.proposalsManager.TOMsToolChanged.connect(functools.partial(self.onGeometryChanged, self.origFeature.getFeature()))
def test_resetSnappingIndex(self): self.pointsLayer.setDependencies([]) self.linesLayer.setDependencies([]) self.pointsLayer2.setDependencies([]) ms = QgsMapSettings() ms.setOutputSize(QSize(100, 100)) ms.setExtent(QgsRectangle(0, 0, 1, 1)) self.assertTrue(ms.hasValidSettings()) u = QgsSnappingUtils() u.setMapSettings(ms) cfg = u.config() cfg.setEnabled(True) cfg.setMode(QgsSnappingConfig.AdvancedConfiguration) cfg.setIndividualLayerSettings(self.pointsLayer, QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels)) u.setConfig(cfg) m = u.snapToMap(QPoint(95, 100)) self.assertTrue(m.isValid()) self.assertTrue(m.hasVertex()) self.assertEqual(m.point(), QgsPointXY(1, 0)) f = QgsFeature(self.linesLayer.fields()) f.setId(1) geom = QgsGeometry.fromWkt("LINESTRING(0 0,1 1)") f.setGeometry(geom) self.linesLayer.startEditing() self.linesLayer.addFeatures([f]) self.linesLayer.commitChanges() l1 = len([f for f in self.pointsLayer.getFeatures()]) self.assertEqual(l1, 4) m = u.snapToMap(QPoint(95, 0)) # snapping not updated self.pointsLayer.setDependencies([]) self.assertEqual(m.isValid(), False) # set layer dependencies self.pointsLayer.setDependencies([QgsMapLayerDependency(self.linesLayer.id())]) # add another line f = QgsFeature(self.linesLayer.fields()) f.setId(2) geom = QgsGeometry.fromWkt("LINESTRING(0 0,0.5 0.5)") f.setGeometry(geom) self.linesLayer.startEditing() self.linesLayer.addFeatures([f]) self.linesLayer.commitChanges() # check the snapped point is OK m = u.snapToMap(QPoint(45, 50)) self.assertTrue(m.isValid()) self.assertTrue(m.hasVertex()) self.assertEqual(m.point(), QgsPointXY(0.5, 0.5)) self.pointsLayer.setDependencies([]) # test chained layer dependencies A -> B -> C cfg.setIndividualLayerSettings(self.pointsLayer2, QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels)) u.setConfig(cfg) self.pointsLayer.setDependencies([QgsMapLayerDependency(self.linesLayer.id())]) self.pointsLayer2.setDependencies([QgsMapLayerDependency(self.pointsLayer.id())]) # add another line f = QgsFeature(self.linesLayer.fields()) f.setId(3) geom = QgsGeometry.fromWkt("LINESTRING(0 0.2,0.5 0.8)") f.setGeometry(geom) self.linesLayer.startEditing() self.linesLayer.addFeatures([f]) self.linesLayer.commitChanges() # check the second snapped point is OK m = u.snapToMap(QPoint(75, 100 - 80)) self.assertTrue(m.isValid()) self.assertTrue(m.hasVertex()) self.assertEqual(m.point(), QgsPointXY(0.7, 0.8)) self.pointsLayer.setDependencies([]) self.pointsLayer2.setDependencies([])
def run(id, gtotool, config, debug): try: #common tool objects iface = gtotool.iface info = gtotool.info gtomain = gtotool.gtomain #tool data activelayer = config.get('active_layer', None) active_tool = config['active_tool'] snapmode = config['snap_mode'] topologicalediting = config['topologicalediting'] snapping_on_intersection = config['snapping_on_intersection'] #default snappings default_snap_type = config['default_snap_type'] default_snap_tolerance = config['default_snap_tolerance'] default_snap_tolerance_unit = config['default_snap_tolerance_unit'] #layers for advanced setting layers = config['layers'] # needed objects prj = QgsProject.instance() snapconfig = QgsSnappingConfig(prj) avoidIntersectLayers = [] if snapmode == 0: snapconfig.setEnabled(False) else: # set default snapping snapconfig.setMode(snapmode) snapconfig.setIntersectionSnapping(snapping_on_intersection) snapconfig.setType(default_snap_type) snapconfig.setUnits(default_snap_tolerance_unit) snapconfig.setTolerance(default_snap_tolerance) if snapmode == QgsSnappingConfig.AdvancedConfiguration: #disable snapping for all layers for maplayername, layer in prj.mapLayers().items(): if isinstance(layer, QgsVectorLayer): snaplayer = snapconfig.individualLayerSettings(layer) if layer.name() in layers: snaplayer.setEnabled(True) else: snaplayer.setEnabled(False) snapconfig.setIndividualLayerSettings(layer, snaplayer) #set settings for layers for setting in layers: if debug: info.log("settings:", setting) maplayer = prj.mapLayersByName(setting['name'])[0] snaplayer = snapconfig.individualLayerSettings(maplayer) snaplayer.setEnabled( setting.get('snap', snaplayer.enabled())) snaplayer.setUnits(setting.get('units', snaplayer.units())) snaplayer.setTolerance( setting.get('tolerance', snaplayer.tolerance())) snaplayer.setType( setting.get('mode', setting.get('snap_type', snaplayer.type()))) snapconfig.setIndividualLayerSettings(maplayer, snaplayer) if setting.get('avoidintersection', True): avoidIntersectLayers.append(maplayer) prj.avoidIntersectionsLayers = avoidIntersectLayers #enable the settings (snapping) snapconfig.setEnabled(True) #set topology editing for project prj.setTopologicalEditing(topologicalediting) #set snappingconfig to project prj.setSnappingConfig(snapconfig) except IndexError as e: info.err(e) try: #set activelayer activelayer = prj.mapLayersByName(activelayer) if activelayer: activelayer = activelayer[0] if isinstance(activelayer, QgsVectorLayer): iface.setActiveLayer(activelayer) except IndexError as e: info.err(e) try: #start editing layer = iface.activeLayer() if not layer.isEditable(): layer.startEditing() # run active tool if active_tool: gtomain.runcmd(active_tool) except IndexError as e: info.err(e)