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)
