def organize_legend(context, available_layers) -> None:
""" Create groups and organize the legend. """
root = context.project().layerTreeRoot()
groups = OrderedDict()
groups[root] = [
"v_itineraire", "v_portion", "segment", "liaison", "repere", "poi_service", "poi_tourisme"]
groups[QgsLayerTreeGroup('Composants')] = [
"element", "portion", "etape", "itineraire"]
groups[QgsLayerTreeGroup('Nomenclatures')] = [
"statut_segment_val", "amenagement_segment_val", "amenagement_type_segment_val"]
for node_composants, content in groups.items():
if root != node_composants:
root.addChildNode(node_composants)
for com in content:
layer_id = available_layers.get(com)
if not layer_id:
continue
layer = root.findLayer(layer_id)
node_composants.addChildNode(layer.clone())
layer.parent().removeChildNode(layer)
def draw(self):
# print("draw")
rb = self.tool.rb
g = rb.asGeometry()
layer = QgsVectorLayer(
"Polygon?crs=" + self.iface.mapCanvas().mapSettings().destinationCrs().authid() + "&field=" + self.tr(
'Drawings') + ":string(255)", self.searchAreaLayerName, "memory")
layer.startEditing()
symbols = layer.renderer().symbols(QgsRenderContext()) # todo which context ?
symbols[0].setColor(self.color)
feature = QgsFeature()
feature.setGeometry(g)
feature.setAttributes([self.searchAreaLayerName])
layer.dataProvider().addFeatures([feature])
layer.commitChanges()
pjt = QgsProject.instance()
layersList = pjt.mapLayersByName(self.searchAreaLayerName)
if layersList is not None and len(layersList) > 0:
pjt.removeMapLayer(layersList[0])
pjt.addMapLayer(layer, False)
if pjt.layerTreeRoot().findGroup(self.tr(self.groupName)) is None:
pjt.layerTreeRoot().insertChildNode(0, QgsLayerTreeGroup(self.tr(self.groupName)))
group = pjt.layerTreeRoot().findGroup(self.tr(self.groupName))
group.insertLayer(0, layer)
self.iface.layerTreeView().refreshLayerSymbology(layer.id())
self.iface.mapCanvas().refresh()
self.tool.reset()
def test_convert_group_to_group_layer(self):
"""
Test converting a QgsLayerTreeGroup to a QgsGroupLayer
"""
group_node = QgsLayerTreeGroup()
options = QgsGroupLayer.LayerOptions(QgsCoordinateTransformContext())
group_layer = group_node.convertToGroupLayer(options)
self.assertFalse(group_layer.childLayers())
self.assertEqual(group_node.groupLayer(), group_layer)
# if a group layer is already assigned, convertToGroupLayer should do nothing
self.assertIsNone(group_node.convertToGroupLayer(options))
group_node.setGroupLayer(None)
# add some child layers to node
layer = QgsVectorLayer("Point?field=fldtxt:string", "layer1", "memory")
group_node.addLayer(layer)
layer2 = QgsVectorLayer("Point?field=fldtxt:string", "layer2",
"memory")
group_node.addLayer(layer2)
group_layer = group_node.convertToGroupLayer(options)
self.assertEqual(group_layer.childLayers(), [layer2, layer])
self.assertEqual(group_node.groupLayer(), group_layer)
def make(self, composition, inomen, mapAreaLayer, showLayers):
# Cleanup
self.deleteGroups(['articulation'])
mapIDsToBeDisplayed = []
instance = QgsProject.instance()
# Creating the articulation frame
gridLayer = self.createGridLayer(inomen)
self.loadStyleToGridLayer(gridLayer)
instance.addMapLayer(gridLayer, False)
mapIDsToBeDisplayed.append(gridLayer.id())
# Creating a copy of mapAreaLayer
mapAreaLayer = self.createVectorLayerFromIter('articulationMapArea', mapAreaLayer.getFeatures())
self.loadStyleToLayer(mapAreaLayer, self.stylesFolder / 'mapExtentStyle.qml')
instance.addMapLayer(mapAreaLayer, False)
mapIDsToBeDisplayed.append(mapAreaLayer.id())
# Updates composition
self.updateMapItem(composition, gridLayer, mapAreaLayer)
if showLayers:
articulationNodeGroup = QgsLayerTreeGroup('articulation')
articulationNodeGroup.setItemVisibilityChecked(False)
for layer in (gridLayer, mapAreaLayer):
articulationNodeGroup.addLayer(layer)
root = instance.layerTreeRoot()
root.addChildNode(articulationNodeGroup)
return mapIDsToBeDisplayed
def make(self,
composition,
mapExtentsLayer,
mapExtents,
layers,
showLayers=False):
mapLayers = []
self.deleteGroups(['map'])
instance = QgsProject.instance()
# Setting up grid layer
mapExtent = self.getExtent(mapExtents)
gridLayer, mapExtentsTransformed = self.createLayerForGrid(
mapExtentsLayer, mapExtents)
self.applyStyleGridLayer(gridLayer)
gridLayer.triggerRepaint()
instance.addMapLayer(gridLayer, False)
# Setting up aux_label, which is reprojected to mapLayers
crs = next(iter(layers['map'])).crs()
copyLabel = self.cloneVectorLayerReproject(gridLayer, 'aux_label', crs)
copyLabelStyle = Path(
__file__).parent.parent / 'styles' / 'grid' / 'aux_label.qml'
copyLabel.loadNamedStyle(str(copyLabelStyle))
instance.addMapLayer(copyLabel, False)
# Setting up aux_moldura
copy = self.cloneVectorLayer(gridLayer, 'aux_moldura')
copyStyle = Path(
__file__).parent.parent / 'styles' / 'grid' / 'style.qml'
copy.loadNamedStyle(str(copyStyle))
instance.addMapLayer(copy, False)
# Setting up mask layer
maskLayer = self.createMaskLayer(mapExtents)
instance.addMapLayer(maskLayer, False)
mapLayers.extend((copy.id(), copyLabel.id(), gridLayer.id(),
maskLayer.id(), *layers['id_map']))
layersToComposition = [
gridLayer, maskLayer, copy, copyLabel, *layers['map'],
*layers['images']
]
self.updateMapItem(composition, mapExtent, mapExtentsTransformed,
gridLayer, layersToComposition)
if showLayers:
mapGroupNode = QgsLayerTreeGroup('map')
mapGroupNode.setItemVisibilityChecked(False)
for lyr in layersToComposition:
mapGroupNode.addLayer(lyr)
root = QgsProject.instance().layerTreeRoot()
root.addChildNode(mapGroupNode)
return mapLayers
def test_copy_layer_tree_group(self):
# copying layer tree group should also copy group layer setting
options = QgsGroupLayer.LayerOptions(QgsCoordinateTransformContext())
group_layer = QgsGroupLayer('group', options)
group_node = QgsLayerTreeGroup()
group_node.setGroupLayer(group_layer)
self.assertEqual(group_node.groupLayer(), group_layer)
group_node2 = group_node.clone()
self.assertEqual(group_node2.groupLayer(), group_layer)
def load_qlr_file(self, path):
# Load qlr into a group owned by us
try:
group1 = QgsLayerTreeGroup()
group2 = QgsProject.instance().layerTreeRoot()
group = group1
# On Windows this locks the parent dirs indefinitely
# See http://hub.qgis.org/issues/14811
# QgsLayerDefinition.loadLayerDefinition(path, group)
# Instead handle file ourselves
f = QFile(path)
if not f.open(QIODevice.ReadOnly):
return False
try:
doc = QDomDocument()
if not doc.setContent(f.readAll()):
return False
rc, rs = QgsLayerDefinition.loadLayerDefinition(
doc, QgsProject.instance(), group, QgsReadWriteContext())
finally:
f.close()
# Get subtree of nodes
nodes = group.children()
# plain list of nodes
nodeslist = []
for addedNode in nodes:
internalid = self._random_string()
nodeinfo = {'internalid': internalid}
addedNode.setCustomProperty(QlrManager.customPropertyName,
internalid)
if isinstance(addedNode, QgsLayerTreeGroup):
nodeinfo['type'] = 'group'
nodeinfo['name'] = addedNode.name()
elif isinstance(addedNode, QgsLayerTreeLayer):
nodeinfo['type'] = 'layer'
nodeinfo['name'] = addedNode.name()
nodeinfo['layerid'] = addedNode.layerId()
nodeslist.append(nodeinfo)
# Remove from parent node. Otherwise we cant add it to a new parent
group.takeChild(addedNode)
self.fileSystemItemToLegendNode[path] = nodeslist
# Insert them into the main project
QgsProject.instance().layerTreeRoot().insertChildNodes(0, nodes)
return True
except Exception as e:
self.log('Failed to load qlr at ' + path + ': ' + str(e))
return False
def make(self, composition, mapArea, showLayers=False, isInternational=False):
# Cleanup
self.deleteGroups(['divisao'])
mapLayers = []
# Inserting necessary layers
divisionGroupNode = QgsLayerTreeGroup('divisao')
divisionGroupNode.setItemVisibilityChecked(False)
layerCountyArea, layerCountyLine, layerStateLine, layerCountryArea, layerCountryLine, layerOcean = self.createLayersGroup()
mapLayers.extend([
layerCountyArea.id(),layerCountyLine.id(), layerStateLine.id(), layerOcean.id(), layerCountryArea.id(), layerCountryLine.id()])
# Getting map extents
gridBound = mapArea.geometry().boundingBox()
gridRectangleLayer = self.createGridRectangle(gridBound, 'divisionMapArea')
mapLayers.append(gridRectangleLayer.id())
# Get map extent for intersections
# TODO: Check possible refactor on getExtent
outerExtents = self.getExtent(gridBound, mapArea)
orderedCountiesByCentroidDistance, orderedCountiesNamesByArea = self.getIntersections(
layerCountyArea, outerExtents, mapArea, isInternational)
# Labeling counties
self.setStyles(layerCountyArea, orderedCountiesByCentroidDistance, orderedCountiesNamesByArea)
# Inserting counties table
html_tabledata = self.customcreateHtmlTableData(orderedCountiesNamesByArea)
self.setMunicipiosTable(composition, html_tabledata)
if not isInternational:
self.hideInternationalCouties(layerCountryArea)
# self.unsetLabel(layerCountry)
# Update map in correct sequence
layersToShow = (
gridRectangleLayer, layerOcean, layerCountryLine, layerCountryArea, layerStateLine, layerCountyLine, layerCountyArea)
for layer in layersToShow:
QgsProject.instance().addMapLayer(layer, False)
divisionGroupNode.addLayer(layer)
if showLayers:
root = QgsProject.instance().layerTreeRoot()
root.addChildNode(divisionGroupNode)
self.updateMapItem(composition, outerExtents, layersToShow)
return mapLayers
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 test_layer_tree_group_layer(self):
"""
Test setting a group layer on a QgsLayerTreeGroup
"""
options = QgsGroupLayer.LayerOptions(QgsCoordinateTransformContext())
group_layer = QgsGroupLayer('group', options)
group_node = QgsLayerTreeGroup()
self.assertFalse(group_node.groupLayer())
group_node.setGroupLayer(group_layer)
self.assertEqual(group_node.groupLayer(), group_layer)
group_layer.deleteLater()
group_layer = None
QCoreApplication.sendPostedEvents(None, QEvent.DeferredDelete)
# should be automatically cleaned
self.assertFalse(group_node.groupLayer())
def make(self,
composition,
mapAreaFeature,
showLayers=False,
isInternational=False):
# Cleanup
self.deleteGroups(['localizacao'])
mapLayers = []
instance = QgsProject.instance()
# Creating layer for mapArea
mapAreaBoundingBox = mapAreaFeature.geometry().boundingBox()
mapAreaLayer = self.createGridRectangle(mapAreaBoundingBox,
'localizationMapArea')
mapLayers.append(mapAreaLayer.id())
# Getting state layer
stateShpPath = Path(
__file__).parent.parent / 'limites' / '2020' / 'Estados_2020.shp'
stateLayerBackground = self.loadShapeLayer(stateShpPath, '',
'backgroundStates')
mapExtents = self.getExtent(mapAreaFeature, stateLayerBackground,
isInternational)
self.setupBackgroundLayer(stateLayerBackground)
self.setLabel(stateLayerBackground, isInternational)
mapLayers.append(stateLayerBackground.id())
# Adding layers
instance.addMapLayer(stateLayerBackground, False)
instance.addMapLayer(mapAreaLayer, False)
# Updating composition
self.updateMapItem(composition, stateLayerBackground, mapAreaLayer,
mapExtents)
if showLayers:
localizationGroupNode = QgsLayerTreeGroup('localizacao')
localizationGroupNode.setItemVisibilityChecked(False)
for layer in (mapAreaLayer, stateLayerBackground):
localizationGroupNode.addLayer(layer)
root = QgsProject.instance().layerTreeRoot()
root.addChildNode(localizationGroupNode)
return mapLayers
def make(self, composition, mapArea, layers, showLayers=False):
self.deleteGroups(['minimap'])
mapExtents = mapArea.geometry().convexHull().boundingBox()
# Creating layers to lock map
layersToLock = []
layersToLock.extend(layers['minimap'])
layersToLock.extend(layers['images'])
self.updateMapItem(composition, mapExtents, layersToLock)
if showLayers:
miniMapGroupNode = QgsLayerTreeGroup('minimap')
miniMapGroupNode.setItemVisibilityChecked(False)
for layer in layersToLock:
miniMapGroupNode.addLayer(layer)
root = QgsProject.instance().layerTreeRoot()
root.addChildNode(miniMapGroupNode)
return layers['id_minimap']
def __add_layer_definition_file(self, file_name, root_group):
"""
shamelessly copied from
https://github.com/qgis/QGIS/blob/master/src/core/qgslayerdefinition.cpp
"""
qfile = QFile(file_name)
if not qfile.open(QIODevice.ReadOnly):
return None
doc = QDomDocument()
if not doc.setContent(qfile):
return None
file_info = QFileInfo(qfile)
QDir.setCurrent(file_info.absoluteDir().path())
root = QgsLayerTreeGroup()
ids = doc.elementsByTagName('id')
for i in range(0, ids.size()):
id_node = ids.at(i)
id_elem = id_node.toElement()
old_id = id_elem.text()
layer_name = old_id[:-17]
date_time = QDateTime.currentDateTime()
new_id = layer_name + date_time.toString('yyyyMMddhhmmsszzz')
id_elem.firstChild().setNodeValue(new_id)
tree_layer_nodes = doc.elementsByTagName('layer-tree-layer')
for j in range(0, tree_layer_nodes.count()):
layer_node = tree_layer_nodes.at(j)
layer_elem = layer_node.toElement()
if old_id == layer_elem.attribute('id'):
layer_node.toElement().setAttribute('id', new_id)
layer_tree_elem = doc.documentElement().firstChildElement(
'layer-tree-group')
load_in_legend = True
if not layer_tree_elem.isNull():
root.readChildrenFromXML(layer_tree_elem)
load_in_legend = False
layers = QgsMapLayer.fromLayerDefinition(doc)
QgsProject.instance().addMapLayers(layers, load_in_legend)
nodes = root.children()
for node in nodes:
root.takeChild(node)
del root
root_group.insertChildNodes(-1, nodes)
return None
def test_group_layer_nested(self):
"""
Test group node with child nodes converted to group layer
"""
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)
group2 = group_node.addGroup('child group 1')
layer2 = QgsVectorLayer("Point?field=fldtxt:string", "layer2",
"memory")
group_node.addLayer(layer2)
layer3 = QgsVectorLayer("Point?field=fldtxt:string", "layer3",
"memory")
layer3_node = group2.addLayer(layer3)
group3 = group2.addGroup('grand child group 1')
group4 = group2.addGroup('grand child group 2')
layer4 = QgsVectorLayer("Point?field=fldtxt:string", "layer4",
"memory")
layer4_node = group3.addLayer(layer4)
layer5 = QgsVectorLayer("Point?field=fldtxt:string", "layer5",
"memory")
layer5_node = group4.addLayer(layer5)
self.assertEqual(group_layer.childLayers(),
[layer2, layer5, layer4, layer3, layer])
layer5_node.setItemVisibilityChecked(False)
self.assertEqual(group_layer.childLayers(),
[layer2, layer4, layer3, layer])
group2.setItemVisibilityChecked(False)
self.assertEqual(group_layer.childLayers(), [layer2, layer])
group2.setItemVisibilityCheckedRecursive(True)
self.assertEqual(group_layer.childLayers(),
[layer2, layer5, layer4, layer3, layer])
def groupSelected(self):
nodes = self.mView.selectedNodes(True)
if len(nodes) < 2 or not QgsLayerTree.isGroup(nodes[0].parent()):
return
parentGroup = nodes[0].parent()
insertIdx = parentGroup.children().index(nodes[0])
newGroup = QgsLayerTreeGroup(self.uniqueGroupName(parentGroup))
for node in nodes:
newGroup.addChildNode(node.clone())
parentGroup.insertChildNode(insertIdx, newGroup)
for node in nodes:
group = node.parent()
if group != None:
group.removeChildNode(node)
self.mView.setCurrentIndex(
self.mView.layerTreeModel().node2index(newGroup))
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)
else:
g = root.findGroup(group)
if g is None:
# Create Group
node_group = QgsLayerTreeGroup(group)
root.insertChildNode(0, node_group)
if isSubGroup:
vg = root.findGroup(groupName)
g = vg.findGroup(group)
else:
g = root.findGroup(group)
g.insertChildNode(0, QgsLayerTreeLayer(layer[0]))
else:
_layerreg.addMapLayers(layer, loadInLegend)
return layer
def object_to_layers_and_tree(obj, input_file, context: Context):
"""
Converts an ESRI object to layers and equivalent layer tree
"""
layers = []
def add_layer(layer, group_node):
nonlocal layers
results = LayerConverter.layer_to_QgsLayer(
layer,
input_file,
context=context,
fallback_crs=QgsCoordinateReferenceSystem('EPSG:4326'))
for res in results:
node = group_node.addLayer(res)
if not layer.visible:
node.setItemVisibilityChecked(False)
if len(node.children()) > 10:
node.setExpanded(False)
layers.append(res)
def add_group(group, parent):
group_node = parent.addGroup(group.name)
for c in group.children:
if isinstance(c, (GroupLayer, BaseMapLayer)):
add_group(c, group_node)
else:
add_layer(c, group_node)
root_node = QgsLayerTreeGroup()
if LayerConverter.is_layer(obj):
add_layer(obj, root_node)
else:
add_group(obj, root_node)
return root_node, layers
def test_group_layer_updates_from_node_visibility(self):
"""
Test that group layer child layers are synced correctly from the group node when layer visibility is changed
"""
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)
layer2 = QgsVectorLayer("Point?field=fldtxt:string", "layer2",
"memory")
layer2_node = group_node.addLayer(layer2)
layer3 = QgsVectorLayer("Point?field=fldtxt:string", "layer3",
"memory")
group_node.addLayer(layer3)
self.assertEqual(group_layer.childLayers(), [layer3, layer2, layer])
layer2_node.setItemVisibilityChecked(False)
self.assertEqual(group_layer.childLayers(), [layer3, layer])
layer2_node.setItemVisibilityChecked(True)
self.assertEqual(group_layer.childLayers(), [layer3, layer2, layer])
def showRequestResult(self, items, append, last, message):
# print("showRequestResult")
if items is None or len(items) == 0:
QApplication.restoreOverrideCursor()
self.__show_status_label(StatusMessageType.LOAD_FINISHED)
self.getDataButton.setEnabled(True)
if message is None or len(message) == 0:
message = "По указанным параметрам ничего не найдено"
self._show_message(self, "Загузка завершена", message)
return
color = QColor(237, 28, 36, 200)
pjt = QgsProject.instance()
layersList = pjt.mapLayersByName(self.resultsLayerName)
if not append:
if layersList is not None and len(layersList) > 0:
pjt.removeMapLayer(layersList[0])
# print("remove results")
layersList.clear()
if not append or layersList is None or len(layersList) == 0:
# print("create layer")
layer = QgsVectorLayer("Point?crs=EPSG:4326"
"&field=coordinatesWKT:string(255)&field=shootingDateTime:string(255)"
"&field=temperature:double(7)&field=pixelSizeInDirection:double(5)"
"&field=pixelSizeAcross:double(5)&field=thermalPower:double(5)"
"&field=baseResourceId:string(255)&field=id:string(255)&field=updated:string(255)"
"&field=satellite:string(10)",
self.resultsLayerName, "memory")
else:
layer = layersList[0]
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
svg_marker = QgsSvgMarkerSymbolLayer(":/plugins/thermal_anomaly/fire.svg")
svg_marker.setSize(6.0)
symbol.changeSymbolLayer(0, svg_marker)
layer.renderer().setSymbol(symbol)
layer.startEditing()
print("all items=", len(items))
poly = QgsGeometry.fromWkt(self.polygon)
for point in items:
symbols = layer.renderer().symbols(QgsRenderContext()) # todo which context ?
symbols[0].setColor(color)
feature = QgsFeature()
coord = QgsGeometry.fromWkt(point["coordinatesWKT"])
feature.setGeometry(coord)
feature.setAttributes([point["coordinatesWKT"], point["shootingDateTime"], point["temperature"],
point["pixelSizeInDirection"], point["pixelSizeAcross"], point["thermalPower"],
point["baseResourceId"], point["id"], point["updated"], point["satellite"]])
layer.dataProvider().addFeatures([feature])
# if not poly.contains(coord):
# print("point out of poly: id =", point["id"], "coord =", point["coordinatesWKT"])
layer.commitChanges()
if not append:
pjt.addMapLayer(layer, False)
if pjt.layerTreeRoot().findGroup(self.tr(self.groupName)) is None:
pjt.layerTreeRoot().insertChildNode(0, QgsLayerTreeGroup(self.tr(self.groupName)))
group = pjt.layerTreeRoot().findGroup(self.tr(self.groupName))
group.insertLayer(0, layer)
self.iface.layerTreeView().refreshLayerSymbology(layer.id())
self.iface.mapCanvas().refresh()
if last:
QApplication.restoreOverrideCursor()
self.__show_status_label(StatusMessageType.LOAD_FINISHED)
self.getDataButton.setEnabled(True)
else:
self.__show_status_label(StatusMessageType.LOAD_STARTED, message)
def getDataButtonClicked(self):
clId = self.leClientID.text()
clSecret = self.leClientSecret.text()
if len(clId) == 0 or len(clSecret) == 0:
self._show_message("Некорректные данные", "Данные пользователя не могут быть пустыми")
return
dateTimeFrom = self.dateTimeEditFrom.dateTime()
dateTimeTo = self.dateTimeEditTo.dateTime()
if dateTimeFrom >= dateTimeTo:
self._show_message("Некорректные данные", "Дата 'По' должна быть больше, чем дата 'С'")
return
pjt = QgsProject.instance()
# clear results
layersList = pjt.mapLayersByName(self.resultsLayerName)
if layersList is not None and len(layersList) > 0:
pjt.removeMapLayer(layersList[0])
self.iface.mapCanvas().refresh()
layersList = pjt.mapLayersByName(self.searchAreaLayerName)
polygonGeometry = None
if layersList is not None and len(layersList) > 0:
feat = list(layersList[0].getFeatures())[0]
if feat.hasGeometry():
polygonGeometry = self.geomTransform(
feat.geometry(),
self.iface.mapCanvas().mapSettings().destinationCrs(),
QgsCoordinateReferenceSystem(4326))
if polygonGeometry is None:
self._show_message("Некорректные данные", "Необходимо задать полигон поиска")
return
availableAreaName = "available_area"
shpLayer = QgsVectorLayer(os.path.dirname(__file__) + "/roi/ZRV.shp", availableAreaName, "ogr")
if not shpLayer.isValid():
self._show_message("Некорректные данные", "Некорректный файл с зоной охвата")
return
intersectionGeom = None
for feature in shpLayer.getFeatures():
if feature.geometry().intersects(polygonGeometry):
intersectionGeom = feature.geometry().intersection(polygonGeometry)
if intersectionGeom == None:
layersList = pjt.mapLayersByName(availableAreaName)
if layersList is not None and len(layersList) > 0:
pjt.removeMapLayer(layersList[0])
symbols = shpLayer.renderer().symbols(QgsRenderContext())
symbols[0].setColor(QColor(76, 205, 53, 84))
pjt.addMapLayer(shpLayer, False)
if pjt.layerTreeRoot().findGroup(self.tr(self.groupName)) is None:
pjt.layerTreeRoot().insertChildNode(0, QgsLayerTreeGroup(self.tr(self.groupName)))
group = pjt.layerTreeRoot().findGroup(self.tr(self.groupName))
group.addLayer(shpLayer)
self.iface.layerTreeView().refreshLayerSymbology(shpLayer.id())
geom = self.geomTransform(
list(shpLayer.getFeatures())[0].geometry(),
QgsCoordinateReferenceSystem(4326),
self.iface.mapCanvas().mapSettings().destinationCrs())
self.iface.mapCanvas().setExtent(geom.boundingBox())
self.iface.mapCanvas().refresh()
self._show_message("Некорректные данные", "Полигон поиска лежит за пределами зоны охвата")
return
self.polygon = intersectionGeom.asWkt()
# print("polygon=", self.polygon)
self.__toggle(False, True)
self.getDataButton.setEnabled(False)
QApplication.setOverrideCursor(Qt.WaitCursor)
self.__show_status_label(StatusMessageType.LOAD_STARTED)
self.dataRequest.dataRequest(clId, clSecret, dateTimeFrom, dateTimeTo, self.polygon)
def __init__(self, parent, geometryWin, numWin):
def populateStatusBar():
statusBar = self.statusBar()
w = QCheckBox("Render", self)
w.setObjectName('renderCheck')
w.setToolTip("Toggle map rendering")
w.setChecked(True)
statusBar.addPermanentWidget(w)
w = QCheckBox("Marker", self)
w.setObjectName('markerCheck')
w.setToolTip("Toggle marker with cursor position from main map")
w.setChecked(False)
statusBar.addPermanentWidget(w, 1)
w = QCheckBox("Extent", self)
w.setObjectName('extentCheck')
w.setToolTip("Show extent of main map")
w.setChecked(False)
statusBar.addPermanentWidget(w, 1)
w = QToolButton(self)
w.setObjectName('highlightBtn')
w.setToolTip("Highlight extent in main map")
w.setText("Highlight")
statusBar.addPermanentWidget(w, 1)
w = QLabel("Scale factor:", self)
w.setObjectName('scaleFactorLabel')
w.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
statusBar.addPermanentWidget(w, 1)
w = QDoubleSpinBox(self)
w.setObjectName('scaleFactorSpin')
w.setToolTip("Current scale factor of main map")
w.setMinimum(0.0)
w.setMaximum(1000.0)
w.setDecimals(3)
w.setValue(1)
w.setSingleStep(.05)
statusBar.addPermanentWidget(w, 1)
w = QToolButton(self)
w.setObjectName('scaleBtn')
w.setToolTip("Set scale for main map")
w.setText("Scale: ")
statusBar.addPermanentWidget(w, 1)
def setupUi():
self.setObjectName("AuxiliaryWindow")
self.setGeometry(geometryWin)
self.addDockWidget(Qt.LeftDockWidgetArea, self.dockLegend)
self.actLegend = self.menuBar().addAction("")
self.actLegend.triggered.connect(self.onActionLegend)
self.canvas.setMapTool(self.toolPan)
self.canvas.setCanvasColor(QColor(255, 255, 255))
self.canvas.enableAntiAliasing(False)
self.canvas.useImageToRender(False)
self.canvas.setWheelAction(QgsMapCanvas.WheelZoom)
self.setCentralWidget(centralWidget)
self.messageBar.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Fixed)
layout = QGridLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.canvas, 0, 0, 2, 1)
layout.addWidget(self.messageBar, 0, 0, 1, 1)
centralWidget.setLayout(layout)
super(AuxiliaryWindow, self).__init__(parent)
centralWidget = QWidget(self)
self.canvas = QgsMapCanvas(centralWidget)
self.messageBar = QgsMessageBar(centralWidget)
self.toolPan = QgsMapToolPan(self.canvas)
self.qgisCanvas = qgis.utils.iface.mapCanvas()
self.qgisTView = qgis.utils.iface.layerTreeView()
self.qgisSyncGroup = None
self.numWin = numWin
self.ltg = QgsLayerTreeGroup('', Qt.Unchecked)
self.dockLegend = AuxiliaryLegend(self, numWin)
self.root = QgsProject.instance().layerTreeRoot()
self.extent = self.actLegend = None
self.marker = MarkerWindow(self.canvas)
setupUi()
populateStatusBar()
self.onCurrentLayerChanged(None)
self.onDestinationCrsChanged_MapUnitsChanged()
self.onHasCrsTransformEnabledChanged(
self.qgisCanvas.hasCrsTransformEnabled())
def run(item, action, mainwindow):
db = item.database()
uri = db.uri()
iface = mainwindow.iface
quoteId = db.connector.quoteId
quoteStr = db.connector.quoteString
# check if the selected item is a topology schema
isTopoSchema = False
if not hasattr(item, 'schema'):
mainwindow.infoBar.pushMessage(
"Invalid topology", u'Select a topology schema to continue.',
Qgis.Info, mainwindow.iface.messageTimeout())
return False
if item.schema() is not None:
sql = u"SELECT srid FROM topology.topology WHERE name = %s" % quoteStr(
item.schema().name)
res = db.executeSql(sql)
isTopoSchema = len(res) > 0
if not isTopoSchema:
mainwindow.infoBar.pushMessage(
"Invalid topology",
u'Schema "{0}" is not registered in topology.topology.'.format(
item.schema().name), Qgis.Warning,
mainwindow.iface.messageTimeout())
return False
if (res[0][0] < 0):
mainwindow.infoBar.pushMessage(
"WARNING",
u'Topology "{0}" is registered as having a srid of {1} in topology.topology, we will assume 0 (for unknown)'
.format(item.schema().name, res[0]), Qgis.Warning,
mainwindow.iface.messageTimeout())
toposrid = '0'
else:
toposrid = str(res[0][0])
# load layers into the current project
toponame = item.schema().name
template_dir = os.path.join(current_path, 'templates')
# do not refresh the canvas until all the layers are added
wasFrozen = iface.mapCanvas().isFrozen()
iface.mapCanvas().freeze()
try:
provider = db.dbplugin().providerName()
uri = db.uri()
# Force use of estimated metadata (topologies can be big)
uri.setUseEstimatedMetadata(True)
# FACES
# face mbr
uri.setDataSource(toponame, 'face', 'mbr', '', 'face_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.Polygon)
layerFaceMbr = QgsVectorLayer(uri.uri(False),
u'%s.face_mbr' % toponame, provider)
layerFaceMbr.loadNamedStyle(os.path.join(template_dir, 'face_mbr.qml'))
face_extent = layerFaceMbr.extent()
# face geometry
sql = u'SELECT face_id, mbr, topology.ST_GetFaceGeometry(%s,' \
'face_id)::geometry(polygon, %s) as geom ' \
'FROM %s.face WHERE face_id > 0' % \
(quoteStr(toponame), toposrid, quoteId(toponame))
uri.setDataSource('', u'(%s\n)' % sql, 'geom', '', 'face_id')
uri.setParam('bbox', 'mbr')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.Polygon)
layerFaceGeom = QgsVectorLayer(uri.uri(False), u'%s.face' % toponame,
provider)
layerFaceGeom.setExtent(face_extent)
layerFaceGeom.loadNamedStyle(os.path.join(template_dir, 'face.qml'))
# face_seed
sql = u'SELECT face_id, mbr, ST_PointOnSurface(' \
'topology.ST_GetFaceGeometry(%s,' \
'face_id))::geometry(point, %s) as geom ' \
'FROM %s.face WHERE face_id > 0' % \
(quoteStr(toponame), toposrid, quoteId(toponame))
uri.setDataSource('', u'(%s)' % sql, 'geom', '', 'face_id')
uri.setParam('bbox', 'mbr')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.Point)
layerFaceSeed = QgsVectorLayer(uri.uri(False),
u'%s.face_seed' % toponame, provider)
layerFaceSeed.setExtent(face_extent)
layerFaceSeed.loadNamedStyle(
os.path.join(template_dir, 'face_seed.qml'))
# TODO: add polygon0, polygon1 and polygon2 ?
# NODES
# node
uri.setDataSource(toponame, 'node', 'geom', '', 'node_id')
uri.removeParam('bbox')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.Point)
layerNode = QgsVectorLayer(uri.uri(False), u'%s.node' % toponame,
provider)
layerNode.loadNamedStyle(os.path.join(template_dir, 'node.qml'))
node_extent = layerNode.extent()
# node labels
uri.setDataSource(toponame, 'node', 'geom', '', 'node_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.Point)
uri.removeParam('bbox')
layerNodeLabel = QgsVectorLayer(uri.uri(False),
u'%s.node_id' % toponame, provider)
layerNodeLabel.setExtent(node_extent)
layerNodeLabel.loadNamedStyle(
os.path.join(template_dir, 'node_label.qml'))
# EDGES
# edge
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
uri.removeParam('bbox')
layerEdge = QgsVectorLayer(uri.uri(False), u'%s.edge' % toponame,
provider)
edge_extent = layerEdge.extent()
# directed edge
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
uri.removeParam('bbox')
layerDirectedEdge = QgsVectorLayer(uri.uri(False),
u'%s.directed_edge' % toponame,
provider)
layerDirectedEdge.setExtent(edge_extent)
layerDirectedEdge.loadNamedStyle(os.path.join(template_dir,
'edge.qml'))
# edge labels
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
uri.removeParam('bbox')
layerEdgeLabel = QgsVectorLayer(uri.uri(False),
u'%s.edge_id' % toponame, provider)
layerEdgeLabel.setExtent(edge_extent)
layerEdgeLabel.loadNamedStyle(
os.path.join(template_dir, 'edge_label.qml'))
# face_left
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
uri.removeParam('bbox')
layerFaceLeft = QgsVectorLayer(uri.uri(False),
u'%s.face_left' % toponame, provider)
layerFaceLeft.setExtent(edge_extent)
layerFaceLeft.loadNamedStyle(
os.path.join(template_dir, 'face_left.qml'))
# face_right
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
uri.removeParam('bbox')
layerFaceRight = QgsVectorLayer(uri.uri(False),
u'%s.face_right' % toponame, provider)
layerFaceRight.setExtent(edge_extent)
layerFaceRight.loadNamedStyle(
os.path.join(template_dir, 'face_right.qml'))
# next_left
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
uri.removeParam('bbox')
layerNextLeft = QgsVectorLayer(uri.uri(False),
u'%s.next_left' % toponame, provider)
layerNextLeft.setExtent(edge_extent)
layerNextLeft.loadNamedStyle(
os.path.join(template_dir, 'next_left.qml'))
# next_right
uri.setDataSource(toponame, 'edge_data', 'geom', '', 'edge_id')
uri.setSrid(toposrid)
uri.setWkbType(QgsWkbTypes.LineString)
uri.removeParam('bbox')
layerNextRight = QgsVectorLayer(uri.uri(False),
u'%s.next_right' % toponame, provider)
layerNextRight.setExtent(edge_extent)
layerNextRight.loadNamedStyle(
os.path.join(template_dir, 'next_right.qml'))
# Add layers to the layer tree
faceLayers = [layerFaceMbr, layerFaceGeom, layerFaceSeed]
nodeLayers = [layerNode, layerNodeLabel]
edgeLayers = [
layerEdge, layerDirectedEdge, layerEdgeLabel, layerFaceLeft,
layerFaceRight, layerNextLeft, layerNextRight
]
QgsProject.instance().addMapLayers(faceLayers, False)
QgsProject.instance().addMapLayers(nodeLayers, False)
QgsProject.instance().addMapLayers(edgeLayers, False)
# Organize layers in groups
groupFaces = QgsLayerTreeGroup(u'Faces')
for layer in faceLayers:
nodeLayer = groupFaces.addLayer(layer)
nodeLayer.setItemVisibilityChecked(False)
nodeLayer.setExpanded(False)
groupNodes = QgsLayerTreeGroup(u'Nodes')
for layer in nodeLayers:
nodeLayer = groupNodes.addLayer(layer)
nodeLayer.setItemVisibilityChecked(False)
nodeLayer.setExpanded(False)
groupEdges = QgsLayerTreeGroup(u'Edges')
for layer in edgeLayers:
nodeLayer = groupEdges.addLayer(layer)
nodeLayer.setItemVisibilityChecked(False)
nodeLayer.setExpanded(False)
supergroup = QgsLayerTreeGroup(u'Topology "%s"' % toponame)
supergroup.insertChildNodes(-1, [groupFaces, groupNodes, groupEdges])
layerTree = QgsProject.instance().layerTreeRoot()
layerTree.addChildNode(supergroup)
# Set layers rendering order
order = layerTree.layerOrder()
order.insert(0, order.pop(order.index(layerFaceMbr)))
order.insert(0, order.pop(order.index(layerFaceGeom)))
order.insert(0, order.pop(order.index(layerEdge)))
order.insert(0, order.pop(order.index(layerDirectedEdge)))
order.insert(0, order.pop(order.index(layerNode)))
order.insert(0, order.pop(order.index(layerFaceSeed)))
order.insert(0, order.pop(order.index(layerNodeLabel)))
order.insert(0, order.pop(order.index(layerEdgeLabel)))
order.insert(0, order.pop(order.index(layerNextLeft)))
order.insert(0, order.pop(order.index(layerNextRight)))
order.insert(0, order.pop(order.index(layerFaceLeft)))
order.insert(0, order.pop(order.index(layerFaceRight)))
layerTree.setHasCustomLayerOrder(True)
layerTree.setCustomLayerOrder(order)
finally:
# Set canvas extent to topology extent, if not yet initialized
canvas = iface.mapCanvas()
if (canvas.fullExtent().isNull()):
ext = node_extent
ext.combineExtentWith(edge_extent)
# Grow by 1/20 of largest side
ext = ext.buffered(max(ext.width(), ext.height()) / 20)
canvas.setExtent(ext)
# restore canvas render flag
if not wasFrozen:
iface.mapCanvas().freeze(False)
return True
def draw(self):
rb = self.tool.rb
g = rb.asGeometry()
ok = True
warning = False
errBuffer_noAtt = False
errBuffer_Vertices = False
layer = self.iface.layerTreeView().currentLayer()
if self.toolname == 'drawBuffer':
if self.bGeom is None:
warning = True
errBuffer_noAtt = True
else:
perim, ok = QInputDialog.getDouble(
self.iface.mainWindow(),
self.tr('Perimeter'),
self.tr('Give a perimeter in m:') + '\n' +
self.tr('(works only with metric crs)'),
min=0)
g = self.bGeom.buffer(perim, 40)
rb.setToGeometry(
g,
QgsVectorLayer("Polygon?crs=" + layer.crs().authid(), "",
"memory"))
if g.length() == 0 and ok:
warning = True
errBuffer_Vertices = True
if self.toolname == 'drawCopies':
if g.length() < 0:
warning = True
errBuffer_noAtt = True
if ok and not warning:
name = ''
ok = True
add = False
index = 0
layers = []
while not name.strip() and not add and ok:
dlg = QDrawLayerDialog(self.iface, self.drawShape)
name, add, index, layers, ok = dlg.getName(
self.iface, self.drawShape)
if ok and not warning:
layer = None
if add:
layer = layers[index]
if self.drawShape in ['point', 'XYpoint']:
g = g.centroid()
else:
if self.drawShape == 'point':
layer = QgsVectorLayer(
"Point?crs=" + self.iface.mapCanvas().mapSettings(
).destinationCrs().authid() + "&field=" +
self.tr('Drawings') + ":string(255)", name, "memory")
g = g.centroid() # force geometry as point
elif self.drawShape == 'XYpoint':
layer = QgsVectorLayer(
"Point?crs=" + self.XYcrs.authid() + "&field=" +
self.tr('Drawings') + ":string(255)", name, "memory")
g = g.centroid()
elif self.drawShape == 'line':
layer = QgsVectorLayer(
"LineString?crs=" + self.iface.mapCanvas().mapSettings(
).destinationCrs().authid() + "&field=" +
self.tr('Drawings') + ":string(255)", name, "memory")
# fix_print_with_import
print("LineString?crs=" + self.iface.mapCanvas(
).mapSettings().destinationCrs().authid() + "&field=" +
self.tr('Drawings') + ":string(255)")
else:
layer = QgsVectorLayer(
"Polygon?crs=" + self.iface.mapCanvas().mapSettings(
).destinationCrs().authid() + "&field=" +
self.tr('Drawings') + ":string(255)", name, "memory")
layer.startEditing()
symbols = layer.renderer().symbols(
QgsRenderContext()) # todo which context ?
symbols[0].setColor(self.settings.getColor())
feature = QgsFeature()
feature.setGeometry(g)
feature.setAttributes([name])
layer.dataProvider().addFeatures([feature])
layer.commitChanges()
if not add:
pjt = QgsProject.instance()
pjt.addMapLayer(layer, False)
if pjt.layerTreeRoot().findGroup(self.tr('Drawings')) is None:
pjt.layerTreeRoot().insertChildNode(
0, QgsLayerTreeGroup(self.tr('Drawings')))
group = pjt.layerTreeRoot().findGroup(self.tr('Drawings'))
group.insertLayer(0, layer)
self.iface.layerTreeView().refreshLayerSymbology(layer.id())
self.iface.mapCanvas().refresh()
else:
if warning:
if errBuffer_noAtt:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('You didn\'t click on a layer\'s attribute !'))
elif errBuffer_Vertices:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('You must give a non-null value for a \
point\'s or line\'s perimeter !'))
else:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('There is no selected layer, or it is not \
vector nor visible !'))
self.tool.reset()
self.resetSB()
self.bGeom = None
def fusionnerJointure(self, cheminCompletParcelle, jointureChoisie):
""" Selon les tables déja ouverte dans le projet : ouverture si necessaire des différents cas de délimiteurs
Jointure par QGIS """
# Vérification du projet ouverte
monProjet = QgsProject.instance()
if monProjet.fileName() == None or monProjet.fileName() == "":
monPrint("Projet en cours de création", T_WAR)
else:
monPrint("Projet ouvert {}".format(monProjet.fileName()))
root = monProjet.layerTreeRoot()
# Création du groupe jointure_date
dateMaintenant = datetime.now()
nomGroupe = MonParcellaire_JOI + " du " + dateMaintenant.strftime(
"%d %b à %Hh%M:%S")
temporaireGroupe = QgsLayerTreeGroup(nomGroupe)
# Positionner en haut de root
root.addChildNode(temporaireGroupe)
nouveauGroupe = temporaireGroupe.clone()
root.insertChildNode(0, nouveauGroupe)
root.removeChildNode(temporaireGroupe)
# Ouverture du vecteur parcelle
parcelle = QgsVectorLayer(
cheminCompletParcelle,
MonParcellaire_PAR + SEP_U + MonParcellaire_JOI, 'ogr')
monProjet.addMapLayer(parcelle, False)
nouveauGroupe.addLayer(parcelle)
# Recherche delimiteur
delimiteur, csv, nomCsv = self.rechercherDelimiteurJointure(
jointureChoisie, "No Pandas")
nomCourtJointure = os.path.basename(jointureChoisie)
monPrint(
"Délimiteur identifié {0} pour {1}".format(delimiteur,
nomCourtJointure), T_OK)
monProjet.addMapLayer(csv, False)
nouveauGroupe.addLayer(csv)
# Jointure
attributsSelectionnes = self.AttributsAJoindre_listWidget.selectedItems(
)
attributsAJoindre = []
for positionAttribut in range(len(attributsSelectionnes)):
attributsAJoindre.append(
str(self.AttributsAJoindre_listWidget.selectedItems()
[positionAttribut].text()))
#monPrint( "Attributs à joindre {}".format( attributsAJoindre))
# Liste des champs dans csv
nomColonnes, _ = self.lireAttributsJointure(jointureChoisie)
attributsAJoindreOrdonne = []
for col in nomColonnes:
if col in attributsAJoindre:
if col != MonParcellaireNomAttribut:
attributsAJoindreOrdonne.append(col)
#monPrint( "Attributs à joindre ordonné {}".format( attributsAJoindreOrdonne))
champVecteur = MonParcellaireNomAttribut
maJointure = QgsVectorLayerJoinInfo()
champCsv = self.AttributJointure_comboBox.currentText()
maJointure.setJoinFieldName(champCsv)
maJointure.setTargetFieldName(champVecteur)
maJointure.setUsingMemoryCache(True)
maJointure.setPrefix("")
maJointure.setJoinLayer(csv)
# Récupérer les champs de jointure
maJointure.setJoinFieldNamesSubset(attributsAJoindreOrdonne)
parcelle.addJoin(maJointure)
return jointureChoisie, attributsAJoindreOrdonne
def renderer(self):
if 'QGIS_AUTH_DB_DIR_PATH' not in os.environ:
os.environ['QGIS_AUTH_DB_DIR_PATH'] = '/tmp'
qgis = None
while True:
options, result = self.queue.get()
# Don't start QGIS until first request
if qgis is None:
qgis = QgsApplication([], False)
qgis.setPrefixPath(self.settings.get('path'), True)
qgis.setDefaultSvgPaths(qgis.svgPaths() +
self.settings.get('svgpaths'))
qgis.setMaxThreads(1)
qgis.initQgis()
try:
if isinstance(options, LegendOptions):
style, = options
layer = self._qgs_memory_layer(style)
layer.setName(style.parent.display_name)
QgsMapLayerRegistry.instance().addMapLayer(layer)
root = QgsLayerTreeGroup()
root.addLayer(layer)
# 'Cannot create a QPixmap when no GUI is being used'
# warning occurs here
model = QgsLayerTreeModel(root)
settings = QgsLegendSettings()
settings.setTitle('')
settings.setBoxSpace(1)
settings.setSymbolSize(QSizeF(5, 3))
settings.setDpi(96)
renderer = QgsLegendRenderer(model, settings)
# Dots per mm
dpmm = settings.dpi() / 25.4
min_size = renderer.minimumSize()
size = QSize(dpmm * min_size.width(),
dpmm * min_size.height())
img = QImage(size, QImage.Format_ARGB32)
img.fill(QColor(0, 0, 0, 0))
painter = QPainter()
painter.begin(img)
painter.scale(dpmm, dpmm)
renderer.drawLegend(painter)
painter.end()
QgsMapLayerRegistry.instance().removeAllMapLayers()
ba = QByteArray()
bf = QBuffer(ba)
bf.open(QIODevice.WriteOnly)
img.save(bf, 'PNG')
bf.close()
buf = StringIO()
buf.write(bf.data())
buf.seek(0)
result.put(buf)
else:
path = features = None
if isinstance(options, VectorRenderOptions):
style, features, render_size, \
extended, target_box = options
layer = self._qgs_memory_layer(style,
features=features)
elif isinstance(options, RasterRenderOptions):
style, path, render_size, \
extended, target_box = options
layer = QgsRasterLayer(path)
layer.loadNamedStyle(
self.env.file_storage.filename(style.qml_fileobj))
settings = QgsMapSettings()
settings.setLayers([layer.id()])
settings.setFlag(QgsMapSettings.DrawLabeling)
settings.setFlag(QgsMapSettings.Antialiasing)
settings.setCrsTransformEnabled(True)
settings.setDestinationCrs(layer.crs())
settings.setMapUnits(layer.crs().mapUnits())
settings.setOutputSize(QSize(*render_size))
settings.setExtent(QgsRectangle(*extended))
settings.setOutputImageFormat(QImage.Format_ARGB32)
bgcolor = QColor.fromRgba(qRgba(255, 255, 255, 0))
settings.setBackgroundColor(bgcolor)
settings.setOutputDpi(96)
QgsMapLayerRegistry.instance().addMapLayer(layer)
settings.setLayers([layer.id()])
# Create QImage by hand to be able to use
# QgsMapRendererCustomPainterJob. Others will not
# allow to workaround a bug with overlay rendering.
img = QImage(settings.outputSize(), QImage.Format_ARGB32)
# These cludges are needed for rendering
# on transparent background, otherwise it's a mess.
img.fill(QColor.fromRgba(qRgba(255, 255, 255, 255)))
img.fill(QColor.fromRgba(qRgba(255, 255, 255, 0)))
# DPI should be equal to settings, otherwise an error.
# In QImage the resolution is set in dots per meter
# for each axis.
dpm = settings.outputDpi() / 25.4 * 1000
img.setDotsPerMeterX(dpm)
img.setDotsPerMeterY(dpm)
painter = QPainter(img)
job = QgsMapRendererCustomPainterJob(settings, painter)
job.renderSynchronously()
painter.end()
QgsMapLayerRegistry.instance().removeAllMapLayers()
img = self._qimage_to_pil(img)
# Clip needed part
result.put(img.crop(target_box))
# Cleanup
if path is not None:
gdal.Unlink(path)
except Exception as exc:
self.logger.error(exc.message)
result.put(exc)
qgis.exitQgis()
