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 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 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 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 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 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 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 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 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 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 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 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 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 _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)
def addLayerGroup(self, muniname):
""" Add all shapefiles in the dowload folder into a group """
root = QgsProject.instance().layerTreeRoot()
layerGroup = root.addGroup(muniname)
zippath = self.dlg.lineEdit_path.text()
wd = os.path.join(zippath, muniname)
for shape_item in os.listdir(wd):
if shape_item.endswith('.shp'):
vlayer = QgsVectorLayer(os.path.join(
wd, shape_item), shape_item, "ogr")
QgsProject.instance().addMapLayer(vlayer, False)
layerGroup.insertChildNode(
1, QgsLayerTreeLayer(vlayer))
def epa2gis(inpname):
plugin_path = os.path.dirname(__file__)
file_extension = os.path.dirname(inpname)
inpname = os.path.basename(inpname)
inp = file_extension + '/' + inpname
if len(file_extension) == 0:
inp = inpname
newpath = file_extension + '/_shapefiles_'
if not os.path.exists(newpath):
os.makedirs(newpath)
iface = qgis.utils.iface
d.LoadFile(inp)
d.BinUpdateClass()
nlinkCount = d.getBinLinkCount()
res = newpath + '\\'
saveFile = res + inpname[:len(inpname) - 4]
# Get all Sections
mixing = d.getMixingSection()
reactions = d.getReactionsSection()
sources = d.getSourcesSection()
rules = d.getRulesSection()
quality = d.getQualitySection()
curves = d.getCurvesSection()
patterns = d.getPatternsSection()
controls = d.getControlsSection()
emitters = d.getEmittersSection()
status = d.getStatusSection()
demands = d.getDemandsSection()
energy = d.getEnergySection()
optReactions = d.getReactionsOptionsSection()
times = d.getTimesSection()
report = d.getReportSection()
options = d.getOptionsSection()
# Get all Section lengths
allSections = [len(energy), len(optReactions), len(demands), len(status), len(emitters), len(controls),
len(patterns),
len(curves[0]), len(quality), len(rules), len(sources), len(reactions), len(mixing), len(times),
len(report),
len(options), d.getBinNodeCount(), d.getBinLinkCount()]
ss = max(allSections)
root = QgsProject.instance().layerTreeRoot()
idx = root.insertGroup(0, inpname[:len(inpname) - 4])
xy = d.getBinNodeCoordinates()
x = xy[0]
y = xy[1]
vertx = xy[2]
verty = xy[3]
vertxyFinal = []
for i in range(len(vertx)):
vertxy = []
for u in range(len(vertx[i])):
vertxy.append([float(vertx[i][u]), float(verty[i][u])])
if vertxy:
vertxyFinal.append(vertxy)
otherDemads = d.getBinNodeBaseDemandsDemSection()
ndID = d.getBinNodeNameID()
ndBaseD = d.getBinNodeBaseDemands()
ndPatID = d.getBinNodeDemandPatternID()
otherDemadsIndex = []
otherDemadsPatterns = []
for i, p in enumerate(otherDemads[1]):
otherDemadsIndex.append(ndID.index(p))
otherDemadsPatterns.append(otherDemads[2][i])
counter = collections.Counter(otherDemadsIndex)
maxCategories = 1
if counter:
maxCategories = max(counter.values())
if not ndBaseD:
ndBaseD = otherDemads[0]
# Get data of Junctions
if d.getBinNodeJunctionCount() > 0:
ndBaseTmp = np.empty((len(ndBaseD), maxCategories,))
ndPatTmp = []
for t in range(0, maxCategories):
for u in range(0, len(ndBaseD)):
ndBaseTmp[u][t] = 0
ndPatTmp.append(['None'] * 2)
for uu in range(0, len(ndBaseD)):
if d.getBinNodeBaseDemands():
ndBaseTmp[uu][0] = ndBaseD[uu]
ndPatTmp[uu][0] = ndPatID[uu]
t = 0
for i, p in enumerate(otherDemadsIndex):
if d.getBinNodeBaseDemands():
ndBaseTmp[p][t] = ndBaseD[otherDemadsIndex[i]]
ndPatTmp[p][t] = ndPatID[otherDemadsIndex[i]]
else:
ndBaseTmp[p][t] = otherDemads[0][i]
ndPatTmp[p][t] = otherDemads[2][i]
t = t + 1
if t > max(counter.values()) - 1:
t = max(counter.values()) - 1
if i > 0:
if otherDemadsIndex[i - 1] == p:
ndBaseTmp[p][t] = otherDemads[0][i]
ndPatTmp[p][t] = otherDemads[2][i]
t = t - 1
# Write Junction Shapefile
fields = ["ID", "Elevation"] # , "pattern", "demand"]
fieldsCode = [0, 1]
for u in range(0, maxCategories):
fields.append('Demand' + str(u + 1))
fields.append('Pattern' + str(u + 1))
fieldsCode.append(1)
fieldsCode.append(0)
posJunction = QgsVectorLayer("point?crs=EPSG:4326", "Junctions", "memory")
prJunction = posJunction.dataProvider()
ndBaseTmp = ndBaseTmp.tolist()
createColumnsAttrb(prJunction, fields, fieldsCode)
posJunction.startEditing()
ndEle = d.getBinNodeJunctionElevations()
# Get data of Pipes
# Write shapefile pipe
if nlinkCount > 0:
posPipe = QgsVectorLayer("LineString?crs=EPSG:4326", "Pipes", "memory")
prPipe = posPipe.dataProvider()
fields = ["ID", "NodeFrom", "NodeTo", "Status", "Length", "Diameter", "Roughness", "MinorLoss"]
fieldsCode = [0, 0, 0, 0, 1, 1, 1, 1]
createColumnsAttrb(prPipe, fields, fieldsCode)
posPipe.startEditing()
pIndex = d.getBinLinkPumpIndex()
vIndex = d.getBinLinkValveIndex()
ndlConn = d.getBinNodesConnectingLinksID()
x1 = []
x2 = []
y1 = []
y2 = []
stat = d.getBinLinkInitialStatus()
kk = 0
ch = 0
linkID = d.getBinLinkNameID()
linkLengths = d.getBinLinkLength()
linkDiameters = d.getBinLinkDiameter()
linkRough = d.getBinLinkRoughnessCoeff()
linkMinorloss = d.getBinLinkMinorLossCoeff()
# Write Tank Shapefile and get tank data
posTank = QgsVectorLayer("point?crs=EPSG:4326", "Tanks", "memory")
prTank = posTank.dataProvider()
fields = ["ID", "Elevation", "InitLevel", "MinLevel", "MaxLevel", "Diameter", "MinVolume", "VolumeCurve"]
fieldsCode = [0, 1, 1, 1, 1, 1, 1, 0]
createColumnsAttrb(prTank, fields, fieldsCode)
posTank.startEditing()
if d.getBinNodeTankCount() > 0:
ndTankelevation = d.getBinNodeTankElevations()
initiallev = d.getBinNodeTankInitialLevel()
minimumlev = d.getBinNodeTankMinimumWaterLevel()
maximumlev = d.getBinNodeTankMaximumWaterLevel()
diameter = d.getBinNodeTankDiameter()
minimumvol = d.getBinNodeTankMinimumWaterVolume()
volumecurv = d.getBinNodeTankVolumeCurveID()
ndTankID = d.getBinNodeTankNameID()
# Write Reservoir Shapefile
posReservoirs = QgsVectorLayer("point?crs=EPSG:4326", "Reservoirs", "memory")
prReservoirs = posReservoirs.dataProvider()
fields = ["ID", "Head"]
fieldsCode = [0, 1]
createColumnsAttrb(prReservoirs, fields, fieldsCode)
head = d.getBinNodeReservoirElevations()
posReservoirs.startEditing()
if times:
posTimes = QgsVectorLayer("point?crs=EPSG:4326", "Times", "memory")
prTimes = posTimes.dataProvider()
if energy:
posE = QgsVectorLayer("point?crs=EPSG:4326", "Energy", "memory")
prE = posE.dataProvider()
if report:
posRep = QgsVectorLayer("point?crs=EPSG:4326", "Report", "memory")
prRep = posRep.dataProvider()
if options:
posOpt = QgsVectorLayer("point?crs=EPSG:4326", "Options", "memory")
prOpt = posOpt.dataProvider()
if optReactions:
posO = QgsVectorLayer("point?crs=EPSG:4326", "Reactions", "memory")
prO = posO.dataProvider()
ppE = []
ppO = []
ppTimes = []
ppRep = []
ppOpt = []
ppMix = []
ppReactions = []
ppSourc = []
ppRul = []
ppPat = []
ppQual = []
ppDem = []
ppStat = []
ppEmit = []
ppCont = []
ppCurv = []
for i in range(ss):
if i < d.getBinNodeJunctionCount():
featJ = QgsFeature()
point = QgsPointXY(float(x[i]), float(y[i]))
featJ.initAttributes(2 + len(ndBaseTmp[0]) * 2)
featJ.setGeometry(QgsGeometry.fromPointXY(point))
featJ.setAttribute(0, ndID[i])
featJ.setAttribute(1, ndEle[i])
w = 2
for j in range(0, len(ndBaseTmp[0])):
featJ.setAttribute(w, ndBaseTmp[i][j])
featJ.setAttribute(w + 1, ndPatTmp[i][j])
w = w + 2
prJunction.addFeatures([featJ])
if i < nlinkCount:
if len(stat) == i:
ch = 1
if ch == 1:
stat.append('OPEN')
x1.append(x[ndID.index(d.getBinLinkFromNode()[i])])
y1.append(y[ndID.index(d.getBinLinkFromNode()[i])])
x2.append(x[ndID.index(d.getBinLinkToNode()[i])])
y2.append(y[ndID.index(d.getBinLinkToNode()[i])])
if i in pIndex:
pass
elif i in vIndex:
pass
else:
point1 = QgsPointXY(float(x1[i]), float(y1[i]))
point2 = QgsPointXY(float(x2[i]), float(y2[i]))
featPipe = QgsFeature()
if vertx[i]:
parts = []
parts.append(point1)
for mm in range(len(vertxyFinal[kk])):
a = vertxyFinal[kk][mm]
parts.append(QgsPointXY(a[0], a[1]))
parts.append(point2)
featPipe.setGeometry((QgsGeometry.fromPolylineXY(parts)))
kk = kk + 1
else:
featPipe.setGeometry(QgsGeometry.fromPolylineXY([point1, point2]))
featPipe.setAttributes(
[linkID[i], ndlConn[0][i], ndlConn[1][i], stat[i], linkLengths[i], linkDiameters[i], linkRough[i],
linkMinorloss[i]])
prPipe.addFeatures([featPipe])
if i < d.getBinNodeTankCount():
p = d.getBinNodeTankIndex()[i] - 1
featTank = QgsFeature()
point = QgsPointXY(float(x[p]), float(y[p]))
featTank.setGeometry(QgsGeometry.fromPointXY(point))
featTank.setAttributes(
[ndTankID[i], ndTankelevation[i], initiallev[i], minimumlev[i], maximumlev[i], diameter[i],
minimumvol[i], volumecurv[i]])
prTank.addFeatures([featTank])
if i < d.getBinNodeReservoirCount():
p = d.getBinNodeReservoirIndex()[i] - 1
feature = QgsFeature()
point = QgsPointXY(float(x[p]), float(y[p]))
feature.setGeometry(QgsGeometry.fromPointXY(point))
feature.setAttributes([ndID[p], head[i]])
prReservoirs.addFeatures([feature])
if i < allSections[12]:
if len(mixing[i]) == 3:
ppMix.append([mixing[i][0], mixing[i][1], mixing[i][2]])
else:
ppMix.append([mixing[i][0], mixing[i][1]])
if i < allSections[11]:
ppReactions.append([reactions[i][0], reactions[i][1], reactions[i][2]])
if i < allSections[10]:
if len(sources[i]) == 4:
ppSourc.append([sources[i][0], sources[i][1], sources[i][2], sources[i][3]])
elif len(sources[i]) == 3:
ppSourc.append([sources[i][0], sources[i][1], sources[i][2]])
else:
ppSourc.append([sources[i][0], sources[i][1]])
if i < allSections[9]:
if len(rules[i]) > 2:
ppRul.append([rules[i][0][1][1], rules[i][1][0] + rules[i][2][0] + rules[i][3][0]])
if i < allSections[8]:
ppQual.append([quality[i][0], quality[i][1]])
if i < allSections[7]:
ppCurv.append([str(curves[0][i][0]), str(curves[0][i][1]), str(curves[0][i][2]), str(curves[1][i])])
if i < allSections[6]:
ppPat.append([patterns[i][0], str(patterns[i][1])])
if i < allSections[5]:
ppCont.append([controls[i]])
if i < allSections[4]:
ppEmit.append([emitters[i][0], emitters[i][1]])
if i < allSections[3]:
ppStat.append([status[i][0], status[i][1]])
if i < allSections[2]:
if len(demands[i]) > 2:
ppDem.append([demands[i][0], demands[i][1], demands[i][2]])
if i < allSections[0]:
mm = energy[i][0]
if mm.upper() == "GLOBAL":
prE.addAttributes([QgsField("Global" + energy[i][1], QVariant.String)])
if len(energy[i]) > 2:
ppE.append(energy[i][2])
else:
ppE.append('')
if mm.upper() == "PUMP":
prE.addAttributes([QgsField("Pump", QVariant.String)])
if len(energy[i]) > 2:
ppE.append(energy[i][1] + ' ' + energy[i][2])
else:
ppE.append(energy[i][1])
elif mm.upper() == "DEMAND":
if energy[i][1].upper() == "CHARGE":
prE.addAttributes([QgsField("DemCharge", QVariant.String)])
if len(energy[i]) > 2:
ppE.append(energy[i][2])
if i < allSections[1]:
mm = optReactions[i][0]
if mm.upper() == "ORDER":
prO.addAttributes([QgsField("Order" + optReactions[i][1], QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][2])
else:
ppO.append('')
elif mm.upper() == "GLOBAL":
prO.addAttributes([QgsField("Global" + optReactions[i][1], QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][2])
else:
ppO.append('')
elif mm.upper() == "BULK":
prO.addAttributes([QgsField("Bulk", QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][1] + ' ' + optReactions[i][2])
else:
ppO.append(optReactions[i][1])
elif mm.upper() == "WALL":
prO.addAttributes([QgsField("Wall", QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][1] + ' ' + optReactions[i][2])
else:
ppO.append(optReactions[i][1])
elif mm.upper() == "TANK":
prO.addAttributes([QgsField("Tank", QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][1] + ' ' + optReactions[i][2])
else:
ppO.append(optReactions[i][1])
elif mm.upper() == "LIMITING":
if optReactions[i][1].upper() == "POTENTIAL":
prO.addAttributes([QgsField("LimPotent", QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][2])
elif mm.upper() == "ROUGHNESS":
if optReactions[i][1].upper() == "CORRELATION":
prO.addAttributes([QgsField("RoughCorr", QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][2])
if i < allSections[13]:
mm = times[i][0]
if mm.upper() == "DURATION":
prTimes.addAttributes([QgsField("Duration", QVariant.String)])
ppTimes.append(times[i][1])
if mm.upper() == "HYDRAULIC":
prTimes.addAttributes([QgsField("HydStep", QVariant.String)])
ppTimes.append(times[i][2])
elif mm.upper() == "QUALITY":
prTimes.addAttributes([QgsField("QualStep", QVariant.String)])
ppTimes.append(times[i][2])
elif mm.upper() == "RULE":
prTimes.addAttributes([QgsField("RuleStep", QVariant.String)])
ppTimes.append(times[i][2])
elif mm.upper() == "PATTERN":
if times[i][1].upper() == "TIMESTEP":
prTimes.addAttributes([QgsField("PatStep", QVariant.String)])
ppTimes.append(times[i][2])
if times[i][1].upper() == "START":
prTimes.addAttributes([QgsField("PatStart", QVariant.String)])
ppTimes.append(times[i][2])
elif mm.upper() == "REPORT":
if times[i][1].upper() == "TIMESTEP":
prTimes.addAttributes([QgsField("RepStep", QVariant.String)])
ppTimes.append(times[i][2])
if times[i][1].upper() == "START":
prTimes.addAttributes([QgsField("RepStart", QVariant.String)])
ppTimes.append(times[i][2])
elif mm.upper() == "START":
if times[i][1].upper() == "CLOCKTIME":
prTimes.addAttributes([QgsField("StartClock", QVariant.String)])
if len(times[i]) > 3:
ppTimes.append(times[i][2] + ' ' + times[i][3])
else:
ppTimes.append(times[i][2])
elif mm.upper() == "STATISTIC":
prTimes.addAttributes([QgsField("Statistic", QVariant.String)])
if times[i][1].upper() == 'NONE' or times[i][1].upper() == 'AVERAGE' or times[i][1].upper() \
== 'MINIMUM' or times[i][1].upper() == 'MAXIMUM' or times[i][1].upper() == 'RANGE':
ppTimes.append(times[i][1])
if i < allSections[14]:
mm = report[i][0]
if mm.upper() == "PAGESIZE":
prRep.addAttributes([QgsField("PageSize", QVariant.String)])
ppRep.append(report[i][1])
if mm.upper() == "FILE":
prRep.addAttributes([QgsField("FileName", QVariant.String)])
ppRep.append(report[i][1])
elif mm.upper() == "STATUS":
prRep.addAttributes([QgsField("Status", QVariant.String)])
ppRep.append(report[i][1])
elif mm.upper() == "SUMMARY":
prRep.addAttributes([QgsField("Summary", QVariant.String)])
ppRep.append(report[i][1])
elif mm.upper() == "ENERGY":
prRep.addAttributes([QgsField("Energy", QVariant.String)])
ppRep.append(report[i][1])
elif mm.upper() == "NODES":
prRep.addAttributes([QgsField("Nodes", QVariant.String)])
if len(report[i]) > 2:
ppRep.append(report[i][1] + ' ' + report[i][2])
else:
ppRep.append(report[i][1])
elif mm.upper() == "LINKS":
prRep.addAttributes([QgsField("Links", QVariant.String)])
if len(report[i]) > 2:
ppRep.append(report[i][1] + ' ' + report[i][2])
else:
ppRep.append(report[i][1])
else:
prRep.addAttributes([QgsField(mm, QVariant.String)])
if len(report[i]) > 2:
ppRep.append(report[i][1] + ' ' + report[i][2])
else:
ppRep.append(report[i][1])
if i < allSections[15]:
mm = options[i][0]
if mm.upper() == "UNITS":
prOpt.addAttributes([QgsField("Units", QVariant.String)])
ppOpt.append(options[i][1])
if mm.upper() == "HYDRAULICS":
prOpt.addAttributes([QgsField("Hydraulics", QVariant.String)])
if len(options[i]) > 2:
ppOpt.append(options[i][1] + ' ' + options[i][2])
else:
ppOpt.append(options[i][1])
elif mm.upper() == "QUALITY":
prOpt.addAttributes([QgsField("Quality", QVariant.String)])
if len(options[i]) > 2:
ppOpt.append(options[i][1] + ' ' + options[i][2])
elif len(options[i]) > 3:
ppOpt.append(options[i][1] + ' ' + options[i][2] + ' ' + options[i][3])
else:
ppOpt.append(options[i][1])
elif mm.upper() == "VISCOSITY":
prOpt.addAttributes([QgsField("Viscosity", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "DIFFUSIVITY":
prOpt.addAttributes([QgsField("Diffusivity", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "SPECIFIC":
if options[i][1].upper() == "GRAVITY":
prOpt.addAttributes([QgsField("SpecGrav", QVariant.String)])
ppOpt.append(options[i][2])
elif mm.upper() == "TRIALS":
prOpt.addAttributes([QgsField("Trials", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "HEADLOSS":
prOpt.addAttributes([QgsField("Headloss", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "ACCURACY":
prOpt.addAttributes([QgsField("Accuracy", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "UNBALANCED":
prOpt.addAttributes([QgsField("Unbalanced", QVariant.String)])
if len(options[i]) > 2:
ppOpt.append(options[i][1] + ' ' + options[i][2])
else:
ppOpt.append(options[i][1])
elif mm.upper() == "PATTERN":
prOpt.addAttributes([QgsField("PatID", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "TOLERANCE":
prOpt.addAttributes([QgsField("Tolerance", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "MAP":
prOpt.addAttributes([QgsField("Map", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "DEMAND":
if options[i][1].upper() == "MULTIPLIER":
prOpt.addAttributes([QgsField("DemMult", QVariant.String)])
ppOpt.append(options[i][2])
elif mm.upper() == "EMITTER":
if options[i][1].upper() == "EXPONENT":
prOpt.addAttributes([QgsField("EmitExp", QVariant.String)])
ppOpt.append(options[i][2])
elif mm.upper() == "CHECKFREQ":
prOpt.addAttributes([QgsField("CheckFreq", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "MAXCHECK":
prOpt.addAttributes([QgsField("MaxCheck", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "DAMPLIMIT":
prOpt.addAttributes([QgsField("DampLimit", QVariant.String)])
ppOpt.append(options[i][1])
writeDBF(posOpt, [ppOpt], prOpt, saveFile, inpname, "_OPTIONS", idx)
writeDBF(posRep, [ppRep], prRep, saveFile, inpname, "_REPORT", idx)
#if times:
writeDBF(posTimes, [ppTimes], prTimes, saveFile, inpname, "_TIMES", idx)
#if energy:
writeDBF(posE, [ppE], prE, saveFile, inpname, "_ENERGY", idx)
#if optReactions:
writeDBF(posO, [ppO], prO, saveFile, inpname, "_REACTIONS", idx)
posMix = QgsVectorLayer("point?crs=EPSG:4326", "Mixing", "memory")
prMix = posMix.dataProvider()
fields = ["Tank_ID", "Model", "Fraction"]
fieldsCode = [0, 0, 1] # 0 String, 1 Double
createColumnsAttrb(prMix, fields, fieldsCode)
writeDBF(posMix, ppMix, prMix, saveFile, inpname, "_MIXING", idx)
posReact = QgsVectorLayer("point?crs=EPSG:4326", "ReactionsI", "memory")
prReact = posReact.dataProvider()
fields = ["Type", "Pipe/Tank", "Coeff."]
fieldsCode = [0, 0, 1]
createColumnsAttrb(prReact, fields, fieldsCode)
writeDBF(posReact, ppReactions, prReact, saveFile, inpname, "_REACTIONS_I", idx)
posSourc = QgsVectorLayer("point?crs=EPSG:4326", "Sources", "memory")
prSourc = posSourc.dataProvider()
fields = ["Node_ID", "Type", "Strength", "Pattern"]
fieldsCode = [0, 0, 1, 0]
createColumnsAttrb(prSourc, fields, fieldsCode)
writeDBF(posSourc, ppSourc, prSourc, saveFile, inpname, "_SOURCES", idx)
posRul = QgsVectorLayer("point?crs=EPSG:4326", "Rules", "memory")
prRul = posRul.dataProvider()
fields = ["Rule_ID", "Rule"]
fieldsCode = [0, 0]
createColumnsAttrb(prRul, fields, fieldsCode)
writeDBF(posRul, ppRul, prRul, saveFile, inpname, "_RULES", idx)
posQual = QgsVectorLayer("point?crs=EPSG:4326", "Sources", "memory")
prQual = posQual.dataProvider()
fields = ["Node_ID", "Init_Qual"]
fieldsCode = [0, 1]
createColumnsAttrb(prQual, fields, fieldsCode)
writeDBF(posQual, ppQual, prQual, saveFile, inpname, "_QUALITY", idx)
posStat = QgsVectorLayer("point?crs=EPSG:4326", "Status", "memory")
prStat = posStat.dataProvider()
fields = ["Link_ID", "Status/Setting"]
fieldsCode = [0, 0]
createColumnsAttrb(prStat, fields, fieldsCode)
writeDBF(posStat, ppStat, prStat, saveFile, inpname, "_STATUS", idx)
posEmit = QgsVectorLayer("point?crs=EPSG:4326", "Emitters", "memory")
prEmit = posEmit.dataProvider()
fields = ["Junc_ID", "Coeff."]
fieldsCode = [0, 1]
createColumnsAttrb(prEmit, fields, fieldsCode)
writeDBF(posEmit, ppEmit, prEmit, saveFile, inpname, "_EMITTERS", idx)
posCont = QgsVectorLayer("point?crs=EPSG:4326", "Controls", "memory")
prCont = posCont.dataProvider()
fields = ["Controls"]
fieldsCode = [0]
createColumnsAttrb(prCont, fields, fieldsCode)
writeDBF(posCont, ppCont, prCont, saveFile, inpname, "_CONTROLS", idx)
posPat = QgsVectorLayer("point?crs=EPSG:4326", "Patterns", "memory")
prPat = posPat.dataProvider()
fields = ["Pattern_ID", "Multipliers"]
fieldsCode = [0, 0]
createColumnsAttrb(prPat, fields, fieldsCode)
writeDBF(posPat, ppPat, prPat, saveFile, inpname, "_PATTERNS", idx)
posCurv = QgsVectorLayer("point?crs=EPSG:4326", "Curves", "memory")
prCurv = posCurv.dataProvider()
fields = ["Curve_ID", "X-Value", "Y-Value", "Type"]
fieldsCode = [0, 0, 0, 0]
createColumnsAttrb(prCurv, fields, fieldsCode)
writeDBF(posCurv, ppCurv, prCurv, saveFile, inpname, "_CURVES", idx)
# Write Valve Shapefile
posValve = QgsVectorLayer("LineString?crs=EPSG:4326", "Valve", "memory")
prValve = posValve.dataProvider()
fields = ["ID", "NodeFrom", "NodeTo", "Diameter", "Type", "Setting", "MinorLoss"]
fieldsCode = [0, 0, 0, 1, 0, 1, 1]
createColumnsAttrb(prValve, fields, fieldsCode)
posValve.startEditing()
if d.getBinLinkValveCount() > 0:
linkID = d.getBinLinkValveNameID()
linkType = d.getBinLinkValveType() # valve type
linkDiameter = d.getBinLinkValveDiameters()
linkInitSett = d.getBinLinkValveSetting() # BinLinkValveSetting
linkMinorloss = d.getBinLinkValveMinorLoss()
for i, p in enumerate(d.getBinLinkValveIndex()):
point1 = QgsPointXY(float(x[ndID.index(d.getBinLinkFromNode()[p])]), float(y[ndID.index(d.getBinLinkFromNode()[p])]))
point2 = QgsPointXY(float(x[ndID.index(d.getBinLinkToNode()[p])]), float(y[ndID.index(d.getBinLinkToNode()[p])]))
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPolylineXY([point1, point2]))
feature.setAttributes(
[linkID[i], ndlConn[0][p], ndlConn[1][p], linkDiameter[i], linkType[i], linkInitSett[i],
linkMinorloss[i]])
prValve.addFeatures([feature])
QgsVectorFileWriter.writeAsVectorFormat(posValve, saveFile + "_valves" + '.shp', "utf-8",
QgsCoordinateReferenceSystem(posValve.crs().authid()), "ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_valves" + '.shp', inpname[:len(inpname) - 4] + "_valves", "ogr")
QgsProject.instance().addMapLayer(ll, False)
nvalves = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, nvalves)
nvalves.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'valvesline' + ".qml")
ll.triggerRepaint()
# Write Pump Shapefile
posPump = QgsVectorLayer("LineString?crs=EPSG:4326", "Pump", "memory")
prPump = posPump.dataProvider()
fields = ["ID", "NodeFrom", "NodeTo", "Power", "Pattern", "Curve"]
fieldsCode = [0, 0, 0, 0, 0, 0]
createColumnsAttrb(prPump, fields, fieldsCode)
posPump.startEditing()
if d.getBinLinkPumpCount() > 0:
curveXY = d.getBinCurvesXY()
curvesID = d.getBinCurvesNameID()
a = curvesID
b = []
for l in a:
if l not in b:
b.append(l)
curvesIDunique = b
CurvesTmpIndices = []
for p in range(0, len(curvesIDunique)):
CurvesTmpIndices.append(curvesID.count(curvesIDunique[p]))
curveIndices = []
Curve = d.getBinLinkPumpCurveNameID()
for i in range(len(Curve)):
curveIndices.append(curvesIDunique.index(Curve[i]))
if d.getBinCurveCount():
CurvesTmpIndicesFinal = []
CurvesTmpIndicesFinal.append([CurvesTmpIndices[index] for index in curveIndices])
CurvesTmp = []
i = 0
for u in range(max(CurvesTmpIndicesFinal[0])):
fields.append('Head' + str(u + 1))
fields.append('Flow' + str(u + 1))
fieldsCode.append(1)
fieldsCode.append(1)
if u < d.getBinCurveCount():
tmp1 = []
for p in range(CurvesTmpIndices[u]):
tmp1.append([curveXY[i][0], curveXY[i][1]])
i = i + 1
CurvesTmp.append(tmp1)
createColumnsAttrb(prPump, fields, fieldsCode)
chPowerPump = d.getBinLinkPumpPower()
pumpID = d.getBinLinkPumpNameID()
patternsIDs = d.getBinLinkPumpPatterns()
ppatt = d.getBinLinkPumpPatternsPumpID()
linkID = d.getBinLinkNameID()
for i, p in enumerate(d.getBinLinkPumpIndex()):
Curve = []
power = []
pattern = []
pumpNameIDPower = d.getBinLinkPumpNameIDPower()
if len(pumpNameIDPower) > 0:
for uu in range(0, len(pumpNameIDPower)):
if pumpNameIDPower[uu] == pumpID[i]:
power = chPowerPump[uu]
if len(patternsIDs) > 0:
for uu in range(0, len(ppatt)):
if ppatt[uu] == pumpID[i]:
pattern = patternsIDs[uu]
point1 = QgsPointXY(float(x[ndID.index(d.getBinLinkFromNode()[p])]), float(y[ndID.index(d.getBinLinkFromNode()[p])]))
point2 = QgsPointXY(float(x[ndID.index(d.getBinLinkToNode()[p])]), float(y[ndID.index(d.getBinLinkToNode()[p])]))
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPolylineXY([point1, point2]))
if not Curve:
Curve = 'NULL'
if not power:
power = 'NULL'
if not pattern:
pattern = 'NULL'
if d.getBinCurveCount() > 0 and len(pumpNameIDPower) == 0:
Curve = d.getBinLinkPumpCurveNameID()[i]
curveIndex = curvesIDunique.index(Curve)
feature.initAttributes(6 + sum(CurvesTmpIndices) * 2 + 1)
feature.setAttribute(0, linkID[p])
feature.setAttribute(1, ndlConn[0][p])
feature.setAttribute(2, ndlConn[1][p])
feature.setAttribute(3, power)
feature.setAttribute(4, pattern)
feature.setAttribute(5, Curve)
if d.getBinCurveCount() == 1:
w = 6
for p in range(CurvesTmpIndices[curveIndex]):
feature.setAttribute(w, CurvesTmp[curveIndex][p][0])
feature.setAttribute(w + 1, CurvesTmp[curveIndex][p][1])
w = w + 2
for j in range(d.getBinCurveCount() - 1):
w = 6
for p in range(CurvesTmpIndices[curveIndex]):
feature.setAttribute(w, CurvesTmp[curveIndex][p][0])
feature.setAttribute(w + 1, CurvesTmp[curveIndex][p][1])
w = w + 2
prPump.addFeatures([feature])
QgsVectorFileWriter.writeAsVectorFormat(posPump,saveFile+"_pumps"+'.shp', "utf-8",
QgsCoordinateReferenceSystem(posPump.crs().authid()), "ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_pumps" + '.shp', inpname[:len(inpname) - 4] + "_pumps", "ogr")
QgsProject.instance().addMapLayer(ll, False)
npump = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, npump)
npump.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'pumpsline' + ".qml")
ll.triggerRepaint()
QgsVectorFileWriter.writeAsVectorFormat(posPipe,saveFile+"_pipes"+'.shp', "utf-8",
QgsCoordinateReferenceSystem(posPipe.crs().authid()), "ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_pipes" + '.shp', inpname[:len(inpname) - 4] + "_pipes", "ogr")
QgsProject.instance().addMapLayer(ll, False)
npipe = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, npipe)
npipe.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'pipes' + ".qml")
ll.triggerRepaint()
iface.mapCanvas().setExtent(ll.extent())
QgsVectorFileWriter.writeAsVectorFormat(posJunction,saveFile+"_junctions"+'.shp', "utf-8",
QgsCoordinateReferenceSystem(posJunction.crs().authid()), "ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_junctions" + '.shp', inpname[:len(inpname) - 4] + "_junctions", "ogr")
QgsProject.instance().addMapLayer(ll, False)
njunc = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, njunc)
njunc.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'junctions' + ".qml")
ll.triggerRepaint()
QgsVectorFileWriter.writeAsVectorFormat(posTank, saveFile + "_tanks" + '.shp', "utf-8",
QgsCoordinateReferenceSystem(posTank.crs().authid()), "ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_tanks" + '.shp', inpname[:len(inpname) - 4] + "_tanks", "ogr")
QgsProject.instance().addMapLayer(ll, False)
ntanks = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, ntanks)
ntanks.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'tanks' + ".qml")
ll.triggerRepaint()
QgsVectorFileWriter.writeAsVectorFormat(posReservoirs, saveFile + "_reservoirs" + '.shp', "utf-8",
QgsCoordinateReferenceSystem(posReservoirs.crs().authid()), "ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_reservoirs" + '.shp', inpname[:len(inpname) - 4] + "_reservoirs", "ogr")
QgsProject.instance().addMapLayer(ll, False)
nres = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, nres)
nres.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'reservoirs' + ".qml")
ll.triggerRepaint()
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_col'] = varlayer['unique_col']
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()
