def testLoadLayerWithPreprocessor(self): """ Test that custom path preprocessor is used when loading layers """ lines_shp_path = os.path.join(TEST_DATA_DIR, 'moooooo.shp') lines_layer = QgsVectorLayer(lines_shp_path, 'Lines', 'ogr') self.assertFalse(lines_layer.isValid()) p = QgsProject() p.addMapLayer(lines_layer) # save project to a temporary file temp_path = tempfile.mkdtemp() temp_project_path = os.path.join(temp_path, 'temp.qgs') self.assertTrue(p.write(temp_project_path)) p2 = QgsProject() self.assertTrue(p2.read(temp_project_path)) l = p2.mapLayersByName('Lines')[0] self.assertEqual(l.name(), 'Lines') self.assertFalse(l.isValid()) # custom processor to fix path def my_processor(path): return path.replace('moooooo', 'lines') QgsPathResolver.setPathPreprocessor(my_processor) p3 = QgsProject() self.assertTrue(p3.read(temp_project_path)) l = p3.mapLayersByName('Lines')[0] self.assertEqual(l.name(), 'Lines') # layer should have correct path now self.assertTrue(l.isValid())
def test_save_restore(self): """ Test saving/restoring a project with a group layer """ p = QgsProject() layer1 = QgsVectorLayer('Point?crs=epsg:3111', 'L1', 'memory') layer2 = QgsVectorLayer('Point?crs=epsg:4326', 'L2', 'memory') layer3 = QgsVectorLayer('Point?crs=epsg:3111', 'L3', 'memory') p.addMapLayer(layer1) p.addMapLayer(layer2) p.addMapLayer(layer3) options = QgsGroupLayer.LayerOptions(QgsCoordinateTransformContext()) group_layer1 = QgsGroupLayer('group 1', options) group_layer1.setChildLayers([layer1, layer2, layer3]) group_layer2 = QgsGroupLayer('group 2', options) group_layer2.setChildLayers([layer3, layer1]) drop_shadow = QgsDropShadowEffect() group_layer2.setPaintEffect(drop_shadow) p.addMapLayer(group_layer1, False) p.addMapLayer(group_layer2, False) with TemporaryDirectory() as d: path = os.path.join(d, 'group_layers.qgs') p.setFileName(path) p.write() p2 = QgsProject() p2.read(path) restored_layer1 = p2.mapLayersByName('L1')[0] restored_layer2 = p2.mapLayersByName('L2')[0] restored_layer3 = p2.mapLayersByName('L3')[0] restored_group_1 = p2.mapLayersByName('group 1')[0] restored_group_2 = p2.mapLayersByName('group 2')[0] self.assertEqual( restored_group_1.childLayers(), [restored_layer1, restored_layer2, restored_layer3]) self.assertEqual(restored_group_2.childLayers(), [restored_layer3, restored_layer1]) self.assertIsInstance(restored_group_2.paintEffect(), QgsDropShadowEffect)
def render_layer(): projectpath = Path('./data/france_parts.qgs') prj = QgsProject() prj.read(str(projectpath.absolute())) layers = layers = prj.mapLayersByName('france_parts') xt = layers[0].extent() width = 1200 height = int(width * xt.height() / xt.width()) options = QgsMapSettings() options.setLayers(layers) options.setBackgroundColor(QColor(255, 255, 255)) options.setOutputSize(QSize(width, height)) options.setExtent(xt) render = QgsMapRendererParallelJob(options) render.start() render.waitForFinished() image = render.renderedImage() return image
def testPathWriter(self): readerId = QgsPathResolver.setPathPreprocessor(self.__test_path_reader) writerId = QgsPathResolver.setPathWriter(self.__test__path_writer) lines_shp_path = os.path.join(TEST_DATA_DIR, 'lines.shp') lines_layer = QgsVectorLayer(lines_shp_path, 'Lines', 'ogr') self.assertTrue(lines_layer.isValid()) p = QgsProject() p.addMapLayer(lines_layer) # save project to a temporary file temp_path = tempfile.mkdtemp() temp_project_path = os.path.join(temp_path, 'temp.qgs') self.assertTrue(p.write(temp_project_path)) with open(temp_project_path) as f: self.assertTrue("@TEST_DATA_DIR@" in f.read()) p2 = QgsProject() self.assertTrue(p2.read(temp_project_path)) l = p2.mapLayersByName('Lines')[0] self.assertEqual(l.isValid(), True) self.assertEqual(l.source(), lines_shp_path) QgsPathResolver.removePathPreprocessor(readerId) QgsPathResolver.removePathWriter(writerId)
def get_ressources(self, params: Dict[str, str], project: QgsProject) -> CadastreResources: """ Find layer and feature corresponding to given parameters """ def get_param(name: str, allowed_values: Sequence[str] = None) -> str: v = params.get(name) if not v: raise CadastreError(400, "Missing parameter '%s'" % name) v = v if allowed_values and v not in allowed_values: raise CadastreError(400, "Invalid or missing value for '%s'" % name) return v # Get layer and expression player = get_param('LAYER') pparcelle = get_param('PARCELLE') ptype = get_param('TYPE', ('parcelle', 'proprietaire', 'fiche')) # Get feature if not PARCELLE_FORMAT_RE.match(pparcelle): raise CadastreError(400, "Invalid PARCELLE format: %s" % pparcelle) # Find layer layer = None lr = project.mapLayersByName(player) if len(lr) > 0: layer = lr[0] else: raise CadastreError(404, "Layer '%s' not found" % player) req = QgsFeatureRequest() req.setFilterExpression(' "geo_parcelle" = \'%s\' ' % pparcelle) it = layer.getFeatures(req) feat = QgsFeature() if not it.nextFeature(feat): raise CadastreError( 404, "Feature not found for parcelle '%s' in layer '%s'" % (pparcelle, player)) # Get layer connection parameters connectionParams = cadastre_common.getConnectionParameterFromDbLayer( layer) connector = cadastre_common.getConnectorFromUri(connectionParams) return CadastreResources(geo_parcelle=pparcelle, feature=feat, type=ptype, layer=layer, layername=player, connector=connector, connectionParams=connectionParams)
def test_localizedCategories(self): # Default locale for tests is EN original_locale = QLocale() locale = QLocale(QLocale.English) locale.setNumberOptions(QLocale.DefaultNumberOptions) QLocale().setDefault(locale) layer = QgsVectorLayer( "Point?field=flddbl:double&field=fldint:integer", "addfeat", "memory") result = QgsCategorizedSymbolRenderer.createCategories( [1234.5, 2345.6, 3456.7], QgsMarkerSymbol(), layer, 'flddouble') self.assertEqual(result[0].label(), '1,234.5') self.assertEqual(result[1].label(), '2,345.6') self.assertEqual(result[2].label(), '3,456.7') # Test a non-dot locale QLocale().setDefault(QLocale(QLocale.Italian)) result = QgsCategorizedSymbolRenderer.createCategories( [[1234.5, 6789.1], 2345.6, 3456.7], QgsMarkerSymbol(), layer, 'flddouble') self.assertEqual(result[0].label(), '1.234,5;6.789,1') self.assertEqual(result[1].label(), '2.345,6') self.assertEqual(result[2].label(), '3.456,7') # Test round trip temp_dir = QTemporaryDir() temp_file = os.path.join(temp_dir.path(), 'project.qgs') project = QgsProject() layer.setRenderer(QgsCategorizedSymbolRenderer('Class', result)) project.addMapLayers([layer]) project.write(temp_file) QLocale().setDefault(original_locale) project = QgsProject() project.read(temp_file) results = project.mapLayersByName('addfeat')[0].renderer().categories() self.assertEqual(result[0].label(), '1.234,5;6.789,1') self.assertEqual(result[1].label(), '2.345,6') self.assertEqual(result[2].label(), '3.456,7') self.assertEqual(result[0].value(), [1234.5, 6789.1]) self.assertEqual(result[1].value(), 2345.6) self.assertEqual(result[2].value(), 3456.7)
def get_ressources(self, params: Dict[str,str], project: QgsProject) -> CadastreResources: """ Find layer and feature corresponding to given parameters """ def get_param(name: str, allowed_values: Sequence[str]=None) -> str: v = params.get(name) if not v: raise CadastreError(400,"Missing parameter '%s'" % name) v = v if allowed_values and not v in allowed_values: raise CadastreError(400,"Invalid or missing value for '%s'" % name) return v # Get layer and expression player = get_param('LAYER') pparcelle = get_param('PARCELLE') ptype = get_param('TYPE',('parcelle', 'proprietaire', 'fiche')) # Get feature if not PARCELLE_FORMAT_RE.match(pparcelle): raise CadastreError(400, "Invalid PARCELLE format: %s" % pparcelle) # Find layer layer = None lr = project.mapLayersByName(player) if len(lr) > 0: layer = lr[0] else: raise CadastreError(404,"Layer '%s' not found" % player) req = QgsFeatureRequest() req.setFilterExpression(' "geo_parcelle" = \'%s\' ' % pparcelle) it = layer.getFeatures(req) feat = QgsFeature() if not it.nextFeature(feat): raise CadastreError(404,"Feature not found for parcelle '%s' in layer '%s'" % (pparcelle,player)) # Get layer connection parameters connectionParams = cadastre_common.getConnectionParameterFromDbLayer(layer) connector = cadastre_common.getConnectorFromUri( connectionParams ) return CadastreResources(geo_parcelle = pparcelle, feature = feat, type = ptype, layer = layer, layername = player, connector = connector, connectionParams = connectionParams)
def test_write(self): self._init_dimensions() with tempfile.TemporaryDirectory() as tmpdirname: path = os.path.join(tmpdirname, 'project.qgs') QgsProject.instance().setFileName(path) QgsProject.instance().write() project = QgsProject() project.read(path) layer1_saved = project.mapLayersByName('layer1')[0] layer2_saved = project.mapLayersByName('layer2')[0] self.assertEqual('', layer1_saved.subsetString()) self.assertEqual('"row" = \'1\'', layer2_saved.subsetString()) self.assertFalse(os.path.exists(path)) self._assert_initial_dimensions_state()
def test_mapLayersByName(self): """ test retrieving map layer by name """ p = QgsProject() # test no crash with empty registry self.assertEqual(p.mapLayersByName('bad'), []) self.assertEqual(p.mapLayersByName(None), []) l1 = createLayer('test') l2 = createLayer('test2') p.addMapLayers([l1, l2]) self.assertEqual(p.mapLayersByName('bad'), []) self.assertEqual(p.mapLayersByName(None), []) self.assertEqual(p.mapLayersByName('test'), [l1]) self.assertEqual(p.mapLayersByName('test2'), [l2]) #duplicate name l3 = createLayer('test') p.addMapLayer(l3) self.assertEqual(set(p.mapLayersByName('test')), set([l1, l3]))
def test_mapLayersByName(self): """ test retrieving map layer by name """ p = QgsProject() # test no crash with empty registry self.assertEqual(p.mapLayersByName('bad'), []) self.assertEqual(p.mapLayersByName(None), []) l1 = createLayer('test') l2 = createLayer('test2') p.addMapLayers([l1, l2]) self.assertEqual(p.mapLayersByName('bad'), []) self.assertEqual(p.mapLayersByName(None), []) self.assertEqual(p.mapLayersByName('test'), [l1]) self.assertEqual(p.mapLayersByName('test2'), [l2]) #duplicate name l3 = createLayer('test') p.addMapLayer(l3) self.assertEqual(set(p.mapLayersByName('test')), set([l1, l3]))
QgsApplication.setPrefixPath(qgisPrefixPath, True) qgs = QgsApplication([], True) QgsApplication.initQgis() # Open the project p = QgsProject() p.read(project_path) canvas = QgsMapCanvas() bridge = QgsLayerTreeMapCanvasBridge( p.layerTreeRoot(), canvas ) bridge.setCanvasLayers() # Get the layers in the project layerList = p.mapLayersByName(parcelle_layer) if not layerList: layers = p.mapLayers() for lname,layer in layers.items(): print(lname+' '+layer.name()+' '+parcelle_layer) layerList = [ layer for lname,layer in layers.items() if layer.name() == parcelle_layer ] layer = layerList[0] # Get Feature req = QgsFeatureRequest() req.setFilterExpression(' "geo_parcelle" = \'%s\' ' % parcelle_id) it = layer.getFeatures(req) feat = None for f in it: feat = f break
def testStyles(self): """Test that styles for rasters and vectors are kept when setDataSource is called""" options = QgsDataProvider.ProviderOptions() temp_dir = QTemporaryDir() p = QgsProject.instance() for f in ( 'bad_layer_raster_test.tfw', 'bad_layer_raster_test.tiff', 'bad_layer_raster_test.tiff.aux.xml', 'bad_layers_test.gpkg', 'good_layers_test.qgs'): copyfile(os.path.join(TEST_DATA_DIR, 'projects', f), os.path.join(temp_dir.path(), f)) project_path = os.path.join(temp_dir.path(), 'good_layers_test.qgs') p = QgsProject().instance() self.assertTrue(p.read(project_path)) self.assertEqual(p.count(), 3) ms = self.getBaseMapSettings() point_a = list(p.mapLayersByName('point_a'))[0] point_b = list(p.mapLayersByName('point_b'))[0] raster = list(p.mapLayersByName('bad_layer_raster_test'))[0] self.assertTrue(point_a.isValid()) self.assertTrue(point_b.isValid()) self.assertTrue(raster.isValid()) ms.setExtent(QgsRectangle(2.81861, 41.98138, 2.81952, 41.9816)) ms.setLayers([point_a, point_b, raster]) image = renderMapToImage(ms) print(os.path.join(temp_dir.path(), 'expected.png')) self.assertTrue(image.save(os.path.join(temp_dir.path(), 'expected.png'), 'PNG')) point_a_source = point_a.publicSource() point_b_source = point_b.publicSource() raster_source = raster.publicSource() point_a.setDataSource(point_a_source, point_a.name(), 'ogr', options) point_b.setDataSource(point_b_source, point_b.name(), 'ogr', options) raster.setDataSource(raster_source, raster.name(), 'gdal', options) self.assertTrue(image.save(os.path.join(temp_dir.path(), 'actual.png'), 'PNG')) self.assertTrue(filecmp.cmp(os.path.join(temp_dir.path(), 'actual.png'), os.path.join(temp_dir.path(), 'expected.png')), False) # Now build a bad project bad_project_path = os.path.join(temp_dir.path(), 'bad_layers_test.qgs') with open(project_path, 'r') as infile: with open(bad_project_path, 'w+') as outfile: outfile.write(infile.read().replace('./bad_layers_test.', './bad_layers_test-BAD_SOURCE.').replace('bad_layer_raster_test.tiff', 'bad_layer_raster_test-BAD_SOURCE.tiff')) self.assertTrue(p.read(bad_project_path)) self.assertEqual(p.count(), 3) point_a = list(p.mapLayersByName('point_a'))[0] point_b = list(p.mapLayersByName('point_b'))[0] raster = list(p.mapLayersByName('bad_layer_raster_test'))[0] self.assertFalse(point_a.isValid()) self.assertFalse(point_b.isValid()) self.assertFalse(raster.isValid()) point_a.setDataSource(point_a_source, point_a.name(), 'ogr', options) point_b.setDataSource(point_b_source, point_b.name(), 'ogr', options) raster.setDataSource(raster_source, raster.name(), 'gdal', options) self.assertTrue(image.save(os.path.join(temp_dir.path(), 'actual_fixed.png'), 'PNG')) self.assertTrue(filecmp.cmp(os.path.join(temp_dir.path(), 'actual_fixed.png'), os.path.join(temp_dir.path(), 'expected.png')), False)
def testStyles(self): """Test that styles for rasters and vectors are kept when setDataSource is called""" temp_dir = QTemporaryDir() p = QgsProject.instance() for f in ('bad_layer_raster_test.tfw', 'bad_layer_raster_test.tiff', 'bad_layer_raster_test.tiff.aux.xml', 'bad_layers_test.gpkg', 'good_layers_test.qgs'): copyfile(os.path.join(TEST_DATA_DIR, 'projects', f), os.path.join(temp_dir.path(), f)) project_path = os.path.join(temp_dir.path(), 'good_layers_test.qgs') p = QgsProject().instance() p.removeAllMapLayers() self.assertTrue(p.read(project_path)) self.assertEqual(p.count(), 4) ms = self.getBaseMapSettings() point_a_copy = list(p.mapLayersByName('point_a copy'))[0] point_a = list(p.mapLayersByName('point_a'))[0] point_b = list(p.mapLayersByName('point_b'))[0] raster = list(p.mapLayersByName('bad_layer_raster_test'))[0] self.assertTrue(point_a_copy.isValid()) self.assertTrue(point_a.isValid()) self.assertTrue(point_b.isValid()) self.assertTrue(raster.isValid()) ms.setExtent(QgsRectangle(2.81861, 41.98138, 2.81952, 41.9816)) ms.setLayers([point_a_copy, point_a, point_b, raster]) image = renderMapToImage(ms) self.assertTrue( image.save(os.path.join(temp_dir.path(), 'expected.png'), 'PNG')) point_a_source = point_a.publicSource() point_b_source = point_b.publicSource() raster_source = raster.publicSource() self._change_data_source(point_a, point_a_source, 'ogr') # Attention: we are not passing the subset string here: self._change_data_source(point_a_copy, point_a_source, 'ogr') self._change_data_source(point_b, point_b_source, 'ogr') self._change_data_source(raster, raster_source, 'gdal') self.assertTrue( image.save(os.path.join(temp_dir.path(), 'actual.png'), 'PNG')) self.assertTrue( filecmp.cmp(os.path.join(temp_dir.path(), 'actual.png'), os.path.join(temp_dir.path(), 'expected.png')), False) # Now build a bad project p.removeAllMapLayers() bad_project_path = os.path.join(temp_dir.path(), 'bad_layers_test.qgs') with open(project_path, 'r') as infile: with open(bad_project_path, 'w+') as outfile: outfile.write(infile.read().replace( './bad_layers_test.', './bad_layers_test-BAD_SOURCE.').replace( 'bad_layer_raster_test.tiff', 'bad_layer_raster_test-BAD_SOURCE.tiff')) p.removeAllMapLayers() self.assertTrue(p.read(bad_project_path)) self.assertEqual(p.count(), 4) point_a_copy = list(p.mapLayersByName('point_a copy'))[0] point_a = list(p.mapLayersByName('point_a'))[0] point_b = list(p.mapLayersByName('point_b'))[0] raster = list(p.mapLayersByName('bad_layer_raster_test'))[0] self.assertFalse(point_a.isValid()) self.assertFalse(point_a_copy.isValid()) self.assertFalse(point_b.isValid()) self.assertFalse(raster.isValid()) ms.setLayers([point_a_copy, point_a, point_b, raster]) image = renderMapToImage(ms) self.assertTrue( image.save(os.path.join(temp_dir.path(), 'bad.png'), 'PNG')) self.assertFalse( filecmp.cmp(os.path.join(temp_dir.path(), 'bad.png'), os.path.join(temp_dir.path(), 'expected.png')), False) self._change_data_source(point_a, point_a_source, 'ogr') # We are not passing the subset string!! self._change_data_source(point_a_copy, point_a_source, 'ogr') self._change_data_source(point_b, point_b_source, 'ogr') self._change_data_source(raster, raster_source, 'gdal') self.assertTrue(point_a.isValid()) self.assertTrue(point_a_copy.isValid()) self.assertTrue(point_b.isValid()) self.assertTrue(raster.isValid()) ms.setLayers([point_a_copy, point_a, point_b, raster]) image = renderMapToImage(ms) self.assertTrue( image.save(os.path.join(temp_dir.path(), 'actual_fixed.png'), 'PNG')) self.assertTrue( filecmp.cmp(os.path.join(temp_dir.path(), 'actual_fixed.png'), os.path.join(temp_dir.path(), 'expected.png')), False)
QgsApplication.setPrefixPath(qgisPrefixPath, True) qgs = QgsApplication([], True) QgsApplication.initQgis() # Open the project p = QgsProject() p.read(project_path) canvas = QgsMapCanvas() bridge = QgsLayerTreeMapCanvasBridge( p.layerTreeRoot(), canvas ) bridge.setCanvasLayers() # Get the layers in the project layerList = p.mapLayersByName(parcelle_layer) if not layerList: layers = p.mapLayers() for lname, layer in layers.items(): print(lname + ' ' + layer.name() + ' ' + parcelle_layer) layerList = [layer for lname, layer in layers.items() if layer.name() == parcelle_layer] layer = layerList[0] # Get Feature req = QgsFeatureRequest() req.setFilterExpression(' "geo_parcelle" = \'%s\' ' % parcelle_id) it = layer.getFeatures(req) feat = None for f in it: feat = f break
class Hoofdscherm(QMainWindow): def __init__(self): QMainWindow.__init__(self) self.setupGui() self.project = QgsProject() urlWithParams = 'type=xyz&url=http://a.tile.openstreetmap.org/%7Bz%7D/%7Bx%7D/%7By%7D.png&zmax=19&zmin=0&crs=EPSG3857' rlaag = QgsRasterLayer(urlWithParams, 'OpenStreetMap', 'wms') if rlaag.isValid(): self.project.addMapLayer(rlaag) else: print('invalid layer') path_to_gpkg = os.path.join(QgsProject.instance().homePath(), "GIS_Data_3857.gpkg") vlayerNamesList = ['Landsgrens', 'Gemeentegrenzen', 'Provinciegrenzen'] lagen = [] for layer in vlayerNamesList: gpkg_layer = path_to_gpkg + "|layername=" + layer vlaag = QgsVectorLayer(gpkg_layer, layer, "ogr") if not vlaag.isValid(): print("Layer failed to load!") else: self.project.addMapLayer(vlaag) lagen.append(vlaag) self.map_canvas.setLayers(lagen + [rlaag]) extent = lagen[0].extent() self.map_canvas.setExtent(extent) def setupGui(self): frame = QFrame(self) frame.setMinimumSize(1400, 800) self.setCentralWidget(frame) self.grid_layout = QGridLayout(frame) self.map_canvas = QgsMapCanvas() self.grid_layout.addWidget(self.map_canvas) # Setup action for zoom in tool self.osm_action = QAction(QIcon(":/osm/osm_data"), "Zoom In", self) # Setup action for pan tool self.pan_action = QAction(QIcon(":/osm/pan"), "Pan", self) # Setup action for ZoomIn tool self.zoomIn_action = QAction(QIcon(":/osm/ZoomIn"), "Zoom in", self) # Setup action for ZoomOut tool self.zoomOut_action = QAction(QIcon(":/osm/ZoomOut"), "Zoom out", self) # create toolbar self.toolbar = self.addToolBar("Map Tools") self.toolbar.addAction(self.osm_action) self.toolbar.addAction(self.pan_action) self.toolbar.addAction(self.zoomIn_action) self.toolbar.addAction(self.zoomOut_action) self.osm_action.triggered.connect(self.osm_tool) self.pan_action.triggered.connect(self.pan_tool) self.zoomIn_action.triggered.connect(self.zoomIn_tool) self.zoomOut_action.triggered.connect(self.zoomOut_tool) def krijg_provincienaam(self, point, mouse_button): layer = self.project.mapLayersByName('Provinciegrenzen')[0] feats = [feat for feat in layer.getFeatures()] geo_pt = QgsGeometry.fromPointXY(QgsPointXY(point.x(), point.y())) id = -1 for feat in feats: if geo_pt.within(feat.geometry()): id = feat.id() provincie = feat.attribute('Provincienaam') break if id != -1: self.Pop_Up = QDialog() self.nd = Ui_Pop_Up(self, provincie) self.nd.setupUi(self.Pop_Up) self.Pop_Up.show() else: print("Geen provincie aangeklikt.") def osm_tool(self): self.tool_osm = QgsMapToolEmitPoint(self.map_canvas) self.tool_osm.canvasClicked.connect(self.krijg_provincienaam) self.map_canvas.setMapTool(self.tool_osm) def pan_tool(self): self.tool_pan = QgsMapToolPan(self.map_canvas) self.map_canvas.setMapTool(self.tool_pan) def zoomIn_tool(self): self.tool_zoomin = QgsMapToolZoom(self.map_canvas, False) self.map_canvas.setMapTool(self.tool_zoomin) def zoomOut_tool(self): self.tool_zoomout = QgsMapToolZoom(self.map_canvas, True) self.map_canvas.setMapTool(self.tool_zoomout)
def create(self, path: str, qgis_project: QgsProject): qgis_project.setAutoTransaction(self.auto_transaction) qgis_project.setEvaluateDefaultValues(self.evaluate_default_values) qgis_layers = list() for layer in self.layers: qgis_layer = layer.create() self.layer_added.emit(qgis_layer.id()) if not self.crs and qgis_layer.isSpatial(): self.crs = qgis_layer.crs() qgis_layers.append(qgis_layer) qgis_project.addMapLayers(qgis_layers, not self.legend) if self.crs: if isinstance(self.crs, QgsCoordinateReferenceSystem): qgis_project.setCrs(self.crs) else: crs = QgsCoordinateReferenceSystem.fromEpsgId(self.crs) if not crs.isValid(): crs = QgsCoordinateReferenceSystem(self.crs) # Fallback qgis_project.setCrs(crs) qgis_relations = list( qgis_project.relationManager().relations().values()) dict_layers = {layer.layer.id(): layer for layer in self.layers} for relation in self.relations: rel = relation.create(qgis_project, qgis_relations) assert rel.isValid() qgis_relations.append(rel) referenced_layer = dict_layers.get(rel.referencedLayerId(), None) referencing_layer = dict_layers.get(rel.referencingLayerId(), None) if referenced_layer and referenced_layer.is_domain: editor_widget_setup = QgsEditorWidgetSetup( "RelationReference", { "Relation": rel.id(), "ShowForm": False, "OrderByValue": True, "ShowOpenFormButton": False, "AllowNULL": True, "FilterExpression": "\"{}\" = '{}'".format(ENUM_THIS_CLASS_COLUMN, relation.child_domain_name) if relation.child_domain_name else "", "FilterFields": list(), }, ) elif referenced_layer and referenced_layer.is_basket_table: editor_widget_setup = QgsEditorWidgetSetup( "RelationReference", { "Relation": rel.id(), "ShowForm": False, "OrderByValue": True, "ShowOpenFormButton": False, "AllowNULL": True, "AllowAddFeatures": False, "FilterExpression": "\"topic\" = '{}' and attribute(get_feature('{}', 't_id', \"dataset\"), 'datasetname') != '{}'" .format( referencing_layer.model_topic_name, "T_ILI2DB_DATASET" if referenced_layer.provider == "ogr" else "t_ili2db_dataset", CATALOGUE_DATASETNAME, ) if referencing_layer.model_topic_name else "", "FilterFields": list(), }, ) else: editor_widget_setup = QgsEditorWidgetSetup( "RelationReference", { "Relation": rel.id(), "ShowForm": False, "OrderByValue": True, "ShowOpenFormButton": False, "AllowAddFeatures": True, "AllowNULL": True, }, ) referencing_layer = rel.referencingLayer() referencing_layer.setEditorWidgetSetup(rel.referencingFields()[0], editor_widget_setup) qgis_project.relationManager().setRelations(qgis_relations) # Set Bag of Enum widget for layer_name, bag_of_enum in self.bags_of_enum.items(): for attribute, bag_of_enum_info in bag_of_enum.items(): layer_obj = bag_of_enum_info[0] cardinality = bag_of_enum_info[1] domain_table = bag_of_enum_info[2] key_field = bag_of_enum_info[3] value_field = bag_of_enum_info[4] minimal_selection = cardinality.startswith("1") current_layer = layer_obj.create() field_widget = "ValueRelation" field_widget_config = { "AllowMulti": True, "UseCompleter": False, "Value": value_field, "OrderByValue": False, "AllowNull": True, "Layer": domain_table.create().id(), "FilterExpression": "", "Key": key_field, "NofColumns": 1, } field_idx = current_layer.fields().indexOf(attribute) setup = QgsEditorWidgetSetup(field_widget, field_widget_config) current_layer.setEditorWidgetSetup(field_idx, setup) if minimal_selection: constraint_expression = 'array_length("{}")>0'.format( attribute) current_layer.setConstraintExpression( field_idx, constraint_expression, self.tr("The minimal selection is 1"), ) for layer in self.layers: layer.create_form(self) if self.legend: self.legend.create(qgis_project) custom_layer_order = list() for custom_layer_name in self.custom_layer_order_structure: custom_layer = qgis_project.mapLayersByName(custom_layer_name) if custom_layer: custom_layer_order.append(custom_layer[0]) if custom_layer_order: root = qgis_project.layerTreeRoot() order = root.customLayerOrder() if root.hasCustomLayerOrder( ) else [] order.extend(custom_layer_order) root.setCustomLayerOrder(custom_layer_order) root.setHasCustomLayerOrder(True) if path: qgis_project.write(path)
class GPS(QObject): def __init__(self, gtomain): super(GPS, self).__init__() self.gtomain = gtomain self.debug = self.gtomain.debug self.helper = self.gtomain.helper self.iface = self.gtomain.iface self.info = self.gtomain.info self.prj = None self.canvas = self.iface.mapCanvas() self.gpsLog = Info(self) self.gpsLog.panel_name = "GTO-GPS" self.mouse = None self.LastMapTool = None try: # settings self.settings = None self.timer_intervall = 1000 self.port = None self.pdop = 0 self.wgs_crs = 'EPSG:4326' self.gps_streaming_distance = 10 # refs self.gpsCon = None self.gpsDetector = None self.gps_active = False self.dic_gpsinfo = {} self.prj_crs = None self.src_crs = None self.transformation = None self.marker = None self.prevPointXY = None self.prevTime = None self.lastGpsInfo = None self.center = False self.scale = 0 # actions mw = self.iface.mainWindow() self.actionGPStoggle = QAction("GTO-GPS", mw) self.actionGPStoggle.setObjectName('mActionGTOgpsToggle') self.actionGPStoggle.setToolTip('GTO GPS starten') self.actionGPStoggle.setIcon( self.gtomain.helper.getIcon('mActionGTOgpsToggle.png')) self.actionGPStoggle.setCheckable(True) self.actionGPStoggle.setChecked(False) self.actionGPStoggle.toggled.connect(self.activate) self.actionGPSaddPoint = QAction("GPS Punkt hinzufügen", mw) self.actionGPSaddPoint.setObjectName('mActionGTOgpsAddPoint') self.actionGPSaddPoint.setToolTip('GPS Punkt hinzufügen') self.actionGPSaddPoint.setIcon( self.gtomain.helper.getIcon('mActionGTOgpsAddPoint.png')) self.actionGPSaddPoint.triggered.connect(self.addPoint) self.actionGPSaddPoint.setEnabled(False) self.actionGPSclick = QAction("GPS Punkt hinzufügen", mw) self.actionGPSclick.setObjectName('mActionGTOgpsAddcPoint') self.actionGPSclick.setToolTip('GPS Punkt hinzufügen') self.actionGPSclick.setIcon( self.gtomain.helper.getIcon('mActionGTOgpsAddcPoint.png')) self.actionGPSclick.triggered.connect(self.gps_click) self.actionGPSclick.setEnabled(False) self.actionGPSstreaming = QAction("GPS streaming", mw) self.actionGPSstreaming.setObjectName('mActionGTOgpsStream') self.actionGPSstreaming.setToolTip('GPS Punkte aufzeichnen') self.actionGPSstreaming.setIcon( self.gtomain.helper.getIcon('mActionGTOgpsStream.png')) self.actionGPSstreaming.setCheckable(True) self.actionGPSstreaming.setEnabled(False) self.actionGPSstreaming.toggled.connect(self.streaming) self.actionGPSsave = QAction("GPS Geometrie speichern", mw) self.actionGPSsave.setObjectName('mActionGTOgpsSave') self.actionGPSsave.setToolTip('GPS Geometrie speichern') self.actionGPSsave.setIcon( self.gtomain.helper.getIcon('mActionGTOgpsSave.png')) self.actionGPSsave.triggered.connect(self.saveGeometry) self.actionGPSsave.setEnabled(False) self.actionGPSaddVertexTool = QAction("GPS AddVertexTool", mw) self.actionGPSaddVertexTool.setObjectName( 'mActionGTOgpsAddVertexTool') self.actionGPSaddVertexTool.setToolTip('GPS add vertex to stream') self.actionGPSaddVertexTool.setIcon( self.gtomain.helper.getIcon('mActionGTOgpsAddVertexTool.png')) self.actionGPSaddVertexTool.setCheckable(True) self.actionGPSaddVertexTool.toggled.connect( self.activateVertexTool) self.actionGPSaddVertexTool.setEnabled(False) # add vertex tool self.streamTool = VertexTool(self.iface, self.canvas, True) self.streamTool.canvasReleased.connect(self.addVertex) self.streamTool.isActive.connect(self.tool_isactive) self.actionGPSlog = QAction("GPS Log", mw) self.actionGPSlog.setObjectName('mActionGTOgpsLog') self.actionGPSlog.setToolTip('GPS events anzeigen') self.actionGPSlog.setIcon( self.gtomain.helper.getIcon('mActionGTOgpsLog.png')) self.actionGPSlog.setCheckable(True) self.actionGPScenter = QAction("GPS zentriere Karte", mw) self.actionGPScenter.setObjectName('mActionGTOgpsCenter') self.actionGPScenter.setToolTip('GPS zentriere Karte') self.actionGPScenter.setIcon( self.gtomain.helper.getIcon('mActionGTOgpsCenter.png')) self.actionGPScenter.setCheckable(True) self.actionGPScenter.toggled.connect(self.activateCenter) self.actionGPSport = GtoWidgetGpsPort(self, mw) self.actionGPSport.portChanged.connect(self.setPort) self.canvas.currentLayerChanged.connect(self.layer_changed) # streaming self.debugXoffset = 0 # debugging self.debugYoffset = 0 # rubberband # get selection color selcolor = self.canvas.selectionColor() mycolor = QColor(selcolor.red(), selcolor.green(), selcolor.blue(), 40) self.rb = QgsRubberBand(self.canvas) self.rb.setStrokeColor(QColor(255, 0, 0, 90)) self.rb.setFillColor(mycolor) self.rb.setLineStyle(Qt.PenStyle(Qt.SolidLine)) self.rb.setWidth(4) # watchdog self.watchdog = QTimer() self.watchdog.setInterval(2000) self.watchdog.timeout.connect(self.watch_dog) # layer self.streamLayer = None self.pointLayer = None self.gps_stream_mode = 0 # "0=rubber, 1=click, 2=both self.gps_debug = False except Exception as e: self.info.err(e) def watch_dog(self): try: self.watchdog.stop() self.gpsLog.log('Status:', self.gpsCon.status()) # doesnt work properly self.marker.setColor(QColor(255, 0, 0)) if self.actionGPSlog.isChecked(): self.gpsLog.log('No signal!') res = self.info.gtoQuestion("GPS deaktivieren? (Empfohlen)", title='Kein GPS Signal!', btns=QMessageBox.Yes | QMessageBox.No, parent=self.iface.mainWindow()) if res == QMessageBox.Yes: self.deactivate() self.actionGPStoggle.setChecked(False) except Exception as e: self.info.err(e) def init(self): try: if self.debug: self.gpsLog.log('gps init') self.actionGPStoggle.setChecked(False) # qgis self.prj = QgsProject().instance() self.canvas = self.iface.mapCanvas() # settings if "GPS" in self.gtomain.settings: # compatible self.settings = self.gtomain.settings["GPS"] else: self.settings = self.gtomain.settings # timer self.timer_intervall = self.settings.get("gps_timer_intervall", 5000) # gps self.port = self.settings.get("gps_port", None) if self.port is None: self.setPort(self.helper.getGlobalSetting('GpsPort')) self.pdop = self.settings.get("gps_pdop", 0) self.actionGPSlog.setChecked(self.settings.get("gps_log", False)) watchdog_interval = self.settings.get("gps_watchdog_interval", 3000) self.watchdog.setInterval(watchdog_interval) # streaming self.pointLayer = self.settings.get("gps_point_layer", None) try: if self.pointLayer is not None: self.pointLayer = self.prj.mapLayersByName( self.pointLayer)[0] geoType = self.pointLayer.geometryType() if geoType != QgsWkbTypes.GeometryType.PointGeometry: self.pointLayer = None except Exception as e: self.pointLayer = None self.info.err(e) self.gps_debug = self.settings.get("gps_debug", False) self.gps_stream_mode = self.settings.get("gps_stream_mode", 0) self.gps_streaming_distance = self.settings.get( "gps_streaming_distance", 1) # map self.center = self.settings.get("gps_center", True) self.actionGPScenter.setChecked(self.center) self.scale = self.settings.get("gps_scale", 0) # transformation self.prj_crs = self.prj.crs() self.wgs_crs = self.settings.get("gps_wgs_crs", 'EPSG:4326') self.init_transformation(self.wgs_crs) except Exception as e: self.info.err(e) def activateCenter(self): self.center = self.actionGPScenter.isChecked() def activate(self): try: self.deactivate() if self.actionGPStoggle.isChecked(): if self.port is None: self.info.msg("Kein GPS Port gesetzt!") return self.actionGPSport.setEnabled(False) if self.actionGPSlog.isChecked(): self.gpsLog.log('gps activate') self.gpsDetector = QgsGpsDetector(self.port) self.gpsDetector.detected[QgsGpsConnection].connect( self.connection_succeed) # self.gpsDetector.detected[QgsNmeaConnection].connect(self.connection_succeed) self.gpsDetector.detectionFailed.connect( self.connection_failed) self.gpsDetector.advance() self.init_marker() except Exception as e: self.info.err(e) def setPort(self, port): try: self.port = port self.actionGPStoggle.setToolTip('GPS on/off (Port:{0})'.format( self.port)) except Exception as e: self.info.err(e) def enableGPSfunctions(self, enabled): try: if self.iface.mainWindow() is None: return # dummy except: # prevent: ERROR: <class 'RuntimeError'> gto_gps.py | line: 240 | ('wrapped C/C++ object of type QgisInterface has been deleted',) # because QGIS is already closing return try: if self.iface.activeLayer() is not None: geoType = self.iface.activeLayer().geometryType() if geoType == QgsWkbTypes.GeometryType.PointGeometry: self.actionGPSaddPoint.setEnabled(enabled) else: self.actionGPSaddPoint.setEnabled(False) self.actionGPSclick.setEnabled(enabled) self.actionGPSstreaming.setEnabled(enabled) self.actionGPSport.setEnabled(not enabled) except Exception as e: self.info.err(e) def connection_succeed(self, connection): try: self.gps_active = True self.gpsCon = connection self.gpsCon.stateChanged.connect(self.status_changed) self.watchdog.start() except Exception as e: self.info.err(e) def connection_failed(self): if not self.gps_active: self.actionGPStoggle.setChecked(False) self.info.msg("GPS konnte nicht initialisiert werden!") self.info.log('GPS connection failed') self.enableGPSfunctions(False) def deactivate(self): try: if self.iface.mainWindow() is None: return # dummy except: # prevent: ERROR: <class 'RuntimeError'> gto_gps.py | line: 240 | ('wrapped C/C++ object of type QgisInterface has been deleted',) # because QGIS is already closing return try: if self.debug: self.info.log('gps deactivate') self.watchdog.stop() self.debugXoffset = 0 self.debugYoffset = 0 self.prevTime = None self.actionGPSstreaming.setChecked(False) self.enableGPSfunctions(False) self.prevPointXY = None if self.gpsCon is not None: if self.actionGPSlog.isChecked(): self.gpsLog.log('gps deactivate') self.gpsCon.close() if self.canvas is not None: self.canvas.scene().removeItem(self.marker) self.gps_active = False except Exception as e: self.info.err(e) def init_marker(self): try: if self.actionGPSlog.isChecked(): self.info.log('gps init_marker') self.marker = QgsVertexMarker(self.canvas) self.marker.setColor(QColor(255, 0, 0)) # (R,G,B) self.marker.setIconSize(10) self.circle = QgsVertexMarker.ICON_CIRCLE self.marker.setIconType(self.circle) # ICON_BOX # ICON_CIRCLE # ICON_CROSS # ICON_DOUBLE_TRIANGLE # ICON_NONE # ICON_X self.marker.setPenWidth(3) except Exception as e: self.info.err(e) def init_transformation(self, wgs_crs): try: self.src_crs = QgsCoordinateReferenceSystem(wgs_crs) self.transformation = QgsCoordinateTransform( self.src_crs, self.prj_crs, self.prj) except Exception as e: self.info.err(e) def status_changed(self, gpsInfo): try: if self.gpsCon.status() != 3: return # 3=data received self.watchdog.stop() self.watchdog.start() if gpsInfo.longitude == 0: return valid = False self.dic_gpsinfo = { "direction": gpsInfo.direction, "elevation": gpsInfo.elevation, "fixMode": gpsInfo.fixMode, "fixType": gpsInfo.fixType, "hacc": gpsInfo.hacc, "satInfoComplete": gpsInfo.satInfoComplete, "speed": gpsInfo.speed, "utcDateTime": gpsInfo.utcDateTime, "vacc": gpsInfo.vacc, "status": gpsInfo.status, "hdop": gpsInfo.hdop, "vdop": gpsInfo.vdop, "pdop": gpsInfo.pdop, "latitude": gpsInfo.latitude, "longitude": gpsInfo.longitude, "satellitesInView": gpsInfo.satellitesInView, "satellitesUsed": gpsInfo.satellitesUsed, "quality": gpsInfo.quality } if self.actionGPSlog.isChecked(): self.gpsLog.log('direction:', gpsInfo.direction) self.gpsLog.log('elevation:', gpsInfo.elevation) self.gpsLog.log('fixMode:', gpsInfo.fixMode) self.gpsLog.log('fixType:', gpsInfo.fixType) self.gpsLog.log('hacc:', gpsInfo.hacc) self.gpsLog.log('satInfoComplete:', gpsInfo.satInfoComplete) self.gpsLog.log('speed:', gpsInfo.speed) self.gpsLog.log('utcDateTime:', gpsInfo.utcDateTime.toString()) self.gpsLog.log('vacc:', gpsInfo.vacc) self.gpsLog.log('status:', gpsInfo.status) self.gpsLog.log('hdop:', gpsInfo.hdop) self.gpsLog.log('vdop:', gpsInfo.vdop) self.gpsLog.log('pdop:', gpsInfo.pdop) self.gpsLog.log('latitude:', gpsInfo.latitude) self.gpsLog.log('longitude:', gpsInfo.longitude) self.gpsLog.log('satellitesInView:', len(gpsInfo.satellitesInView)) self.gpsLog.log('satellitesUsed:', gpsInfo.satellitesUsed) self.gpsLog.log('quality:', gpsInfo.quality) self.gpsLog.log("---------------------") if gpsInfo.pdop >= self.pdop: # gps ok valid = True self.enableGPSfunctions(True) self.marker.setColor(QColor(0, 200, 0)) else: self.enableGPSfunctions(False) self.marker.setColor(QColor(255, 0, 0)) wgs84_pointXY = QgsPointXY(gpsInfo.longitude, gpsInfo.latitude) wgs84_point = QgsPoint(wgs84_pointXY) wgs84_point.transform(self.transformation) if self.gps_debug: self.debugXoffset = self.debugXoffset + random.randint( 0, int(self.gps_streaming_distance)) self.debugYoffset = self.debugYoffset + random.randint( 0, int(self.gps_streaming_distance)) x = wgs84_point.x() + self.debugXoffset y = wgs84_point.y() + self.debugYoffset else: x = wgs84_point.x() y = wgs84_point.y() if self.actionGPSlog.isChecked(): self.gpsLog.log("x:", x) self.gpsLog.log("y:", y) self.gpsLog.log("--------------------") mapPointXY = QgsPointXY(x, y) self.lastGpsInfo = gtoGPSinfo(gpsInfo, mapPointXY, valid) # map if self.center and valid: self.canvas.setCenter(mapPointXY) if self.scale > 0: self.canvas.zoomScale(self.scale) self.marker.setCenter(mapPointXY) self.marker.show() # streaming gpsDateTime = None diff = 0 if self.pointLayer is not None: self.actionGPSaddPoint.setEnabled(valid) if self.actionGPSstreaming.isChecked( ) and valid and not self.actionGPSaddVertexTool.isChecked(): if self.prevTime is None: self.prevTime = gpsInfo.utcDateTime.currentDateTime() else: gpsDateTime = gpsInfo.utcDateTime.currentDateTime() diff = self.prevTime.msecsTo(gpsDateTime) if diff < self.timer_intervall: return if self.prevPointXY is None: self.prevPointXY = mapPointXY self.prevTime = gpsDateTime if self.pointLayer is not None: self.addPoint() else: if self.gps_stream_mode == 1: self.gps_click() elif self.gps_stream_mode == 2: self.gps_click() self.addVertex(mapPointXY) else: self.addVertex(mapPointXY) else: qgsDistance = QgsDistanceArea() distance = qgsDistance.measureLine( [self.prevPointXY, mapPointXY]) if distance > self.gps_streaming_distance and diff > self.timer_intervall: self.prevTime = gpsDateTime self.prevPointXY = mapPointXY if self.pointLayer is not None: self.addPoint() else: if self.gps_stream_mode == 1: self.gps_click() elif self.gps_stream_mode == 2: self.gps_click() self.addVertex(mapPointXY) else: self.addVertex(mapPointXY) except Exception as e: self.info.err(e) def gps_click(self): from pynput.mouse import Button, Controller try: if self.gps_active: if self.debug: self.gpsLog.log('gps_click') actionAddFeature = self.iface.mainWindow().findChild( QAction, 'mActionAddFeature') gtoGpsInfo = self.lastGpsInfo if gtoGpsInfo.isValid and actionAddFeature.isChecked(): self.mouse = Controller() mapX = gtoGpsInfo.mapPointXY.x() mapY = gtoGpsInfo.mapPointXY.y() pointXY = self.canvas.getCoordinateTransform().transform( mapX, mapY) # map coords to device coords x = pointXY.x() y = pointXY.y() p = self.canvas.mapToGlobal(QPoint( x, y)) # device coords to screen coords x = p.x() y = p.y() prevX, prevY = self.mouse.position self.mouse.position = (x, y) if self.debug: self.gpsLog.log('addPoint', x, "/", y) self.mouse.click(Button.left, 1) self.mouse.position = (prevX, prevY) except Exception as e: self.info.err(e) def layer_changed(self): try: self.actionGPSstreaming.setChecked(False) if self.gps_active: geoType = self.iface.activeLayer().geometryType() if geoType == QgsWkbTypes.GeometryType.PointGeometry or self.pointLayer is not None: self.actionGPSaddPoint.setEnabled(True) else: self.actionGPSaddPoint.setEnabled(False) except Exception as e: self.info.err(e) def streaming(self): try: self.actionGPSsave.setEnabled(False) self.actionGPSaddVertexTool.setChecked(False) self.activateVertexTool() if self.pointLayer is not None: return if self.actionGPSstreaming.isChecked(): if self.streamLayer is not None: self.actionGPSstreaming.setChecked(False) res = self.saveGeometry() if res == QMessageBox.Cancel: return self.actionGPSstreaming.setChecked(True) geoType = self.iface.activeLayer().geometryType() if geoType == QgsWkbTypes.GeometryType.PolygonGeometry or geoType == QgsWkbTypes.GeometryType.LineGeometry: self.streamLayer = self.iface.activeLayer() self.actionGPSaddVertexTool.setEnabled(True) self.rb.reset(geoType) else: self.actionGPSstreaming.setChecked(False) self.actionGPSaddVertexTool.setEnabled(False) self.info.msg( "Aktiver Layer muss vom Typ Polgone oder Line sein!") else: self.actionGPSaddVertexTool.setEnabled(False) if self.streamLayer is not None: geoType = self.streamLayer.geometryType() tools = self.settings.get('gps_afterstream_tools', []) if geoType == QgsWkbTypes.GeometryType.PolygonGeometry: if self.rb.numberOfVertices() > 2: self.actionGPSsave.setEnabled(True) self.gtomain.runcmd(tools) if geoType == QgsWkbTypes.GeometryType.LineGeometry: if self.rb.numberOfVertices() > 1: self.actionGPSsave.setEnabled(True) self.gtomain.runcmd(tools) except Exception as e: self.info.err(e) def addPoint(self): try: if self.gps_active: if self.actionGPSlog.isChecked(): self.gpsLog.log('addPoint') gtoGpsInfo = self.lastGpsInfo if gtoGpsInfo.isValid: if self.pointLayer is not None: layer = self.pointLayer else: layer = self.iface.activeLayer() geoType = layer.geometryType() if geoType != QgsWkbTypes.GeometryType.PointGeometry: self.info.msg("Kein Punktlayer ausgewählt!") return # create feature feat = QgsVectorLayerUtils.createFeature(layer) tr = QgsCoordinateTransform(self.prj_crs, layer.crs(), self.prj) tr_point = tr.transform(gtoGpsInfo.mapPointXY) geo = QgsGeometry.fromPointXY(tr_point) feat.setGeometry(geo) # set attributes gps_addpoint_attributes = self.settings.get( "gps_addpoint_attributes", {}) for k, v in gps_addpoint_attributes.items(): feat[k] = layer.fields().field(k).convertCompatible( self.dic_gpsinfo[v]) # add to layer if self.pointLayer is not None: # add to provider (res, outFeats) = layer.dataProvider().addFeatures([feat]) layer.select(outFeats[0].id()) else: if not layer.isEditable(): layer.startEditing() layer.beginEditCommand('Add stream geometry') layer.addFeatures([feat]) layer.endEditCommand() self.helper.refreshLayer(layer) except Exception as e: self.info.err(e) def saveGeometry(self, force=False): try: if self.streamLayer is not None: if not force: res = self.info.gtoQuestion( "GPS Stream-Geometry in Layer \n{0}\nspeichern?". format(self.streamLayer.name()), title='GPS Streaming', btns=QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel, parent=self.iface.mainWindow()) if res == QMessageBox.Cancel: return res if res == QMessageBox.No: self.actionGPSsave.setEnabled(False) self.streamLayer = None self.rb.reset() return # create feature feat = QgsVectorLayerUtils.createFeature(self.streamLayer) geo = self.rb.asGeometry() feat.setGeometry(geo) # add to layer if not self.streamLayer.isEditable(): self.streamLayer.startEditing() self.streamLayer.beginEditCommand('Add stream geometry') self.streamLayer.addFeatures([feat]) self.streamLayer.endEditCommand() # add to provider # (res, outFeats) = self.streamLayer.dataProvider().addFeatures([feat]) # self.streamLayer.select(outFeats[0].id()) # reset streaming self.actionGPSsave.setEnabled(False) self.streamLayer = None self.rb.reset() except Exception as e: self.streamLayer.destroyEditCommand() self.info.err(e) def addVertex(self, point): try: self.rb.addPoint(point) except Exception as e: self.info.err(e) def activateVertexTool(self): try: if self.actionGPSaddVertexTool.isChecked(): if self.actionGPSlog.isChecked(): self.gpsLog.log('activated VertexTool: stream paused') self.LastMapTool = self.canvas.mapTool() self.canvas.setMapTool(self.streamTool) else: if self.actionGPSlog.isChecked(): self.gpsLog.log('deactivated VertexTool: stream resumed') self.canvas.setMapTool(self.LastMapTool) except Exception as e: self.info.err(e) def tool_isactive(self, active): try: pass except Exception as e: self.info.err(e)
else: fieldIdx = lyr.dataProvider().fieldNameIndex('nome') if fieldIdx == -1: self.displayErrorMessage( self.tr( 'O atributo "nome" não existe na camada selecionada')) else: instance = QgsProject().instance() geomType = lyr.geometryType() if geomType == QgsWkbTypes.PointGeometry: destLayerName = 'edicao_texto_generico_p' elif geomType == QgsWkbTypes.LineGeometry: destLayerName = 'edicao_texto_generico_l' else: destLayerName = None destLayer = instance.mapLayersByName(destLayerName) if destLayerName is None: self.displayErrorMessage( self.tr(f'Não válido para camadas tipo área')) elif len(destLayer) != 1: self.displayErrorMessage( self.tr(f'A camada "{destLayerName}" não existe')) else: destLayer = destLayer[0] destLayer.startEditing() for feat in lyr.getSelectedFeatures(): if self.checkAttrIsEmpty(feat, 'nome'): break destFeat = QgsFeature(destLayer.fields()) if geomType == QgsWkbTypes.PointGeometry: self.setPointFeatValues(feat, destFeat)