def _loadLayer(self):
fName = self.leOutputShape.text()
layer = QgsVectorLayer(fName, QFileInfo(fName).baseName(), "ogr")
if layer.isValid():
layer.loadNamedStyle(os.path.join(pluginPath, "resources", "photos.qml"))
QgsMapLayerRegistry.instance().addMapLayer(layer)
else:
self.iface.messageBar().pushWarning(self.tr("No output"), self.tr("Cannot load output shapefile"))
def testSingleSymbolNoScaleDependencies(self):
layer = QgsVectorLayer("Point", "addfeat", "memory")
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.qml' % (unitTestDataPath(), "singleSymbol"))
layer.loadNamedStyle(mFilePath)
dom, root = self.layerToSld(layer)
# print("No dep on single symbol:" + dom.toString())
self.assertScaleDenominator(root, None, None)
def special_search(self, easter_code="isogeo"):
"""Make some special actions in certains cases.
:param str easter_code: easter egg label. Available values:
* isogeo: display Isogeo logo and zoom in our office location
* picasa: change QGS project title
"""
canvas = iface.mapCanvas()
if easter_code == "isogeo":
# WMS
wms_params = {"service": "WMS",
"version": "1.3.0",
"request": "GetMap",
"layers": "Isogeo:isogeo_logo",
"crs": "EPSG:3857",
"format": "image/png",
"styles": "isogeo_logo",
"url": "http://noisy.hq.isogeo.fr:6090/geoserver/Isogeo/ows?"
}
wms_uri = unquote(urlencode(wms_params))
wms_lyr = QgsRasterLayer(wms_uri, u"Ici c'est Isogeo !", "wms")
if wms_lyr.isValid:
QgsMapLayerRegistry.instance().addMapLayer(wms_lyr)
logger.info("Isogeo easter egg used and WMS displayed!")
else:
logger.error("WMS layer failed: {}"
.format(wms_lyr.error().message()))
# WFS
uri = QgsDataSourceURI()
uri.setParam("url", "http://noisy.hq.isogeo.fr:6090/geoserver/Isogeo/ows?")
uri.setParam("service", "WFS")
uri.setParam("version", "1.1.0")
uri.setParam("typename", "Isogeo:isogeo_logo")
uri.setParam("srsname", "EPSG:3857")
uri.setParam("restrictToRequestBBOX", "0")
wfs_uri = uri.uri()
wfs_lyr = QgsVectorLayer(wfs_uri, u"Ici c'est Isogeo !", "WFS")
if wfs_lyr.isValid:
wfs_style = path.join(path.dirname(path.realpath(__file__)),
"isogeo.qml")
wfs_lyr.loadNamedStyle(wfs_style)
QgsMapLayerRegistry.instance().addMapLayer(wfs_lyr)
canvas.setExtent(wfs_lyr.extent())
logger.debug("Isogeo easter egg used")
else:
logger.error("Esater egg - WFS layer failed: {}"
.format(wfs_lyr.error().message()))
elif easter_code == "picasa":
project = QgsProject.instance()
project.setTitle(u"Isogeo, le Picasa de l'information géographique")
logger.debug("Picasa easter egg used")
else:
pass
# ending method
return
def testCategorizedNoScaleDependencies(self):
layer = QgsVectorLayer("Polygon", "addfeat", "memory")
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.qml' % (unitTestDataPath(), "categorized"))
layer.loadNamedStyle(mFilePath)
dom, root = self.layerToSld(layer)
# print("Categorized no scale deps:" + dom.toString())
ruleCount = root.elementsByTagName('se:Rule').size()
for i in range(0, ruleCount):
self.assertScaleDenominator(root, None, None, i)
def get_layer(self, type):
uri = 'point?crs=epsg:4326&field=id:string&field=type:string&field=number:string&field=time:string'
new_lyr = QgsVectorLayer(uri, 'Yandex Transport', 'memory')
layer_style_path = path.join(path.dirname(__file__), 'styles/', 'all.qml')
if path.isfile(layer_style_path):
new_lyr.loadNamedStyle(layer_style_path)
self._layer_registry.append(new_lyr)
self._updater.paused = not len(self._layer_registry)
return new_lyr
def _loadLayer(self):
fName = self.fwOutputShape.filePath()
layer = QgsVectorLayer(fName, os.path.basename(fName), "ogr")
if layer.isValid():
layer.loadNamedStyle(
os.path.join(pluginPath, "resources", "photos.qml"))
QgsProject.instance().addMapLayer(layer)
else:
self.iface.messageBar().pushWarning(
self.tr("No output"),
self.tr("Can not load output file."))
def testSingleSymbolScaleDependencies(self):
layer = QgsVectorLayer("Point", "addfeat", "memory")
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.qml' % (unitTestDataPath(), "singleSymbol"))
layer.loadNamedStyle(mFilePath)
layer.setMaximumScale(1000)
layer.setMinimumScale(500000)
layer.setScaleBasedVisibility(True)
dom, root = self.layerToSld(layer)
# print("Scale dep on single symbol:" + dom.toString())
self.assertScaleDenominator(root, '1000', '500000')
def show(filePath,stylePath):
"""show csv as layer"""
uri = "file:" + 3*os.path.sep + filePath + "?crs=%s&delimiter=%s&xField=%s&yField=%s&decimal=%s" % ("EPSG:4326",",", "Lon_deg", "Lat_deg", ".")
uri = os.path.join(uri).replace('\\','/')
layerName = filePath.rsplit(os.path.sep,1)
layerName = layerName[1][:-4]
layer = QgsVectorLayer(uri, layerName, "delimitedtext")
if stylePath:
stylePath = os.path.join(stylePath).replace('\\','/')
layer.loadNamedStyle(stylePath)
QgsMapLayerRegistry.instance().addMapLayer(layer)
def loadEDGVLayer(self, uri, layer_name, provider):
vlayer = QgsVectorLayer(uri.uri(), layer_name, provider)
vlayer.setCrs(self.crs)
QgsMapLayerRegistry.instance().addMapLayer(vlayer) #added due to api changes
if self.isSpatialite and (self.dbVersion == '3.0' or self.dbVersion == '2.1.3'):
lyr = '_'.join(layer_name.replace('\r', '').split('_')[1::])
else:
lyr = layer_name.replace('\r','')
vlayerQml = os.path.join(self.qmlPath, lyr+'.qml')
vlayer.loadNamedStyle(vlayerQml, False)
QgsMapLayerRegistry.instance().addMapLayer(vlayer)
if not vlayer.isValid():
QgsMessageLog.logMessage(vlayer.error().summary(), "DSG Tools Plugin", QgsMessageLog.CRITICAL)
def testCategorizedWithScaleDependencies(self):
layer = QgsVectorLayer("Polygon", "addfeat", "memory")
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.qml' % (unitTestDataPath(), "categorized"))
layer.loadNamedStyle(mFilePath)
layer.setMaximumScale(1000)
layer.setMinimumScale(500000)
layer.setScaleBasedVisibility(True)
dom, root = self.layerToSld(layer)
# print("Categorized with scale deps:" + dom.toString())
ruleCount = root.elementsByTagName('se:Rule').size()
for i in range(0, ruleCount):
self.assertScaleDenominator(root, '1000', '500000', i)
def __add_dkm_layers(self):
dkmgem = self.json_settings.dkm_gemeinde(self.curr_gem_name)
if VRP_DEBUG is True:
QgsMessageLog.logMessage('__add_dkm_layers: {0}'.format(dkmgem.keys()), DLG_CAPTION)
QgsMessageLog.logMessage('__add_dkm_layers: {0}'.format(dkmgem['shpgnr']), DLG_CAPTION)
QgsMessageLog.logMessage('__add_dkm_layers: {0}'.format(dkmgem['qmlgnr']), DLG_CAPTION)
QgsMessageLog.logMessage('__add_dkm_layers: {0}'.format(dkmgem['shpgstk']), DLG_CAPTION)
QgsMessageLog.logMessage('__add_dkm_layers: {0}'.format(dkmgem['qmlgstk']), DLG_CAPTION)
lyr = QgsVectorLayer(dkmgem['shpgstk'], dkmgem['lyrnamegstk'], 'ogr')
lyr.loadNamedStyle(dkmgem['qmlgstk'])
QgsMapLayerRegistry.instance().addMapLayer(lyr)
self.dkm_coverage_layer = lyr
lyr = QgsVectorLayer(dkmgem['shpgnr'], dkmgem['lyrnamegnr'], 'ogr')
lyr.loadNamedStyle(dkmgem['qmlgnr'])
QgsMapLayerRegistry.instance().addMapLayer(lyr)
def loadFeatureLayer(cls, table):
uri = QgsDataSourceURI()
uri.setDatabase(cls._PalFeaturesDb)
uri.setDataSource('', table, 'geometry')
vlayer = QgsVectorLayer(uri.uri(), table, 'spatialite')
# .qml should contain only style for symbology
vlayer.loadNamedStyle(os.path.join(cls._PalDataDir,
'{0}.qml'.format(table)))
cls._MapRegistry.addMapLayer(vlayer)
cls._MapRenderer.setLayerSet([vlayer.id()])
# zoom to aoi
cls._MapRenderer.setExtent(cls.aoiExtent())
cls._Canvas.zoomToFullExtent()
return vlayer
def load(fileName, name=None, crs=None, style=None):
"""Loads a layer/table into the current project, given its file.
"""
if fileName is None:
return
prjSetting = None
settings = QSettings()
if crs is not None:
prjSetting = settings.value('/Projections/defaultBehaviour')
settings.setValue('/Projections/defaultBehaviour', '')
if name is None:
name = os.path.split(fileName)[1]
qgslayer = QgsVectorLayer(fileName, name, 'ogr')
if qgslayer.isValid():
if crs is not None and qgslayer.crs() is None:
qgslayer.setCrs(crs, False)
if style is None:
if qgslayer.geometryType() == QGis.Point:
style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_POINT_STYLE)
elif qgslayer.geometryType() == QGis.Line:
style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_LINE_STYLE)
else:
style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_POLYGON_STYLE)
qgslayer.loadNamedStyle(style)
QgsMapLayerRegistry.instance().addMapLayers([qgslayer])
else:
qgslayer = QgsRasterLayer(fileName, name)
if qgslayer.isValid():
if crs is not None and qgslayer.crs() is None:
qgslayer.setCrs(crs, False)
if style is None:
style = ProcessingConfig.getSetting(ProcessingConfig.RASTER_STYLE)
qgslayer.loadNamedStyle(style)
QgsMapLayerRegistry.instance().addMapLayers([qgslayer])
iface.legendInterface().refreshLayerSymbology(qgslayer)
else:
if prjSetting:
settings.setValue('/Projections/defaultBehaviour', prjSetting)
raise RuntimeError('Could not load layer: ' + unicode(fileName)
+ '\nCheck the procesing framework log to look for errors')
if prjSetting:
settings.setValue('/Projections/defaultBehaviour', prjSetting)
return qgslayer
def _append_resource_to_map(self, ngw_resource, parent_resource, summary_extent):
children = ngw_resource.get_children()
wfs_resources = [ch for ch in children if isinstance(ch, NGWWfsService)]
if len(wfs_resources) < 1:
#TODO: show error
return
wfs_resource = wfs_resources[0]
#Serach/Add group
toc_root = QgsProject.instance().layerTreeRoot()
parent_group = toc_root.findGroup(parent_resource.common.display_name)
if not parent_group:
parent_group = toc_root.insertGroup(0, parent_resource.common.display_name)
layers_group = parent_group.insertGroup(0, ngw_resource.common.display_name)
try:
layers_group.setExpanded(False)
except:
pass
styles_path = path.join(path.dirname(__file__), 'styles/', ngw_resource.common.cls + '/')
#Add layers
for wfs_layer in wfs_resource.wfs.layers:
url = wfs_resource.get_wfs_url(wfs_layer.keyname) + '&srsname=EPSG:3857&VERSION=1.0.0&REQUEST=GetFeature'
qgs_wfs_layer = QgsVectorLayer(url, wfs_layer.display_name, 'WFS')
#summarize extent
self._summ_extent(summary_extent, qgs_wfs_layer)
QgsMapLayerRegistry.instance().addMapLayer(qgs_wfs_layer, False)
toc_layer = layers_group.insertLayer(0, qgs_wfs_layer)
try:
toc_layer.setExpanded(False)
except:
pass
layer_style_path = path.join(styles_path, wfs_layer.keyname + '.qml')
if path.isfile(layer_style_path):
qgs_wfs_layer.loadNamedStyle(layer_style_path)
else:
message = self.tr('Style for layer "%s" (%s) not found!') % (wfs_layer.display_name, wfs_layer.keyname)
QgsMessageLog.logMessage(message, level=QgsMessageLog.WARNING)
self.update_dicts(qgs_wfs_layer)
def test09_Leaflet_json_pnt_single(self):
"""Leaflet JSON point single (test_qgis2web_dialog.test_Leaflet_json_pnt_single)"""
layer = QgsVectorLayer("/home/travis/build/tomchadwin/qgis2web/test_data/point.shp", "point", "ogr")
if not layer:
print "Layer failed to load!"
registry = QgsMapLayerRegistry.instance()
registry.addMapLayer(layer)
layer.loadNamedStyle("/home/travis/build/tomchadwin/qgis2web/test_data/point_single.qml")
referenceFile = open('/home/travis/build/tomchadwin/qgis2web/test_data/leaflet_json_point_single.html', 'r')
referenceOutput = referenceFile.read()
self.dialog = MainDialog(IFACE)
self.dialog.paramsTreeOL.itemWidget(self.dialog.paramsTreeOL.findItems("Extent",
(Qt.MatchExactly |
Qt.MatchRecursive))[0], 1).setCurrentIndex(1)
self.dialog.leaflet.click()
testFile = open(self.dialog.preview.url().toString().replace("file://",""))
testOutput = testFile.read()
self.assertEqual(testOutput, referenceOutput)
def test26_Leaflet_wfs_poly_graduated(self):
"""Leaflet WFS polygon graduated (test_qgis2web_dialog.test_Leaflet_wfs_poly_graduated)"""
layer = QgsVectorLayer("http://maps.nationalparks.gov.uk/geoserver/wfs?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME=yorkshire_dales:ydnpa_conservationareas&SRSNAME=EPSG:27700", "polygon", "WFS")
if not layer:
print "Layer failed to load!"
registry = QgsMapLayerRegistry.instance()
registry.addMapLayer(layer)
layer.loadNamedStyle("/home/travis/build/tomchadwin/qgis2web/test_data/wfs_polygon_graduated.qml")
referenceFile = open('/home/travis/build/tomchadwin/qgis2web/test_data/leaflet_wfs_polygon_graduated.html', 'r')
referenceOutput = referenceFile.read()
self.dialog = MainDialog(IFACE)
self.dialog.paramsTreeOL.itemWidget(self.dialog.paramsTreeOL.findItems("Extent",
(Qt.MatchExactly |
Qt.MatchRecursive))[0], 1).setCurrentIndex(1)
self.dialog.leaflet.click()
testFile = open(self.dialog.preview.url().toString().replace("file://",""))
testOutput = testFile.read()
self.assertEqual(testOutput, referenceOutput)
def _loadLayer(self, layerPath, layerName, stylePath):
layer = None
layerId = ''
layerList = QgsMapLayerRegistry.instance().mapLayersByName(layerName)
if (len(layerList) > 0):
layer = layerList[0]
self._iface.legendInterface().moveLayer(layer, self._collectionGroupIndex)
else:
fullLayerPath = self.projectPath + '/' + layerPath
layer = QgsVectorLayer(fullLayerPath, layerName, 'ogr')
layer = layers.addLayerToLegend(self._iface, layer, self._collectionGroupIndex)
if layer and layer.isValid():
layerId = layer.id()
self._setDefaultSnapping(layer)
layer.loadNamedStyle(stylePath)
self._iface.legendInterface().setLayerExpanded(layer, False)
else:
layer = None
return layer, layerId
def test35_OL3_poly_graduated(self):
"""OL3 polygon graduated (test_qgis2web_dialog.test_OL3_poly_graduated)"""
layer = QgsVectorLayer("/home/travis/build/tomchadwin/qgis2web/test_data/polygon.shp", "polygon", "ogr")
if not layer:
print "Layer failed to load!"
registry = QgsMapLayerRegistry.instance()
registry.addMapLayer(layer)
layer.loadNamedStyle("/home/travis/build/tomchadwin/qgis2web/test_data/json_polygon_graduated.qml")
referenceFile = open('/home/travis/build/tomchadwin/qgis2web/test_data/ol3_json_polygon_graduated.html', 'r')
referenceOutput = referenceFile.read()
self.dialog = MainDialog(IFACE)
self.dialog.paramsTreeOL.itemWidget(self.dialog.paramsTreeOL.findItems("Extent",
(Qt.MatchExactly |
Qt.MatchRecursive))[0], 1).setCurrentIndex(1)
self.dialog.ol3.click()
testFile = open(self.dialog.preview.url().toString().replace("file://",""))
testOutput = testFile.read()
testStyleFile = open(self.dialog.preview.url().toString().replace("file://","").replace("index.html", "styles/polygon_style.js"))
testStyleOutput = testStyleFile.read()
testOutput += testStyleOutput
self.assertEqual(testOutput, referenceOutput)
def loadFeatureLayer(cls, table, chk=False):
if chk and cls._MapRegistry.mapLayersByName(table):
return
uri = QgsDataSourceURI()
uri.setDatabase(cls._PalFeaturesDb)
uri.setDataSource("", table, "geometry")
vlayer = QgsVectorLayer(uri.uri(), table, "spatialite")
# .qml should contain only style for symbology
vlayer.loadNamedStyle(os.path.join(cls._PalDataDir, "{0}.qml".format(table)))
# qDebug('render_lyr = {0}'.format(repr(vlayer)))
cls._MapRegistry.addMapLayer(vlayer)
# place new layer on top of render stack
render_lyrs = [vlayer.id()]
render_lyrs.extend(cls._MapSettings.layers())
# qDebug('render_lyrs = {0}'.format(repr(render_lyrs)))
cls._MapSettings.setLayers(render_lyrs)
# zoom to aoi
cls._MapSettings.setExtent(cls.aoiExtent())
cls._Canvas.zoomToFullExtent()
return vlayer
def testRuleBasedNoRootScaleDependencies(self):
layer = QgsVectorLayer("Polygon", "addfeat", "memory")
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.qml' % (unitTestDataPath(), "ruleBased"))
status = layer.loadNamedStyle(mFilePath)
dom, root = self.layerToSld(layer)
print(("Rule based, no root scale deps:" + dom.toString()))
ruleCount = root.elementsByTagName('se:Rule').size()
self.assertScaleDenominator(root, '1000', '40000000', 0)
self.assertScaleDenominator(root, None, None, 1)
def __add_layers(self, thema):
try:
layers = []
for quelle in thema.quellen:
pfad = quelle.pfad.replace('{gem_name}', self.gem_name)
qml = None
if not quelle.qml is None:
qml = quelle.qml.replace('{gem_name}', self.gem_name)
if VRP_DEBUG is True: QgsMessageLog.logMessage('adding lyr:\n{0}\n{1}'.format(pfad, qml), DLG_CAPTION)
if pfad.lower().endswith('.shp') is True:
lyr = QgsVectorLayer(pfad, quelle.name, 'ogr')
if not quelle.filter is None:
if VRP_DEBUG is True: QgsMessageLog.logMessage('{0}'.format(quelle.filter), DLG_CAPTION)
#exp = QgsExpression(quelle.filter)
#if exp.hasParserError():
# QgsMessageLog.logMessage( u'Filter ungültig!\nQuelle:[{0}]\nFilter:{1}'.format(quelle.name, quelle.filter), DLG_CAPTION)
#else:
# exp.prepare(lyr.pendingFields())
lyr.setSubsetString(quelle.filter)
else:
fileinfo = QFileInfo(pfad)
basename = fileinfo.baseName()
lyr = QgsRasterLayer(pfad, basename)
if not lyr.isValid():
QgsMessageLog.logMessage( u'Raster [{0}] konnte nicht geladen werden:\n{1}'.format(thema.name, pfad), DLG_CAPTION)
continue
if not qml is None:
lyr.loadNamedStyle(qml)
QgsMapLayerRegistry.instance().addMapLayer(lyr)
#turn off layer, if no qml present
#for layer that should not be displayed but should be
#used for statistics
if qml is None:
self.legiface.setLayerVisible(lyr, False)
layers.append(lyr)
return layers
except:
msg = 'export pdf (__add_layers): {0}'.format(sys.exc_info()[0])
QgsMessageLog.logMessage(msg, DLG_CAPTION)
return None
def testGraduatedNoScaleDependencies(self):
layer = QgsVectorLayer("Polygon", "addfeat", "memory")
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.qml' %
(unitTestDataPath(), "graduated"))
status = layer.loadNamedStyle(mFilePath) # NOQA
dom, root = self.layerToSld(layer)
# print("Graduated no scale deps:" + dom.toString())
ruleCount = root.elementsByTagName('se:Rule').size()
for i in range(0, ruleCount):
self.assertScaleDenominator(root, None, None, i)
def loadFeatureLayer(cls, table, chk=False):
if chk and cls._MapRegistry.mapLayersByName(table):
return
uri = QgsDataSourceUri()
uri.setDatabase(cls._PalFeaturesDb)
uri.setDataSource('', table, 'geometry')
vlayer = QgsVectorLayer(uri.uri(), table, 'spatialite')
# .qml should contain only style for symbology
vlayer.loadNamedStyle(
os.path.join(cls._PalDataDir, '{0}.qml'.format(table)))
# qDebug('render_lyr = {0}'.format(repr(vlayer)))
cls._MapRegistry.addMapLayer(vlayer)
# place new layer on top of render stack
render_lyrs = [vlayer]
render_lyrs.extend(cls._MapSettings.layers())
# qDebug('render_lyrs = {0}'.format(repr(render_lyrs)))
cls._MapSettings.setLayers(render_lyrs)
# zoom to aoi
cls._MapSettings.setExtent(cls.aoiExtent())
cls._Canvas.zoomToFullExtent()
return vlayer
def createLayer(self):
'''Create a memory layer from the zoom to locations'''
rowcnt = self.resultsTable.rowCount()
if rowcnt == 0:
return
attr = []
for item, label in enumerate(LABELS[0:self.numCol]):
label = label.lower()
if item <= 1:
attr.append(QgsField(label, QVariant.Double))
else:
attr.append(QgsField(label, QVariant.String))
ptLayer = QgsVectorLayer("Point?crs=epsg:4326", u"Lat Lon Locations", "memory")
provider = ptLayer.dataProvider()
provider.addAttributes(attr)
ptLayer.updateFields()
for id in range(rowcnt):
item = self.resultsTable.item(id, 0).data(Qt.UserRole)
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(item.lon, item.lat)))
attr = [item.lat, item.lon, item.label]
for i in range(3, self.numCol):
attr.append(item.data[i - 3])
feature.setAttributes(attr)
provider.addFeatures([feature])
ptLayer.updateExtents()
if self.settings.multiZoomStyleID == 1:
settings = QgsPalLayerSettings()
settings.fieldName = 'label'
settings.placement = QgsPalLayerSettings.AroundPoint
labeling = QgsVectorLayerSimpleLabeling(settings)
ptLayer.setLabeling(labeling)
ptLayer.setLabelsEnabled(True)
elif self.settings.multiZoomStyleID == 2 and os.path.isfile(self.settings.customQMLFile()):
ptLayer.loadNamedStyle(self.settings.customQMLFile())
QgsProject.instance().addMapLayer(ptLayer)
def createLayer(self):
'''Create a memory layer from the zoom to locations'''
rowcnt = self.resultsTable.rowCount()
if rowcnt == 0:
return
attr = []
for item, label in enumerate(LABELS[0:self.numCol]):
label = label.lower()
if item <= 1:
attr.append(QgsField(label, QVariant.Double))
else:
attr.append(QgsField(label, QVariant.String))
ptLayer = QgsVectorLayer("Point?crs=epsg:4326", u"Lat Lon Locations", "memory")
provider = ptLayer.dataProvider()
provider.addAttributes(attr)
ptLayer.updateFields()
for id in range(rowcnt):
item = self.resultsTable.item(id, 0).data(Qt.UserRole)
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(item.lon, item.lat)))
attr = [item.lat, item.lon, item.label]
for i in range(3, self.numCol):
attr.append(item.data[i-3])
feature.setAttributes(attr)
provider.addFeatures([feature])
ptLayer.updateExtents()
if self.settings.multiZoomStyleID == 1:
settings = QgsPalLayerSettings()
settings.fieldName = 'label'
settings.placement = QgsPalLayerSettings.AroundPoint
labeling = QgsVectorLayerSimpleLabeling(settings)
ptLayer.setLabeling(labeling)
ptLayer.setLabelsEnabled(True)
elif self.settings.multiZoomStyleID == 2 and os.path.isfile(self.settings.customQMLFile()):
ptLayer.loadNamedStyle(self.settings.customQMLFile())
QgsProject.instance().addMapLayer(ptLayer)
def testRuleBasedNoRootScaleDependencies(self):
layer = QgsVectorLayer("Polygon", "addfeat", "memory")
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.qml' %
(unitTestDataPath(), "ruleBased"))
status = layer.loadNamedStyle(mFilePath)
dom, root = self.layerToSld(layer)
print(("Rule based, no root scale deps:" + dom.toString()))
ruleCount = root.elementsByTagName('se:Rule').size()
self.assertScaleDenominator(root, '1000', '40000000', 0)
self.assertScaleDenominator(root, None, None, 1)
def addPointToLayer(self, x, y, z):
x = float(x)
y = float(y)
z = float(z)
name = 'Obliczone wysokości - GUGiK NMT'
layers = QgsProject.instance().mapLayersByName(name)
if not layers:
layer = QgsVectorLayer(
'PointZ?crs=epsg:2180&field=x:double&field=y:double&field=z:double',
name, 'memory')
QgsProject.instance().addMapLayer(layer, False)
layerTree = self.iface.layerTreeCanvasBridge().rootGroup()
layerTree.insertChildNode(0, QgsLayerTreeLayer(layer))
treeRoot = QgsProject.instance().layerTreeRoot()
if treeRoot.hasCustomLayerOrder():
order = treeRoot.customLayerOrder()
order.insert(
0,
order.pop(
order.index(
QgsProject.instance().mapLayersByName(name)[0])))
treeRoot.setCustomLayerOrder(order)
layer.loadNamedStyle(
os.path.join(self.plugin_dir, 'layer_style.qml'), True)
else:
layer = layers[0]
feature = QgsFeature()
point = QgsGeometry(QgsPoint(x, y, z))
feature.setGeometry(point)
feature.setAttributes([x, y, z])
layer.startEditing()
layer.addFeature(feature)
layer.commitChanges()
layer.reload()
def create_result_layer(self, name, addToMap=True, qml=None):
featureType = 'Polygon?crs=' + self.iface.mapCanvas().mapSettings(
).destinationCrs().authid()
layer = QgsVectorLayer(featureType, name, 'memory')
provider = layer.dataProvider()
fields = []
fields.append(QgsField('id', QVariant.LongLong, 'int8'))
fields.append(QgsField('name', QVariant.String))
for cat_key in self.output_categories:
fields.append(QgsField(cat_key, QVariant.LongLong, 'int8'))
provider.addAttributes(fields)
layer.updateFields()
if addToMap:
QgsProject.instance().addMapLayer(layer)
if qml is not None:
layer.loadNamedStyle(qml)
self.dst_layer = layer
self.dst_provider = provider
def __add_thema_layer(self, node):
layers = []
thema = node.data(0, Qt.UserRole)
if thema.quellen is None:
return layers
for quelle in thema.quellen:
pfad = quelle.pfad.replace('{gem_name}', self.curr_gem_name)
qml = None
if not quelle.qml is None:
qml = quelle.qml.replace('{gem_name}', self.curr_gem_name)
if VRP_DEBUG is True:
QgsMessageLog.logMessage('ADD LAYER: {0}'.format(pfad), DLG_CAPTION)
QgsMessageLog.logMessage('LAYER QML: {0}'.format(qml), DLG_CAPTION)
if os.path.isfile(pfad) is False:
QMessageBox.warning(self.iface.mainWindow(), DLG_CAPTION, u'Thema [{0}] nicht vorhanden:\n{1}'.format(thema.name, pfad))
else:
layer = None
if pfad.endswith('.shp') is True:
layer = QgsVectorLayer(pfad, quelle.name, "ogr")
else:
fileinfo = QFileInfo(pfad)
basename = fileinfo.baseName()
layer = QgsRasterLayer(pfad, basename)
if not layer.isValid():
QMessageBox.warning(self.iface.mainWindow(), DLG_CAPTION, u'Raster [{0}] konnte nicht geladen werden:\n{1}'.format(thema.name, pfad))
continue
if not qml is None and not layer is None:
layer.loadNamedStyle(qml)
#QgsMapLayerRegistry.instance().addMapLayer(layer)
if not layer is None:
layers.append(deepcopy(layer))
#if len(layers) > 1:
# leg = self.iface.legendInterface()
# idx = leg.addGroup(thema.name)
# for lyr in layers:
# leg.moveLayer(lyr, idx)
return layers
def testRuleBasedNoRootScaleDependencies(self):
layer = QgsVectorLayer("Polygon", "addfeat", "memory")
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.qml' % (unitTestDataPath(), "ruleBased"))
status = layer.loadNamedStyle(mFilePath) # NOQA
layer.setMaximumScale(5000)
layer.setMinimumScale(50000000)
layer.setScaleBasedVisibility(True)
dom, root = self.layerToSld(layer)
# print("Rule based, with root scale deps:" + dom.toString())
ruleCount = root.elementsByTagName('se:Rule').size() # NOQA
self.assertScaleDenominator(root, '5000', '40000000', 0)
self.assertScaleDenominator(root, '5000', '50000000', 1)
def testRuleBasedNoRootScaleDependencies(self):
layer = QgsVectorLayer("Polygon", "addfeat", "memory")
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.qml' % (unitTestDataPath(), "ruleBased"))
status = layer.loadNamedStyle(mFilePath) # NOQA
layer.setMinimumScale(5000)
layer.setMaximumScale(50000000)
layer.setScaleBasedVisibility(True)
dom, root = self.layerToSld(layer)
# print("Rule based, with root scale deps:" + dom.toString())
ruleCount = root.elementsByTagName('se:Rule').size() # NOQA
self.assertScaleDenominator(root, '5000', '40000000', 0)
self.assertScaleDenominator(root, '5000', '50000000', 1)
def add_error_layer(self, dbfile):
""" Adds an database as layers, expects layers: error_point,
error_linestring and error_polygon. """
tables = ['error_point', 'error_linestring', 'error_polygon']
group_name = os.path.splitext(os.path.basename(dbfile))[0]
legend_group = QgsProject.instance().layerTreeRoot().insertGroup(0, group_name)
for table in tables:
# Create new layer
layer = QgsVectorLayer(dbfile + '|layername=' + table, table, 'ogr')
if not layer:
print('error creating layer')
# Set encoding on the layer
layer.setProviderEncoding(u'UTF-8')
layer.dataProvider().setEncoding(u'UTF-8')
# Add style from file
style_file = os.path.join(self.plugin_dir, 'styles', '{0}.qml'.format(table))
if os.path.isfile(style_file):
layer.loadNamedStyle(style_file)
# Add layer to qgis - but dont add to legend directly
if QgsMapLayerRegistry.instance().addMapLayer(layer, False):
legend_group.addLayer(layer)
else:
print('Unable to add layer: {}'.format(table))
def testCategorizedFunctionConflict(self):
layer = QgsVectorLayer("Point", "addfeat", "memory")
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.qml' % (unitTestDataPath(), "categorizedFunctionConflict"))
status = layer.loadNamedStyle(mFilePath) # NOQA
dom, root = self.layerToSld(layer)
# print("Rule based, with root scale deps:" + dom.toString())
ruleCount = root.elementsByTagName('se:Rule').size() # NOQA
self.assertEqual(7, ruleCount)
self.assertRuleRangeFilter(root, 0, 'Area', '0', True, '500', True)
self.assertRuleRangeFilter(root, 1, 'Area', '500', False, '1000', True)
self.assertRuleRangeFilter(root, 2, 'Area', '1000', False, '5000', True)
self.assertRuleRangeFilter(root, 3, 'Area', '5000', False, '10000', True)
self.assertRuleRangeFilter(root, 4, 'Area', '10000', False, '50000', True)
self.assertRuleRangeFilter(root, 5, 'Area', '50000', False, '100000', True)
self.assertRuleRangeFilter(root, 6, 'Area', '100000', False, '200000', True)
def testCategorizedFunctionConflict(self):
layer = QgsVectorLayer("Point", "addfeat", "memory")
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.qml' % (unitTestDataPath(), "categorizedFunctionConflict"))
status = layer.loadNamedStyle(mFilePath) # NOQA
dom, root = self.layerToSld(layer)
# print("Rule based, with root scale deps:" + dom.toString())
ruleCount = root.elementsByTagName('se:Rule').size() # NOQA
self.assertEqual(7, ruleCount)
self.assertRuleRangeFilter(root, 0, 'Area', '0', True, '500', True)
self.assertRuleRangeFilter(root, 1, 'Area', '500', False, '1000', True)
self.assertRuleRangeFilter(root, 2, 'Area', '1000', False, '5000', True)
self.assertRuleRangeFilter(root, 3, 'Area', '5000', False, '10000', True)
self.assertRuleRangeFilter(root, 4, 'Area', '10000', False, '50000', True)
self.assertRuleRangeFilter(root, 5, 'Area', '50000', False, '100000', True)
self.assertRuleRangeFilter(root, 6, 'Area', '100000', False, '200000', True)
def load(self, insertion_point: QgsLayerTreeRegistryBridge.InsertionPoint,
loading_options: LoadingOptions) -> bool:
layer = None
if self.postgis_datasource is not None and loading_options.loading_mode == LoadingMode.PG:
uri = postgis_datasource_to_uri(self.postgis_datasource,
loading_options.pg_auth_id,
loading_options.pg_service)
if uri:
layer = QgsVectorLayer(uri.uri(False), self.name, "postgres")
if layer.isValid() and self.qml:
with NamedTemporaryFile(mode='w',
suffix='.qml',
delete=False,
encoding='utf-8') as fh:
fh.write(self.qml)
msg, ok = layer.loadNamedStyle(fh.name)
fh.close()
if not ok:
info(
'SoLocator could not load QML style for layer {ln}. {emsg} URI: {uri}'
.format(ln=self.name,
emsg=msg,
uri=uri.uri(False)), Qgis.Warning)
if layer is None:
if image_format_force_jpeg(self.name, self.is_background):
img_format = 'jpeg'
else:
img_format = loading_options.wms_image_format
url = wms_datasource_to_url(self.wms_datasource, self.crs,
img_format)
layer = QgsRasterLayer(url, self.name, 'wms')
QgsProject.instance().addMapLayer(layer, False)
if not layer.isValid():
info(
'Layer {} konnte nicht korrekt geladen werden.'.format(
self.name), Qgis.Warning)
return False
else:
if insertion_point.position >= 0:
insertion_point.group.insertLayer(insertion_point.position,
layer)
else:
insertion_point.group.addLayer(layer)
return True
def create_sdl_for_fgdb_layer(fgdb_path, layer_name):
parent_dir = path.abspath(path.join(fgdb_path, '..'))
qml_path = path.join(parent_dir, "{}.qml".format(layer_name))
sld_path = path.join(parent_dir, "{}.sld".format(layer_name))
if not path.isfile(qml_path):
print("Missing QML:", layer_name)
return
uri = "{}|layername={}".format(fgdb_path, layer_name)
layer = QgsVectorLayer(uri, layer_name, "ogr")
load_msg, load_success = layer.loadNamedStyle(qml_path)
if not load_success:
print("Error loading QML: {}, {}".format(layer_name, load_msg))
return
write_success = layer.saveSldStyle(sld_path)
if not write_success:
print("Error writing SDL: {}".format(layer_name))
return
print("Complete: {}".format(layer_name))
def addTROlayers(self,jsonfile,epsg,layername,troformat):
lcheck = True
path_to_tro_layer = jsonfile
maplayerName = layername
uriLine = path_to_tro_layer + "|geometrytype=LineString"
uriPoint = path_to_tro_layer + "|geometrytype=Point"
uriPolygon = path_to_tro_layer + "|geometrytype=Polygon"
vlayer = QgsVectorLayer(path_to_tro_layer , maplayerName, "ogr")
vlayerPoint = QgsVectorLayer(uriPoint , maplayerName, "ogr")
vlayerLine = QgsVectorLayer(uriLine, maplayerName, "ogr")
vlayerPolygon = QgsVectorLayer(uriPolygon, maplayerName, "ogr")
point_style_file = os.path.join(self.plugin_dir,"style","{}_POINT.qml".format(troformat))
line_style_file = os.path.join(self.plugin_dir,"style","{}_LINESTRING.qml".format(troformat))
polygon_style_file = os.path.join(self.plugin_dir,"style","{}_POLYGON.qml".format(troformat))
vlayerPoint.loadNamedStyle(point_style_file)
vlayerLine.loadNamedStyle(line_style_file)
vlayerPolygon.loadNamedStyle(polygon_style_file)
if not vlayer.isValid():
print("Layer failed to load!")
lcheck = False
else:
#Add Layers to map
QgsProject.instance().addMapLayer(vlayerPoint)
QgsProject.instance().addMapLayer(vlayerLine)
QgsProject.instance().addMapLayer(vlayerPolygon)
crs = vlayer.crs()
crs.createFromId(int(epsg))
#Set projection of file from dialog
vlayerPoint.setCrs(crs)
vlayerLine.setCrs(crs)
vlayerPolygon.setCrs(crs)
return lcheck
def loadMapPreview(self, gidstr):
""" if has geometry column load to map canvas """
layerToSet = []
srs = QgsCoordinateReferenceSystem(self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId)
sqlite_DB_path = '{}{}{}'.format(self.HOME, os.sep, "pyarchinit_DB_folder")
path_cfg = '{}{}{}'.format(sqlite_DB_path, os.sep, 'config.cfg')
conf = open(path_cfg, "r")
con_sett = conf.read()
conf.close()
settings = Settings(con_sett)
settings.set_configuration()
if settings.SERVER == 'postgres':
uri = QgsDataSourceUri()
# set host name, port, database name, username and password
uri.setConnection(settings.HOST, settings.PORT, settings.DATABASE, settings.USER, settings.PASSWORD)
# layerUS
uri.setDataSource("public", "pyarchinit_archeozoo_view", "the_geom", gidstr, "id_archzoo")
layerUS = QgsVectorLayer(uri.uri(), "Fauna", "postgres")
if layerUS.isValid():
# self.USLayerId = layerUS.getLayerID()
# style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'us_caratterizzazioni.qml')
# layerUS.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerUS], False)
layerToSet.append(layerUS)
# layerQuote
uri.setDataSource("public", "pyarchinit_quote_view", "the_geom", gidstr, "id_us")
layerQUOTE = QgsVectorLayer(uri.uri(), "Quote", "postgres")
if layerQUOTE.isValid():
# style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'stile_quote.qml')
# layerQUOTE.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerQUOTE], False)
layerToSet.append(layerQUOTE)
return layerToSet
elif settings.SERVER == 'sqlite':
sqliteDB_path = os.path.join(os.sep, 'pyarchinit_DB_folder', 'pyarchinit_db.sqlite')
db_file_path = '{}{}'.format(self.HOME, sqliteDB_path)
uri = QgsDataSourceUri()
uri.setDatabase(db_file_path)
# layerQuote
uri.setDataSource('', 'pyarchinit_quote_view', 'the_geom', gidstr, "ROWID")
layerQUOTE = QgsVectorLayer(uri.uri(), 'pyarchinit_quote_view', 'spatialite')
if layerQUOTE.isValid():
###QMessageBox.warning(self, "TESTER", "OK Layer Quote valido",#QMessageBox.Ok)
style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'quote_us_view.qml')
layerQUOTE.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerQUOTE], False)
layerToSet.append(layerQUOTE)
else:
pass
# QMessageBox.warning(self, "TESTER", "OK Layer Quote non valido", #QMessageBox.Ok)
uri.setDataSource('', 'pyarchinit_us_view', 'the_geom', gidstr, "ROWID")
layerUS = QgsVectorLayer(uri.uri(), 'pyarchinit_us_view', 'spatialite')
if layerUS.isValid():
# QMessageBox.warning(self, "TESTER", "OK ayer US valido", #QMessageBox.Ok)
style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'us_view.qml')
layerUS.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerUS], False)
layerToSet.append(layerQUOTE)
else:
pass
# QMessageBox.warning(self, "TESTER", "NOT! Layer US not valid",#QMessageBox.Ok)
return layerToSet
def load(self, layer, visible=True, collapsed_legend=False,
collapsed_group=True):
settings = QSettings("CatAIS", "VeriSO")
module_name = settings.value("project/appmodule")
provider = settings.value("project/provider")
db_host = settings.value("project/dbhost")
db_port = settings.value("project/dbport")
db_name = settings.value("project/dbname")
db_schema = settings.value("project/dbschema")
db_user = settings.value("project/dbuser")
db_pwd = settings.value("project/dbpwd")
db_admin = settings.value("project/dbadmin")
db_admin_pwd = settings.value("project/dbadminpwd")
epsg = settings.value("project/epsg")
if not db_schema:
self.message_bar.pushMessage("Error", tr(
"Missing database schema parameter."),
QgsMessageBar.CRITICAL, duration=0)
return
if not db_host:
self.message_bar.pushMessage("Error", tr(
"Missing database host parameter."), QgsMessageBar.CRITICAL,
duration=0)
return
if not db_name:
self.message_bar.pushMessage("Error", tr(
"Missing database name parameter."), QgsMessageBar.CRITICAL,
duration=0)
return
if not db_port:
self.message_bar.pushMessage("Error", tr(
"Missing database port parameter."), QgsMessageBar.CRITICAL,
duration=0)
return
if not db_user:
self.message_bar.pushMessage("Error", tr(
"Missing database user parameter."), QgsMessageBar.CRITICAL,
duration=0)
return
if not db_pwd:
self.message_bar.pushMessage("Error", tr(
"Missing database user password parameter."),
QgsMessageBar.CRITICAL, duration=0)
return
if not db_admin:
self.message_bar.pushMessage("Error", tr(
"Missing database administrator parameter."),
QgsMessageBar.CRITICAL, duration=0)
return
if not db_admin_pwd:
self.message_bar.pushMessage("Error", tr(
"Missing database administrator password parameter."),
QgsMessageBar.CRITICAL, duration=0)
return
if not provider:
self.message_bar.pushMessage("Error", tr(
"Missing provider parameter. Cannot load layer."),
QgsMessageBar.CRITICAL, duration=0)
return
if not module_name:
self.message_bar.pushMessage("Error", tr(
"Missing module name parameter. Cannot load layer."),
QgsMessageBar.CRITICAL, duration=0)
return
try:
# Postgres
if layer["type"] == "postgres":
featuretype = str(layer["featuretype"])
title = layer["title"]
key = str(layer["key"])
try:
readonly = (layer["readonly"])
except:
readonly = True
try:
geom = str(layer["geom"])
if geom == "":
geom = None
except:
geom = None
try:
style = str(layer["style"])
except:
style = ""
try:
group = str(layer["group"])
except:
group = None
try:
sql = str(layer["sql"])
except:
sql = ""
# Overwrite the active project settings/parameters to add
# *any* postgres layers.
try:
params = layer["params"]
provider = layer["type"]
db_host = params["dbhost"]
db_port = str(params["dbport"])
db_name = params["dbname"]
db_schema = params["dbschema"]
db_user = params["dbuser"]
db_pwd = params["dbpwd"]
db_admin = params["dbadmin"]
db_admin_pwd = params["dbadminpwd"]
except:
pass
uri = QgsDataSourceURI()
if readonly:
uri.setConnection(db_host, db_port, db_name, db_user,
db_pwd)
else:
uri.setConnection(db_host, db_port, db_name, db_admin,
db_admin_pwd)
uri.setDataSource(db_schema, featuretype, geom, sql, key)
my_layer = QgsVectorLayer(uri.uri(), title, provider)
# WMS / WMTS:
# WMTS is a bit ugly since we need to know the tileMatrixSet:
# Load layer manually in QGIS once an look for the tileMatrixSet
# in the layer properties.
elif layer["type"] in["wms", "wmts"]:
url = layer["url"]
title = layer["title"]
layers = layer["layers"]
format = layer["format"]
try:
tilematrixset = layer["tilematrixset"]
except:
tilematrixset = None
try:
crs = layer["crs"]
except:
crs = "EPSG:" + str(epsg)
try:
styles = layer["styles"]
except:
styles = ""
try:
group = layer["group"]
except:
group = None
try:
style = layer["style"]
except:
style = ""
my_layers = layers.split(",")
my_styles = styles.split(",")
layer_string = ""
style_string = ""
for my_layer in my_layers:
layer_string += "&layers=" + my_layer
# So werden einfach leere Styles requested.
# Korrekterweise wäre style=qml und wmsstyle = Style der
# vom WMS requested wird.
style_string += "&styles="
if layer["type"] == "wms":
uri = "IgnoreGetMapUrl=1&crs=" + crs + layer_string + \
style_string + "&format=" + format + "&url=" + url
else:
uri = "crs=" + crs + layer_string + style_string + \
"&format=" + format + "&tileMatrixSet=" + \
tilematrixset + "&url=" + url
my_layer = QgsRasterLayer(uri, title, "wms", False)
# local ogr and gdal formats
elif layer["type"] in ["gdal", "ogr"]:
title = layer["title"]
url = layer["url"]
try:
style = str(layer["style"])
except:
style = ""
try:
group = str(layer["group"])
except:
group = None
if layer["type"] == 'ogr':
my_layer = QgsVectorLayer(url, title, layer["type"])
else:
my_layer = QgsRasterLayer(url, title)
else:
self.message_bar.pushMessage(
"Error",
tr(
"Data provider not yet supported: ") + str(
layer["type"]), QgsMessageBar.CRITICAL,
duration=0)
return
if style != "":
if style.startswith('global_qml'):
qml_dir = "/plugins/veriso/"
else:
qml_dir = "/plugins/veriso/modules/%s/qml/" % \
module_name
"""qml_path = QDir.convertSeparators(QDir.cleanPath(
QgsApplication.qgisSettingsDirPath() +
qml_dir + style))"""
qml_path=QDir.convertSeparators(QDir.cleanPath(
(os.path.realpath(__file__)).split("plugins")[0] +qml_dir + style))
qml = QDir.convertSeparators(QDir.cleanPath(qml_path))
my_layer.loadNamedStyle(qml)
if not my_layer.isValid():
# str(title) throws some ascii out of range error...
self.message_bar.pushMessage("Error", title + tr(
" is not valid layer."), QgsMessageBar.CRITICAL,
duration=0)
return
else:
# QgsMapLayerRegistry.instance().addMapLayer(my_layer)
if group: # Layer soll in eine bestimmte Gruppe hinzugefügt
# werden.
QgsMapLayerRegistry.instance().addMapLayer(my_layer, False)
my_group_node = self.root.findGroup(group)
if not my_group_node: # Gruppe noch nicht vorhanden.
my_group_node = self.root.addGroup(group)
# Achtung: Das ist eher ein Workaround. Meines
# Erachtens hats noch einen Bug.
# Mit QgsMapLayerRegistry.instance().addMapLayer(
# my_layer, False) wird
# ein Layer noch nicht in die Legende gehängt.
# Anschliessend kann man ihn
# mit my_layer_node = self.root.addLayer(my_layer)
# der Legende hinzufügen.
# Das führt aber dazu, dass was mit dem MapCanvas
# nicht mehr stimmt, dh.
# .setExtent() funktioniert nicht mehr richtig. Wird
# der Layer jedoch direkt
# in die Legende gehängt, funktioniert .setExtent()
# tadellos. Jetzt wird halt
# momentan der Layer direkt eingehängt und
# anschliessend in die gewünschte
# Gruppe verschoben.
# Kleiner (positiver) Nebeneffekt: Der Layer ist
# defaultmässig ausgeschaltet.
#
# NEIN: Anscheinend ist es ein Problem wenn man dann
# layer_node.setVisible(Qt.Checked)
# macht. Dann funktionierts nicht mehr. -> Wieder
# zurückändern auf einfachere Methode.
# "Umweg": Hat Probleme gemacht, falls ein Gruppe
# "active" war. Dann wurden der neue
# Layer ebenfalls (zusätzlich) ihr hinzugefügt.
# print my_layer.id()
# my_layer_node = self.root.findLayer(
# my_layer.id())
# print my_layer_node
# cloned_layer = my_layer_node.clone()
# print cloned_layer
# my_group_node.insertChildNode(0,
# cloned_layer)
# self.root.removeChildNode(
# my_layer_node)
# my_layer_node = self.root.findLayer(
# my_layer.id()) # Layer bekommt neuen layer_node.
# "Direkt(er)"
my_layer_node = my_group_node.insertLayer(0, my_layer)
else:
QgsMapLayerRegistry.instance().addMapLayer(my_layer, False)
my_layer_node = self.root.addLayer(my_layer)
my_layer_node.setVisible(Qt.Unchecked)
my_layer_node.setCustomProperty("showFeatureCount",True)
if visible:
my_layer_node.setVisible(Qt.Checked)
if collapsed_legend:
my_layer_node.setExpanded(False)
else:
my_layer_node.setExpanded(True)
if 'my_group_node' in locals():
if collapsed_group:
my_group_node.setExpanded(False)
else:
my_group_node.setExpanded(True)
return my_layer
except Exception as e:
self.message_bar.pushMessage("Error", str(e),
QgsMessageBar.CRITICAL, duration=0)
QgsMessageLog.logMessage(str(e), "VeriSO", QgsMessageLog.CRITICAL)
return
def charge_individui_us(self, data):
# Clean Qgis Map Later Registry
# QgsMapLayerRegistry.instance().removeAllMapLayers()
# Get the user input, starting with the table name
# self.find_us_cutted(data)
cfg_rel_path = os.path.join(os.sep, 'pyarchinit_DB_folder', 'config.cfg')
file_path = '{}{}'.format(self.HOME, cfg_rel_path)
conf = open(file_path, "r")
con_sett = conf.read()
conf.close()
settings = Settings(con_sett)
settings.set_configuration()
if settings.SERVER == 'sqlite':
sqliteDB_path = os.path.join(os.sep, 'pyarchinit_DB_folder', 'pyarchinit_db.sqlite')
db_file_path = '{}{}'.format(self.HOME, sqliteDB_path)
gidstr = id_us = "id_us = '" + str(data[0]) + "'"
if len(data) > 1:
for i in range(len(data)):
gidstr += " OR id_us = '" + str(data[i]) + "'"
uri = QgsDataSourceUri()
uri.setDatabase(db_file_path)
uri.setDataSource('', 'pyarchinit_us_view', 'Geometry', gidstr, "gid")
layerUS = QgsVectorLayer(uri.uri(), 'pyarchinit_us_view', 'spatialite')
###################################################################�
if layerUS.isValid():
# self.USLayerId = layerUS.getLayerID()
# style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'us_caratterizzazioni.qml')
# layerUS.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerUS], True)
uri.setDataSource('', 'pyarchinit_quote_view', 'Geometry', gidstr, "gid")
layerQUOTE = QgsVectorLayer(uri.uri(), 'pyarchinit_quote_view', 'spatialite')
if layerQUOTE.isValid():
QgsProject.instance().addMapLayers([layerQUOTE], True)
elif settings.SERVER == 'postgres':
uri = QgsDataSourceUri()
# set host name, port, database name, username and password
uri.setConnection(settings.HOST, settings.PORT, settings.DATABASE, settings.USER, settings.PASSWORD)
gidstr = id_us = "id_archzoo = " + str(data[0])
if len(data) > 1:
for i in range(len(data)):
gidstr += " OR id_archzoo = " + str(data[i])
srs = QgsCoordinateReferenceSystem(self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId)
uri.setDataSource("public", "pyarchinit_archeozoo_view", "the_geom", gidstr, "gid")
layerUS = QgsVectorLayer(uri.uri(), "Fauna", "postgres")
if layerUS.isValid():
layerUS.setCrs(srs)
# self.USLayerId = layerUS.getLayerID()
# style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'us_caratterizzazioni.qml')
style_path = QFileDialog.getOpenFileName(self, 'Open file', self.LAYER_STYLE_PATH)
layerUS.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerUS], True)
uri.setDataSource("public", "pyarchinit_quote_view", "the_geom", gidstr, "gid")
layerQUOTE = QgsVectorLayer(uri.uri(), "Quote Unita' Stratigrafiche", "postgres")
if layerQUOTE.isValid():
layerQUOTE.setCrs(srs)
style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'stile_quote.qml')
layerQUOTE.loadNamedStyle(style_path)
try:
QgsProject.instance().addMapLayers([layerQUOTE], True)
except Exception as e:
pass
def run(item, action, mainwindow):
db = item.database()
uri = db.uri()
iface = mainwindow.iface
quoteId = db.connector.quoteId
quoteStr = db.connector.quoteString
# check if the selected item is a topology schema
isTopoSchema = False
if not hasattr(item, 'schema'):
mainwindow.infoBar.pushMessage(
"Invalid topology", u'Select a topology schema to continue.',
QgsMessageBar.INFO, mainwindow.iface.messageTimeout())
return False
if item.schema() is not None:
sql = u"SELECT srid FROM topology.topology WHERE name = %s" % quoteStr(
item.schema().name)
c = db.connector._get_cursor()
db.connector._execute(c, sql)
res = db.connector._fetchone(c)
isTopoSchema = res is not None
if not isTopoSchema:
mainwindow.infoBar.pushMessage(
"Invalid topology",
u'Schema "{0}" is not registered in topology.topology.'.format(
item.schema().name), QgsMessageBar.WARNING,
mainwindow.iface.messageTimeout())
return False
if (res[0] < 0):
mainwindow.infoBar.pushMessage(
"WARNING",
u'Topology "{0}" is registered as having a srid of {1} in topology.topology, we will assume 0 (for unknown)'
.format(item.schema().name, res[0]), QgsMessageBar.WARNING,
mainwindow.iface.messageTimeout())
toposrid = '0'
else:
toposrid = str(res[0])
# load layers into the current project
toponame = item.schema().name
template_dir = os.path.join(current_path, 'templates')
# do not refresh the canvas until all the layers are added
wasFrozen = iface.mapCanvas().isFrozen()
iface.mapCanvas().freeze()
try:
provider = db.dbplugin().providerName()
uri = db.uri()
# Force use of estimated metadata (topologies can be big)
uri.setUseEstimatedMetadata(True)
# FACES
# face mbr
uri.setDataSource(toponame, 'face', 'mbr', '', 'face_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.Polygon)
layerFaceMbr = QgsVectorLayer(uri.uri(False),
u'%s.face_mbr' % toponame, provider)
layerFaceMbr.loadNamedStyle(os.path.join(template_dir, 'face_mbr.qml'))
face_extent = layerFaceMbr.extent()
# face geometry
sql = u'SELECT face_id, topology.ST_GetFaceGeometry(%s,' \
'face_id)::geometry(polygon, %s) as geom ' \
'FROM %s.face WHERE face_id > 0' % \
(quoteStr(toponame), toposrid, quoteId(toponame))
uri.setDataSource('', u'(%s\n)' % sql, 'geom', '', 'face_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.Polygon)
layerFaceGeom = QgsVectorLayer(uri.uri(False), u'%s.face' % toponame,
provider)
layerFaceGeom.setExtent(face_extent)
layerFaceGeom.loadNamedStyle(os.path.join(template_dir, 'face.qml'))
# face_seed
sql = u'SELECT face_id, ST_PointOnSurface(' \
'topology.ST_GetFaceGeometry(%s,' \
'face_id))::geometry(point, %s) as geom ' \
'FROM %s.face WHERE face_id > 0' % \
(quoteStr(toponame), toposrid, quoteId(toponame))
uri.setDataSource('', u'(%s)' % sql, 'geom', '', 'face_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.Point)
layerFaceSeed = QgsVectorLayer(uri.uri(False),
u'%s.face_seed' % toponame, provider)
layerFaceSeed.setExtent(face_extent)
layerFaceSeed.loadNamedStyle(
os.path.join(template_dir, 'face_seed.qml'))
# TODO: add polygon0, polygon1 and polygon2 ?
# NODES
# node
uri.setDataSource(toponame, 'node', 'geom', '', 'node_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.Point)
layerNode = QgsVectorLayer(uri.uri(False), u'%s.node' % toponame,
provider)
layerNode.loadNamedStyle(os.path.join(template_dir, 'node.qml'))
node_extent = layerNode.extent()
# node labels
uri.setDataSource(toponame, 'node', 'geom', '', 'node_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.Point)
layerNodeLabel = QgsVectorLayer(uri.uri(False),
u'%s.node_id' % toponame, provider)
layerNodeLabel.setExtent(node_extent)
layerNodeLabel.loadNamedStyle(
os.path.join(template_dir, 'node_label.qml'))
# EDGES
# edge
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
layerEdge = QgsVectorLayer(uri.uri(False), u'%s.edge' % toponame,
provider)
edge_extent = layerEdge.extent()
# directed edge
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
layerDirectedEdge = QgsVectorLayer(uri.uri(False),
u'%s.directed_edge' % toponame,
provider)
layerDirectedEdge.setExtent(edge_extent)
layerDirectedEdge.loadNamedStyle(os.path.join(template_dir,
'edge.qml'))
# edge labels
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
layerEdgeLabel = QgsVectorLayer(uri.uri(False),
u'%s.edge_id' % toponame, provider)
layerEdgeLabel.setExtent(edge_extent)
layerEdgeLabel.loadNamedStyle(
os.path.join(template_dir, 'edge_label.qml'))
# face_left
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
layerFaceLeft = QgsVectorLayer(uri.uri(False),
u'%s.face_left' % toponame, provider)
layerFaceLeft.setExtent(edge_extent)
layerFaceLeft.loadNamedStyle(
os.path.join(template_dir, 'face_left.qml'))
# face_right
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
layerFaceRight = QgsVectorLayer(uri.uri(False),
u'%s.face_right' % toponame, provider)
layerFaceRight.setExtent(edge_extent)
layerFaceRight.loadNamedStyle(
os.path.join(template_dir, 'face_right.qml'))
# next_left
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
layerNextLeft = QgsVectorLayer(uri.uri(False),
u'%s.next_left' % toponame, provider)
layerNextLeft.setExtent(edge_extent)
layerNextLeft.loadNamedStyle(
os.path.join(template_dir, 'next_left.qml'))
# next_right
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
layerNextRight = QgsVectorLayer(uri.uri(False),
u'%s.next_right' % toponame, provider)
layerNextRight.setExtent(edge_extent)
layerNextRight.loadNamedStyle(
os.path.join(template_dir, 'next_right.qml'))
# Add layers to the layer tree
faceLayers = [layerFaceMbr, layerFaceGeom, layerFaceSeed]
nodeLayers = [layerNode, layerNodeLabel]
edgeLayers = [
layerEdge, layerDirectedEdge, layerEdgeLabel, layerEdgeFaceLeft,
layerEdgeFaceRight, layerEdgeNextLeft, layerEdgeNextRight
]
QgsProject.instance().addMapLayers(faceLayers, False)
groupFaces = QgsLayerTreeGroup(u'Faces')
for layer in faceLayers:
nodeLayer = groupFaces.addLayer(layer)
nodeLayer.setVisible(Qt.Unchecked)
nodeLayer.setExpanded(False)
groupNodes = QgsLayerTreeGroup(u'Nodes')
for layer in faceLayers:
nodeLayer = groupNodes.addLayer(layer)
nodeLayer.setVisible(Qt.Unchecked)
nodeLayer.setExpanded(False)
groupEdges = QgsLayerTreeGroup(u'Edges')
for layer in faceLayers:
nodeLayer = groupEdges.addLayer(layer)
nodeLayer.setVisible(Qt.Unchecked)
nodeLayer.setExpanded(False)
supergroup = QgsLayerTreeGroup(u'Topology "%s"' % toponame)
supergroup.insertChildNodes(-1, [groupFaces, groupNodes, groupEdges])
QgsProject.instance().layerTreeRoot().addChildNode(supergroup)
finally:
# Set canvas extent to topology extent, if not yet initialized
canvas = iface.mapCanvas()
if (canvas.fullExtent().isNull()):
ext = node_extent
ext.combineExtentWith(edge_extent)
# Grow by 1/20 of largest side
ext = ext.buffer(max(ext.width(), ext.height()) / 20)
canvas.setExtent(ext)
# restore canvas render flag
if not wasFrozen:
iface.mapCanvas().freeze(False)
return True
def run(item, action, mainwindow):
db = item.database()
uri = db.uri()
iface = mainwindow.iface
quoteId = db.connector.quoteId
quoteStr = db.connector.quoteString
# check if the selected item is a topology schema
isTopoSchema = False
if not hasattr(item, 'schema'):
mainwindow.infoBar.pushMessage("Invalid topology", u'Select a topology schema to continue.', QgsMessageBar.INFO,
mainwindow.iface.messageTimeout())
return False
if item.schema() is not None:
sql = u"SELECT srid FROM topology.topology WHERE name = %s" % quoteStr(item.schema().name)
c = db.connector._get_cursor()
db.connector._execute(c, sql)
res = db.connector._fetchone(c)
isTopoSchema = res is not None
if not isTopoSchema:
mainwindow.infoBar.pushMessage("Invalid topology",
u'Schema "{0}" is not registered in topology.topology.'.format(
item.schema().name), QgsMessageBar.WARNING,
mainwindow.iface.messageTimeout())
return False
if (res[0] < 0):
mainwindow.infoBar.pushMessage("WARNING", u'Topology "{0}" is registered as having a srid of {1} in topology.topology, we will assume 0 (for unknown)'.format(item.schema().name, res[0]), QgsMessageBar.WARNING, mainwindow.iface.messageTimeout())
toposrid = '0'
else:
toposrid = unicode(res[0])
# load layers into the current project
toponame = item.schema().name
template_dir = os.path.join(current_path, 'templates')
registry = QgsMapLayerRegistry.instance()
legend = iface.legendInterface()
# do not refresh the canvas until all the layers are added
prevRenderFlagState = iface.mapCanvas().renderFlag()
iface.mapCanvas().setRenderFlag(False)
try:
supergroup = legend.addGroup(u'Topology "%s"' % toponame, False)
provider = db.dbplugin().providerName()
uri = db.uri()
# FACES
group = legend.addGroup(u'Faces', False, supergroup)
# face mbr
uri.setDataSource(toponame, 'face', 'mbr', '', 'face_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBPolygon)
layer = QgsVectorLayer(uri.uri(), u'%s.face_mbr' % toponame, provider)
layer.loadNamedStyle(os.path.join(template_dir, 'face_mbr.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
face_extent = layer.extent()
# face geometry
sql = u'SELECT face_id, topology.ST_GetFaceGeometry(%s, face_id) as geom ' \
'FROM %s.face WHERE face_id > 0' % (quoteStr(toponame), quoteId(toponame))
uri.setDataSource('', u'(%s\n)' % sql, 'geom', '', 'face_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBPolygon)
layer = QgsVectorLayer(uri.uri(), u'%s.face' % toponame, provider)
layer.setExtent(face_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'face.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# face_seed
sql = u'SELECT face_id, ST_PointOnSurface(topology.ST_GetFaceGeometry(%s, face_id)) as geom ' \
'FROM %s.face WHERE face_id > 0' % (quoteStr(toponame), quoteId(toponame))
uri.setDataSource('', u'(%s)' % sql, 'geom', '', 'face_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBPoint)
layer = QgsVectorLayer(uri.uri(), u'%s.face_seed' % toponame, provider)
layer.setExtent(face_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'face_seed.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# TODO: add polygon0, polygon1 and polygon2 ?
# NODES
group = legend.addGroup(u'Nodes', False, supergroup)
# node
uri.setDataSource(toponame, 'node', 'geom', '', 'node_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBPoint)
layer = QgsVectorLayer(uri.uri(), u'%s.node' % toponame, provider)
layer.loadNamedStyle(os.path.join(template_dir, 'node.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
node_extent = layer.extent()
# node labels
uri.setDataSource(toponame, 'node', 'geom', '', 'node_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBPoint)
layer = QgsVectorLayer(uri.uri(), u'%s.node_id' % toponame, provider)
layer.setExtent(node_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'node_label.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# EDGES
group = legend.addGroup(u'Edges', False, supergroup)
# edge
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBLineString)
layer = QgsVectorLayer(uri.uri(), u'%s.edge' % toponame, provider)
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
edge_extent = layer.extent()
# directed edge
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBLineString)
layer = QgsVectorLayer(uri.uri(), u'%s.directed_edge' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'edge.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# edge labels
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBLineString)
layer = QgsVectorLayer(uri.uri(), u'%s.edge_id' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'edge_label.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# face_left
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBLineString)
layer = QgsVectorLayer(uri.uri(), u'%s.face_left' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'face_left.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# face_right
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBLineString)
layer = QgsVectorLayer(uri.uri(), u'%s.face_right' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'face_right.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# next_left
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBLineString)
layer = QgsVectorLayer(uri.uri(), u'%s.next_left' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'next_left.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# next_right
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QGis.WKBLineString)
layer = QgsVectorLayer(uri.uri(), u'%s.next_right' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'next_right.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
finally:
# Set canvas extent to topology extent, if not yet initialized
canvas = iface.mapCanvas()
if (canvas.fullExtent().isNull()):
ext = node_extent
ext.combineExtentWith(edge_extent)
# Grow by 1/20 of largest side
ext = ext.buffer(max(ext.width(), ext.height()) / 20)
canvas.setExtent(ext)
# restore canvas render flag
iface.mapCanvas().setRenderFlag(prevRenderFlagState)
return True
def nodeDuplicate(node,newname=None,position='bottom',target_node=None):
import time
if oeq_global.isStringOrUnicode(node):
node = nodeByName(node)
if len(node) == 0:
return None
node = node[0]
if target_node == None:
target_node = node.parent()
else:
if oeq_global.isStringOrUnicode(target_node):
target_node = nodeByName(target_node)
if len(target_node) == 0:
return None
target_node = target_node[0]
#
#print node.layer().name()
#print newname
layer = node.layer()
# source of the layer
provider = layer.dataProvider()
#print "---------------------"
#print provider.crs().authid()
#print layer.crs().authid()
#print "---------------------"
# creation of the shapefiles:
pathfile = os.path.join(oeq_global.OeQ_project_path(),newname+'.shp')
ct_pathfile = os.path.join(oeq_global.OeQ_project_path(),newname+'.qml')
writer = QgsVectorFileWriter(pathfile, "CP1250", provider.fields(), provider.geometryType(), layer.crs(), "ESRI Shapefile")
#print writer
outelem = QgsFeature()
# iterating over the input layer
for elem in layer.getFeatures():
outelem.setGeometry(elem.geometry() )
outelem.setAttributes(elem.attributes())
writer.addFeature(outelem)
del writer
oeq_global.OeQ_wait_for_file(pathfile)
#time.sleep(1)
newlayer = QgsVectorLayer(pathfile, newname, "ogr")
#print layer.isValid()
QgsMapLayerRegistry.instance().addMapLayer(newlayer, True)
newlayer.setCrs(layer.crs())
#oeq_global.OeQ_wait_for_renderer(60000)
#print newlayer.name()
newnode = nodeByName(newlayer.name())
if len(newnode) == 0:
return None
newnode = newnode[0]
# oeq_global.OeQ_unlockQgis()
#time.sleep(1)
newlayer.loadNamedStyle(ct_pathfile)
nodeCollapse(newnode)
#time.sleep(1)
#position = nodePosition(node,target_node)
newnode=nodeMove(newnode,position,target_node)
#time.sleep(1)
#oeq_global.OeQ_unlockQgis()
#oeq_global.OeQ_wait(0.5)
#print "+++++++++++++++"
return newnode
def run(item, action, mainwindow):
db = item.database()
uri = db.uri()
iface = mainwindow.iface
quoteId = db.connector.quoteId
quoteStr = db.connector.quoteString
# check if the selected item is a topology schema
isTopoSchema = False
if not hasattr(item, 'schema'):
mainwindow.infoBar.pushMessage("Invalid topology", u'Select a topology schema to continue.', QgsMessageBar.INFO, mainwindow.iface.messageTimeout())
return False
if item.schema() is not None:
sql = u"SELECT srid FROM topology.topology WHERE name = %s" % quoteStr(item.schema().name)
c = db.connector._get_cursor()
db.connector._execute( c, sql )
res = db.connector._fetchone( c )
isTopoSchema = res is not None
if not isTopoSchema:
mainwindow.infoBar.pushMessage("Invalid topology", u'Schema "{0}" is not registered in topology.topology.'.format(item.schema().name), QgsMessageBar.WARNING, mainwindow.iface.messageTimeout())
return False
toposrid = str(res[0])
# load layers into the current project
toponame = item.schema().name
template_dir = os.path.join(current_path, 'templates')
registry = QgsMapLayerRegistry.instance()
legend = iface.legendInterface()
# do not refresh the canvas until all the layers are added
prevRenderFlagState = iface.mapCanvas().renderFlag()
iface.mapCanvas().setRenderFlag( False )
try:
supergroup = legend.addGroup(u'Topology "%s"' % toponame, False)
provider = db.dbplugin().providerName()
uri = db.uri()
# FACES
group = legend.addGroup(u'Faces', False, supergroup)
# face mbr
uri.setDataSource(toponame, 'face', 'mbr', '', 'face_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBPolygon )
layer = QgsVectorLayer(uri.uri(), u'%s.face_mbr' % toponame, provider)
layer.loadNamedStyle(os.path.join(template_dir, 'face_mbr.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
face_extent = layer.extent()
# face geometry
sql = u'SELECT face_id, topology.ST_GetFaceGeometry(%s, face_id) as geom ' \
'FROM %s.face WHERE face_id > 0' % (quoteStr(toponame), quoteId(toponame))
uri.setDataSource('', u'(%s\n)' % sql, 'geom', '', 'face_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBPolygon )
layer = QgsVectorLayer(uri.uri(), u'%s.face' % toponame, provider)
layer.setExtent(face_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'face.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# face_seed
sql = u'SELECT face_id, ST_PointOnSurface(topology.ST_GetFaceGeometry(%s, face_id)) as geom ' \
'FROM %s.face WHERE face_id > 0' % (quoteStr(toponame), quoteId(toponame))
uri.setDataSource('', u'(%s)' % sql, 'geom', '', 'face_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBPoint )
layer = QgsVectorLayer(uri.uri(), u'%s.face_seed' % toponame, provider)
layer.setExtent(face_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'face_seed.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# TODO: add polygon0, polygon1 and polygon2 ?
# NODES
group = legend.addGroup(u'Nodes', False, supergroup)
# node
uri.setDataSource(toponame, 'node', 'geom', '', 'node_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBPoint )
layer = QgsVectorLayer(uri.uri(), u'%s.node' % toponame, provider)
layer.loadNamedStyle(os.path.join(template_dir, 'node.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
node_extent = layer.extent()
# node labels
uri.setDataSource(toponame, 'node', 'geom', '', 'node_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBPoint )
layer = QgsVectorLayer(uri.uri(), u'%s.node_id' % toponame, provider)
layer.setExtent(node_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'node_label.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# EDGES
group = legend.addGroup(u'Edges', False, supergroup)
# edge
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBLineString )
layer = QgsVectorLayer(uri.uri(), u'%s.edge' % toponame, provider)
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
edge_extent = layer.extent()
# directed edge
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBLineString )
layer = QgsVectorLayer(uri.uri(), u'%s.directed_edge' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'edge.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# edge labels
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBLineString )
layer = QgsVectorLayer(uri.uri(), u'%s.edge_id' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'edge_label.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# face_left
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBLineString )
layer = QgsVectorLayer(uri.uri(), u'%s.face_left' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'face_left.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# face_right
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBLineString )
layer = QgsVectorLayer(uri.uri(), u'%s.face_right' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'face_right.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# next_left
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBLineString )
layer = QgsVectorLayer(uri.uri(), u'%s.next_left' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'next_left.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
# next_right
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid( toposrid )
uri.setWkbType( QGis.WKBLineString )
layer = QgsVectorLayer(uri.uri(), u'%s.next_right' % toponame, provider)
layer.setExtent(edge_extent)
layer.loadNamedStyle(os.path.join(template_dir, 'next_right.qml'))
registry.addMapLayers([layer])
legend.moveLayer(layer, group)
legend.setLayerVisible(layer, False)
legend.setLayerExpanded(layer, False)
finally:
# restore canvas render flag
iface.mapCanvas().setRenderFlag( prevRenderFlagState )
return True
def testStyle(self):
# First test with invalid URI
vl = QgsVectorLayer('/idont/exist.gpkg', 'test', 'ogr')
self.assertFalse(vl.dataProvider().isSaveAndLoadStyleToDatabaseSupported())
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase()
self.assertEqual(related_count, -1)
self.assertEqual(idlist, [])
self.assertEqual(namelist, [])
self.assertEqual(desclist, [])
self.assertNotEqual(errmsg, "")
qml, errmsg = vl.getStyleFromDatabase("1")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
qml, success = vl.loadNamedStyle('/idont/exist.gpkg')
self.assertFalse(success)
errorMsg = vl.saveStyleToDatabase("name", "description", False, "")
self.assertNotEqual(errorMsg, "")
# Now with valid URI
tmpfile = os.path.join(self.basetestpath, 'testStyle.gpkg')
ds = ogr.GetDriverByName('GPKG').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbMultiPolygon)
lyr.CreateField(ogr.FieldDefn('foo', ogr.OFTString))
f = ogr.Feature(lyr.GetLayerDefn())
f['foo'] = 'bar'
lyr.CreateFeature(f)
f = None
lyr = ds.CreateLayer('test2', geom_type=ogr.wkbMultiPolygon)
lyr.CreateField(ogr.FieldDefn('foo', ogr.OFTString))
f = ogr.Feature(lyr.GetLayerDefn())
f['foo'] = 'bar'
lyr.CreateFeature(f)
f = None
ds = None
vl = QgsVectorLayer('{}|layername=test'.format(tmpfile), 'test', 'ogr')
self.assertTrue(vl.isValid())
vl2 = QgsVectorLayer('{}|layername=test2'.format(tmpfile), 'test2', 'ogr')
self.assertTrue(vl2.isValid())
self.assertTrue(vl.dataProvider().isSaveAndLoadStyleToDatabaseSupported())
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase()
self.assertEqual(related_count, 0)
self.assertEqual(idlist, [])
self.assertEqual(namelist, [])
self.assertEqual(desclist, [])
self.assertNotEqual(errmsg, "")
qml, errmsg = vl.getStyleFromDatabase("not_existing")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
qml, success = vl.loadNamedStyle('{}|layerid=0'.format(tmpfile))
self.assertFalse(success)
errorMsg = vl.saveStyleToDatabase("name", "description", False, "")
self.assertEqual(errorMsg, "")
qml, errmsg = vl.getStyleFromDatabase("not_existing")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase()
self.assertEqual(related_count, 1)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1'])
self.assertEqual(namelist, ['name'])
self.assertEqual(desclist, ['description'])
qml, errmsg = vl.getStyleFromDatabase("100")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
qml, errmsg = vl.getStyleFromDatabase("1")
self.assertTrue(qml.startswith('<!DOCTYPE qgis'), qml)
self.assertEqual(errmsg, "")
# Try overwrite it but simulate answer no
settings = QgsSettings()
settings.setValue("/qgis/overwriteStyle", False)
errorMsg = vl.saveStyleToDatabase("name", "description_bis", False, "")
self.assertNotEqual(errorMsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase()
self.assertEqual(related_count, 1)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1'])
self.assertEqual(namelist, ['name'])
self.assertEqual(desclist, ['description'])
# Try overwrite it and simulate answer yes
settings = QgsSettings()
settings.setValue("/qgis/overwriteStyle", True)
errorMsg = vl.saveStyleToDatabase("name", "description_bis", False, "")
self.assertEqual(errorMsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase()
self.assertEqual(related_count, 1)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1'])
self.assertEqual(namelist, ['name'])
self.assertEqual(desclist, ['description_bis'])
errorMsg = vl2.saveStyleToDatabase("name_test2", "description_test2", True, "")
self.assertEqual(errorMsg, "")
errorMsg = vl.saveStyleToDatabase("name2", "description2", True, "")
self.assertEqual(errorMsg, "")
errorMsg = vl.saveStyleToDatabase("name3", "description3", True, "")
self.assertEqual(errorMsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase()
self.assertEqual(related_count, 3)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1', '3', '4', '2'])
self.assertEqual(namelist, ['name', 'name2', 'name3', 'name_test2'])
self.assertEqual(desclist, ['description_bis', 'description2', 'description3', 'name_test2'])
# Check that layers_style table is not list in subLayers()
vl = QgsVectorLayer(tmpfile, 'test', 'ogr')
sublayers = vl.dataProvider().subLayers()
self.assertEqual(len(sublayers), 2, sublayers)
class QVisualize:
"""QGIS Plugin Implementation."""
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(self.plugin_dir, 'i18n',
'QVisualize_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference
self.dlg = QVisualizeDialog()
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&QVisualize')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'QVisualize')
self.toolbar.setObjectName(u'QVisualize')
# noinspection PyMethodMayBeStatic
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('QVisualize', message)
def add_action(self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar.
:param icon_path: Path to the icon for this action. Can be a resource
path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
:type icon_path: str
:param text: Text that should be shown in menu items for this action.
:type text: str
:param callback: Function to be called when the action is triggered.
:type callback: function
:param enabled_flag: A flag indicating if the action should be enabled
by default. Defaults to True.
:type enabled_flag: bool
:param add_to_menu: Flag indicating whether the action should also
be added to the menu. Defaults to True.
:type add_to_menu: bool
:param add_to_toolbar: Flag indicating whether the action should also
be added to the toolbar. Defaults to True.
:type add_to_toolbar: bool
:param status_tip: Optional text to show in a popup when mouse pointer
hovers over the action.
:type status_tip: str
:param parent: Parent widget for the new action. Defaults None.
:type parent: QWidget
:param whats_this: Optional text to show in the status bar when the
mouse pointer hovers over the action.
:returns: The action that was created. Note that the action is also
added to self.actions list.
:rtype: QAction
"""
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToMenu(self.menu, action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = ':/plugins/qvisualize/icon.png'
self.add_action(icon_path,
text=self.tr(u'QVisualize'),
callback=self.run,
parent=self.iface.mainWindow())
self.dlg.start.clicked.connect(self.start)
self.dlg.close_btn.clicked.connect(self.close)
self.dlg.allfeature.clicked.connect(self.allfeature)
self.dlg.finalfeature.clicked.connect(self.finalfeature)
self.canvas = self.iface.mapCanvas()
def finalfeature(self):
pass
def allfeature(self):
pass
def close(self):
self.dlg.close()
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginMenu(self.tr(u'&QVisualize'), action)
self.iface.removeToolBarIcon(action)
# remove the toolbar
del self.toolbar
def run_task(self, task, wait_time):
attr = [QgsField('fid', QVariant.String)]
self.temp_data.addAttributes(attr)
self.temp.updateFields()
FEATURES = self.selected_layer.getFeatures()
if not self.show__all_data:
for i, elem in enumerate(FEATURES):
feat = QgsFeature()
self.temp.startEditing()
feat.setGeometry(elem.geometry())
feat.setAttributes([str(i)])
self.temp.addFeatures([feat])
self.temp.commitChanges()
for feat_tmp in self.temp.getFeatures():
break
break
else:
feat_tmp = QgsFeature()
if self.show__all_data:
self.temp.startEditing()
for i, elem in enumerate(FEATURES):
task.setProgress((i / self.total) * 100)
if not self.show__all_data:
self.temp.startEditing()
self.temp.changeGeometry(feat_tmp.id(), elem.geometry())
self.temp.commitChanges()
else:
feat_tmp.setGeometry(elem.geometry())
feat_tmp.setAttributes([str(i)])
self.temp.addFeatures([feat_tmp])
sleep(wait_time)
self.temp.triggerRepaint()
if task.isCanceled():
self.stopped(task)
return None
self.temp.commitChanges()
def stopped(self, task):
try:
self.temp.commitChanges()
except:
pass
QgsMessageLog.logMessage(
'Task "{name}" was canceled'.format(name=task.description()),
MESSAGE_CATEGORY, Qgis.Info)
def completed(self, exception, result=None):
"""This is called when doSomething is finished.
Exception is not None if doSomething raises an exception.
Result is the return value of doSomething."""
if exception is None:
if result is None:
QgsMessageLog.logMessage(
'Completed with no exception and no result ' \
'(probably manually canceled by the user)',
MESSAGE_CATEGORY, Qgis.Warning)
else:
QgsMessageLog.logMessage(
'Task {name} completed\n'
'Total: {total} ( with {iterations} '
'iterations)'.format(name=result['task'],
total=result['total'],
iterations=result['iterations']),
MESSAGE_CATEGORY, Qgis.Info)
else:
QgsMessageLog.logMessage("Exception: {}".format(exception),
MESSAGE_CATEGORY, Qgis.Critical)
raise exception
def run(self):
"""Run method that performs all the real work"""
# show the dialog
self.dlg.comboBox.clear()
self.project = QgsProject.instance()
# Initial layer list
self.layer_list_name = []
self.layer_list = []
self.shp_type = 'Point'
for layer in self.canvas.layers():
if layer.type() == 0: #vectorlayer
if layer.wkbType() == 1 or layer.wkbType(
) == 3 or layer.wkbType() == 6 or layer.wkbType() == 3001:
self.layer_list_name.append(layer.name())
self.layer_list.append(layer)
self.dlg.comboBox.addItems(self.layer_list_name)
self.dlg.show()
def start(self):
# Layer selection
self.currentLayer = self.dlg.comboBox.currentText()
if self.currentLayer == '':
msgBox = QMessageBox()
msgBox.setIcon(QMessageBox.Warning)
msgBox.setWindowTitle('QVisualize')
msgBox.setText('Select a point/polygon layer.')
msgBox.setStandardButtons(QMessageBox.Ok)
msgBox.setWindowFlags(Qt.CustomizeWindowHint
| Qt.WindowStaysOnTopHint
| Qt.WindowCloseButtonHint)
msgBox.exec_()
return
self.selected_layer_index = self.layer_list_name.index(
self.currentLayer)
self.selected_layer = self.layer_list[self.selected_layer_index]
self.iface.setActiveLayer(self.selected_layer)
if self.selected_layer.wkbType() == 3:
self.shp_type = 'Polygon'
if self.selected_layer.wkbType() == 6:
self.shp_type = 'MultiPolygon'
if self.selected_layer.wkbType() == 3001:
self.shp_type = 'PointZM'
self.total = self.selected_layer.featureCount()
# Time delay
time_delay = self.dlg.time_delay.value()
# All features or final show
if self.dlg.allfeature.isChecked():
self.show__all_data = True
if self.dlg.finalfeature.isChecked():
self.show__all_data = False
self.selected_layer.saveNamedStyle(self.plugin_dir + "\\tmp.qml")
self.project.layerTreeRoot().findLayer(
self.selected_layer.id()).setItemVisibilityChecked(False)
self.temp = QgsVectorLayer(
self.shp_type + "?crs=" + self.selected_layer.crs().authid(),
self.currentLayer + "_qvisualize", "memory")
self.temp.loadNamedStyle(self.plugin_dir + "\\tmp.qml")
self.temp_data = self.temp.dataProvider()
self.project.addMapLayer(self.temp)
task = QgsTask.fromFunction(u'QVisualize',
self.run_task,
on_finished=self.completed,
wait_time=time_delay)
QgsApplication.taskManager().addTask(task)
self.dlg.close()
def open_file(
dialog=None,
osm_file=None,
output_geom_types=None,
white_list_column=None,
layer_name="OsmFile",
config_outputs=None,
output_dir=None,
final_query=None,
prefix_file=None):
"""
Open an osm file.
Memory layer if no output directory is set, or Geojson in the output directory.
:param final_query: The query where the file comes from. Might be empty if
it's a local OSM file.
:type final_query: basestring
"""
outputs = {}
if output_dir:
for layer in ['points', 'lines', 'multilinestrings', 'multipolygons']:
if not prefix_file:
prefix_file = layer_name
outputs[layer] = join(
output_dir, prefix_file + "_" + layer + ".geojson")
if isfile(outputs[layer]):
raise FileOutPutException(suffix='(' + outputs[layer] + ')')
# Legacy, waiting to remove the OsmParser for QGIS >= 3.6
# Change in osm_file_dialog.py L131 too
output_geom_legacy = [l.value.lower() for l in output_geom_types]
if not white_list_column:
white_list_column = {}
white_list_legacy = (
{l.value.lower(): csv for l, csv in white_list_column.items()}
)
LOGGER.info('The OSM file is: {}'.format(osm_file))
# Parsing the file
osm_parser = OsmParser(
osm_file=osm_file,
layers=output_geom_legacy,
white_list_column=white_list_legacy)
osm_parser.signalText.connect(dialog.set_progress_text)
osm_parser.signalPercentage.connect(dialog.set_progress_percentage)
start_time = time.time()
layers = osm_parser.parse()
elapsed_time = time.time() - start_time
parser_time = time.strftime("%Hh %Mm %Ss", time.gmtime(elapsed_time))
LOGGER.info('The OSM parser took: {}'.format(parser_time))
# Finishing the process with geojson or memory layer
num_layers = 0
for i, (layer, item) in enumerate(layers.items()):
dialog.set_progress_percentage(i / len(layers) * 100)
QApplication.processEvents()
if item['featureCount'] and LayerType(layer.capitalize()) in output_geom_types:
final_layer_name = layer_name
# If configOutputs is not None (from My Queries)
if config_outputs:
if config_outputs[layer]['namelayer']:
final_layer_name = config_outputs[layer]['namelayer']
if output_dir:
dialog.set_progress_text(tr('From memory to GeoJSON: ' + layer))
# Transforming the vector file
osm_geometries = {
'points': QgsWkbTypes.Point,
'lines': QgsWkbTypes.LineString,
'multilinestrings': QgsWkbTypes.MultiLineString,
'multipolygons': QgsWkbTypes.MultiPolygon}
memory_layer = item['vector_layer']
encoding = get_default_encoding()
writer = QgsVectorFileWriter(
outputs[layer],
encoding,
memory_layer.fields(),
osm_geometries[layer],
memory_layer.crs(),
"GeoJSON")
for f in memory_layer.getFeatures():
writer.addFeature(f)
del writer
# Loading the final vector file
new_layer = QgsVectorLayer(outputs[layer], final_layer_name, "ogr")
else:
new_layer = item['vector_layer']
new_layer.setName(final_layer_name)
# Try to set styling if defined
if config_outputs and config_outputs[layer]['style']:
new_layer.loadNamedStyle(config_outputs[layer]['style'])
else:
# Loading default styles
if layer == "multilinestrings" or layer == "lines":
if "colour" in item['tags']:
new_layer.loadNamedStyle(
join(dirname(dirname(abspath(__file__))),
"styles",
layer + "_colour.qml"))
# Add action about OpenStreetMap
add_actions(new_layer, item['tags'])
if final_query:
QgsExpressionContextUtils.setLayerVariable(
new_layer, 'quickosm_query', final_query)
QgsProject.instance().addMapLayer(new_layer)
num_layers += 1
return num_layers
def add_layers_old_method(self):
"""
this method is depreceated and should no longer be used
"""
try: #newstyle
MyGroup = self.legend.addGroup("Midvatten_OBS_DB", 1, -1)
except: #olddstyle
MyGroup = self.legend.addGroup("Midvatten_OBS_DB")
uri = QgsDataSourceUri()
uri.setDatabase(
self.settingsdict['database']
) #MacOSX fix1 #earlier sent byte string, now intending to send unicode string
for tablename in self.default_nonspatlayers: # first the non-spatial tables, THEY DO NOT ALL HAVE CUSTOM UI FORMS
firststring = 'dbname="' + self.settingsdict[
'database'] + '" table="' + tablename + '"' #MacOSX fix1 #earlier sent byte string, now unicode
layer = QgsVectorLayer(
firststring, self.dbtype
) # Adding the layer as 'spatialite' and not ogr vector layer is preferred
if not layer.isValid():
utils.MessagebarAndLog.critical(
bar_msg='Error, Failed to load layer %s!' % tablename)
else:
QgsProject.instance().addMapLayers([layer])
group_index = self.legend.groups().index('Midvatten_OBS_DB')
self.legend.moveLayer(self.legend.layers()[0], group_index)
filename = tablename + ".qml" # load styles
stylefile = os.path.join(os.sep, os.path.dirname(__file__),
"..", "definitions", filename)
layer.loadNamedStyle(stylefile)
if tablename in ('w_levels', 'w_flow', 'stratigraphy'):
if utils.getcurrentlocale(
)[0] == 'sv_SE': #swedish forms are loaded only if locale settings indicate sweden
filename = tablename + ".ui"
else:
filename = tablename + "_en.ui"
try: # python bindings for setEditorLayout were introduced in qgis-master commit 9183adce9f257a097fc54e5a8a700e4d494b2962 november 2012
layer.setEditorLayout(2)
except:
pass
uifile = os.path.join(os.sep, os.path.dirname(__file__),
"..", "ui", filename)
layer.setEditForm(uifile)
formlogic = "form_logics." + tablename + "_form_open"
layer.setEditFormInit(formlogic)
for tablename in self.default_layers: # then the spatial ones, NOT ALL HAVE CUSTOM UI FORMS
uri.setDataSource('', tablename, 'Geometry')
layer = QgsVectorLayer(
uri.uri(), self.dbtype
) # Adding the layer as 'spatialite' instead of ogr vector layer is preferred
if not layer.isValid():
utils.MessagebarAndLog.critical(
bar_msg='Error, Failed to load layer %s!' % tablename)
else:
filename = tablename + ".qml"
stylefile = os.path.join(os.sep, os.path.dirname(__file__),
"..", "definitions", filename)
layer.loadNamedStyle(stylefile)
if tablename in defs.get_subset_of_tables_fr_db(
category='default_layers_w_ui'
): #= THE ONES WITH CUSTOM UI FORMS
if utils.getcurrentlocale(
)[0] == 'sv_SE': #swedish forms are loaded only if locale settings indicate sweden
filename = tablename + ".ui"
else:
filename = tablename + "_en.ui"
uifile = os.path.join(os.sep, os.path.dirname(__file__),
"..", "ui", filename)
try: # python bindings for setEditorLayout were introduced in qgis-master commit 9183adce9f257a097fc54e5a8a700e4d494b2962 november 2012
layer.setEditorLayout(2)
except:
pass
layer.setEditForm(uifile)
if tablename in ('obs_points', 'obs_lines'):
formlogic = "form_logics." + tablename + "_form_open"
layer.setEditFormInit(formlogic)
QgsProject.instance().addMapLayers([layer])
group_index = self.legend.groups().index(
'Midvatten_OBS_DB') # SIPAPI UPDATE 2.0
self.legend.moveLayer(self.legend.layers()[0], group_index)
if tablename == 'obs_points': #zoom to obs_points extent
qgis.utils.iface.mapCanvas().setExtent(layer.extent())
elif tablename == 'w_lvls_last_geom': #we do not want w_lvls_last_geom to be visible by default
self.legend.setLayerVisible(layer, False)
def download_tiles(self, force=None):
#calculate zoom_level con current canvas extents
ex = self.iface.mapCanvas().extent()
wgs84_minimum = self.transformToWGS84(
QgsPointXY(ex.xMinimum(), ex.yMinimum()))
wgs84_maximum = self.transformToWGS84(
QgsPointXY(ex.xMaximum(), ex.yMaximum()))
bounds = (wgs84_minimum.x(), wgs84_minimum.y(), wgs84_maximum.x(),
wgs84_maximum.y())
map_units_per_pixel = (wgs84_maximum.x() - wgs84_minimum.x()
) / self.iface.mapCanvas().width()
zoom_level = ZoomForPixelSize(map_units_per_pixel)
if zoom_level > 14:
zoom_level = 14
try:
ranges = getTileRange(bounds, zoom_level)
except ValueError:
return
if not self.actual_ranges or not (
ranges[0][0] == self.actual_ranges[0][0]
and ranges[0][1] == self.actual_ranges[0][1]
and ranges[1][0] == self.actual_ranges[1][0]
and ranges[1][1] == self.actual_ranges[1][1]):
#print ("ZOOM_LEVEL", zoom_level, "NEW RANGES", ranges, "LAST RANGES", self.actual_ranges)
self.actual_ranges = ranges
x_range = ranges[0]
y_range = ranges[1]
overview_features = []
sequences_features = []
images_features = []
progress = progressBar(self, 'go2mapillary')
start_time = datetime.datetime.now()
for y in range(y_range[0], y_range[1] + 1):
for x in range(x_range[0], x_range[1] + 1):
folderPath = os.path.join(self.cache_dir, str(zoom_level),
str(x))
filePathMvt = os.path.join(folderPath, str(y) + '.mvt')
#filePathJson = os.path.join(folderPath, str(y) + '.json')
if not os.path.exists(folderPath):
os.makedirs(folderPath)
res = None
if not os.path.exists(filePathMvt) or (
datetime.datetime.fromtimestamp(
os.path.getmtime(filePathMvt)) <
(datetime.datetime.now() - self.expire_time)):
# make the URL
url = getURL(x, y, zoom_level, SERVER_URL)
with open(filePathMvt, 'wb') as f:
response = requests.get(url,
proxies=getProxiesConf(),
stream=True)
total_length = response.headers.get(
'content-length')
if total_length is None: # no content length header
f.write(response.content)
else:
dl = 0
total_length = int(total_length)
progress.start(
total_length,
'caching vector tile [%d,%d,%d]' %
(x, y, zoom_level))
QgsMessageLog.logMessage("MISS [%d,%d,%d]" %
(x, y, zoom_level),
tag="go2mapillary",
level=Qgis.Info)
for data in response.iter_content(
chunk_size=4096):
dl += len(data)
f.write(data)
progress.setProgress(dl)
if os.path.exists(filePathMvt):
progress.start(
0, 'loading vector tile [%d,%d,%d]' %
(x, y, zoom_level))
if not res:
with open(filePathMvt, "rb") as f:
mvt = f.read()
QgsMessageLog.logMessage("CACHE [%d,%d,%d]" %
(x, y, zoom_level),
tag="go2mapillary",
level=Qgis.Info)
else:
mvt = res.content
bounds = mercantile.bounds(x, y, zoom_level)
tile_box = (bounds.west, bounds.south, bounds.east,
bounds.north)
json_data = mapbox_vector_tile.decode(
mvt, quantize_bounds=tile_box)
if "mapillary-sequence-overview" in json_data:
overview_features = overview_features + json_data[
"mapillary-sequence-overview"]["features"]
elif "mapillary-sequences" in json_data:
sequences_features = sequences_features + json_data[
"mapillary-sequences"]["features"]
if "mapillary-images" in json_data and zoom_level == 14:
images_features = images_features + json_data[
"mapillary-images"]["features"]
# print("loading time", datetime.datetime.now() - start_time)
progress.stop('loading complete')
for level in LAYER_LEVELS:
geojson_file = os.path.join(self.cache_dir,
"mapillary_%s.geojson" % level)
try:
QgsProject.instance().removeMapLayer(
getattr(self, level + 'Layer').id())
except:
pass
if locals()[level + '_features']:
setattr(self, level, True)
geojson = {
"type": "FeatureCollection",
"features": locals()[level + '_features']
}
with open(geojson_file, 'w') as outfile:
json.dump(geojson, outfile)
defLyr = QgsVectorLayer(
os.path.join(self.cache_dir,
'mapillary_%s.geojson' % level),
"Mapillary " + level, "ogr")
defLyr.loadNamedStyle(
os.path.join(os.path.dirname(__file__), "res",
"mapillary_%s.qml" % level))
QgsExpressionContextUtils.setLayerVariable(
defLyr, "mapillaryCurrentKey",
self.module.viewer.locationKey)
defLyr.setCrs(QgsCoordinateReferenceSystem(4326))
QgsProject.instance().addMapLayer(defLyr)
self.iface.addCustomActionForLayerType(
getattr(self.module, 'filterAction_' + level),
None,
QgsMapLayer.VectorLayer,
allLayers=False)
self.module.filterDialog.applySqlFilter(layer=defLyr)
self.iface.addCustomActionForLayer(
getattr(self.module, 'filterAction_' + level), defLyr)
legendLayerNode = QgsProject.instance().layerTreeRoot(
).findLayer(defLyr.id())
legendLayerNode.setExpanded(False)
defLyr.setDisplayExpression('"key"')
setattr(self, level + 'Layer', defLyr)
else:
setattr(self, level, False)
else:
pass
def postProcessLayer(self, layer: QgsVectorLayer, context, feedback):
layer.loadNamedStyle(self.qml_path)
layer.triggerRepaint()
class CanvasLayerSaver:
def __init__(
self,
name,
features=None,
crs=QgsCoordinateReferenceSystem(4326),
color=QColor("lightGray"),
style=None,
):
self.name = name
self.color = color
self.transformer = transformToWGS(crs)
self.features = features
self.style = style
self.addPolygonLayer()
def addPolygonLayer(self):
try:
# FIXME: we do not consider if there are several layers with the same name here
existinglayer = QgsProject.instance().mapLayersByName(self.name)[0]
QgsProject.instance().removeMapLayer(existinglayer.id())
except IndexError:
# if such layer does not exist we can pass over
pass
# arbitrary decision taken: WGS84 for these layers
self.layer = QgsVectorLayer(
"Polygon?crs=epsg:4326&field=centerx:double&field=centery:double&field=interval:double",
self.name,
"memory",
)
pr = self.layer.dataProvider()
if self.features:
for feature in self.features:
if isinstance(feature, QgsFeature):
geom = feature.geometry()
feature.setGeometry(self.reprojectToWGS84(geom))
pr.addFeatures([feature])
elif isinstance(feature, QgsGeometry):
qgsFeature = QgsFeature()
qgsFeature.setGeometry(self.reprojectToWGS84(feature))
pr.addFeatures([qgsFeature])
self.layer.updateExtents()
QgsProject.instance().addMapLayer(self.layer)
if self.style:
self.layer.loadNamedStyle(self.style)
else:
renderer = QgsSingleSymbolRenderer.defaultRenderer(
QgsWkbTypes.PolygonGeometry)
symbol = renderer.symbol()
symbol.setColor(self.color)
symbol.symbolLayer(0).setStrokeColor(self.color)
symbol.symbolLayer(0).setFillColor(QColor(0, 0, 0, 0))
symbol.symbolLayer(0).setStrokeWidth(0.5)
self.layer.setRenderer(renderer)
def reprojectToWGS84(self, geom):
geomType = geom.type()
if geomType == QgsWkbTypes.LineGeometry:
geomList = geom.asPolyline()
elif geomType == QgsWkbTypes.PolygonGeometry:
geomList = geom.asPolygon()
newGeom = []
for j in range(len(geomList)):
if geomType == QgsWkbTypes.LineGeometry:
newGeom.append(self.transformer.transform(geomList[j]))
elif geomType == QgsWkbTypes.PolygonGeometry:
line = geomList[j]
for i in range(len(line)):
point = line[i]
newGeom.append(self.transformer.transform(point))
if geomType == QgsWkbTypes.LineGeometry:
return QgsGeometry.fromPolylineXY(newGeom)
elif geomType == QgsWkbTypes.PolygonGeometry:
return QgsGeometry.fromPolygonXY([newGeom])
else:
# TODO, from qgis 3.18 it will be possible to use the method
# QgsWkbTypes.translatedDisplayString() to have much nicer error message
pushWarning(
"not implemented: cannot save layer type: {}".format(geomType))
def charge_vector_layers_periodo(self, cont_per):
self.cont_per = str(cont_per)
# Clean Qgis Map Later Registry
# QgsMapLayerRegistry.instance().removeAllMapLayers()
# Get the user input, starting with the table name
# self.find_us_cutted(data)
cfg_rel_path = os.path.join(os.sep, 'pyarchinit_DB_folder', 'config.cfg')
file_path = '{}{}'.format(self.HOME, cfg_rel_path)
conf = open(file_path, "r")
con_sett = conf.read()
conf.close()
settings = Settings(con_sett)
settings.set_configuration()
if settings.SERVER == 'sqlite':
sqliteDB_path = os.path.join(os.sep, 'pyarchinit_DB_folder', 'pyarchinit_db.sqlite')
db_file_path = '{}{}'.format(self.HOME, sqliteDB_path)
uri = QgsDataSourceUri()
uri.setDatabase(db_file_path)
cont_per_string = "cont_per = '" + self.cont_per + "' OR cont_per LIKE '" + self.cont_per + "/%' OR cont_per LIKE '%/" + self.cont_per + "' OR cont_per LIKE '%/" + self.cont_per + "/%'"
uri.setDataSource('', 'pyarchinit_us_view', 'the_geom', cont_per_string, "ROWID")
layerUS = QgsVectorLayer(uri.uri(), 'pyarchinit_us_view', 'spatialite')
srs = QgsCoordinateReferenceSystem(self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId)
if layerUS.isValid():
QMessageBox.warning(self, "TESTER", "OK Layer US valido", QMessageBox.Ok)
# self.USLayerId = layerUS.getLayerID()
# style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'us_view.qml')
style_path = QFileDialog.getOpenFileName(self, 'Open file', self.LAYER_STYLE_PATH)
layerUS.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerUS], True)
else:
QMessageBox.warning(self, "TESTER", "OK Layer US non valido", QMessageBox.Ok)
uri.setDataSource('', 'pyarchinit_quote_view', 'the_geom', cont_per_string, "ROWID")
layerQUOTE = QgsVectorLayer(uri.uri(), 'pyarchinit_quote_view', 'spatialite')
if layerQUOTE.isValid():
# self.USLayerId = layerUS.getLayerID()
style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'quote_us_view.qml')
layerQUOTE.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerQUOTE], True)
elif settings.SERVER == 'postgres':
uri = QgsDataSourceUri()
# set host name, port, database name, username and password
uri.setConnection(settings.HOST, settings.PORT, settings.DATABASE, settings.USER, settings.PASSWORD)
# cont_per_string = "cont_per = '" + self.cont_per + "' OR cont_per LIKE '" + self.cont_per + "/%' OR cont_per LIKE '%/" + self.cont_per + "' OR cont_per LIKE '%/" + self.cont_per + "/%'"
srs = QgsCoordinateReferenceSystem(self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId)
uri.setDataSource("public", "pyarchinit_archeozoo_view", "the_geom", cont_per_string, "id")
layerUS = QgsVectorLayer(uri.uri(), "Fauna", "postgres")
if layerUS.isValid():
layerUS.setCrs(srs)
# self.USLayerId = layerUS.getLayerID()
# style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'us_caratterizzazioni.qml')
style_path = QFileDialog.getOpenFileName(self, 'Open file', self.LAYER_STYLE_PATH)
layerUS.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerUS], True)
uri.setDataSource("public", "pyarchinit_quote_view", "the_geom", cont_per_string, "gid")
layerQUOTE = QgsVectorLayer(uri.uri(), "Quote Unita' Stratigrafiche", "postgres")
if layerQUOTE.isValid():
layerQUOTE.setCrs(srs)
style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'stile_quote.qml')
layerQUOTE.loadNamedStyle(style_path)
try:
QgsProject.instance().addMapLayers([layerQUOTE], True)
except Exception as e:
pass
def processLoading(self):
'''
Load all the layers in QGIS
and apply corresponding style
'''
self.startTime = datetime.now()
QApplication.setOverrideCursor(Qt.WaitCursor)
# default style to apply for Cadastre layers
self.themeDir = str(self.dialog.liTheme.currentText())
if not os.path.exists(
os.path.join(self.qc.plugin_dir, "styles/%s" % self.themeDir)):
self.themeDir = self.defaultThemeDir
# set Cadastre SVG path if not set
cadastreSvgPath = os.path.join(self.qc.plugin_dir,
"styles/%s/svg" % self.themeDir)
s = QSettings()
qgisSvgPaths = s.value("svg/searchPathsForSVG", 10, type=str)
a = list(qgisSvgPaths)
if cadastreSvgPath not in a:
a.append(cadastreSvgPath)
s.setValue("svg/searchPathsForSVG", a)
self.qc.updateLog(
u"* Le chemin contenant les SVG du plugin Cadastre a été ajouté dans les options de QGIS"
)
# Get selected options
providerName = self.dialog.dbpluginclass.providerName()
qgisCadastreLayers = []
self.dialog.schema = str(self.dialog.liDbSchema.currentText())
self.dialog.totalSteps = len(self.qgisCadastreLayerList)
# Run the loading
self.updateTimer()
self.qc.updateLog(u'Chargement des tables :')
# Get database list of tables
if self.dialog.dbType == 'postgis':
schemaSearch = [
s for s in self.dialog.db.schemas()
if s.name == self.dialog.schema
]
schemaInst = schemaSearch[0]
dbTables = self.dialog.db.tables(schemaInst)
if self.dialog.dbType == 'spatialite':
dbTables = self.dialog.db.tables()
# Get commune filter by expression
communeExpression = self.dialog.communeFilter.text().strip()
communeFilter = None
cExp = QgsExpression(communeExpression)
if communeExpression != '' and not cExp.hasParserError():
self.qc.updateLog(u'Filtrage à partir des communes : %s' %
communeExpression)
cReq = QgsFeatureRequest(cExp)
cTableList = [a for a in dbTables if a.name == 'geo_commune']
cTable = cTableList[0]
cUniqueCol = 'ogc_fid'
cSchema = self.dialog.schema
cGeomCol = 'geom'
cLayerUri = self.dialog.db.uri()
cLayerUri.setDataSource(cSchema, cTable.name, cGeomCol, '',
cUniqueCol)
clayer = QgsVectorLayer(cLayerUri.uri(), 'com', providerName)
cfeatures = clayer.getFeatures(cReq)
cids = [a['commune'] for a in cfeatures]
if len(cids):
communeFilter = cids
else:
self.qc.updateLog(
u'Filtrage à partir des communes, expression invalide : %s' %
cExp.parserErrorString())
# Loop throuhg qgisQastreLayerList and load each corresponding table
for item in self.qgisCadastreLayerList:
if item['label'] not in self.mainLayers and self.dialog.cbMainLayersOnly.isChecked(
):
continue
if 'dbType' in item and item['dbType'] != self.dialog.dbType:
continue
# update progress bar
self.qc.updateLog(u'* %s' % item['label'])
self.dialog.step += 1
self.qc.updateProgressBar()
# Tables - Get db_manager table instance
tableList = [a for a in dbTables if a.name == item['table']]
if len(tableList) == 0 and 'isView' not in item:
self.qc.updateLog(u' - Aucune table trouvée pour %s' %
item['label'])
continue
if tableList:
table = tableList[0]
source = table.name
try:
uniqueField = table.getValidQGisUniqueFields(True)
uniqueCol = uniqueField.name
except:
uniqueCol = 'ogc_fid'
schema = self.dialog.schema
# View
if 'isView' in item:
if self.dialog.dbType == 'spatialite':
schemaReplace = ''
else:
schemaReplace = '"%s".' % self.dialog.schema
source = item['table'].replace('schema.', schemaReplace)
uniqueCol = item['key']
schema = None
sql = item['sql']
geomCol = item['geom']
if communeFilter:
communeFilterText = "'" + "', '".join(communeFilter) + "'"
nschema = ''
if self.dialog.dbType == 'postgis':
nschema = '"%s".' % schema
if 'subset' in item:
subset = item['subset']
sql += subset % communeFilterText
else:
itemcol = item['table']
if item['table'] == 'geo_label':
itemcol = 'ogc_fid'
subset = itemcol + '''
IN (
SELECT b.''' + itemcol + '''
FROM ''' + nschema + item['table'] + ''' b
JOIN ''' + nschema + '''geo_commune c
ON ST_Within(b.geom, c.geom)
WHERE 2>1
AND c.geo_commune IN ( %s )
)
'''
if sql:
sql += ' AND '
sql += subset % communeFilterText
# Create vector layer
alayerUri = self.dialog.db.uri()
alayerUri.setDataSource(schema, source, geomCol, sql, uniqueCol)
vlayer = QgsVectorLayer(alayerUri.uri(), item['label'],
providerName)
# apply style
qmlPath = os.path.join(
self.qc.plugin_dir,
"styles/%s/%s.qml" % (self.themeDir, item['name']))
if os.path.exists(qmlPath):
vlayer.loadNamedStyle(qmlPath)
# append vector layer to the list
qgisCadastreLayers.append(vlayer)
self.updateTimer()
# Get canvas and disable rendering
from qgis.utils import iface
canvas = iface.mapCanvas()
canvas.freeze(True)
# Add all layers to QGIS registry (but not yet to the layer tree)
self.qc.updateLog(u'Ajout des couches dans le registre de QGIS')
QgsProject.instance().addMapLayers(qgisCadastreLayers, False)
self.updateTimer()
# Create a group "Cadastre" and move all layers into it
self.qc.updateLog(u'Ajout des couches dans le groupe Cadastre')
root = QgsProject.instance().layerTreeRoot()
g1 = root.findGroup(u"Cadastre")
if g1:
gf = root.findGroup(u"Fond")
if not gf:
gf = g1.addGroup("Fond")
ge = root.findGroup(u'Étiquettes cadastre')
if not ge:
ge = gf.addGroup(u'Étiquettes cadastre')
gd = root.findGroup(u"Données cadastre")
if not gd:
gd = gf.addGroup(u"Données cadastre")
else:
g1 = root.insertGroup(0, "Cadastre")
gf = g1.addGroup("Fond")
ge = gf.addGroup(u'Étiquettes cadastre')
gd = gf.addGroup(u'Données cadastre')
variables = QgsProject.instance().customVariables()
for layer in qgisCadastreLayers:
#~ layer.updateExtents()
# Get layertree item
nodeLayer = QgsLayerTreeLayer(layer)
# Get layer options
qlayer = [
a for a in self.qgisCadastreLayerList
if a['label'] == layer.name()
]
if qlayer:
qlayer = qlayer[0]
# Move layer to proper group
if qlayer['group'] == 'E':
ge.insertChildNode(0, nodeLayer)
elif qlayer['group'] == 'D':
gd.insertChildNode(0, nodeLayer)
else:
g1.insertChildNode(0, nodeLayer)
# Enable/Disable layer
if not qlayer['active']:
nodeLayer.setItemVisibilityChecked(Qt.Unchecked)
else:
# Move layer to Cadastre group
g1.insertChildNode(-1, nodeLayer)
# Do not expand layer legend
nodeLayer.setExpanded(False)
# set varaibles
if layer.name() in self.variableLayers:
varlayer = self.variableLayers[layer.name()]
variables['cadastre_' + varlayer['var_key'] +
'_layer_id'] = layer.id()
variables['cadastre_' + varlayer['var_key'] +
'_unique_field'] = varlayer['unique_field']
QgsProject.instance().setCustomVariables(variables)
self.updateTimer()
# Zoom to full extent
self.qc.updateLog(u'Zoom sur les couches')
canvas.zoomToFullExtent()
canvas.freeze(False)
canvas.refresh()
self.updateTimer()
# progress bar
self.dialog.step += 1
self.qc.updateProgressBar()
# Emit signal
self.qc.updateLog(u'Mise à jour des outils cadastre')
self.cadastreLoadingFinished.emit()
self.updateTimer()
# Final message
QApplication.restoreOverrideCursor()
QMessageBox.information(
self.dialog, u"Cadastre",
u"Les données ont bien été chargées dans QGIS")
self.dialog.pbProcess.setValue(0)
QApplication.restoreOverrideCursor()
def import_action(self):
self.dlg.txtFeedback.setText('Attendi.....')
chkbox_value = self.dlg.chkActivate.isChecked(
) #button per aggiungere il layer su mappa
chkbox_str = '%s' % (chkbox_value)
#Verifico se ho scelto di salvare su DB o su SHP:
shp_value = self.dlg.chkShp.isChecked()
db_value = self.dlg.chkDB.isChecked()
input_cxf = self.dlg.fileBrowse_txt.text()
#input_cxf = r'C:\ARPA-2015\fatti_miei\AndreaMGOS-lavori\QGis_custom_plugins\dati_cxf-orbassano\G087_003800.CXF'
basename = path_basename(input_cxf).upper()
foglio = parse_foglio(input_cxf[:-4])
#Al momento non riuscendo ad escluderli, do precedenza a shp:
if (shp_value == True):
output_dir = self.dlg.dirBrowse_txt.text()
#output_dir = r'C:\Users\riccardo\Desktop'
dest_dir = '%s\\%s' % (output_dir, basename[:-4])
#foglio = parse_foglio(input_cxf[:-4])
#Comando dinamico per scrivere su cartella scelta dall'utente:
write_foglio(foglio,
dest_dir,
point_borders=False,
format_name='ESRI Shapefile')
elif (db_value == True):
#Prova per scrivere su DB PostgreSQL in percorso fisso - IN SVILUPPO:
userDB = self.dlg.usrDB.text()
pwdDB = self.dlg.pwdDB.text()
hostDB = self.dlg.hostDB.text()
portDB = self.dlg.portDB.text()
nameDB = self.dlg.nameDB.text()
schemaDB = self.dlg.schemaDB.text()
dest_dir = "dbname=%s host=%s port=%s user=%s password=%s active_schema=%s" % (
nameDB, hostDB, portDB, userDB, pwdDB, schemaDB)
param_conn = "PG:%s" % (dest_dir)
#param_conn = PG:"dbname=tucatuca host=localhost port=5432 user=postgres password=ARTURO active_schema=public"
write_foglio(foglio,
param_conn,
point_borders=False,
format_name='PostgreSQL')
'''
Aggiungo il layer su mappa: funzione NON IMPLEMENTATA in quanto non so il NOME DEL LAYER GENERATO a prescindere!! Al momento carica gli SHP ma sicuramente penso sia impossibile riuscire a caricare i dati eventualmente caricati su DB.
'''
if (chkbox_value == True):
pedice = "%s_%s_%s" % (foglio['CODICE COMUNE'],
foglio['NUMERO FOGLIO'],
foglio['CODICE SVILUPPO'])
layer_path = '%s' % (
dest_dir) #'C:\\Users\\riccardo\\Desktop\\G087_003800'
#metodo di caricamento con QgsVectorLayer
layer_bordi_name = 'CATASTO_BORDI_%s' % (pedice)
layer_testi_name = 'CATASTO_TESTI_%s' % (pedice)
layer_fiduciali_name = 'CATASTO_FIDUCIALI_%s' % (pedice)
layer_simboli_name = 'CATASTO_SIMBOLI_%s' % (pedice)
#carico elementi in mappa:
layer_bordi = QgsVectorLayer(
layer_path + "\\" + layer_bordi_name + ".shp",
layer_bordi_name, "ogr")
layer_testi = QgsVectorLayer(
layer_path + "\\" + layer_testi_name + ".shp",
layer_testi_name, "ogr")
layer_fiduciali = QgsVectorLayer(
layer_path + "\\" + layer_fiduciali_name + ".shp",
layer_fiduciali_name, "ogr")
layer_simboli = QgsVectorLayer(
layer_path + "\\" + layer_simboli_name + ".shp",
layer_simboli_name, "ogr")
lista_layer_to_load = [
layer_simboli, layer_fiduciali, layer_testi, layer_bordi
]
QgsMapLayerRegistry.instance().addMapLayers(lista_layer_to_load)
#assegno uno stile - inmm se carico in LatLon, altrimenti lo stile piu' corretto e' senza pedice ed e' in unita mappa:
layer_bordi.loadNamedStyle(
os.getenv("HOME") +
'/.qgis2/python/plugins/ImportCatastoCXF/qml_base/catasto_bordi_inmm.qml'
)
layer_testi.loadNamedStyle(
os.getenv("HOME") +
'/.qgis2/python/plugins/ImportCatastoCXF/qml_base/catasto_testi_inmm.qml'
)
layer_fiduciali.loadNamedStyle(
os.getenv("HOME") +
'/.qgis2/python/plugins/ImportCatastoCXF/qml_base/catasto_fiduciali_inmm.qml'
)
layer_simboli.loadNamedStyle(
os.getenv("HOME") +
'/.qgis2/python/plugins/ImportCatastoCXF/qml_base/catasto_simboli_inmm.qml'
)
'''
#Questo metodo di caricamento in mappa e' piu' diretto ma non consente di applicare uno stile
layer_name_arr = ['CATASTO_BORDI_', 'CATASTO_TESTI_', 'CATASTO_FIDUCIALI_', 'CATASTO_SIMBOLI_', 'CATASTO_LINEE_']
for elemento in layer_name_arr:
layername = '%s%s' % (elemento, pedice)
layer_full_path = '%s\%s.shp' % (layer_path, layername)
#carico elementi in mappa:
layer = self.iface.addVectorLayer(layer_full_path, layername, "ogr")
#assegno uno stile qml - NON FUNZIONA!
if (elemento == 'CATASTO_BORDI_'):
layer.loadNamedStyle('qml_base/catasto_bordi.qml')
elif (elemento == 'CATASTO_TESTI_'):
layer.loadNamedStyle('qml_base/catasto_testi.qml')
elif (elemento == 'CATASTO_FIDUCIALI_'):
layer.loadNamedStyle('qml_base/catasto_fiduciali.qml')
elif (elemento == 'CATASTO_SIMBOLI_'):
layer.loadNamedStyle('qml_base/catasto_simboli.qml')
if not layer:
print "Layer failed to load!"
'''
self.dlg.txtFeedback.setText('Conversione avvenuta con successo!!')
def addDiffLayer(repo, layername, commit):
styles = [diffStylePoints, diffStyleLines, diffStylePolygons]
geomTypes = ["Point","LineString","Polygon"]
beforeFilename = tempFilename("gpkg")
repo.exportdiff(layername, commit.commitid, commit.parent.commitid, beforeFilename)
beforeLayer = loadLayerNoCrsDialog(beforeFilename, layername, "ogr")
afterFilename = tempFilename("gpkg")
repo.exportdiff(layername, commit.parent.commitid, commit.commitid, afterFilename)
afterLayer = loadLayerNoCrsDialog(afterFilename, layername, "ogr")
beforeCon = sqlite3.connect(beforeFilename)
beforeCursor = beforeCon.cursor()
afterCon = sqlite3.connect(afterFilename)
afterCursor = afterCon.cursor()
attributes = [v[1] for v in beforeCursor.execute("PRAGMA table_info('%s');" % layername)]
attrnames = [f.name() for f in beforeLayer.pendingFields()]
layerFeatures = []
beforeCursor.execute("SELECT * FROM %s_changes WHERE audit_op=2;" % layername)
modified = beforeCursor.fetchall()
for m in modified:
geogigfid = m[0]
beforeGpkgfid = gpkgfidFromGeogigfid(beforeCursor, layername, geogigfid)
beforeCursor.execute("SELECT * FROM %s WHERE fid='%s';" % (layername, beforeGpkgfid))
featureRow = beforeCursor.fetchone()
attrs = {attr: featureRow[attributes.index(attr)] for attr in attrnames}
attrs["changetype"] = MODIFIED_BEFORE
request = QgsFeatureRequest()
request.setFilterFid(beforeGpkgfid)
feature = next(beforeLayer.getFeatures(request))
layerFeatures.append({"attrs":attrs, "geom": QgsGeometry(feature.geometry())})
afterGpkgfid = gpkgfidFromGeogigfid(afterCursor, layername, geogigfid)
afterCursor.execute("SELECT * FROM %s WHERE fid='%s';" % (layername,afterGpkgfid))
featureRow = afterCursor.fetchone()
attrs = {attr: featureRow[attributes.index(attr)] for attr in attrnames}
attrs["changetype"] = MODIFIED_AFTER
request = QgsFeatureRequest()
request.setFilterFid(beforeGpkgfid)
feature = next(afterLayer.getFeatures(request))
layerFeatures.append({"attrs":attrs, "geom": QgsGeometry(feature.geometry())})
afterCursor.execute("SELECT * FROM %s_changes WHERE audit_op=1;" % layername)
added = afterCursor.fetchall()
for a in added:
geogigfid = a[0]
afterGpkgfid = gpkgfidFromGeogigfid(afterCursor, layername, geogigfid)
afterCursor.execute("SELECT * FROM %s WHERE fid='%s';" % (layername, afterGpkgfid))
featureRow = afterCursor.fetchone()
attrs = {attr: featureRow[attributes.index(attr)] for attr in attrnames}
attrs["changetype"] = ADDED
request = QgsFeatureRequest()
request.setFilterFid(afterGpkgfid)
feature = next(afterLayer.getFeatures(request))
layerFeatures.append({"attrs":attrs, "geom": QgsGeometry(feature.geometry())})
beforeCursor.execute("SELECT * FROM %s_changes WHERE audit_op=1;" % layername)
removed = beforeCursor.fetchall()
for r in removed:
geogigfid = r[0]
beforeGpkgfid = gpkgfidFromGeogigfid(beforeCursor, layername, geogigfid)
beforeCursor.execute("SELECT * FROM %s WHERE fid='%s';" % (layername, beforeGpkgfid))
featureRow = beforeCursor.fetchone()
attrs = {attr: featureRow[attributes.index(attr)] for attr in attrnames}
attrs["changetype"] = REMOVED
request = QgsFeatureRequest()
request.setFilterFid(beforeGpkgfid)
feature = next(beforeLayer.getFeatures(request))
layerFeatures.append({"attrs":attrs, "geom": QgsGeometry(feature.geometry())})
attrnames.append("changetype")
uriFields = "&".join(["field=%s" % f for f in attrnames])
uri = "%s?crs=%s&%s" % (geomTypes[beforeLayer.geometryType()], beforeLayer.crs().authid(), uriFields)
layer = QgsVectorLayer(uri, "diff", "memory")
featuresList = []
for feature in layerFeatures:
qgsfeature = QgsFeature()
qgsfeature.setGeometry(feature["geom"])
qgsfeature.setAttributes([feature["attrs"][attr] for attr in attrnames])
featuresList.append(qgsfeature)
layer.dataProvider().addFeatures(featuresList)
layer.updateExtents()
QgsMapLayerRegistry.instance().addMapLayers([layer])
layer.loadNamedStyle(styles[layer.geometryType()])
class MapBiomasAlertRequest(QObject):
killProcess = pyqtSignal()
currentProcess = pyqtSignal(str)
finishedProcess = pyqtSignal()
showExtentProcess = pyqtSignal()
message = pyqtSignal(Qgis.MessageLevel, str)
def __init__(self, canvas):
super().__init__()
self.nameCatalog = 'mapbiomas_alert_valid'
self.apiMB = API_MapbiomasAlert()
self.killProcess.connect(self.apiMB.kill)
self.canvas = canvas
self.project = QgsProject.instance()
self.layerTreeRoot = self.project.layerTreeRoot()
self.mapCanvasGeom = MapCanvasGeometry()
self.pluginName = 'MapBiomas'
self.crsCatalog = QgsCoordinateReferenceSystem('EPSG:4674')
self.styleFile = 'mapbiomas_alert.qml'
self.alert = None
self.alert_id = None
self.response = None
self.isRunning = None
def __del__(self):
self.killProcess.disconnect(self.apiMB.kill)
def _createCatalog(self):
key_value = lambda k: "field={key}:{value}".format(
key=k, value=self.apiMB.fields[k]['definition'])
l_fields = [key_value(k) for k in self.apiMB.fields.keys()]
l_fields.insert(
0, "Multipolygon?crs={}".format(self.crsCatalog.authid().lower()))
l_fields.append('index=yes')
uri = '&'.join(l_fields)
self.alert = QgsVectorLayer(uri, self.nameCatalog, 'memory')
self.alert.loadNamedStyle(
os.path.join(os.path.dirname(__file__), self.styleFile))
self.alert_id = self.alert.id()
def _responseFinished(self, response):
self.response = response
def actionsForm(self, nameAction, feature_id=None):
"""
Run action defined in layer, provide by style file
:param nameAction: Name of action
:params feature_id: Feature ID
"""
# Actions functions
def flash(feature_id):
geom = self.alert.getFeature(feature_id).geometry()
self.mapCanvasGeom.flash([geom], self.alert)
return {'isOk': True}
def zoom(feature_id):
geom = self.alert.getFeature(feature_id).geometry()
self.mapCanvasGeom.zoom([geom], self.alert)
return {'isOk': True}
def report(feature_id):
feat = self.alert.getFeature(feature_id)
alerta_id = feat['alerta_id']
cars_ids = feat['cars']
if len(cars_ids) == 0:
url = "{}/{}".format(API_MapbiomasAlert.urlReport, alerta_id)
QDesktopServices.openUrl(QUrl(url))
else:
for car_id in cars_ids.split('\n'):
url = "{}/{}/car/{}".format(API_MapbiomasAlert.urlReport,
alerta_id, car_id)
QDesktopServices.openUrl(QUrl(url))
return {'isOk': True}
actionsFunc = {'flash': flash, 'zoom': zoom, 'report': report}
if not nameAction in actionsFunc.keys():
return {
'isOk': False,
'message': "Missing action '{}'".format(nameAction)
}
return actionsFunc[nameAction](feature_id)
def requestPopulateCatalog(self):
def getWktExtent():
crsCanvas = self.canvas.mapSettings().destinationCrs()
ct = QgsCoordinateTransform(crsCanvas, self.crsCatalog,
self.project)
extent = self.canvas.extent(
) if crsCanvas == self.crsCatalog else ct.transform(
self.canvas.extent())
return extent.asWktPolygon()
def populate(features):
provider = self.alert.dataProvider()
for item in features:
atts = [item[k] for k in self.apiMB.fields]
feat = QgsFeature()
feat.setAttributes(atts)
geom = item['geometry']
if not geom is None:
feat.setGeometry(geom)
provider.addFeature(feat)
del item
def finished(response):
self.response = response
if not response['isOk']:
self.message.emit(Qgis.Critical, response['message'])
return
if len(self.response['features']) == 0:
self.message.emit(Qgis.Warning,
"Inside this view don't have alerts")
del response['features']
return
populate(response['features'])
del response['features']
self.message.emit(Qgis.Success, 'Finished OK')
def closeTableAttribute():
layer_id = self.alert_id
widgets = QApplication.instance().allWidgets()
for tb in filter(
lambda w: isinstance(w, QDialog) and layer_id in w.
objectName(), widgets):
tb.close()
self.currentProcess.emit('Populate Catalog')
existsCatalog = not self.alert is None and not self.project.mapLayer(
self.alert_id) is None
if not existsCatalog:
self._createCatalog()
else:
name = "Receiving... - {}".format(self.nameCatalog)
self.alert.setName(name)
self.alert.dataProvider().truncate() # Delete all features
closeTableAttribute()
self.response = None
self.calculateMetadata = True
self.message.emit(Qgis.Info, 'Request features...')
url = self.apiMB.getUrlAlerts(getWktExtent())
self.apiMB.getAlerts(url, finished)
self.calculateMetadata = False
if self.response['isOk']:
if not existsCatalog:
self.project.addMapLayer(self.alert, addToLegend=False)
root = self.project.layerTreeRoot()
root.insertLayer(0, self.alert).setCustomProperty(
"showFeatureCount", True)
else:
self.alert.setName(self.nameCatalog)
self.alert.triggerRepaint()
else:
root = self.project.layerTreeRoot()
if not root.findLayer(self.alert) is None:
root.removeLayer(self.alert)
def searchAlert(self):
self.currentProcess.emit('Check server')
self.apiMB.isHostLive(self._responseFinished)
if not self.response['isOk']:
self.message.emit(Qgis.Critical, 'MapBioma server is out')
self.finishedProcess.emit()
return
self.currentProcess.emit('Search alerts')
if self.canvas.layerCount() == 0:
msg = 'Need layer(s) in map'
self.message.emit(Qgis.Warning, msg)
else:
self.apiMB.access.isKill = False
self.showExtentProcess.emit()
self.requestPopulateCatalog()
self.finishedProcess.emit()
@pyqtSlot()
def onCancel(self):
self.killProcess.emit()
class Layer:
'''
wrapper of a vector layer in the QGIS layer tree with some
convenient functions. Can be grouped and addressed by its name.
'''
def __init__(self,
layername: str,
data_path: str,
groupname: str = '',
prepend: bool = True):
'''
Parameters
----------
layername : str
name of the layer in the data source
data_path : str
path to the data source of the layer
groupname : str, optional
name of the parent group, will be created if not existing, can be
nested by joining groups with '/' e.g. 'Projekt/Hintergrundkarten',
defaults to add layer to the root of the layer tree
prepend : bool
prepend the group of the layer if True (prepends each group if
nested), append if False, defaults to prepending the group
'''
self.layername = layername
self.data_path = data_path
self.layer = None
self._l = None
self.groupname = groupname
self.prepend = prepend
@property
def parent(self) -> QgsLayerTreeGroup:
'''
the parent group of the layer
'''
parent = QgsProject.instance().layerTreeRoot()
if self.groupname:
parent = Layer.add_group(self.groupname, prepend=self.prepend)
return parent
@property
def _tree_layer(self) -> QgsLayerTreeLayer:
'''
tree representation of the layer
'''
if not self.layer:
return None
return self.parent.findLayer(self.layer)
@property
def layer(self) -> QgsVectorLayer:
'''
the wrapped vector layer
'''
try:
layer = self._layer
if layer is not None:
# call function on layer to check if it still exists
layer.id()
except RuntimeError:
return None
return layer
@layer.setter
def layer(self, layer: QgsVectorLayer):
self._layer = layer
@classmethod
def add_group(cls,
groupname: str,
prepend: bool = True) -> QgsLayerTreeGroup:
'''
add a group to the layer tree
Parameters
----------
groupname : str
name of the parent group, will be created if not existing, can be
nested by joining groups with '/' e.g. 'Projekt/Hintergrundkarten'
prepend : bool, optional
prepend the group if True (prepends each group if nested),
append if False, defaults to prepending the group
Returns
----------
QgsLayerTreeGroup
the created group (the deepest one in hierarchy if nested)
'''
groupnames = groupname.split('/')
parent = QgsProject.instance().layerTreeRoot()
group = cls._nest_groups(parent, groupnames, prepend=prepend)
return group
@classmethod
def _nest_groups(cls,
parent: QgsLayerTreeGroup,
groupnames: List[str],
prepend: bool = True) -> QgsLayerTreeGroup:
'''recursively nests groups in order of groupnames'''
if len(groupnames) == 0:
return parent
next_parent = parent.findGroup(groupnames[0])
if not next_parent:
next_parent = (parent.insertGroup(0, groupnames[0])
if prepend else parent.addGroup(groupnames[0]))
return cls._nest_groups(next_parent, groupnames[1:], prepend=prepend)
@classmethod
def find(cls, label: str, groupname: str = '') -> List[QgsLayerTreeLayer]:
'''
deep find tree layer by name in a group recursively
Parameters
----------
label : str
label of the tree layer
groupname : str, optional
name of the group to search in, can be nested by joining groups with
'/' e.g. 'Projekt/Hintergrundkarten', defaults to searching in layer
tree root
Returns
----------
list
list of tree layers matching the name, empty list if none found
'''
parent = QgsProject.instance().layerTreeRoot()
if groupname:
groupnames = groupname.split('/')
while groupnames:
g = groupnames.pop(0)
parent = parent.findGroup(g)
if not parent:
return []
def deep_find(node, label):
found = []
if node:
for child in node.children():
if child.name() == label:
found.append(child)
found.extend(deep_find(child, label))
return found
found = deep_find(parent, label)
return found
def draw(self,
style_path: str = None,
label: str = '',
redraw: str = True,
checked: bool = True,
filter: str = None,
expanded: bool = True,
prepend: bool = False) -> QgsVectorLayer:
'''
load the data into a vector layer, draw it and add it to the layer tree
Parameters
----------
label : str, optional
label of the layer, defaults to layer name this is initialized with
style_path : str, optional
a QGIS style (.qml) can be applied to the layer, defaults to no
style
redraw : bool, optional
replace old layer with same name in same group if True,
only create if not existing if set to False, else it is refreshed,
defaults to redrawing the layer
checked: bool, optional
set check state of layer in layer tree, defaults to being checked
filter: str, optional
QGIS filter expression to filter the layer, defaults to no filtering
expanded: str, optional
sets the legend to expanded or not, defaults to an expanded legend
prepend: bool, optional
prepend the layer to the other layers in its group if True,
append it if False, defaults to appending the layer
Returns
----------
QgsVectorLayer
the created, replaced or refreshed vector layer
'''
if not self.layer:
layers = Layer.find(label, groupname=self.groupname)
if layers:
self.layer = layers[0].layer()
if redraw:
self.remove()
else:
iface.mapCanvas().refreshAllLayers()
if not self.layer:
self.layer = QgsVectorLayer(self.data_path, self.layername, "ogr")
if label:
self.layer.setName(label)
QgsProject.instance().addMapLayer(self.layer, False)
self.layer.loadNamedStyle(style_path)
tree_layer = self._tree_layer
if not tree_layer:
tree_layer = self.parent.insertLayer(0, self.layer) if prepend else\
self.parent.addLayer(self.layer)
tree_layer.setItemVisibilityChecked(checked)
tree_layer.setExpanded(expanded)
if filter is not None:
self.layer.setSubsetString(filter)
return self.layer
def set_visibility(self, state: bool):
'''
change check state of layer, layer is not visible if unchecked
Parameters
----------
state: bool
set check state of layer in layer tree
'''
tree_layer = self._tree_layer
if tree_layer:
tree_layer.setItemVisibilityChecked(state)
def zoom_to(self):
'''
zooms map canvas to the extent of this layer
'''
if not self.layer:
return
canvas = iface.mapCanvas()
self.layer.updateExtents()
transform = QgsCoordinateTransform(
self.layer.crs(),
canvas.mapSettings().destinationCrs(), QgsProject.instance())
canvas.setExtent(transform.transform(self.layer.extent()))
def remove(self):
'''
remove the layer from map and layer tree
'''
if not self.layer:
return
QgsProject.instance().removeMapLayer(self.layer.id())
self.layer = None
def testStyle(self):
# First test with invalid URI
vl = QgsVectorLayer('/idont/exist.gpkg', 'test', 'ogr')
self.assertFalse(
vl.dataProvider().isSaveAndLoadStyleToDatabaseSupported())
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, -1)
self.assertEqual(idlist, [])
self.assertEqual(namelist, [])
self.assertEqual(desclist, [])
self.assertNotEqual(errmsg, "")
qml, errmsg = vl.getStyleFromDatabase("1")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
qml, success = vl.loadNamedStyle('/idont/exist.gpkg')
self.assertFalse(success)
errorMsg = vl.saveStyleToDatabase("name", "description", False, "")
self.assertNotEqual(errorMsg, "")
# Now with valid URI
tmpfile = os.path.join(self.basetestpath, 'testStyle.gpkg')
ds = ogr.GetDriverByName('GPKG').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbMultiPolygon)
lyr.CreateField(ogr.FieldDefn('foo', ogr.OFTString))
f = ogr.Feature(lyr.GetLayerDefn())
f['foo'] = 'bar'
lyr.CreateFeature(f)
f = None
lyr = ds.CreateLayer('test2', geom_type=ogr.wkbMultiPolygon)
lyr.CreateField(ogr.FieldDefn('foo', ogr.OFTString))
f = ogr.Feature(lyr.GetLayerDefn())
f['foo'] = 'bar'
lyr.CreateFeature(f)
f = None
ds = None
vl = QgsVectorLayer('{}|layername=test'.format(tmpfile), 'test', 'ogr')
self.assertTrue(vl.isValid())
vl2 = QgsVectorLayer('{}|layername=test2'.format(tmpfile), 'test2',
'ogr')
self.assertTrue(vl2.isValid())
self.assertTrue(
vl.dataProvider().isSaveAndLoadStyleToDatabaseSupported())
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, 0)
self.assertEqual(idlist, [])
self.assertEqual(namelist, [])
self.assertEqual(desclist, [])
self.assertNotEqual(errmsg, "")
qml, errmsg = vl.getStyleFromDatabase("not_existing")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
qml, success = vl.loadNamedStyle('{}|layerid=0'.format(tmpfile))
self.assertFalse(success)
errorMsg = vl.saveStyleToDatabase("name", "description", False, "")
self.assertEqual(errorMsg, "")
qml, errmsg = vl.getStyleFromDatabase("not_existing")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, 1)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1'])
self.assertEqual(namelist, ['name'])
self.assertEqual(desclist, ['description'])
qml, errmsg = vl.getStyleFromDatabase("100")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
qml, errmsg = vl.getStyleFromDatabase("1")
self.assertTrue(qml.startswith('<!DOCTYPE qgis'), qml)
self.assertEqual(errmsg, "")
# Try overwrite it but simulate answer no
settings = QSettings()
settings.setValue("/qgis/overwriteStyle", False)
errorMsg = vl.saveStyleToDatabase("name", "description_bis", False, "")
self.assertNotEqual(errorMsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, 1)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1'])
self.assertEqual(namelist, ['name'])
self.assertEqual(desclist, ['description'])
# Try overwrite it and simulate answer yes
settings = QSettings()
settings.setValue("/qgis/overwriteStyle", True)
errorMsg = vl.saveStyleToDatabase("name", "description_bis", False, "")
self.assertEqual(errorMsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, 1)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1'])
self.assertEqual(namelist, ['name'])
self.assertEqual(desclist, ['description_bis'])
errorMsg = vl2.saveStyleToDatabase("name_test2", "description_test2",
True, "")
self.assertEqual(errorMsg, "")
errorMsg = vl.saveStyleToDatabase("name2", "description2", True, "")
self.assertEqual(errorMsg, "")
errorMsg = vl.saveStyleToDatabase("name3", "description3", True, "")
self.assertEqual(errorMsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, 3)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1', '3', '4', '2'])
self.assertEqual(namelist, ['name', 'name2', 'name3', 'name_test2'])
self.assertEqual(
desclist,
['description_bis', 'description2', 'description3', 'name_test2'])
# Check that layers_style table is not list in subLayers()
vl = QgsVectorLayer(tmpfile, 'test', 'ogr')
sublayers = vl.dataProvider().subLayers()
self.assertEqual(len(sublayers), 2, sublayers)
class ProductionFrame(QFrame, FORM_CLASS):
def __init__(self, dockwidget, parent=None):
"""Constructor."""
super(ProductionFrame, self).__init__(parent)
self.setupUi(self)
self.dockwidget = dockwidget
self.layer_registry = LayerRegistry()
self.db = db
self.db.connect()
self.building_layer = QgsVectorLayer()
self.add_outlines()
# Set up edit dialog
self.edit_dialog = EditDialog(self)
self.change_instance = None
self.cb_production.setChecked(True)
# set up signals and slots
self.btn_exit.clicked.connect(self.exit_clicked)
self.cb_production.clicked.connect(self.cb_production_clicked)
QgsProject.instance().layerWillBeRemoved.connect(self.layers_removed)
self.setup_toolbar()
def setup_toolbar(self):
if "Add Outline" not in (
action.text() for action in iface.building_toolbar.actions()):
image_dir = os.path.join(__location__, "..", "icons")
icon_path = os.path.join(image_dir, "plus.png")
icon = QIcon()
icon.addFile(icon_path, QSize(8, 8))
self.add_action = QAction(icon, "Add Outline",
iface.building_toolbar)
iface.registerMainWindowAction(self.add_action, "Ctrl+1")
self.add_action.triggered.connect(self.canvas_add_outline)
iface.building_toolbar.addAction(self.add_action)
if "Edit Geometry" not in (
action.text() for action in iface.building_toolbar.actions()):
image_dir = os.path.join(__location__, "..", "icons")
icon_path = os.path.join(image_dir, "edit_geometry.png")
icon = QIcon()
icon.addFile(icon_path, QSize(8, 8))
self.edit_geom_action = QAction(icon, "Edit Geometry",
iface.building_toolbar)
iface.registerMainWindowAction(self.edit_geom_action, "Ctrl+2")
self.edit_geom_action.triggered.connect(self.canvas_edit_geometry)
iface.building_toolbar.addAction(self.edit_geom_action)
if "Edit Attributes" not in (
action.text() for action in iface.building_toolbar.actions()):
image_dir = os.path.join(__location__, "..", "icons")
icon_path = os.path.join(image_dir, "edit_attributes.png")
icon = QIcon()
icon.addFile(icon_path, QSize(8, 8))
self.edit_attrs_action = QAction(icon, "Edit Attributes",
iface.building_toolbar)
iface.registerMainWindowAction(self.edit_attrs_action, "Ctrl+3")
self.edit_attrs_action.triggered.connect(
self.canvas_edit_attribute)
iface.building_toolbar.addAction(self.edit_attrs_action)
iface.building_toolbar.show()
def add_outlines(self):
"""
Add building outlines to canvas
"""
path = os.path.join(os.path.dirname(os.path.dirname(__file__)),
"styles/")
self.layer_registry.remove_layer(self.building_layer)
self.building_historic = self.layer_registry.add_postgres_layer(
"historic_outlines", "building_outlines", "shape", "buildings", "",
"end_lifespan is not NULL")
self.building_historic.loadNamedStyle(path + "building_historic.qml")
self.building_layer = None
self.building_layer = self.layer_registry.add_postgres_layer(
"building_outlines", "building_outlines", "shape", "buildings", "",
"end_lifespan is NULL")
self.building_layer.loadNamedStyle(path + "building_blue.qml")
iface.setActiveLayer(self.building_layer)
@pyqtSlot(bool)
def cb_production_clicked(self, checked):
group = QgsProject.instance().layerTreeRoot().findGroup(
"Building Tool Layers")
if checked:
group.setItemVisibilityCheckedRecursive(True)
else:
group.setItemVisibilityCheckedRecursive(False)
def canvas_add_outline(self):
"""
When add outline radio button toggled
"""
self.edit_dialog.show()
self.edit_dialog.add_outline()
self.change_instance = self.edit_dialog.get_change_instance()
self.circle_tool = None
self.polyline = None
# setup circle button
image_dir = os.path.join(__location__, "..", "icons")
icon_path = os.path.join(image_dir, "circle.png")
icon = QIcon()
icon.addFile(icon_path, QSize(8, 8))
self.circle_action = QAction(icon, "Draw Circle",
iface.building_toolbar)
iface.registerMainWindowAction(self.circle_action, "Ctrl+0")
self.circle_action.triggered.connect(self.circle_tool_clicked)
self.circle_action.setCheckable(True)
iface.building_toolbar.addAction(self.circle_action)
def circle_tool_clicked(self):
if self.circle_action.isChecked():
circle_tool.setup_circle(self)
else:
iface.actionAddFeature().trigger()
def canvas_edit_attribute(self):
"""
When edit outline radio button toggled
"""
self.edit_dialog.show()
self.edit_dialog.edit_attribute()
self.change_instance = self.edit_dialog.get_change_instance()
def canvas_edit_geometry(self):
"""
When edit geometry radio button toggled
"""
self.edit_dialog.edit_geometry()
self.edit_dialog.show()
self.change_instance = self.edit_dialog.get_change_instance()
@pyqtSlot()
def exit_clicked(self):
"""
Called when edit production exit button clicked.
"""
self.close_frame()
self.dockwidget.lst_sub_menu.clearSelection()
def close_frame(self):
"""
Clean up and remove the edit production frame.
"""
if self.change_instance is not None:
self.edit_dialog.close()
iface.actionCancelEdits().trigger()
QgsProject.instance().layerWillBeRemoved.disconnect(
self.layers_removed)
self.layer_registry.remove_layer(self.building_layer)
self.layer_registry.remove_layer(self.building_historic)
# reset toolbar
for action in iface.building_toolbar.actions():
if action.objectName() not in ["mActionPan"]:
iface.building_toolbar.removeAction(action)
iface.building_toolbar.hide()
from buildings.gui.menu_frame import MenuFrame
dw = self.dockwidget
dw.stk_options.removeWidget(dw.stk_options.currentWidget())
dw.new_widget(MenuFrame(dw))
@pyqtSlot()
def edit_cancel_clicked(self):
if len(QgsProject.instance().mapLayersByName("building_outlines")) > 0:
if isinstance(self.change_instance,
production_changes.EditAttribute):
try:
self.building_layer.selectionChanged.disconnect(
self.change_instance.selection_changed)
except TypeError:
pass
elif isinstance(self.change_instance,
production_changes.EditGeometry):
try:
self.building_layer.geometryChanged.disconnect()
except TypeError:
pass
elif isinstance(self.change_instance,
production_changes.AddProduction):
try:
self.building_layer.featureAdded.disconnect()
except TypeError:
pass
try:
self.building_layer.featureDeleted.disconnect()
except TypeError:
pass
try:
self.building_layer.geometryChanged.disconnect()
except TypeError:
pass
if self.polyline:
self.polyline.reset()
if isinstance(self.circle_tool, PointTool):
self.circle_tool.canvas_clicked.disconnect()
self.circle_tool.mouse_moved.disconnect()
self.circle_tool.deactivate()
iface.actionPan().trigger()
iface.actionCancelEdits().trigger()
self.setup_toolbar()
self.change_instance = None
@pyqtSlot(str)
def layers_removed(self, layerids):
self.layer_registry.update_layers()
for layer in ["building_outlines", "historic_outlines"]:
if layer in layerids:
self.cb_production.setDisabled(1)
iface.messageBar().pushMessage(
"ERROR",
"Required layer Removed! Please reload the buildings plugin or the current frame before continuing",
level=Qgis.Critical,
duration=5,
)
return
