def openLayer(self,
group,
name,
ext=".shp",
results=False,
toEnd=False,
sectors=False,
issues=False):
showName = name
name = name.replace(' ', '')
layerName = self.NetworkName + "_" + name
if os.path.exists(os.path.join(self.ProjectDirectory,
layerName + ext)):
vlayer = QgsVectorLayer(
os.path.join(self.ProjectDirectory, layerName + ext), showName,
"ogr")
if not ext == ".dbf":
if results:
self.setResultStyle(vlayer)
elif sectors:
self.setSectorsStyle(vlayer)
elif issues:
pass
else:
self.setStyle(vlayer, name.lower())
QgsProject.instance().addMapLayer(vlayer, group is None)
if group is not None:
if toEnd:
group.addChildNode(QgsLayerTreeLayer(vlayer))
else:
group.insertChildNode(0, QgsLayerTreeLayer(vlayer))
del vlayer
if results:
self.orderResultLayers(group)
def layers_create(self, missing=None):
"""Utworzenie warstw w projekcie. Podanie atrybutu 'missing' spowoduje, że tylko wybrane warstwy będą dodane."""
# Ustalenie ilości dodawanych warstw:
i_max = len(missing) if missing else self.lyr_cnt
# Utworzenie listy ze słownikami warstw do dodania:
lyrs = []
if missing:
for l_dict in self.lyrs:
if l_dict["name"] in missing:
lyrs.append(l_dict)
else:
lyrs = self.lyrs
i = 0
# Dodanie warstw:
for l_dict in lyrs:
i += 1
raw_uri = l_dict["uri"]
uri = eval("f'{}'".format(raw_uri))
if l_dict["source"] == "wms" or l_dict["source"] == "gdal":
lyr = QgsRasterLayer(uri, l_dict["name"], l_dict["source"])
lyr_required = False
else:
lyr = QgsVectorLayer(uri, l_dict["name"], l_dict["source"])
lyr_required = True
if not lyr.isValid() and not lyr_required:
m_text = f'Nie udało się poprawnie wczytać podkładu mapowego: {l_dict["name"]}. Naciśnięcie Tak spowoduje kontynuowanie uruchamiania wtyczki (podkład mapowy nie będzie wyświetlany), naciśnięcie Nie przerwie proces uruchamiania wtyczki. Jeśli problem będzie się powtarzał, zaleca się powiadomienie administratora systemu.'
reply = QMessageBox.question(dlg.app, "WellMatch", m_text,
QMessageBox.Yes, QMessageBox.No)
if reply == QMessageBox.No:
return False
elif not lyr.isValid() and lyr_required:
m_text = f'Nie udało się poprawnie wczytać warstwy: {l_dict["name"]}. Jeśli problem będzie się powtarzał, proszę o powiadomienie administratora systemu ([email protected]).'
QMessageBox.critical(dlg.app, "WellMatch", m_text)
return False
if l_dict["source"] == "memory":
lyr.setCustomProperty("skipMemoryLayersCheck", 1)
pr = lyr.dataProvider()
pr.addAttributes(l_dict["attrib"])
lyr.updateFields()
if "crs" in l_dict:
lyr.setCrs(CRS_1992)
dlg.proj.addMapLayer(lyr, False)
if l_dict["root"]:
parent_grp = self.root
parent_grp.insertChildNode(l_dict["pos"],
QgsLayerTreeLayer(lyr))
parent_grp.findLayer(lyr).setItemVisibilityChecked(
l_dict["visible"])
else:
if "pos" in l_dict:
parent_grp = self.root.findGroup(l_dict["parent"])
parent_grp.insertChildNode(l_dict["pos"],
QgsLayerTreeLayer(lyr))
parent_grp.findLayer(lyr).setItemVisibilityChecked(False)
else:
parent_grp = self.root.findGroup(l_dict["parent"])
node = parent_grp.addLayer(lyr)
node.setItemVisibilityChecked(l_dict["visible"])
lyr.loadNamedStyle(f'{STYLE_PATH}{l_dict["style"]}')
return True
def testNodeCustomProperties(self):
layer = QgsVectorLayer("Point?field=fldtxt:string", "layer1", "memory")
layer1_node = QgsLayerTreeLayer(layer)
spy = QSignalSpy(layer1_node.customPropertyChanged)
self.assertFalse(layer1_node.customProperty('test'))
self.assertNotIn('test', layer1_node.customProperties())
layer1_node.setCustomProperty('test', 'value')
self.assertEqual(len(spy), 1)
# set to same value, should be no extra signal
layer1_node.setCustomProperty('test', 'value')
self.assertEqual(len(spy), 1)
self.assertIn('test', layer1_node.customProperties())
self.assertEqual(layer1_node.customProperty('test'), 'value')
layer1_node.setCustomProperty('test', 'value2')
self.assertEqual(len(spy), 2)
self.assertIn('test', layer1_node.customProperties())
self.assertEqual(layer1_node.customProperty('test'), 'value2')
layer1_node.removeCustomProperty('test')
self.assertEqual(len(spy), 3)
self.assertFalse(layer1_node.customProperty('test'))
self.assertNotIn('test', layer1_node.customProperties())
# already removed, should be no extra signal
layer1_node.removeCustomProperty('test')
self.assertEqual(len(spy), 3)
def testLegend(self):
renderer = QgsPointCloudAttributeByRampRenderer()
renderer.setAttribute('Intensity')
renderer.setMinimum(200)
renderer.setMaximum(800)
ramp = QgsStyle.defaultStyle().colorRamp("Viridis")
shader = QgsColorRampShader(200, 800, ramp.clone())
shader.setClassificationMode(QgsColorRampShader.EqualInterval)
shader.classifyColorRamp(classes=4)
renderer.setColorRampShader(shader)
layer = QgsPointCloudLayer(
unitTestDataPath() + '/point_clouds/ept/sunshine-coast/ept.json',
'test', 'ept')
layer_tree_layer = QgsLayerTreeLayer(layer)
nodes = renderer.createLegendNodes(layer_tree_layer)
self.assertEqual(len(nodes), 4)
self.assertEqual(nodes[0].data(Qt.DisplayRole), '200')
self.assertEqual(nodes[1].data(Qt.DisplayRole), '400')
self.assertEqual(nodes[2].data(Qt.DisplayRole), '600')
self.assertEqual(nodes[3].data(Qt.DisplayRole), '800')
shader = QgsColorRampShader(200, 600, ramp.clone())
shader.setClassificationMode(QgsColorRampShader.EqualInterval)
shader.classifyColorRamp(classes=2)
renderer.setColorRampShader(shader)
nodes = renderer.createLegendNodes(layer_tree_layer)
self.assertEqual(len(nodes), 2)
self.assertEqual(nodes[0].data(Qt.DisplayRole), '200')
self.assertEqual(nodes[1].data(Qt.DisplayRole), '600')
def addGeojsonsToMap(iface, fileList, Groupname="", size=1, color=None, geometrytype="LineString" ):
"""Add a series of geojson's to a map
Args:
iface (QgisInterface): the interface with the mainWindow
fileList (list): list of path's to geojson files
Groupname (str, optional): the name of the group of layers, Defaults to "".
size (int, optional): the line width in mm. Defaults to 1 mm.
color (QColor, optional): the color of the output layers. Defaults to None in that case a random color is chosen.
geometrytype (string, optional): the geometrytype of the outputlayers. Defaults to "LineString".
Returns:
(list): A list of added layers
"""
if len(fileList) > 1:
root = QgsProject.instance().layerTreeRoot()
shapeGroup = root.addGroup(Groupname)
lyrList = []
for gjsFile in fileList:
lyrName = os.path.basename( os.path.splitext(gjsFile)[0] )
lyr = QgsVectorLayer('{0}|layername={1}|geometrytype=LineString'.format(gjsFile, lyrName), lyrName, "ogr")
if len(fileList) == 1:
QgsProject.instance().addMapLayer(lyr)
sym = lyr.renderer().symbols(QgsRenderContext())[0]
if color: sym.setColor( color )
if size: sym.setWidth( size )
if len(fileList) > 1:
QgsProject.instance().addMapLayer(lyr, False)
shapeGroup.insertChildNode(1, QgsLayerTreeLayer(lyr))
lyr.triggerRepaint()
lyrList.append(lyr)
return lyrList
def test_icon_horizontal_flipped(self):
r = QgsGradientColorRamp(QColor(200, 0, 0, 100),
QColor(0, 200, 0, 200))
# need a layer in order to make legend nodes
layer = QgsVectorLayer('dummy', 'test', 'memory')
layer_tree_layer = QgsLayerTreeLayer(layer)
settings = QgsColorRampLegendNodeSettings()
settings.setDirection(QgsColorRampLegendNodeSettings.MaximumToMinimum)
settings.setOrientation(Qt.Horizontal)
node = TestColorRampLegend(layer_tree_layer, r, settings, 5, 10)
pixmap = node.data(Qt.DecorationRole)
im = QImage(pixmap.size(), QImage.Format_ARGB32)
im.fill(QColor(255, 255, 255))
p = QPainter(im)
p.drawPixmap(0, 0, pixmap)
p.end()
self.assertTrue(
self.imageCheck('color_ramp_legend_node_flipped_horizontal_icon',
'color_ramp_legend_node_flipped_horizontal_icon',
im, 10))
def test_icon_prefix_suffix(self):
r = QgsGradientColorRamp(QColor(200, 0, 0, 100),
QColor(0, 200, 0, 200))
# need a layer in order to make legend nodes
layer = QgsVectorLayer('dummy', 'test', 'memory')
layer_tree_layer = QgsLayerTreeLayer(layer)
settings = QgsColorRampLegendNodeSettings()
settings.setPrefix('pref ')
settings.setSuffix(' suff')
node = TestColorRampLegend(layer_tree_layer, r, settings, 5, 10)
pixmap = node.data(Qt.DecorationRole)
im = QImage(pixmap.size(), QImage.Format_ARGB32)
im.fill(QColor(255, 255, 255))
p = QPainter(im)
p.drawPixmap(0, 0, pixmap)
p.end()
self.assertTrue(
self.imageCheck('color_ramp_legend_node_prefix_suffix_icon',
'color_ramp_legend_node_prefix_suffix_icon', im,
10))
def add_layer(layer: QgsMapLayer,
name: str = None,
index: int = -1,
color: typing.Tuple[int, int, int] = None,
size: float = None,
file: str = None,
parent: QgsLayerTreeNode = None,
show_feature_count: bool = True) -> None:
if name:
layer.setName(name)
if isinstance(layer, QgsVectorLayer):
if color or size or file:
update_symbology(layer, color=color, size=size, file=file)
elif isinstance(layer, QgsRasterLayer):
# TODO update symbology
pass
instance = QgsProject.instance()
instance.addMapLayer(layer, False)
layerTreeNode = QgsLayerTreeLayer(layer)
layerTreeNode.setCustomProperty('showFeatureCount', show_feature_count)
parent = parent if parent else instance.layerTreeRoot()
parent.insertChildNode(index, layerTreeNode)
def test_icon_with_settings(self):
r = QgsGradientColorRamp(QColor(200, 0, 0, 100), QColor(0, 200, 0, 200))
# need a layer in order to make legend nodes
layer = QgsVectorLayer('dummy', 'test', 'memory')
layer_tree_layer = QgsLayerTreeLayer(layer)
settings = QgsColorRampLegendNodeSettings()
format = QgsBasicNumericFormat()
format.setShowTrailingZeros(True)
format.setNumberDecimalPlaces(3)
settings.setNumericFormat(format)
settings.setDirection(QgsColorRampLegendNodeSettings.MaximumToMinimum)
node = TestColorRampLegend(layer_tree_layer, r, settings, 5, 10)
pixmap = node.data(Qt.DecorationRole)
im = QImage(pixmap.size(), QImage.Format_ARGB32)
im.fill(QColor(255, 255, 255))
p = QPainter(im)
p.drawPixmap(0, 0, pixmap)
p.end()
self.assertTrue(self.imageCheck('color_ramp_legend_node_settings_icon', 'color_ramp_legend_node_settings_icon', im, 10))
def create_rt_avg_mon_shp(self):
input1 = QgsProject.instance().mapLayersByName("mf_grid (MODFLOW)")[0]
QSWATMOD_path_dict = self.dirs_and_paths()
# Copy mf_grid shapefile to swatmf_results tree
name = "rt_nitrate_avg_mon"
name_ext = "rt_nitrate_avg_mon.shp"
output_dir = QSWATMOD_path_dict['SMshps']
# Check if there is an exsting mf_head shapefile
if not any(lyr.name() == (name)
for lyr in list(QgsProject.instance().mapLayers().values())):
rt_no3_shp = os.path.join(output_dir, name_ext)
QgsVectorFileWriter.writeAsVectorFormat(input1, rt_no3_shp, "utf-8",
input1.crs(), "ESRI Shapefile")
layer = QgsVectorLayer(rt_no3_shp, '{0}'.format(name), 'ogr')
# Put in the group
root = QgsProject.instance().layerTreeRoot()
swatmf_results = root.findGroup("swatmf_results")
QgsProject.instance().addMapLayer(layer, False)
swatmf_results.insertChildNode(0, QgsLayerTreeLayer(layer))
msgBox = QMessageBox()
msgBox.setWindowIcon(QtGui.QIcon(':/QSWATMOD2/pics/sm_icon.png'))
msgBox.setWindowTitle("Created!")
msgBox.setText(
"'rt_nitrate_avg_mon.shp' file has been created in 'swatmf_results' group!"
)
msgBox.exec_()
msgBox = QMessageBox()
def test_group_layer_updates_from_node(self):
"""
Test that group layer child layers are synced correctly from the group node
"""
group_node = QgsLayerTreeGroup('my group')
options = QgsGroupLayer.LayerOptions(QgsCoordinateTransformContext())
group_layer = group_node.convertToGroupLayer(options)
self.assertFalse(group_layer.childLayers())
layer = QgsVectorLayer("Point?field=fldtxt:string", "layer1", "memory")
group_node.addLayer(layer)
self.assertEqual(group_layer.childLayers(), [layer])
layer2 = QgsVectorLayer("Point?field=fldtxt:string", "layer2",
"memory")
group_node.insertLayer(0, layer2)
self.assertEqual(group_layer.childLayers(), [layer, layer2])
layer3 = QgsVectorLayer("Point?field=fldtxt:string", "layer3",
"memory")
layer4 = QgsVectorLayer("Point?field=fldtxt:string", "layer4",
"memory")
layer3_node = QgsLayerTreeLayer(layer3)
layer4_node = QgsLayerTreeLayer(layer4)
group_node.insertChildNodes(1, [layer3_node, layer4_node])
self.assertEqual(group_layer.childLayers(),
[layer, layer4, layer3, layer2])
layer5 = QgsVectorLayer("Point?field=fldtxt:string", "layer5",
"memory")
layer5_node = QgsLayerTreeLayer(layer5)
group_node.addChildNode(layer5_node)
self.assertEqual(group_layer.childLayers(),
[layer5, layer, layer4, layer3, layer2])
group_node.removeChildNode(layer3_node)
self.assertEqual(group_layer.childLayers(),
[layer5, layer, layer4, layer2])
group_node.removeLayer(layer)
self.assertEqual(group_layer.childLayers(), [layer5, layer4, layer2])
group_node.removeChildren(0, 2)
self.assertEqual(group_layer.childLayers(), [layer5])
group_node.removeAllChildren()
self.assertEqual(group_layer.childLayers(), [])
def sub_shapefile(self):
APEXMOD_path_dict = self.dirs_and_paths()
settings = QSettings()
if settings.contains('/APEXMOD/LastInputPath'):
path = str(settings.value('/APEXMOD/LastInputPath'))
else:
path = ''
title = "Choose SUB Shapefile!"
inFileName, __ = QFileDialog.getOpenFileNames(
None, title, path,
"Shapefiles (*.shp);;All files (*.*)"
)
if inFileName:
settings.setValue('/APEXMOD/LastInputPath', os.path.dirname(str(inFileName)))
output_dir = APEXMOD_path_dict['org_shps']
inInfo = QFileInfo(inFileName[0])
inFile = inInfo.fileName()
pattern = os.path.splitext(inFileName[0])[0] + '.*'
inName = 'sub_org'
for f in glob.iglob(pattern):
suffix = os.path.splitext(f)[1]
if os.name == 'nt':
outfile = ntpath.join(output_dir, inName + suffix)
else:
outfile = posixpath.join(output_dir, inName + suffix)
shutil.copy(f, outfile)
if os.name == 'nt':
sub_obj = ntpath.join(output_dir, inName + ".shp")
else:
sub_obj = posixpath.join(output_dir, inName + ".shp")
# time stamp
time = datetime.now().strftime('[%m/%d/%y %H:%M:%S]')
self.dlg.textEdit_sm_link_log.append(time+' -> ' + "Checking SUB geometries ... processing")
self.dlg.label_StepStatus.setText("Checking 'SUB' ... ")
QCoreApplication.processEvents()
# fixgeometries
sub_shp_file = 'sub_apex.shp'
sub_shp_f = os.path.join(output_dir, sub_shp_file)
params = {
'INPUT': sub_obj,
'OUTPUT': sub_shp_f
}
processing.run('native:fixgeometries', params)
layer = QgsVectorLayer(sub_shp_f, '{0} ({1})'.format("sub","APEX"), 'ogr')
# Put in the group
root = QgsProject.instance().layerTreeRoot()
swat_group = root.findGroup("APEX")
QgsProject.instance().addMapLayer(layer, False)
swat_group.insertChildNode(0, QgsLayerTreeLayer(layer))
self.dlg.lineEdit_subbasin_shapefile.setText(sub_shp_f)
time = datetime.now().strftime('[%m/%d/%y %H:%M:%S]')
self.dlg.textEdit_sm_link_log.append(time+' -> ' + "Checking SUB geometries ... passed")
self.dlg.label_StepStatus.setText("Step Status: ")
QCoreApplication.processEvents()
def _lang(self):
'''
Lang Simplification Algorithm
'''
'''
Densify By Count >>> Delete holes >>> Smooth (QGIS) || Generalize (Grass)
'''
densify_by_count = processing.run('qgis:densifygeometries',
{'INPUT': self.gpkg_path + '|layername=zones',
'VERTICES': 3,
'OUTPUT': 'ogr:dbname=\'' + self.gpkg_path + '\' table=\"densifyByCount\" ('
'geom)'})
delete_holes = processing.run('qgis:deleteholes',
{'INPUT': densify_by_count['OUTPUT'],
'MIN_AREA': 30,
'OUTPUT': 'ogr:dbname=\'' + self.gpkg_path + '\' table=\"deleteHoles\" (geom)'})
# qgis
# smooth = processing.run('qgis:smoothgeometry',
# { 'INPUT': deleteHoles['OUTPUT'],
# 'ITERATIONS': 10,
# 'OFFSET': 0.25,
# 'MAX_ANGLE': 180,
# 'OUTPUT': 'ogr:dbname=\''+ self.gpkg_path +'\' table=\"smooth\" (geom)'})
# # extract vertices (polygon to nodes)
# processing.run('qgis: extractvertices',
# { 'INPUT': self.gpkg_path + '|layername=zones',
# 'OUTPUT' : 'TEMPORARY_OUTPUT' })
# grass
grass_generalize = processing.run('grass7:v.generalize',
{'input': delete_holes['OUTPUT'],
'method': 2,
'threshold': 1,
'output': 'TEMPORARY_OUTPUT',
'error': 'TEMPORARY_OUTPUT'})
grass_generalize_converted = processing.run('gdal:convertformat', {
'INPUT': grass_generalize['output'],
'OPTIONS': '',
'OUTPUT': 'grass_generalize_converted.shp'})
grass_generalize_converted_toGpkg = QgsVectorLayer(grass_generalize_converted['OUTPUT'],
'grass_generalize_lang', "ogr")
# self._saveIntoGpkg(grass_generalize_converted_toGpkg,'grass_generalize_lang')
# grass_generalize_convertedd = QgsVectorLayer(grass_generalize_converted['OUTPUT'], 'grass_generalize_lang', "ogr")
# grass_generalize_converted_toMap = QgsVectorLayer(self.gpkg_path + '|layername=grass_generalize_lang', 'grass_generalize_lang', "ogr")
generalize_layer = QgsProject.instance().addMapLayer(grass_generalize_converted_toGpkg, False)
root = QgsProject.instance().layerTreeRoot()
group_gtfs = root.findGroup('zones')
group_gtfs.insertChildNode(0, QgsLayerTreeLayer(generalize_layer))
def orderResultLayers(self, group):
layers = [tree_layer.layer()
for tree_layer in group.findLayers()] # Only in group
for layer in layers:
if not layer.geometryType() == 0: # Point
clonedLayer = layer.clone()
QgsProject.instance().addMapLayer(clonedLayer, group is None)
if group is not None:
group.addChildNode(QgsLayerTreeLayer(clonedLayer))
QgsProject.instance().removeMapLayer(layer.id())
def gw_delay(self):
APEXMOD_path_dict = self.dirs_and_paths()
# Create apexmf_results tree inside
root = QgsProject.instance().layerTreeRoot()
input1 = QgsProject.instance().mapLayersByName("hru (SWAT)")[0]
# Copy sub shapefile to be under "p from mf"
name = "gw_delay"
name_ext = "gw_delay.shp"
output_dir = APEXMOD_path_dict['apexmf_shps']
# Check if there is an exsting mf_head shapefile
# if not any(lyr.name() == ("conv_runoff") for lyr in QgsProject.instance().mapLayers().values()):
gw_delay_shapefile = os.path.join(output_dir, name_ext)
QgsVectorFileWriter.writeAsVectorFormat(input1,
gw_delay_shapefile, "utf-8",
input1.crs(), "ESRI Shapefile")
layer = QgsVectorLayer(gw_delay_shapefile, '{0}'.format("gw_delay"), 'ogr')
# Put in the group
# root = QgsProject.instance().layerTreeRoot()
# conv_runoff = root.findGroup("Pumping from MODFLOW")
QgsProject.instance().addMapLayer(layer, False)
sm = root.findGroup("APEX-MODFLOW")
sm.insertChildNode(0, QgsLayerTreeLayer(layer))
input2 = QgsProject.instance().mapLayersByName("gw_delay")[0]
fields = input2.dataProvider()
fdname = [
fields.indexFromName(field.name()) for field in fields.fields()
if not field.name() == 'HRU_ID'
]
fields.deleteAttributes(fdname)
input2.updateFields()
gwd = QgsField('gw_delay', QVariant.Int)
fields.addAttributes([gwd])
input2.updateFields()
gwd_idx = fields.fields().indexFromName('gw_delay')
feats = input2.getFeatures()
input2.startEditing()
delay_multi = self.dlg.spinBox_gw_delay_multi.value()
for feat in feats:
# attr = feat.attributes() # this can be used for changing value based on value from other column
input2.changeAttributeValue(feat.id(), gwd_idx, delay_multi)
input2.commitChanges()
msgBox.setWindowTitle("Created!")
msgBox.setText("'gw_delay.shp' file has been created!")
msgBox.exec_()
def openTreeLayer(self, group, name, treeName, link=False):
layerPath = os.path.join(
self.ProjectDirectory,
self.NetworkName + "_" + name + "_Tree_" + treeName + ".shp")
if os.path.exists(layerPath):
vlayer = QgsVectorLayer(layerPath, name, "ogr")
if link:
self.setTreeStyle(vlayer)
QgsProject.instance().addMapLayer(vlayer, group is None)
if group is not None:
group.insertChildNode(0, QgsLayerTreeLayer(vlayer))
del vlayer
def testCustomLayerOrderChanged(self):
layer = QgsVectorLayer("Point?field=fldtxt:string", "layer1", "memory")
layer2 = QgsVectorLayer("Point?field=fldtxt:string", "layer2",
"memory")
layer_tree = QgsLayerTree()
layer_order_changed_spy = QSignalSpy(
layer_tree.customLayerOrderChanged)
layer1_node = QgsLayerTreeLayer(layer)
layer_tree.addChildNode(layer1_node)
self.assertEqual(len(layer_order_changed_spy), 1)
layer2_node = QgsLayerTreeLayer(layer2)
layer_tree.addChildNode(layer2_node)
self.assertEqual(len(layer_order_changed_spy), 2)
# simulate a layer move in the tree
layer3_node = QgsLayerTreeLayer(layer)
layer_tree.addChildNode(layer3_node)
self.assertEqual(len(layer_order_changed_spy), 3)
layer_tree.removeChildNode(layer1_node)
self.assertEqual(len(layer_order_changed_spy), 4)
def open_layer_group(self, name):
""" add layer group to canvas """
project = QgsProject.instance() # get project instance
# enable custom layer order
rg = self.iface.layerTreeCanvasBridge().rootGroup()
if not rg.hasCustomLayerOrder():
rg.setHasCustomLayerOrder(True)
# check if thematics group in tree
root = project.layerTreeRoot()
themGroup = root.findGroup(self.tr("Thematics"))
if themGroup is None:
# create the group at the end of tree
themGroup = root.insertGroup(-1, self.tr("Thematics"))
if name in self.layers:
for l in self.layers[name]:
valid = False
typ = ""
if l.startswith("url="):
# wms layer
nam = self.wms_name(l)
if nam:
lobjs = project.mapLayersByName(nam)
if not lobjs: # not in project yet
# open wms
r = QgsRasterLayer(l, nam, "wms")
valid = r.isValid()
typ = "wms"
else:
# local vector/raster layer
ext = os.path.splitext(os.path.split(l)[1])[1]
nam = os.path.splitext(os.path.split(l)[1])[0]
lobjs = project.mapLayersByName(nam)
if lobjs: # layer in project yet
continue
if ext in ('.tif', '.jpg', '.png', '.vrt'):
# open raster
r = QgsRasterLayer(l, nam)
valid = r.isValid()
typ = "raster"
else:
# open vector
r = QgsVectorLayer(l, nam, 'ogr')
valid = r.isValid()
typ = "vector"
if valid:
project.addMapLayer(r, False)
themGroup.insertChildNode(-1, QgsLayerTreeLayer(r))
if typ == "vector":
self.reorder(r) # change layer position in layer order
else:
QMessageBox.warning(
None, self.tr("Layer"),
self.tr("Cannot open layer: {}").format(nam))
def addLayerToGroup(self, layer, groupname, subgroupname=None):
"""
Adds a layer to a group into layer panel.
:param layer: (QgsMapLayer) layer to be added to canvas.
:param groupname: (str) name for group to nest the layer.
:param subgroupname: (str) name for the subgroup to be added.
"""
root = QgsProject.instance().layerTreeRoot()
layer = layer if isinstance(layer, QgsMapLayer) \
else QgsProcessingUtils.mapLayerFromString(layer)
QgsProject.instance().addMapLayer(layer, False)
root.insertChildNode(-1, QgsLayerTreeLayer(layer))
def test_draw_settings(self):
r = QgsGradientColorRamp(QColor(200, 0, 0, 100),
QColor(0, 200, 0, 200))
# need a layer in order to make legend nodes
layer = QgsVectorLayer('dummy', 'test', 'memory')
layer_tree_layer = QgsLayerTreeLayer(layer)
settings = QgsColorRampLegendNodeSettings()
format = QgsBasicNumericFormat()
format.setShowTrailingZeros(True)
format.setNumberDecimalPlaces(3)
settings.setNumericFormat(format)
settings.setDirection(QgsColorRampLegendNodeSettings.MaximumToMinimum)
node = QgsColorRampLegendNode(layer_tree_layer, r, settings, 5, 10)
ls = QgsLegendSettings()
item_style = ls.style(QgsLegendStyle.SymbolLabel)
item_style.setFont(QgsFontUtils.getStandardTestFont('Bold', 18))
ls.setStyle(QgsLegendStyle.SymbolLabel, item_style)
item_context = QgsLayerTreeModelLegendNode.ItemContext()
image = QImage(400, 250, QImage.Format_ARGB32)
image.fill(QColor(255, 255, 255))
p = QPainter(image)
ms = QgsMapSettings()
ms.setExtent(QgsRectangle(1, 10, 1, 10))
ms.setOutputSize(image.size())
context = QgsRenderContext.fromMapSettings(ms)
context.setPainter(p)
context.setScaleFactor(150 / 25.4) # 150 DPI
p.scale(context.scaleFactor(), context.scaleFactor())
item_context.context = context
item_context.painter = p
item_context.top = 1
item_context.columnLeft = 3
item_context.columnRight = 30
item_context.patchSize = QSizeF(12, 40)
symbol_size = node.drawSymbol(ls, item_context, 0)
node.drawSymbolText(ls, item_context, symbol_size)
p.end()
self.assertTrue(
self.imageCheck('color_ramp_legend_node_settings_draw',
'color_ramp_legend_node_settings_draw', image))
def addLayer(layer, loadInLegend=True, group=None, isSubGroup=False):
"""
Add one or several layers to the QGIS session and layer registry.
@param layer: The layer object or list with layers to add the QGIS layer registry and session.
@param loadInLegend: True if this layer should be added to the legend.
:return: The added layer
"""
global groupName
if not hasattr(layer, "__iter__"):
layer = [layer]
if group is not None:
_layerreg.addMapLayers(layer, False)
root = _layerreg.layerTreeRoot()
if isSubGroup:
vg = root.findGroup(groupName)
g = vg.findGroup(group)
g.insertChildNode(0, QgsLayerTreeLayer(layer[0]))
else:
g = root.findGroup(group)
g.insertChildNode(0, QgsLayerTreeLayer(layer[0]))
else:
_layerreg.addMapLayers(layer, loadInLegend)
return layer
def testLegend(self):
renderer = QgsPointCloudClassifiedRenderer()
renderer.setAttribute('Classification')
renderer.setCategories([QgsPointCloudCategory(3, QColor(255, 0, 0), 'cat 3'),
QgsPointCloudCategory(7, QColor(0, 255, 0), 'cat 7')])
layer = QgsPointCloudLayer(unitTestDataPath() + '/point_clouds/ept/sunshine-coast/ept.json', 'test', 'ept')
layer_tree_layer = QgsLayerTreeLayer(layer)
nodes = renderer.createLegendNodes(layer_tree_layer)
self.assertEqual(len(nodes), 2)
self.assertEqual(nodes[0].data(Qt.DisplayRole), 'cat 3')
self.assertEqual(nodes[0].data(QgsLayerTreeModelLegendNode.RuleKeyRole), '3')
self.assertEqual(nodes[1].data(Qt.DisplayRole), 'cat 7')
self.assertEqual(nodes[1].data(QgsLayerTreeModelLegendNode.RuleKeyRole), '7')
def writeDBF(pos, pp, pr, save_file, inpname, param, idx):
pos.startEditing()
for i in range(len(pp)):
feat = QgsFeature()
feat.setAttributes(pp[i])
pr.addFeatures([feat])
epsgCode = pos.crs().authid()
QgsVectorFileWriter.writeAsVectorFormat(pos, save_file + param + '.dbf', "utf-8",
QgsCoordinateReferenceSystem(epsgCode), "DBF file")
ll = QgsVectorLayer(save_file + param + '.dbf', inpname[:len(inpname) - 4] + param, "ogr")
QgsProject.instance().addMapLayer(ll, False)
nn = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, nn)
nn.setCustomProperty("showFeatureCount", True)
def add_layer(self, layer):
# add a layer to the registry, if not already there
layers = self.project.mapLayers()
for name, alayer in layers.items():
if alayer == layer:
return
self.project.addMapLayer(layer, False)
# make sure the mask layer is on top of other layers
lt = QgsProject.instance().layerTreeRoot()
# insert a new on top
self.disable_add_layer_signal = True
lt.insertChildNode(0, QgsLayerTreeLayer(layer))
self.disable_add_layer_signal = False
def create_sm_riv(self):
APEXMOD_path_dict = self.dirs_and_paths()
if not any(lyr.name() == ("apexmf_riv")
for lyr in list(QgsProject.instance().mapLayers().values())):
# Create apexmf_results tree inside
root = QgsProject.instance().layerTreeRoot()
if root.findGroup("apexmf_results"):
sm_results_group = root.findGroup("apexmf_results")
else:
sm_results_group = root.insertGroup(0, "apexmf_results")
input1 = QgsProject.instance().mapLayersByName("mf_grid (MODFLOW)")[0]
input2 = QgsProject.instance().mapLayersByName(
"river_grid (APEX-MODFLOW)")[0]
feats_mf_grid = input1.getFeatures()
feats = input2.getFeatures()
grid_id = set([f.attribute('grid_id') for f in feats])
#hm = set(grid_id)
riv_mat = []
for f in feats_mf_grid:
grid_no = f.attribute("grid_id")
for i in grid_id:
if grid_no == i:
riv_mat.append(f.id())
input1.selectByIds(riv_mat)
name_ext = "apexmf_riv.shp"
output_dir = APEXMOD_path_dict['apexmf_shps']
# Save just the selected features of the target layer
sm_riv_shapefile = os.path.join(output_dir, name_ext)
# Extract selected features
processing.run("native:saveselectedfeatures", {
'INPUT': input1,
'OUTPUT': sm_riv_shapefile
})
# Deselect the features
input1.removeSelection()
layer = QgsVectorLayer(sm_riv_shapefile, '{0}'.format("apexmf_riv"),
'ogr')
# Put in the group
root = QgsProject.instance().layerTreeRoot()
sm_results_group = root.findGroup("apexmf_results")
QgsProject.instance().addMapLayer(layer, False)
sm_results_group.insertChildNode(0, QgsLayerTreeLayer(layer))
layer = QgsProject.instance().addMapLayer(layer)
def copySelected(self, layer, mem_layer, geom_type):
''' Copy from selected layer to memory layer '''
self.manageMemLayers()
# Create memory layer if not already set
if mem_layer is None:
uri = geom_type+"?crs=epsg:"+self.srid
mem_layer = QgsVectorLayer(uri, "selected_"+layer.name(), "memory")
# Copy attributes from main layer to memory layer
attrib_names = layer.dataProvider().fields()
names_list = attrib_names.toList()
newattributeList = []
for attrib in names_list:
aux = mem_layer.fieldNameIndex(attrib.name())
if aux == -1:
newattributeList.append(QgsField(attrib.name(), attrib.type()))
mem_layer.dataProvider().addAttributes(newattributeList)
mem_layer.updateFields()
# Insert layer in the top of the TOC
root = QgsProject.instance().layerTreeRoot()
QgsMapLayerRegistry.instance().addMapLayer(mem_layer, False)
node_layer = QgsLayerTreeLayer(mem_layer)
root.insertChildNode(0, node_layer)
# Prepare memory layer for editing
mem_layer.startEditing()
# Iterate over selected features
cfeatures = []
for sel_feature in layer.selectedFeatures():
attributes = []
attributes.extend(sel_feature.attributes())
cfeature = QgsFeature()
cfeature.setGeometry(sel_feature.geometry())
cfeature.setAttributes(attributes)
cfeatures.append(cfeature)
# Add features, commit changes and refresh canvas
mem_layer.dataProvider().addFeatures(cfeatures)
mem_layer.commitChanges()
self.iface.mapCanvas().refresh()
self.iface.mapCanvas().zoomToSelected(layer)
# Make sure layer is always visible
self.iface.legendInterface().setLayerVisible(mem_layer, True)
return mem_layer
def addLayer(layer, loadInLegend=True, group=None):
"""
Add one or several layers to the QGIS session and layer registry.
:param layer: The layer object or list with layers to add the QGIS layer registry and session.
:param loadInLegend: True if this layer should be added to the legend.
:return: The added layer
"""
if not hasattr(layer, "__iter__"):
layer = [layer]
_layerreg.addMapLayers(layer, loadInLegend)
if group is not None:
root = QgsProject.instance().layerTreeRoot()
g = root.findGroup(group)
g.insertChildNode(0, QgsLayerTreeLayer(layer[0]))
return layer
def add_ee_image_layer(self, date_start, image, name, shown, opacity):
url = "type=xyz&url=" + self.get_ee_image_url(image)
layer = QgsRasterLayer(url, name, "wms")
self.update_ee_layer_properties(date_start, layer, image, opacity)
QgsProject.instance().addMapLayer(layer)
root = QgsProject.instance().layerTreeRoot()
#layer_list = root.checkedLayers()
#idx = self._last_raster(layer_list)
group = root.findGroup('S2SRC')
if not group:
group = root.insertGroup(0, 'S2SRC')
#root.insertChildNode(0, QgsLayerTreeLayer(layer))
group.insertChildNode(0, QgsLayerTreeLayer(layer))
if not (shown is None):
root.findLayer(layer.id()).setItemVisibilityChecked(shown)
def addLayerToGroup(self, layer, groupname):
"""
Adds a layer to a group.
:param layer: (QgsMapLayer) layer to be added to canvas.
:param groupname: (str) name for group to nest the layer.
"""
root = QgsProject.instance().layerTreeRoot()
for g in root.children():
if g.name() == groupname:
group = g
break
else:
group = root.addGroup(groupname)
QgsProject.instance().addMapLayer(layer, False)
group.insertChildNode(1, QgsLayerTreeLayer(layer))
def _insert_layer(self, layer, qml_file, duration):
# Build pyramids
self.out("Building pyramids ...")
layer = self._build_pyramids(layer)
# Style layer with qml file
if qml_file:
self._set_qml(layer, qml_file)
# Set opacity - also for black white (without QML):
# Sets the opacity for the layer, where opacity is a value
# between 0 (totally transparent) and 1.0 (fully opaque).
opa = 0.6 # 0.6 = 40% transparency
if isinstance(layer, QgsRasterLayer):
layer.renderer().setOpacity(opa)
else:
# layer.setLayerTransparency(40) # % this method seems only be available for vector layer
layer.setOpacity(opa)
# Set zero values to transparent
if self._no_zeros:
self._set_zeroes_invisible(layer)
# Set temporal settings for layer (since QGIS 3.14)
if self.temporal and Qgis.QGIS_VERSION_INT >= 31400:
self.out("Setting temporal settings ...")
self._set_time_range(layer)
# Insert layer at a certain position
# Add the layer to the QGIS Map Layer Registry (the second argument must be set to False
# to specify a custom position:
QgsProject.instance().addMapLayer(
layer, False) # first add the layer without showing it
# obtain the layer tree of the top-level group in the project
layerTree = self._iface.layerTreeCanvasBridge().rootGroup()
# The position is a number starting from 0, with -1 an alias for the end.
# Index 0: ganz oben, Index 1: 2. Position unter der Vektor-Layer-Gruppe:
layerTree.insertChildNode(1, QgsLayerTreeLayer(layer))
# mark the new layer and zoom to it's extent:
self._iface.setActiveLayer(layer)
self._iface.zoomToActiveLayer()
self._show_message(Qgis.Success, layer.name(), duration)
