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)
