def testReadWriteXml(self):
p = QgsProject()
l = QgsLayout(p)
l.initializeDefaults()
guides = l.guides()
# add some guides
g1 = QgsLayoutGuide(Qt.Horizontal, QgsLayoutMeasurement(5, QgsUnitTypes.LayoutCentimeters), l.pageCollection().page(0))
guides.addGuide(g1)
g2 = QgsLayoutGuide(Qt.Vertical, QgsLayoutMeasurement(6, QgsUnitTypes.LayoutInches), l.pageCollection().page(0))
guides.addGuide(g2)
guides.setVisible(False)
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
self.assertTrue(guides.writeXml(elem, doc, QgsReadWriteContext()))
l2 = QgsLayout(p)
l2.initializeDefaults()
guides2 = l2.guides()
self.assertTrue(guides2.readXml(elem.firstChildElement(), doc, QgsReadWriteContext()))
guide_list = guides2.guidesOnPage(0)
self.assertEqual(len(guide_list), 2)
self.assertEqual(guide_list[0].orientation(), Qt.Horizontal)
self.assertEqual(guide_list[0].position().length(), 5.0)
self.assertEqual(guide_list[0].position().units(), QgsUnitTypes.LayoutCentimeters)
self.assertEqual(guide_list[1].orientation(), Qt.Vertical)
self.assertEqual(guide_list[1].position().length(), 6.0)
self.assertEqual(guide_list[1].position().units(), QgsUnitTypes.LayoutInches)
def testWriteReadXmlProj6(self):
# setup a context
context = QgsCoordinateTransformContext()
proj_1 = '+proj=pipeline +step +proj=axisswap +order=2,1 +step +proj=unitconvert +xy_in=deg +xy_out=rad +step +proj=push +v_3 +step +proj=cart +ellps=intl +step +proj=helmert +x=-18.944 +y=-379.364 +z=-24.063 +rx=-0.04 +ry=0.764 +rz=-6.431 +s=3.657 +convention=coordinate_frame +step +inv +proj=cart +ellps=WGS84 +step +proj=pop +v_3 +step +proj=unitconvert +xy_in=rad +xy_out=deg +step +proj=axisswap +order=2,1'
proj_2 = '+proj=pipeline +step +proj=axisswap +order=2,1 +step +proj=unitconvert +xy_in=deg +xy_out=rad +step +proj=push +v_3 +step +proj=cart +ellps=intl +step +proj=helmert +x=-150 +y=-250 +z=-1 +step +inv +proj=cart +ellps=WGS84 +step +proj=pop +v_3 +step +proj=unitconvert +xy_in=rad +xy_out=deg +step +proj=axisswap +order=2,1'
self.assertTrue(context.addCoordinateOperation(QgsCoordinateReferenceSystem(4204),
QgsCoordinateReferenceSystem(4326), proj_1))
self.assertTrue(context.addCoordinateOperation(QgsCoordinateReferenceSystem(4205),
QgsCoordinateReferenceSystem(4326), proj_2))
self.assertEqual(context.coordinateOperations(),
{('EPSG:4204', 'EPSG:4326'): proj_1,
('EPSG:4205', 'EPSG:4326'): proj_2})
# save to xml
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
context.writeXml(elem, QgsReadWriteContext())
# restore from xml
context2 = QgsCoordinateTransformContext()
context2.readXml(elem, QgsReadWriteContext())
# check result
self.assertEqual(context2.coordinateOperations(),
{('EPSG:4204', 'EPSG:4326'): proj_1,
('EPSG:4205', 'EPSG:4326'): proj_2})
def testMissingTransformsProj6(self):
return # TODO -- this seems impossible to determine with existing PROJ6 api
# fudge context xml with a missing transform
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
contextElem = doc.createElement("transformContext")
transformElem = doc.createElement("srcDest")
transformElem.setAttribute("source", 'EPSG:4204')
transformElem.setAttribute("dest", 'EPSG:4326')
# fake a proj string with a grid which will NEVER exist
fake_proj = '+proj=pipeline +step +proj=axisswap +order=2,1 +step +proj=unitconvert +xy_in=deg +xy_out=rad +step +inv +proj=hgridshift +grids=this_is_not_a_real_grid.gsb +step +proj=unitconvert +xy_in=rad +xy_out=deg +step +proj=axisswap +order=2,1'
transformElem.setAttribute("coordinateOp", fake_proj)
contextElem.appendChild(transformElem)
elem2 = doc.createElement("test2")
elem2.appendChild(contextElem)
# restore from xml
context2 = QgsCoordinateTransformContext()
ok, errors = context2.readXml(elem2, QgsReadWriteContext())
self.assertFalse(ok)
# check result
self.assertEqual(errors, ['not valid'])
def testReadExtentOnTable(self):
# vector layer based on a standard table
vl0 = QgsVectorLayer(self.dbconn + ' sslmode=disable key=\'pk\' srid=4326 type=POLYGON table="qgis_test"."some_poly_data" (geom) sql=', 'test', 'postgres')
self.assertTrue(vl0.isValid())
self.assertTrue(vl0.dataProvider().hasMetadata())
# set a custom extent
originalExtent = vl0.extent()
customExtent = QgsRectangle(-80, 80, -70, 90)
vl0.setExtent(customExtent)
# write xml
doc = QDomDocument("testdoc")
elem = doc.createElement("maplayer")
self.assertTrue(vl0.writeLayerXml(elem, doc, QgsReadWriteContext()))
# read xml with the custom extent. It should not be used by default
vl1 = QgsVectorLayer()
vl1.readLayerXml(elem, QgsReadWriteContext())
self.assertTrue(vl1.isValid())
self.assertEqual(vl1.extent(), originalExtent)
# read xml with custom extent with readExtent option. Extent read from
# xml document should NOT be used because we don't have a view or a
# materialized view
vl2 = QgsVectorLayer()
vl2.setReadExtentFromXml(True)
vl2.readLayerXml(elem, QgsReadWriteContext())
self.assertTrue(vl2.isValid())
self.assertEqual(vl2.extent(), originalExtent)
def testSaveCanvasVariablesToProject(self):
"""
Ensure that temporary canvas atlas variables are not written to project
"""
c1 = QgsMapCanvas()
c1.setObjectName('c1')
c1.expressionContextScope().setVariable('atlas_featurenumber', 1111)
c1.expressionContextScope().setVariable('atlas_pagename', 'bb')
c1.expressionContextScope().setVariable('atlas_feature', QgsFeature(1))
c1.expressionContextScope().setVariable('atlas_featureid', 22)
c1.expressionContextScope().setVariable('atlas_geometry', QgsGeometry.fromWkt('Point( 1 2 )'))
c1.expressionContextScope().setVariable('vara', 1111)
c1.expressionContextScope().setVariable('varb', 'bb')
doc = QDomDocument("testdoc")
elem = doc.createElement("qgis")
doc.appendChild(elem)
c1.writeProject(doc)
c2 = QgsMapCanvas()
c2.setObjectName('c1')
c2.readProject(doc)
self.assertCountEqual(c2.expressionContextScope().variableNames(), ['vara', 'varb'])
self.assertEqual(c2.expressionContextScope().variable('vara'), 1111)
self.assertEqual(c2.expressionContextScope().variable('varb'), 'bb')
def testReadWriteXml(self):
"""
Test reading and writing layout manager state to XML
"""
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
# save to xml
doc = QDomDocument("testdoc")
elem = manager.writeXml(doc)
doc.appendChild(elem)
# restore from xml
project2 = QgsProject()
manager2 = QgsLayoutManager(project2)
self.assertTrue(manager2.readXml(elem, doc))
self.assertEqual(len(manager2.compositions()), 3)
names = [c.name() for c in manager2.compositions()]
self.assertEqual(set(names), {'test composition', 'test composition2', 'test composition3'})
def _change_data_source(self, layer, datasource, provider_key):
"""Due to the fact that a project r/w context is not available inside
the map layers classes, the original style and subset string restore
happens in app, this function replicates app behavior"""
options = QgsDataProvider.ProviderOptions()
subset_string = ''
if not layer.isValid():
try:
subset_string = layer.dataProvider().subsetString()
except:
pass
layer.setDataSource(datasource, layer.name(), provider_key, options)
if subset_string:
layer.setSubsetString(subset_string)
self.assertTrue(layer.originalXmlProperties(), layer.name())
context = QgsReadWriteContext()
context.setPathResolver(QgsProject.instance().pathResolver())
errorMsg = ''
doc = QDomDocument()
self.assertTrue(doc.setContent(layer.originalXmlProperties()))
layer_node = QDomNode(doc.firstChild())
self.assertTrue(layer.readSymbology(layer_node, errorMsg, context))
def testWriteReadXml(self):
# setup a context
context = QgsCoordinateTransformContext()
source_id_1 = QgsDatumTransform.datumTransformations(QgsCoordinateReferenceSystem(4204),
QgsCoordinateReferenceSystem(4326))[0].sourceTransformId
dest_id_1 = QgsDatumTransform.datumTransformations(QgsCoordinateReferenceSystem(4204),
QgsCoordinateReferenceSystem(4326))[0].destinationTransformId
source_id_2 = QgsDatumTransform.datumTransformations(QgsCoordinateReferenceSystem(4205),
QgsCoordinateReferenceSystem(4326))[0].sourceTransformId
dest_id_2 = QgsDatumTransform.datumTransformations(QgsCoordinateReferenceSystem(4205),
QgsCoordinateReferenceSystem(4326))[0].destinationTransformId
self.assertTrue(context.addSourceDestinationDatumTransform(QgsCoordinateReferenceSystem(4204),
QgsCoordinateReferenceSystem(4326), source_id_1, dest_id_1))
self.assertTrue(context.addSourceDestinationDatumTransform(QgsCoordinateReferenceSystem(4205),
QgsCoordinateReferenceSystem(4326), source_id_2, dest_id_2))
self.assertEqual(context.sourceDestinationDatumTransforms(), {('EPSG:4204', 'EPSG:4326'): QgsDatumTransform.TransformPair(source_id_1, dest_id_1),
('EPSG:4205', 'EPSG:4326'): QgsDatumTransform.TransformPair(source_id_2, dest_id_2)})
# save to xml
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
context.writeXml(elem, QgsReadWriteContext())
# restore from xml
context2 = QgsCoordinateTransformContext()
context2.readXml(elem, QgsReadWriteContext())
# check result
self.assertEqual(context2.sourceDestinationDatumTransforms(), {('EPSG:4204', 'EPSG:4326'): QgsDatumTransform.TransformPair(source_id_1, dest_id_1),
('EPSG:4205', 'EPSG:4326'): QgsDatumTransform.TransformPair(source_id_2, dest_id_2)})
def testWriteReadXmlSingleVariant(self):
# setup a context
context = QgsCoordinateTransformContext()
self.assertTrue(context.addSourceDatumTransform(QgsCoordinateReferenceSystem('EPSG:3111'), 1))
self.assertTrue(context.addSourceDatumTransform(QgsCoordinateReferenceSystem('EPSG:28356'), 2))
self.assertTrue(context.addDestinationDatumTransform(QgsCoordinateReferenceSystem('EPSG:3113'), 11))
self.assertTrue(context.addDestinationDatumTransform(QgsCoordinateReferenceSystem('EPSG:28355'), 12))
self.assertTrue(context.addSourceDestinationDatumTransform(QgsCoordinateReferenceSystem('EPSG:3111'),
QgsCoordinateReferenceSystem('EPSG:4283'), 1, 2))
self.assertTrue(context.addSourceDestinationDatumTransform(QgsCoordinateReferenceSystem('EPSG:28356'),
QgsCoordinateReferenceSystem(4283), 3, 4))
self.assertEqual(context.sourceDatumTransforms(), {'EPSG:3111': 1, 'EPSG:28356': 2})
self.assertEqual(context.destinationDatumTransforms(), {'EPSG:3113': 11, 'EPSG:28355': 12})
self.assertEqual(context.sourceDestinationDatumTransforms(), {('EPSG:3111', 'EPSG:4283'): (1, 2),
('EPSG:28356', 'EPSG:4283'): (3, 4)})
# save to xml
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
context.writeXml(elem, QgsReadWriteContext())
# restore from xml
context2 = QgsCoordinateTransformContext()
context2.readXml(elem, QgsReadWriteContext())
# check result
self.assertEqual(context2.sourceDatumTransforms(), {'EPSG:3111': 1, 'EPSG:28356': 2})
self.assertEqual(context2.destinationDatumTransforms(), {'EPSG:3113': 11, 'EPSG:28355': 12})
self.assertEqual(context2.sourceDestinationDatumTransforms(), {('EPSG:3111', 'EPSG:4283'): (1, 2),
('EPSG:28356', 'EPSG:4283'): (3, 4)})
def on_btnLoad_clicked(self):
fileName, _ = QFileDialog.getOpenFileName(None,
self.tr('Import Colors and elevations from XML'),
QDir.homePath(),
self.tr('XML files (*.xml *.XML)'))
if fileName == '':
return
doc = QDomDocument()
with codecs.open(fileName, 'r', encoding='utf-8') as f:
content = f.read()
if not doc.setContent(content):
QMessageBox.critical(None,
self.tr('Error parsing XML'),
self.tr('The XML file could not be loaded'))
return
self.reliefClassTree.clear()
reliefColorList = doc.elementsByTagName('ReliefColor')
for i in range(reliefColorList.length()):
elem = reliefColorList.at(i).toElement()
item = QTreeWidgetItem()
item.setText(0, elem.attribute('MinElevation'))
item.setText(1, elem.attribute('MaxElevation'))
item.setBackground(2, QBrush(QColor(int(elem.attribute('red')),
int(elem.attribute('green')),
int(elem.attribute('blue')))))
self.reliefClassTree.addTopLevelItem(item)
def testSubstitutionMap(self):
"""Test that we can use degree symbols in substitutions.
"""
# Create a point and convert it to text containing a degree symbol.
myPoint = QgsPoint(12.3, -33.33)
myCoordinates = myPoint.toDegreesMinutesSeconds(2)
myTokens = myCoordinates.split(',')
myLongitude = myTokens[0]
myLatitude = myTokens[1]
myText = 'Latitude: %s, Longitude: %s' % (myLatitude, myLongitude)
# Load the composition with the substitutions
myComposition = QgsComposition(self.iface.mapCanvas().mapSettings())
mySubstitutionMap = {'replace-me': myText}
myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt')
with open(myFile) as f:
myTemplateContent = f.read()
myDocument = QDomDocument()
myDocument.setContent(myTemplateContent)
myComposition.loadFromTemplate(myDocument, mySubstitutionMap)
# We should be able to get map0
myMap = myComposition.getComposerMapById(0)
myMessage = ('Map 0 could not be found in template %s', myFile)
assert myMap is not None, myMessage
def testQgsSVGFillSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsSVGFillSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSVGFillSymbolLayer.createFromSld(
mDoc.elementsByTagName('PolygonSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSVGFillSymbolLayer(""))
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 'accommodation_camping.svg'
mValue = os.path.basename(mSymbolLayer.svgFilePath())
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 6
mValue = mSymbolLayer.patternWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsSvgMarkerSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsSvgMarkerSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSvgMarkerSymbolLayer.createFromSld(mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSvgMarkerSymbolLayer(""))
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 'skull.svg'
mValue = os.path.basename(mSymbolLayer.path())
print(("VALUE", mSymbolLayer.path()))
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 12
mValue = mSymbolLayer.size()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 45
mValue = mSymbolLayer.angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def layerToSld(self, layer, properties={}):
dom = QDomDocument()
root = dom.createElement("FakeRoot")
dom.appendChild(root)
errorMessage = ''
layer.writeSld(root, dom, errorMessage, properties)
return dom, root, errorMessage
def testSymbolSizeAfterReload(self):
# create a layer
layer = createLayerWithOnePoint()
# load a sld with marker size
sld = 'symbol_layer/QgsSvgMarkerSymbolLayer.sld'
mFilePath = os.path.join(TEST_DATA_DIR, sld)
layer.loadSldStyle(mFilePath)
# get the size and unit of the symbol
sl = layer.renderer().symbol().symbolLayers()[0]
first_size = sl.size()
first_unit = sl.outputUnit() # in pixels
# export sld into a qdomdocument with namespace processing activated
doc = QDomDocument()
msg = ""
layer.exportSldStyle(doc, msg)
doc.setContent(doc.toString(), True)
self.assertTrue(msg == "")
# reload the same sld
root = doc.firstChildElement("StyledLayerDescriptor")
el = root.firstChildElement("NamedLayer")
layer.readSld(el, msg)
# extract the size and unit of symbol
sl = layer.renderer().symbol().symbolLayers()[0]
second_size = sl.size()
second_unit = sl.outputUnit()
# size and unit should be the same after export and reload the same
# sld description
self.assertEqual(first_size, second_size)
self.assertEqual(first_unit, second_unit)
def testReadWriteXml(self):
pr = QgsProject()
l = QgsLayout(pr)
p = QPolygonF()
p.append(QPointF(0.0, 0.0))
p.append(QPointF(100.0, 0.0))
p.append(QPointF(200.0, 100.0))
shape = QgsLayoutItemPolyline(p, l)
props = {}
props["color"] = "255,0,0,255"
props["width"] = "10.0"
props["capstyle"] = "square"
style = QgsLineSymbol.createSimple(props)
shape.setSymbol(style)
#save original item to xml
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
self.assertTrue(shape.writeXml(elem, doc, QgsReadWriteContext()))
shape2 = QgsLayoutItemPolyline(l)
self.assertTrue(shape2.readXml(elem.firstChildElement(), doc, QgsReadWriteContext()))
self.assertEqual(shape2.nodes(), shape.nodes())
self.assertEqual(shape2.symbol().symbolLayer(0).color().name(), '#ff0000')
def layerToSld(self, mapLayer):
dom = QDomDocument()
root = dom.createElement("FakeRoot")
dom.appendChild(root)
error = None
mapLayer.writeSld(root, dom, error, {})
return dom, root
def testReadWriteXml(self):
pr = QgsProject()
l = QgsLayout(pr)
p = QPolygonF()
p.append(QPointF(0.0, 0.0))
p.append(QPointF(100.0, 0.0))
p.append(QPointF(200.0, 100.0))
shape = QgsLayoutItemPolygon(p, l)
props = {}
props["color"] = "green"
props["style"] = "solid"
props["style_border"] = "solid"
props["color_border"] = "red"
props["width_border"] = "10.0"
props["joinstyle"] = "miter"
style = QgsFillSymbol.createSimple(props)
shape.setSymbol(style)
#save original item to xml
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
self.assertTrue(shape.writeXml(elem, doc, QgsReadWriteContext()))
shape2 = QgsLayoutItemPolygon(l)
self.assertTrue(shape2.readXml(elem.firstChildElement(), doc, QgsReadWriteContext()))
self.assertEqual(shape2.nodes(), shape.nodes())
self.assertEqual(shape2.symbol().symbolLayer(0).color().name(), '#008000')
self.assertEqual(shape2.symbol().symbolLayer(0).strokeColor().name(), '#ff0000')
def copy_layer_settings(self, source_layer, target_layer):
# copy filter
if target_layer.type() == QgsVectorLayer:
target_layer.setSubsetString(source_layer.subsetString())
# copy symbology
error = ""
doc = QDomDocument()
node = doc.createElement("symbology")
doc.appendChild(node)
source_layer.writeSymbology(node, doc, error, QgsReadWriteContext())
if not error:
target_layer.readSymbology(node, error, QgsReadWriteContext())
if error:
QMessageBox.warning(None, "Could not copy symbology", error)
# copy scale based visibility
try:
target_layer.setScaleBasedVisibility(source_layer.hasScaleBasedVisibility())
except:
# Fall back to the deprecated function
target_layer.toggleScaleBasedVisibility(source_layer.hasScaleBasedVisibility())
target_layer.setMinimumScale(source_layer.minimumScale())
target_layer.setMaximumScale(source_layer.maximumScale())
#copy CRS
target_layer.setCrs(source_layer.crs(), False)
def testSaveMultipleCanvasesToProject(self):
# test saving/restoring canvas state to project with multiple canvases
c1 = QgsMapCanvas()
c1.setObjectName('c1')
c1.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:3111'))
c1.setRotation(45)
c2 = QgsMapCanvas()
c2.setObjectName('c2')
c2.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
c2.setRotation(65)
doc = QDomDocument("testdoc")
elem = doc.createElement("qgis")
doc.appendChild(elem)
c1.writeProject(doc)
c2.writeProject(doc)
c3 = QgsMapCanvas()
c3.setObjectName('c1')
c4 = QgsMapCanvas()
c4.setObjectName('c2')
c3.readProject(doc)
c4.readProject(doc)
self.assertEqual(c3.mapSettings().destinationCrs().authid(), 'EPSG:3111')
self.assertEqual(c3.rotation(), 45)
self.assertEqual(c4.mapSettings().destinationCrs().authid(), 'EPSG:4326')
self.assertEqual(c4.rotation(), 65)
def testQgsCentroidFillSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsCentroidFillSymbolLayerV2'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsCentroidFillSymbolLayerV2.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsCentroidFillSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'regular_star'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'#55aaff'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'#00ff00'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).borderColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testReadWriteXml(self):
"""
Test reading and writing layout manager state to XML
"""
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of layouts
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
# save to xml
doc = QDomDocument("testdoc")
elem = manager.writeXml(doc)
doc.appendChild(elem)
# restore from xml
project2 = QgsProject()
manager2 = QgsLayoutManager(project2)
self.assertTrue(manager2.readXml(elem, doc))
self.assertEqual(len(manager2.layouts()), 3)
names = [c.name() for c in manager2.layouts()]
self.assertCountEqual(names, ['test layout', 'test layout2', 'test layout3'])
def processAlgorithm(self, parameters, context, feedback):
layer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
style = self.parameterAsFile(parameters, self.STYLE, context)
with open(style) as f:
xml = "".join(f.readlines())
d = QDomDocument()
d.setContent(xml)
layer.importNamedStyle(d)
layer.triggerRepaint()
return {self.INPUT: layer}
def testSaveRestore(self):
""" test saving and restoring collections """
c = QgsStringReplacementCollection([QgsStringReplacement('aa', '11', False, False),
QgsStringReplacement('bb', '22', True, True)])
doc = QDomDocument("testdoc")
elem = doc.createElement("replacements")
c.writeXml(elem, doc)
c2 = QgsStringReplacementCollection()
c2.readXml(elem)
self.assertEqual(c2.replacements(), c.replacements())
def __init__(self, parent=None, xml=None):
super(XmlDialog, self).__init__(parent)
self.setupUi(self)
# self.setWindowTitle(wfs.identification.title)
document = QDomDocument()
document.setContent(xml)
model = DomDocumentModel(document)
self.treeView.setModel(model)
def testQgsRasterMinMaxOrigin(self):
mmo = QgsRasterMinMaxOrigin()
mmo_default = QgsRasterMinMaxOrigin()
self.assertEqual(mmo, mmo_default)
mmo = QgsRasterMinMaxOrigin()
self.assertEqual(mmo.limits(), QgsRasterMinMaxOrigin.None_)
mmo.setLimits(QgsRasterMinMaxOrigin.CumulativeCut)
self.assertEqual(mmo.limits(), QgsRasterMinMaxOrigin.CumulativeCut)
self.assertNotEqual(mmo, mmo_default)
mmo = QgsRasterMinMaxOrigin()
self.assertEqual(mmo.extent(), QgsRasterMinMaxOrigin.WholeRaster)
mmo.setExtent(QgsRasterMinMaxOrigin.UpdatedCanvas)
self.assertEqual(mmo.extent(), QgsRasterMinMaxOrigin.UpdatedCanvas)
self.assertNotEqual(mmo, mmo_default)
mmo = QgsRasterMinMaxOrigin()
self.assertEqual(mmo.statAccuracy(), QgsRasterMinMaxOrigin.Estimated)
mmo.setStatAccuracy(QgsRasterMinMaxOrigin.Exact)
self.assertEqual(mmo.statAccuracy(), QgsRasterMinMaxOrigin.Exact)
self.assertNotEqual(mmo, mmo_default)
mmo = QgsRasterMinMaxOrigin()
self.assertAlmostEqual(mmo.cumulativeCutLower(), 0.02)
mmo.setCumulativeCutLower(0.1)
self.assertAlmostEqual(mmo.cumulativeCutLower(), 0.1)
self.assertNotEqual(mmo, mmo_default)
mmo = QgsRasterMinMaxOrigin()
self.assertAlmostEqual(mmo.cumulativeCutUpper(), 0.98)
mmo.setCumulativeCutUpper(0.9)
self.assertAlmostEqual(mmo.cumulativeCutUpper(), 0.9)
self.assertNotEqual(mmo, mmo_default)
mmo = QgsRasterMinMaxOrigin()
self.assertAlmostEqual(mmo.stdDevFactor(), 2.0)
mmo.setStdDevFactor(2.5)
self.assertAlmostEqual(mmo.stdDevFactor(), 2.5)
self.assertNotEqual(mmo, mmo_default)
mmo = QgsRasterMinMaxOrigin()
mmo.setLimits(QgsRasterMinMaxOrigin.CumulativeCut)
mmo.setExtent(QgsRasterMinMaxOrigin.UpdatedCanvas)
mmo.setStatAccuracy(QgsRasterMinMaxOrigin.Exact)
mmo.setCumulativeCutLower(0.1)
mmo.setCumulativeCutUpper(0.9)
mmo.setStdDevFactor(2.5)
doc = QDomDocument()
parentElem = doc.createElement("test")
mmo.writeXml(doc, parentElem)
mmoUnserialized = QgsRasterMinMaxOrigin()
mmoUnserialized.readXml(parentElem)
self.assertEqual(mmo, mmoUnserialized)
def testPrintMapFromTemplate(self):
"""Test that we can get a map to render in the template."""
myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif')
myFileInfo = QFileInfo(myPath)
myRasterLayer = QgsRasterLayer(myFileInfo.filePath(),
myFileInfo.completeBaseName())
myRenderer = QgsMultiBandColorRenderer(
myRasterLayer.dataProvider(), 2, 3, 4
)
#mRasterLayer.setRenderer( rasterRenderer )
myPipe = myRasterLayer.pipe()
assert myPipe.set(myRenderer), "Cannot set pipe renderer"
QgsMapLayerRegistry.instance().addMapLayers([myRasterLayer])
myMapRenderer = QgsMapRenderer()
myLayerStringList = []
myLayerStringList.append(myRasterLayer.id())
myMapRenderer.setLayerSet(myLayerStringList)
myMapRenderer.setProjectionsEnabled(False)
myComposition = QgsComposition(myMapRenderer)
myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt')
with open(myFile) as f:
myTemplateContent = f.read()
myDocument = QDomDocument()
myDocument.setContent(myTemplateContent)
myComposition.loadFromTemplate(myDocument)
# now render the map, first zooming to the raster extents
myMap = myComposition.getComposerMapById(0)
myMessage = ('Map 0 could not be found in template %s', myFile)
assert myMap is not None, myMessage
myExtent = myRasterLayer.extent()
myMap.setNewExtent(myExtent)
myImagePath = os.path.join(str(QDir.tempPath()),
'template_map_render_python.png')
myPageNumber = 0
myImage = myComposition.printPageAsRaster(myPageNumber)
myImage.save(myImagePath)
assert os.path.exists(myImagePath), 'Map render was not created.'
# Not sure if this is a predictable way to test but its quicker than
# rendering.
myFileSize = QFileInfo(myImagePath).size()
myExpectedFileSize = 100000
myMessage = ('Expected file size to be greater than %s, got %s'
' for %s' %
(myExpectedFileSize, myFileSize, myImagePath))
assert myFileSize > myExpectedFileSize, myMessage
def createEllipseSymbolLayer(self):
# No way to build it programmatically...
mTestName = 'QgsEllipseSymbolLayer'
mFilePath = QDir.toNativeSeparators(
'%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsEllipseSymbolLayer.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
return mSymbolLayer
def testNoSubstitutionMap(self):
"""Test that we can get a map if we use no text substitutions."""
myComposition = QgsComposition(self.iface.mapCanvas().mapSettings())
myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt')
with open(myFile) as f:
myTemplateContent = f.read()
myDocument = QDomDocument()
myDocument.setContent(myTemplateContent)
myComposition.loadFromTemplate(myDocument)
# We should be able to get map0
myMap = myComposition.getComposerMapById(0)
myMessage = ('Map 0 could not be found in template %s', myFile)
assert myMap is not None, myMessage
def testQgsSimpleLineSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = "QgsSimpleLineSymbolLayerV2"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSimpleLineSymbolLayerV2.createFromSld(
mDoc.elementsByTagName("LineSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsSimpleLineSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#aa007f"
mValue = mSymbolLayer.color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 1.26
mValue = mSymbolLayer.width()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.RoundCap
mValue = mSymbolLayer.penCapStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.MiterJoin
mValue = mSymbolLayer.penJoinStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = True
mValue = mSymbolLayer.useCustomDashPattern()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = [5.0, 2.0]
mValue = mSymbolLayer.customDashVector()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
class at(object):
def __init__(
self,
data_uri,
wards_uri,
palika_uri,
dists_uri,
dists_syle,
pka_style,
pka_hide_style,
ward_style,
atlas_style,
parent_join_cd,
to_join_code,
img_type,
out_path,
pka_list=None,
):
self.data_uri = data_uri
self.wards_uri = wards_uri
self.palika_uri = palika_uri
self.dists_uri = dists_uri
self.dists_syle = dists_syle
self.pka_style = pka_style
self.pka_hide_style = pka_hide_style
self.ward_style = ward_style
self.atlas_style = atlas_style
self.parent_join_cd = parent_join_cd
self.to_join_code = to_join_code
self.pka_list = pka_list
self.img_type = img_type
self.out_path = out_path
def setup(self):
self.app = QgsApplication([], False)
# Only use this for Mac OS
# [Ref: https://stackoverflow.com/questions/1854/python-what-os-am-i-running-on] # noqa
if platform.system() == 'Darwin':
self.app.setPrefixPath(
'/Applications/QGIS3.app/Contents/MacOS',
True,
)
self.app.initQgis()
def make_maps(self):
self.project = QgsProject.instance()
self.project.setCrs(
QgsCoordinateReferenceSystem(
4326, QgsCoordinateReferenceSystem.EpsgCrsId))
self.add_layer(self.get_map_data(self.data_uri, 'Map Data'))
self.add_layer(self.wards_uri, 'wards', 'ogr')
self.add_layer(self.palika_uri, 'palika_hide',
'ogr') # for hiding other palikas while atlasing
self.add_layer(self.palika_uri, 'palikas', 'ogr')
self.add_layer(self.dists_uri, 'dists', 'ogr')
self.join_lays(parent='wards',
parent_code=self.parent_join_cd,
to_join='data',
to_join_code=self.to_join_code)
self.apply_styling('dists', self.dists_syle)
self.apply_styling('palikas', self.pka_style)
self.apply_styling('palika_hide', self.pka_hide_style)
self.apply_styling('wards', self.ward_style)
self.make_atlas('palikas')
self.write_proj('%s/inprog.qgs' % self.out_path)
self.project.clear()
def add_layer(self, *args):
"""add map layer and check to see if layer properly added.
supports:
data file (single param)
geojson (multiple param)
shp (multiple param)
recieve param: (directory, layer name, type)
note: can also add with QgsProject.instance().addMapLayer() """
nm = None
#check to see if we're sending an already formed layer to add - used for data file
if len(args) == 1 & isinstance(args[0], QgsVectorLayer):
print('Importing {} as a vector'.format(args[0]))
self.project.addMapLayer(args[0])
nm = args[0].name()
elif len(args) > 1:
print('Importing {} as a vector'.format(args[0]))
print(args)
self.project.addMapLayer(QgsVectorLayer(*args))
nm = args[1]
if nm:
self.get_layer(nm)
else:
print()
print('***Bad map layer for {}***'.format(str(args)))
print()
def get_layer(self, nm):
# return layer object based on its given name, not Qs internal identifier
#if the name isn't there, return none
layz = {
v.name(): v
for k, v in self.project.layerStore().mapLayers().items()
}
if nm in layz:
return layz[nm]
else:
raise Exception("%s not in layer listing!" % nm)
def join_lays(self, parent, parent_code, to_join, to_join_code):
joinObject = QgsVectorLayerJoinInfo()
joinObject.setJoinFieldName(to_join_code)
joinObject.setTargetFieldName(parent_code)
joinObject.setJoinLayerId(self.get_layer(to_join).id())
joinObject.setUsingMemoryCache(True)
joinObject.setJoinLayer(self.get_layer(to_join))
self.get_layer(parent).addJoin(joinObject)
def write_proj(self, loc):
self.project.write(loc)
def get_layers(self):
return self.project.layerStore().mapLayers()
def apply_styling(self, lay, style):
print(lay)
print(style)
self.get_layer(lay).loadNamedStyle(style)
def _open_atlas_styling(self):
with open(self.atlas_style, 'r') as templateFile:
self.templateContent = templateFile.read()
self.document = QDomDocument()
self.document.setContent(self.templateContent)
def make_atlas(self, at_lay):
# https: // github.com / carey136 / Standalone - Export - Atlas - QGIS3 / blob / master / AtlasExport.py
self._open_atlas_styling()
self.layout = QgsPrintLayout(self.project)
self.layout.loadFromTemplate(self.document, QgsReadWriteContext(),
True)
self.myLayout = self.layout
self.myAtlas = self.myLayout.atlas()
self.myAtlasMap = self.myAtlas.layout()
#### atlas query ####
self.myAtlas.setCoverageLayer(self.get_layer(at_lay))
self.myAtlas.setEnabled(True)
self.myAtlas.beginRender()
self.myAtlas.setFilterFeatures(True)
assert (isinstance(self.pka_list, list))
#do this for instances where tup len == 1 and there is a trailing comma
tup_rep = str(self.pka_list).replace('[', '(').replace(']', ')')
if self.pka_list:
self.myAtlas.setFilterExpression('"PalikaCode" IN %s' % tup_rep)
#### image output name ####
self.myAtlas.setFilenameExpression('PalikaCode')
print("Creating maps for output format: %s" % self.img_type)
print("Creating maps for for codes: %s" % tup_rep)
#### image and pdf settings ####
pathlib.Path(self.out_path).mkdir(parents=True, exist_ok=True)
if self.img_type == 'svg':
image_settings = QgsLayoutExporter(
self.myAtlasMap).SvgExportSettings()
image_settings.dpi = -1
image_settings.exportMetadata = False
result, error = QgsLayoutExporter.exportToSvg(
self.myAtlas,
baseFilePath=self.out_path,
settings=image_settings)
if not result == QgsLayoutExporter.Success:
print(error)
elif self.img_type == 'png':
image_settings = QgsLayoutExporter(
self.myAtlasMap).ImageExportSettings()
imageExtension = '.png'
result, error = QgsLayoutExporter.exportToImage(
self.myAtlas,
baseFilePath=self.out_path,
extension=imageExtension,
settings=image_settings)
if not result == QgsLayoutExporter.Success:
print(error)
print("Map script completed")
def _get_xls_row_vals(self, row):
"""get all values from an excel row"""
return [v.value for v in row]
def _transform_map_data(self):
"""
take palika | ward 1 ... | ward n layout to palika-# | val
returns a list of tuples
"""
WARD_FMT = '%s-%s'
self.map_data_trans = []
lookup = {
i.column: ''.join(filter(lambda x: x.isdigit(), i.value))
for i in self.sht[1]
}
#skip over header
rs = iter(self.sht.rows)
next(rs)
next(rs)
for r in rs:
pka = r[0].value
for c in r[1:]:
if c.value is None:
c.value = 0
self.map_data_trans.append(
(WARD_FMT % (pka, lookup[c.column]), c.value))
def get_map_data(self, uri, sht_nm):
"""
work around for pulling out Map Data sheet and writing to csv then reading as layer
"""
self.wb = load_workbook(uri, data_only=True)
self.sht = self.wb.get_sheet_by_name(sht_nm)
TMP_DATA = 'tmp_data.csv'
self._transform_map_data()
with open('/tmp/%s' % TMP_DATA, 'w', newline="") as f:
c = csv.writer(f)
c.writerow(('ward', 'value'))
for r in self.map_data_trans:
c.writerow(r)
vl = QgsVectorLayer('/tmp/%s' % TMP_DATA, 'data', 'ogr')
return vl
def exit(self):
self.app.exit()
def testBasic(self):
renderer = QgsPointCloudRgbRenderer()
renderer.setBlueAttribute('b')
self.assertEqual(renderer.blueAttribute(), 'b')
renderer.setGreenAttribute('g')
self.assertEqual(renderer.greenAttribute(), 'g')
renderer.setRedAttribute('r')
self.assertEqual(renderer.redAttribute(), 'r')
redce = QgsContrastEnhancement()
redce.setMinimumValue(100)
redce.setMaximumValue(120)
redce.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchAndClipToMinimumMaximum)
renderer.setRedContrastEnhancement(redce)
greence = QgsContrastEnhancement()
greence.setMinimumValue(130)
greence.setMaximumValue(150)
greence.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.StretchToMinimumMaximum)
renderer.setGreenContrastEnhancement(greence)
bluece = QgsContrastEnhancement()
bluece.setMinimumValue(170)
bluece.setMaximumValue(190)
bluece.setContrastEnhancementAlgorithm(
QgsContrastEnhancement.ClipToMinimumMaximum)
renderer.setBlueContrastEnhancement(bluece)
renderer.setMaximumScreenError(18)
renderer.setMaximumScreenErrorUnit(QgsUnitTypes.RenderInches)
renderer.setPointSize(13)
renderer.setPointSizeUnit(QgsUnitTypes.RenderPoints)
renderer.setPointSizeMapUnitScale(QgsMapUnitScale(1000, 2000))
rr = renderer.clone()
self.assertEqual(rr.maximumScreenError(), 18)
self.assertEqual(rr.maximumScreenErrorUnit(),
QgsUnitTypes.RenderInches)
self.assertEqual(rr.pointSize(), 13)
self.assertEqual(rr.pointSizeUnit(), QgsUnitTypes.RenderPoints)
self.assertEqual(rr.pointSizeMapUnitScale().minScale, 1000)
self.assertEqual(rr.pointSizeMapUnitScale().maxScale, 2000)
self.assertEqual(rr.blueAttribute(), 'b')
self.assertEqual(rr.greenAttribute(), 'g')
self.assertEqual(rr.redAttribute(), 'r')
self.assertEqual(rr.redContrastEnhancement().minimumValue(), 100)
self.assertEqual(rr.redContrastEnhancement().maximumValue(), 120)
self.assertEqual(
rr.redContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.StretchAndClipToMinimumMaximum)
self.assertEqual(rr.greenContrastEnhancement().minimumValue(), 130)
self.assertEqual(rr.greenContrastEnhancement().maximumValue(), 150)
self.assertEqual(
rr.greenContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.StretchToMinimumMaximum)
self.assertEqual(rr.blueContrastEnhancement().minimumValue(), 170)
self.assertEqual(rr.blueContrastEnhancement().maximumValue(), 190)
self.assertEqual(
rr.blueContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.ClipToMinimumMaximum)
doc = QDomDocument("testdoc")
elem = renderer.save(doc, QgsReadWriteContext())
r2 = QgsPointCloudRgbRenderer.create(elem, QgsReadWriteContext())
self.assertEqual(r2.maximumScreenError(), 18)
self.assertEqual(r2.maximumScreenErrorUnit(),
QgsUnitTypes.RenderInches)
self.assertEqual(r2.pointSize(), 13)
self.assertEqual(r2.pointSizeUnit(), QgsUnitTypes.RenderPoints)
self.assertEqual(r2.pointSizeMapUnitScale().minScale, 1000)
self.assertEqual(r2.pointSizeMapUnitScale().maxScale, 2000)
self.assertEqual(r2.blueAttribute(), 'b')
self.assertEqual(r2.greenAttribute(), 'g')
self.assertEqual(r2.redAttribute(), 'r')
self.assertEqual(r2.redContrastEnhancement().minimumValue(), 100)
self.assertEqual(r2.redContrastEnhancement().maximumValue(), 120)
self.assertEqual(
r2.redContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.StretchAndClipToMinimumMaximum)
self.assertEqual(r2.greenContrastEnhancement().minimumValue(), 130)
self.assertEqual(r2.greenContrastEnhancement().maximumValue(), 150)
self.assertEqual(
r2.greenContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.StretchToMinimumMaximum)
self.assertEqual(r2.blueContrastEnhancement().minimumValue(), 170)
self.assertEqual(r2.blueContrastEnhancement().maximumValue(), 190)
self.assertEqual(
r2.blueContrastEnhancement().contrastEnhancementAlgorithm(),
QgsContrastEnhancement.ClipToMinimumMaximum)
QgsProject.instance().removeMapLayer(layer)
iface.mapCanvas().setCrsTransformEnabled(True) # todo QGIS3
iface.mapCanvas().setDestinationCrs(QgsCoordinateReferenceSystem(
2056)) # TODO QGIS3 use QgsProject.instance().setCrs instead
QCoreApplication.processEvents()
# set SRID to 2056
if 'srid' in config_data:
for layer in QgsProject.instance().mapLayers().values():
if layer.hasGeometryType():
layer.setCrs(QgsCoordinateReferenceSystem(int(
config_data['srid'])))
source = layer.source().replace('21781', str(
(config_data['srid'])))
document = QDomDocument("style")
map_layers_element = document.createElement("maplayers")
map_layer_element = document.createElement("maplayer")
layer.writeLayerXml(map_layer_element, document)
# modify DOM element with new layer reference
map_layer_element.firstChildElement(
"datasource").firstChild().setNodeValue(source)
map_layers_element.appendChild(map_layer_element)
document.appendChild(map_layers_element)
# reload layer definition
layer.readLayerXml(map_layer_element)
layer.reload()
# translation
for layer in QgsProject.instance().mapLayers().values():
if layer.id() in tr_data['layers']:
def testAddItemsFromXml(self):
p = QgsProject()
l = QgsLayout(p)
# add some items
item1 = QgsLayoutItemLabel(l)
item1.setId('xxyyxx')
item1.attemptMove(QgsLayoutPoint(4, 8, QgsUnitTypes.LayoutMillimeters))
item1.attemptResize(
QgsLayoutSize(18, 12, QgsUnitTypes.LayoutMillimeters))
l.addItem(item1)
item2 = QgsLayoutItemLabel(l)
item2.setId('zzyyzz')
item2.attemptMove(
QgsLayoutPoint(1.4, 1.8, QgsUnitTypes.LayoutCentimeters))
item2.attemptResize(
QgsLayoutSize(2.8, 2.2, QgsUnitTypes.LayoutCentimeters))
l.addItem(item2)
doc = QDomDocument("testdoc")
# store in xml
elem = l.writeXml(doc, QgsReadWriteContext())
l2 = QgsLayout(p)
new_items = l2.addItemsFromXml(elem, doc, QgsReadWriteContext())
self.assertEqual(len(new_items), 2)
items = l2.items()
self.assertTrue([i for i in items if i.id() == 'xxyyxx'])
self.assertTrue([i for i in items if i.id() == 'zzyyzz'])
self.assertTrue(new_items[0] in l2.items())
self.assertTrue(new_items[1] in l2.items())
new_item1 = [i for i in items if i.id() == 'xxyyxx'][0]
new_item2 = [i for i in items if i.id() == 'zzyyzz'][0]
self.assertEqual(new_item1.positionWithUnits(),
QgsLayoutPoint(4, 8, QgsUnitTypes.LayoutMillimeters))
self.assertEqual(new_item1.sizeWithUnits(),
QgsLayoutSize(18, 12, QgsUnitTypes.LayoutMillimeters))
self.assertEqual(
new_item2.positionWithUnits(),
QgsLayoutPoint(1.4, 1.8, QgsUnitTypes.LayoutCentimeters))
self.assertEqual(
new_item2.sizeWithUnits(),
QgsLayoutSize(2.8, 2.2, QgsUnitTypes.LayoutCentimeters))
# test with a group
group = QgsLayoutItemGroup(l)
group.addItem(item1)
group.addItem(item2)
l.addLayoutItem(group)
elem = l.writeXml(doc, QgsReadWriteContext())
l3 = QgsLayout(p)
new_items = l3.addItemsFromXml(elem, doc, QgsReadWriteContext())
self.assertEqual(len(new_items), 3)
items = l3.items()
self.assertTrue([i for i in items if i.id() == 'xxyyxx'])
self.assertTrue([i for i in items if i.id() == 'zzyyzz'])
self.assertTrue(new_items[0] in l3.items())
self.assertTrue(new_items[1] in l3.items())
self.assertTrue(new_items[2] in l3.items())
# f*** you sip, I'll just manually cast
new_group = sip.cast(l3.itemByUuid(group.uuid()), QgsLayoutItemGroup)
self.assertIsNotNone(new_group)
other_items = [i for i in new_items if i.type() != new_group.type()]
self.assertCountEqual(new_group.items(), other_items)
# test restoring at set position
l3 = QgsLayout(p)
new_items = l3.addItemsFromXml(elem, doc, QgsReadWriteContext(),
QPointF(10, 30))
self.assertEqual(len(new_items), 3)
items = l3.items()
new_item1 = [i for i in items if i.id() == 'xxyyxx'][0]
new_item2 = [i for i in items if i.id() == 'zzyyzz'][0]
self.assertEqual(
new_item1.positionWithUnits(),
QgsLayoutPoint(10, 30, QgsUnitTypes.LayoutMillimeters))
self.assertEqual(new_item1.sizeWithUnits(),
QgsLayoutSize(18, 12, QgsUnitTypes.LayoutMillimeters))
self.assertEqual(
new_item2.positionWithUnits(),
QgsLayoutPoint(2.0, 4.0, QgsUnitTypes.LayoutCentimeters))
self.assertEqual(
new_item2.sizeWithUnits(),
QgsLayoutSize(2.8, 2.2, QgsUnitTypes.LayoutCentimeters))
# paste in place
l4 = QgsLayout(p)
page = QgsLayoutItemPage(l)
page.setPageSize('A3')
l4.pageCollection().addPage(page)
page = QgsLayoutItemPage(l)
page.setPageSize('A6')
l4.pageCollection().addPage(page)
new_items = l4.addItemsFromXml(elem, doc, QgsReadWriteContext(),
QPointF(10, 30), True)
self.assertEqual(len(new_items), 3)
new_item1 = [i for i in new_items if i.id() == 'xxyyxx'][0]
new_item2 = [i for i in new_items if i.id() == 'zzyyzz'][0]
self.assertEqual(new_item1.pagePositionWithUnits(),
QgsLayoutPoint(4, 8, QgsUnitTypes.LayoutMillimeters))
self.assertEqual(new_item1.sizeWithUnits(),
QgsLayoutSize(18, 12, QgsUnitTypes.LayoutMillimeters))
self.assertEqual(new_item1.page(), 0)
self.assertEqual(
new_item2.pagePositionWithUnits(),
QgsLayoutPoint(1.4, 1.8, QgsUnitTypes.LayoutCentimeters))
self.assertEqual(
new_item2.sizeWithUnits(),
QgsLayoutSize(2.8, 2.2, QgsUnitTypes.LayoutCentimeters))
self.assertEqual(new_item2.page(), 0)
# paste in place, page 2
new_items = l4.addItemsFromXml(elem, doc, QgsReadWriteContext(),
QPointF(10, 550), True)
self.assertEqual(len(new_items), 3)
new_item1 = [i for i in new_items if i.id() == 'xxyyxx'][0]
new_item2 = [i for i in new_items if i.id() == 'zzyyzz'][0]
self.assertEqual(new_item1.pagePositionWithUnits(),
QgsLayoutPoint(4, 8, QgsUnitTypes.LayoutMillimeters))
self.assertEqual(new_item1.page(), 1)
self.assertEqual(new_item1.sizeWithUnits(),
QgsLayoutSize(18, 12, QgsUnitTypes.LayoutMillimeters))
self.assertEqual(
new_item2.pagePositionWithUnits(),
QgsLayoutPoint(1.4, 1.8, QgsUnitTypes.LayoutCentimeters))
self.assertEqual(new_item2.page(), 1)
self.assertEqual(
new_item2.sizeWithUnits(),
QgsLayoutSize(2.8, 2.2, QgsUnitTypes.LayoutCentimeters))
def saveStyleFromQgisLayer(layer, server, user, repo):
doc = QDomDocument()
layer.exportNamedStyle(doc,
categories=QgsMapLayer.Symbology
| QgsMapLayer.Labeling)
server.addStyle(user, repo, layer.name(), doc.toString())
def test_read_write_project(self):
"""
Test reading and writing to project document
"""
# fake project document
doc = QDomDocument("test")
doc.appendChild(doc.createElement('qgis'))
original = PlotSettings('test',
properties={
'marker_width': 2,
'marker_size': 5
},
layout={
'title': 'my plot',
'legend_orientation': 'v',
'font_xlabel_color': "#00FFFF"
})
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_FILTER,
QgsProperty.fromExpression('"ap">50'))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_MARKER_SIZE,
QgsProperty.fromExpression('5+6'))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_COLOR, QgsProperty.fromExpression("'red'"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_STROKE_WIDTH,
QgsProperty.fromExpression('12/2'))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_TITLE,
QgsProperty.fromExpression("concat('my', '_title')"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_LEGEND_TITLE,
QgsProperty.fromExpression("concat('my', '_legend')"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_X_TITLE,
QgsProperty.fromExpression("concat('my', '_x_axis')"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_Y_TITLE,
QgsProperty.fromExpression("concat('my', '_y_axis')"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_Z_TITLE,
QgsProperty.fromExpression("concat('my', '_z_axis')"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_X_MIN, QgsProperty.fromExpression("-1*10"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_X_MAX, QgsProperty.fromExpression("+1*10"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_Y_MIN, QgsProperty.fromExpression("-1*10"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_Y_MAX, QgsProperty.fromExpression("+1*10"))
original.write_to_project(doc)
res = PlotSettings('gg')
res.read_from_project(doc)
self.assertEqual(res.plot_type, original.plot_type)
self.assertEqual(res.properties, original.properties)
self.assertEqual(res.layout, original.layout)
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_FILTER),
original.data_defined_properties.property(
PlotSettings.PROPERTY_FILTER))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_MARKER_SIZE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_MARKER_SIZE))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_COLOR),
original.data_defined_properties.property(
PlotSettings.PROPERTY_COLOR))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_STROKE_WIDTH),
original.data_defined_properties.property(
PlotSettings.PROPERTY_STROKE_WIDTH))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_TITLE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_TITLE))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_LEGEND_TITLE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_LEGEND_TITLE))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_X_TITLE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_X_TITLE))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_Y_TITLE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_Y_TITLE))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_Z_TITLE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_Z_TITLE))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_X_MIN),
original.data_defined_properties.property(
PlotSettings.PROPERTY_X_MIN))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_X_MAX),
original.data_defined_properties.property(
PlotSettings.PROPERTY_X_MAX))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_Y_MIN),
original.data_defined_properties.property(
PlotSettings.PROPERTY_Y_MIN))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_Y_MAX),
original.data_defined_properties.property(
PlotSettings.PROPERTY_Y_MAX))
def testLoadWriteRenderingScaleVisibility(self):
"""Test write and load scale visibility, see GH #33840"""
vl = QgsVectorLayer("LineString?crs=epsg:4326", "result", "memory")
vl.setScaleBasedVisibility(True)
vl.setMinimumScale(125.0)
vl.setMaximumScale(1.25)
style = QDomDocument()
style.setContent(
"<!DOCTYPE qgis PUBLIC 'http://mrcc.com/qgis.dtd' 'SYSTEM'><qgis></qgis>"
)
node = style.firstChild()
self.assertTrue(
vl.writeStyle(node, style, "Error writing style",
QgsReadWriteContext(), QgsMapLayer.Rendering))
style_content = style.toString()
del (vl)
# Read
vl2 = QgsVectorLayer("LineString?crs=epsg:4326", "result", "memory")
self.assertFalse(vl2.hasScaleBasedVisibility())
style2 = QDomDocument()
style2.setContent(style_content)
self.assertTrue(
vl2.readStyle(style.namedItem('qgis'), "Error reading style",
QgsReadWriteContext(), QgsMapLayer.Rendering))
self.assertTrue(vl2.hasScaleBasedVisibility())
self.assertEqual(vl2.minimumScale(), 125.0)
self.assertEqual(vl2.maximumScale(), 1.25)
def add_layers_to_canvas_with_custom_orders(order,
impact_function,
iface=None):
"""Helper to add layers to the map canvas following a specific order.
From top to bottom in the legend:
[
('FromCanvas', layer name, full layer URI, QML),
('FromAnalysis', layer purpose, layer group, None),
...
]
The full layer URI is coming from our helper.
:param order: Special structure the list of layers to add.
:type order: list
:param impact_function: The multi exposure impact function used.
:type impact_function: MultiExposureImpactFunction
:param iface: QGIS QgisAppInterface instance.
:type iface: QgisAppInterface
"""
root = QgsProject.instance().layerTreeRoot()
# Make all layers hidden.
for child in root.children():
child.setItemVisibilityChecked(False)
group_analysis = root.insertGroup(0, impact_function.name)
group_analysis.setItemVisibilityChecked(True)
group_analysis.setCustomProperty(MULTI_EXPOSURE_ANALYSIS_FLAG, True)
# Insert layers in the good order in the group.
for layer_definition in order:
if layer_definition[0] == FROM_CANVAS['key']:
style = QDomDocument()
style.setContent(layer_definition[3])
layer = load_layer(layer_definition[2], layer_definition[1])[0]
layer.importNamedStyle(style)
QgsProject.instance().addMapLayer(layer, False)
layer_node = group_analysis.addLayer(layer)
layer_node.setItemVisibilityChecked(True)
else:
if layer_definition[2] == impact_function.name:
for layer in impact_function.outputs:
if layer.keywords['layer_purpose'] == layer_definition[1]:
QgsProject.instance().addMapLayer(layer, False)
layer_node = group_analysis.addLayer(layer)
layer_node.setItemVisibilityChecked(True)
try:
title = layer.keywords['title']
if qgis_version() >= 21800:
layer.setName(title)
else:
layer.setLayerName(title)
except KeyError:
pass
break
else:
for sub_impact_function in impact_function.impact_functions:
# Iterate over each sub impact function used in the
# multi exposure analysis.
if sub_impact_function.name == layer_definition[2]:
for layer in sub_impact_function.outputs:
purpose = layer_definition[1]
if layer.keywords['layer_purpose'] == purpose:
QgsProject.instance().addMapLayer(layer, False)
layer_node = group_analysis.addLayer(layer)
layer_node.setItemVisibilityChecked(True)
try:
title = layer.keywords['title']
if qgis_version() >= 21800:
layer.setName(title)
else:
layer.setLayerName(title)
except KeyError:
pass
break
if iface:
iface.setActiveLayer(impact_function.analysis_impacted)
def copyLayerViaXmlReadWrite(self, source, dest):
# write to xml
doc = QDomDocument("testdoc")
elem = doc.createElement("maplayer")
self.assertTrue(source.writeLayerXml(elem, doc, QgsReadWriteContext()))
self.assertTrue(dest.readLayerXml(elem, QgsReadWriteContext()), QgsProject.instance())
def testWriteReadXmlSingleVariant(self):
# setup a context
context = QgsCoordinateTransformContext()
self.assertTrue(
context.addSourceDatumTransform(
QgsCoordinateReferenceSystem('EPSG:3111'), 1))
self.assertTrue(
context.addSourceDatumTransform(
QgsCoordinateReferenceSystem('EPSG:28356'), 2))
self.assertTrue(
context.addDestinationDatumTransform(
QgsCoordinateReferenceSystem('EPSG:3113'), 11))
self.assertTrue(
context.addDestinationDatumTransform(
QgsCoordinateReferenceSystem('EPSG:28355'), 12))
self.assertTrue(
context.addSourceDestinationDatumTransform(
QgsCoordinateReferenceSystem('EPSG:3111'),
QgsCoordinateReferenceSystem('EPSG:4283'), 1, 2))
self.assertTrue(
context.addSourceDestinationDatumTransform(
QgsCoordinateReferenceSystem('EPSG:28356'),
QgsCoordinateReferenceSystem(4283), 3, 4))
self.assertEqual(context.sourceDatumTransforms(), {
'EPSG:3111': 1,
'EPSG:28356': 2
})
self.assertEqual(context.destinationDatumTransforms(), {
'EPSG:3113': 11,
'EPSG:28355': 12
})
self.assertEqual(
context.sourceDestinationDatumTransforms(), {
('EPSG:3111', 'EPSG:4283'): (1, 2),
('EPSG:28356', 'EPSG:4283'): (3, 4)
})
# save to xml
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
context.writeXml(elem, QgsReadWriteContext())
# restore from xml
context2 = QgsCoordinateTransformContext()
context2.readXml(elem, QgsReadWriteContext())
# check result
self.assertEqual(context2.sourceDatumTransforms(), {
'EPSG:3111': 1,
'EPSG:28356': 2
})
self.assertEqual(context2.destinationDatumTransforms(), {
'EPSG:3113': 11,
'EPSG:28355': 12
})
self.assertEqual(
context2.sourceDestinationDatumTransforms(), {
('EPSG:3111', 'EPSG:4283'): (1, 2),
('EPSG:28356', 'EPSG:4283'): (3, 4)
})
def test_settings(self):
settings = QgsColorRampLegendNodeSettings()
settings.setDirection(QgsColorRampLegendNodeSettings.MaximumToMinimum)
self.assertEqual(settings.direction(),
QgsColorRampLegendNodeSettings.MaximumToMinimum)
settings.setMinimumLabel('min')
self.assertEqual(settings.minimumLabel(), 'min')
settings.setMaximumLabel('max')
self.assertEqual(settings.maximumLabel(), 'max')
settings.setPrefix('pref')
self.assertEqual(settings.prefix(), 'pref')
settings.setSuffix('suff')
self.assertEqual(settings.suffix(), 'suff')
self.assertEqual(settings.orientation(), Qt.Vertical)
settings.setOrientation(Qt.Horizontal)
self.assertEqual(settings.orientation(), Qt.Horizontal)
# Test default
self.assertTrue(settings.useContinuousLegend())
settings.setUseContinuousLegend(False)
self.assertFalse(settings.useContinuousLegend())
self.assertFalse(settings.textFormat().isValid())
tf = QgsTextFormat()
tf.setSize(13)
settings.setTextFormat(tf)
self.assertEqual(settings.textFormat().size(), 13)
self.assertIsNotNone(settings.numericFormat())
settings.setNumericFormat(QgsBearingNumericFormat())
self.assertIsInstance(settings.numericFormat(),
QgsBearingNumericFormat)
settings2 = QgsColorRampLegendNodeSettings(settings)
self.assertEqual(settings2.direction(),
QgsColorRampLegendNodeSettings.MaximumToMinimum)
self.assertEqual(settings2.minimumLabel(), 'min')
self.assertEqual(settings2.maximumLabel(), 'max')
self.assertIsInstance(settings2.numericFormat(),
QgsBearingNumericFormat)
self.assertEqual(settings2.prefix(), 'pref')
self.assertEqual(settings2.suffix(), 'suff')
self.assertEqual(settings2.textFormat().size(), 13)
self.assertEqual(settings2.orientation(), Qt.Horizontal)
settings2.setTextFormat(QgsTextFormat())
settings2a = QgsColorRampLegendNodeSettings(settings2)
self.assertFalse(settings2a.textFormat().isValid())
doc = QDomDocument("testdoc")
elem = doc.createElement('test')
settings.writeXml(doc, elem, QgsReadWriteContext())
settings3 = QgsColorRampLegendNodeSettings()
settings3.readXml(elem, QgsReadWriteContext())
self.assertEqual(settings3.direction(),
QgsColorRampLegendNodeSettings.MaximumToMinimum)
self.assertEqual(settings3.minimumLabel(), 'min')
self.assertEqual(settings3.maximumLabel(), 'max')
self.assertIsInstance(settings3.numericFormat(),
QgsBearingNumericFormat)
self.assertEqual(settings3.prefix(), 'pref')
self.assertEqual(settings3.suffix(), 'suff')
self.assertEqual(settings3.textFormat().size(), 13)
self.assertEqual(settings3.orientation(), Qt.Horizontal)
self.assertFalse(settings3.useContinuousLegend())
# no text format
elem = doc.createElement('test2')
settings2.writeXml(doc, elem, QgsReadWriteContext())
settings3a = QgsColorRampLegendNodeSettings()
settings3a.readXml(elem, QgsReadWriteContext())
self.assertFalse(settings3a.textFormat().isValid())
def test_getcapabilities(self):
project = self._project_path
assert os.path.exists(project), "Project file not found: " + project
# without cache
query_string = '?MAP=%s&SERVICE=WMS&VERSION=1.3.0&REQUEST=%s' % (urllib.parse.quote(project), 'GetCapabilities')
header, body = self._execute_request(query_string)
doc = QDomDocument("wms_getcapabilities_130.xml")
doc.setContent(body)
# with cache
header, body = self._execute_request(query_string)
# without cache
query_string = '?MAP=%s&SERVICE=WMS&VERSION=1.1.1&REQUEST=%s' % (urllib.parse.quote(project), 'GetCapabilities')
header, body = self._execute_request(query_string)
# with cache
header, body = self._execute_request(query_string)
# without cache
query_string = '?MAP=%s&SERVICE=WFS&VERSION=1.1.0&REQUEST=%s' % (urllib.parse.quote(project), 'GetCapabilities')
header, body = self._execute_request(query_string)
# with cache
header, body = self._execute_request(query_string)
# without cache
query_string = '?MAP=%s&SERVICE=WFS&VERSION=1.0.0&REQUEST=%s' % (urllib.parse.quote(project), 'GetCapabilities')
header, body = self._execute_request(query_string)
# with cache
header, body = self._execute_request(query_string)
# without cache
query_string = '?MAP=%s&SERVICE=WCS&VERSION=1.0.0&REQUEST=%s' % (urllib.parse.quote(project), 'GetCapabilities')
header, body = self._execute_request(query_string)
# with cache
header, body = self._execute_request(query_string)
# without cache
query_string = '?MAP=%s&SERVICE=WMTS&VERSION=1.0.0&REQUEST=%s' % (urllib.parse.quote(project), 'GetCapabilities')
header, body = self._execute_request(query_string)
# with cache
header, body = self._execute_request(query_string)
filelist = [f for f in os.listdir(self._servercache._cache_dir) if f.endswith(".xml")]
self.assertEqual(len(filelist), 6, 'Not enough file in cache')
cacheManager = self._server_iface.cacheManager()
self.assertTrue(cacheManager.deleteCachedDocuments(None), 'deleteCachedDocuments does not return True')
filelist = [f for f in os.listdir(self._servercache._cache_dir) if f.endswith(".xml")]
self.assertEqual(len(filelist), 0, 'All files in cache are not deleted ')
prj = QgsProject()
prj.read(project)
query_string = '?MAP=%s&SERVICE=WMS&VERSION=1.3.0&REQUEST=%s' % (urllib.parse.quote(project), 'GetCapabilities')
request = QgsBufferServerRequest(query_string, QgsServerRequest.GetMethod, {}, None)
accessControls = self._server_iface.accessControls()
cDoc = QDomDocument("wms_getcapabilities_130.xml")
self.assertFalse(cacheManager.getCachedDocument(cDoc, prj, request, accessControls), 'getCachedDocument is not None')
self.assertTrue(cacheManager.setCachedDocument(doc, prj, request, accessControls), 'setCachedDocument false')
self.assertTrue(cacheManager.getCachedDocument(cDoc, prj, request, accessControls), 'getCachedDocument is None')
self.assertEqual(doc.documentElement().tagName(), cDoc.documentElement().tagName(), 'cachedDocument not equal to provide document')
self.assertTrue(cacheManager.deleteCachedDocuments(None), 'deleteCachedDocuments does not return True')
def _open_atlas_styling(self):
with open(self.atlas_style, 'r') as templateFile:
self.templateContent = templateFile.read()
self.document = QDomDocument()
self.document.setContent(self.templateContent)
df.fillna(0, inplace=True)
for lc in region.keys():
if lc in lc_labels:
df.iloc[:, 0][lc] = float(region[lc])
report_tables[region["regionId"]] = df
for region in data["values_as_percentchange"]:
if region["yyyy"] == str(period):
df = report_tables[region["regionId"]]
for lc in region.keys():
if lc in lc_labels:
df.iloc[:, 1][lc] = float(region[lc])
# Load the report template
with open(template_file) as tf:
template_content = tf.read()
template_document = QDomDocument()
template_document.setContent(template_content)
map_settings = iface.mapCanvas().mapSettings()
composition = QgsComposition(map_settings)
composition.loadFromTemplate(template_document)
# Set up atlas to produce one report per region
vector_layer = dataobjects.getObjectFromUri(vector)
atlas = composition.atlasComposition()
atlas.setCoverageLayer(vector_layer)
atlas.setEnabled(True)
composition.setAtlasMode(QgsComposition.ExportAtlas)
atlas_map = composition.getComposerItemById("atlas_map")
atlas_map.setAtlasDriven(True)
atlas_map.setLayerSet([vector_layer.id(), raster_layer.id()])
def test_readwrite(self):
"""
Test reading and writing plot settings from XML
"""
doc = QDomDocument("properties")
original = PlotSettings('test',
properties={
'marker_width': 2,
'marker_size': 5
},
layout={
'title': 'my plot',
'legend_orientation': 'v'
})
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_FILTER,
QgsProperty.fromExpression('"ap">50'))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_MARKER_SIZE,
QgsProperty.fromExpression('5+6'))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_COLOR, QgsProperty.fromExpression("'red'"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_STROKE_WIDTH,
QgsProperty.fromExpression('12/2'))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_TITLE,
QgsProperty.fromExpression("concat('my', '_title')"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_LEGEND_TITLE,
QgsProperty.fromExpression("concat('my', '_legend')"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_X_TITLE,
QgsProperty.fromExpression("concat('my', '_x_axis')"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_Y_TITLE,
QgsProperty.fromExpression("concat('my', '_y_axis')"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_Z_TITLE,
QgsProperty.fromExpression("concat('my', '_z_axis')"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_X_MIN, QgsProperty.fromExpression("-1*10"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_X_MAX, QgsProperty.fromExpression("+1*10"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_Y_MIN, QgsProperty.fromExpression("-1*10"))
original.data_defined_properties.setProperty(
PlotSettings.PROPERTY_Y_MAX, QgsProperty.fromExpression("+1*10"))
elem = original.write_xml(doc)
self.assertFalse(elem.isNull())
res = PlotSettings('gg')
# test reading a bad element
bad_elem = QDomElement()
self.assertFalse(res.read_xml(bad_elem))
self.assertTrue(res.read_xml(elem))
self.assertEqual(res.plot_type, original.plot_type)
self.assertEqual(res.properties, original.properties)
self.assertEqual(res.layout, original.layout)
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_FILTER),
original.data_defined_properties.property(
PlotSettings.PROPERTY_FILTER))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_MARKER_SIZE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_MARKER_SIZE))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_COLOR),
original.data_defined_properties.property(
PlotSettings.PROPERTY_COLOR))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_STROKE_WIDTH),
original.data_defined_properties.property(
PlotSettings.PROPERTY_STROKE_WIDTH))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_TITLE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_TITLE))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_LEGEND_TITLE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_LEGEND_TITLE))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_X_TITLE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_X_TITLE))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_Y_TITLE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_Y_TITLE))
self.assertEqual(
res.data_defined_properties.property(
PlotSettings.PROPERTY_Z_TITLE),
original.data_defined_properties.property(
PlotSettings.PROPERTY_Z_TITLE))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_X_MIN),
original.data_defined_properties.property(
PlotSettings.PROPERTY_X_MIN))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_X_MAX),
original.data_defined_properties.property(
PlotSettings.PROPERTY_X_MAX))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_Y_MIN),
original.data_defined_properties.property(
PlotSettings.PROPERTY_Y_MIN))
self.assertEqual(
res.data_defined_properties.property(PlotSettings.PROPERTY_Y_MAX),
original.data_defined_properties.property(
PlotSettings.PROPERTY_Y_MAX))
def symbolToSld(self, symbolLayer):
dom = QDomDocument()
root = dom.createElement("FakeRoot")
dom.appendChild(root)
symbolLayer.toSld(dom, root, {})
return dom, root
def testSaveLoadTemplate(self):
tmpfile = os.path.join(self.basetestpath, 'testTemplate.qpt')
p = QgsProject()
l = QgsLayout(p)
l.initializeDefaults()
# add some items
item1 = QgsLayoutItemLabel(l)
item1.setId('xxyyxx')
item1.attemptMove(QgsLayoutPoint(4, 8, QgsUnitTypes.LayoutMillimeters))
item1.attemptResize(
QgsLayoutSize(18, 12, QgsUnitTypes.LayoutMillimeters))
l.addItem(item1)
item2 = QgsLayoutItemLabel(l)
item2.setId('zzyyzz')
item2.attemptMove(
QgsLayoutPoint(1.4, 1.8, QgsUnitTypes.LayoutCentimeters))
item2.attemptResize(
QgsLayoutSize(2.8, 2.2, QgsUnitTypes.LayoutCentimeters))
l.addItem(item2)
uuids = {item1.uuid(), item2.uuid()}
original_uuids = {item1.uuid(), item2.uuid()}
self.assertTrue(l.saveAsTemplate(tmpfile, QgsReadWriteContext()))
l2 = QgsLayout(p)
with open(tmpfile) as f:
template_content = f.read()
doc = QDomDocument()
doc.setContent(template_content)
# adding to existing items
new_items, ok = l2.loadFromTemplate(doc, QgsReadWriteContext(), False)
self.assertTrue(ok)
self.assertEqual(len(new_items), 2)
items = l2.items()
self.assertTrue([i for i in items if i.id() == 'xxyyxx'])
self.assertTrue([i for i in items if i.id() == 'zzyyzz'])
self.assertTrue(new_items[0] in l2.items())
self.assertTrue(new_items[1] in l2.items())
# double check that new items have a unique uid
self.assertNotIn(new_items[0].uuid(), uuids)
self.assertIn(new_items[0].templateUuid(), original_uuids)
uuids.add(new_items[0].uuid())
self.assertNotIn(new_items[1].uuid(), uuids)
self.assertIn(new_items[1].templateUuid(), original_uuids)
uuids.add(new_items[1].uuid())
# adding to existing items
new_items2, ok = l2.loadFromTemplate(doc, QgsReadWriteContext(), False)
self.assertTrue(ok)
self.assertEqual(len(new_items2), 2)
items = l2.items()
self.assertEqual(len(items), 4)
self.assertTrue([i for i in items if i.id() == 'xxyyxx'])
self.assertTrue([i for i in items if i.id() == 'zzyyzz'])
self.assertTrue(new_items[0] in l2.items())
self.assertTrue(new_items[1] in l2.items())
self.assertTrue(new_items2[0] in l2.items())
self.assertTrue(new_items2[1] in l2.items())
self.assertNotIn(new_items2[0].uuid(), uuids)
self.assertIn(new_items2[0].templateUuid(), original_uuids)
uuids.add(new_items[0].uuid())
self.assertNotIn(new_items2[1].uuid(), uuids)
self.assertIn(new_items2[1].templateUuid(), original_uuids)
uuids.add(new_items[1].uuid())
# clearing existing items
new_items3, ok = l2.loadFromTemplate(doc, QgsReadWriteContext(), True)
self.assertTrue(ok)
self.assertEqual(len(new_items3), 3) # includes page
items = l2.items()
self.assertTrue([
i for i in items
if isinstance(i, QgsLayoutItem) and i.id() == 'xxyyxx'
])
self.assertTrue([
i for i in items
if isinstance(i, QgsLayoutItem) and i.id() == 'zzyyzz'
])
self.assertTrue(new_items3[0] in l2.items())
self.assertTrue(new_items3[1] in l2.items())
self.assertIn(new_items3[0].templateUuid(), original_uuids)
self.assertIn(new_items3[1].templateUuid(), original_uuids)
self.assertEqual(l2.itemByUuid(new_items3[0].templateUuid(), True),
new_items3[0])
self.assertEqual(l2.itemByUuid(new_items3[1].templateUuid(), True),
new_items3[1])
def testQgsGraduatedSymbolRenderer_2(self):
"""Test QgsGraduatedSymbolRenderer: Adding /removing/editing classes """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
symbol.setColor(QColor(255, 0, 0))
# Add class without start and end ranges
renderer.addClass(symbol.clone())
renderer.addClass(symbol.clone())
renderer.updateRangeLabel(1, 'Second range')
renderer.updateRangeLowerValue(1, 10.0)
renderer.updateRangeUpperValue(1, 25.0)
renderer.updateRangeRenderState(1, False)
symbol.setColor(QColor(0, 0, 255))
renderer.updateRangeSymbol(1, symbol.clone())
# Add as a rangeobject
symbol.setColor(QColor(0, 255, 0))
range = QgsRendererRange(20.0, 25.5, symbol.clone(), 'Third range',
False)
renderer.addClassRange(range)
# Add class by lower and upper
renderer.addClassLowerUpper(25.5, 30.5)
# (Update label for sorting tests)
renderer.updateRangeLabel(3, 'Another range')
self.assertEqual(
dumpRangeLabels(renderer.ranges()),
'(0.0 - 0.0,Second range,Third range,Another range,)',
'Added ranges labels not correct')
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)',
'Added ranges lower/upper values not correct')
# Check that clone function works
renderer2 = renderer.clone()
self.assertEqual(dumpGraduatedRenderer(renderer),
dumpGraduatedRenderer(renderer2),
"clone function doesn't replicate renderer properly")
# Check save and reload from Dom works
doc = QDomDocument()
element = renderer.save(doc, QgsReadWriteContext())
renderer2 = QgsGraduatedSymbolRenderer.create(element,
QgsReadWriteContext())
self.assertEqual(
dumpGraduatedRenderer(renderer), dumpGraduatedRenderer(renderer2),
"Save/create from DOM doesn't replicate renderer properly")
# Check sorting
renderer.sortByLabel()
self.assertEqual(
dumpRangeList(renderer.ranges(), labelsOnly=True),
'(0.0 - 0.0,Another range,Second range,Third range,)',
'sortByLabel not correct')
renderer.sortByValue()
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)',
'sortByValue not correct')
renderer.sortByValue(Qt.DescendingOrder)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(25.5000-30.5000,20.0000-25.5000,10.0000-25.0000,0.0000-0.0000,)',
'sortByValue descending not correct')
# Check deleting
renderer.deleteClass(2)
self.assertEqual(dumpRangeBreaks(renderer.ranges()),
'(25.5000-30.5000,20.0000-25.5000,0.0000-0.0000,)',
'deleteClass not correct')
renderer.deleteAllClasses()
self.assertEqual(len(renderer.ranges()), 0,
"deleteAllClasses didn't delete all")
def parse_xml(self):
"""Parse the xml file. Returns false if there is failure."""
xml_file = QFile(self._xml_path)
if not xml_file.open(QIODevice.ReadOnly):
return False
document = QDomDocument()
if not document.setContent(xml_file):
return False
xml_file.close()
document_element = document.documentElement()
if document_element.tagName() != "qgis_style":
return False
# Get all the symbols
self._symbols = []
symbols_element = document_element.firstChildElement("symbols")
symbol_element = symbols_element.firstChildElement()
context = QgsReadWriteContext()
context.setPathResolver(QgsProject.instance().pathResolver())
while not symbol_element.isNull():
if symbol_element.tagName() == "symbol":
symbol = QgsSymbolLayerUtils.loadSymbol(
symbol_element, context)
if symbol:
self._symbols.append({
"name":
symbol_element.attribute("name"),
"symbol":
symbol
})
symbol_element = symbol_element.nextSiblingElement()
# Get all the colorramps
self._colorramps = []
ramps_element = document_element.firstChildElement("colorramps")
ramp_element = ramps_element.firstChildElement()
while not ramp_element.isNull():
if ramp_element.tagName() == "colorramp":
colorramp = QgsSymbolLayerUtils.loadColorRamp(ramp_element)
if colorramp:
self._colorramps.append({
"name":
ramp_element.attribute("name"),
"colorramp":
colorramp
})
ramp_element = ramp_element.nextSiblingElement()
# Get all the TextFormats - textformats - textformat
self._textformats = []
textformats_element = document_element.firstChildElement("textformats")
textformat_element = textformats_element.firstChildElement()
while not textformat_element.isNull():
if textformat_element.tagName() == "textformat":
textformat = QgsTextFormat()
textformat.readXml(textformat_element, QgsReadWriteContext())
if textformat:
self._textformats.append({
"name":
textformat_element.attribute("name"),
"textformat":
textformat,
})
textformat_element = textformat_element.nextSiblingElement()
# Get all the LabelSettings - labelsettings - labelsetting -
# QgsPalLayerSettings.readXML?
self._labelsettings = []
labels_element = document_element.firstChildElement("labelsettings")
label_element = labels_element.firstChildElement()
while not label_element.isNull():
if label_element.tagName() == "labelsetting":
labelsettings = QgsPalLayerSettings()
labelsettings.readXml(label_element, QgsReadWriteContext())
if labelsettings:
self._labelsettings.append({
"name":
label_element.attribute("name"),
"labelsettings":
labelsettings,
})
label_element = label_element.nextSiblingElement()
return True
def testBlockingItems(self):
"""
Test rendering map item with blocking items
"""
format = QgsTextFormat()
format.setFont(QgsFontUtils.getStandardTestFont("Bold"))
format.setSize(20)
format.setNamedStyle("Bold")
format.setColor(QColor(0, 0, 0))
settings = QgsPalLayerSettings()
settings.setFormat(format)
settings.fieldName = "'X'"
settings.isExpression = True
settings.placement = QgsPalLayerSettings.OverPoint
vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl",
"memory")
vl.setRenderer(QgsNullSymbolRenderer())
f = QgsFeature(vl.fields(), 1)
for x in range(15):
for y in range(15):
f.setGeometry(QgsPoint(x, y))
vl.dataProvider().addFeature(f)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
vl.setLabelsEnabled(True)
p = QgsProject()
engine_settings = QgsLabelingEngineSettings()
engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly,
True)
p.setLabelingEngineSettings(engine_settings)
p.addMapLayer(vl)
layout = QgsLayout(p)
layout.initializeDefaults()
p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
map = QgsLayoutItemMap(layout)
map.attemptSetSceneRect(QRectF(10, 10, 180, 180))
map.setFrameEnabled(True)
map.zoomToExtent(vl.extent())
map.setLayers([vl])
map.setId('map')
layout.addLayoutItem(map)
map2 = QgsLayoutItemMap(layout)
map2.attemptSetSceneRect(QRectF(0, 5, 50, 80))
map2.setFrameEnabled(True)
map2.setBackgroundEnabled(False)
map2.setId('map2')
layout.addLayoutItem(map2)
map3 = QgsLayoutItemMap(layout)
map3.attemptSetSceneRect(QRectF(150, 160, 50, 50))
map3.setFrameEnabled(True)
map3.setBackgroundEnabled(False)
map3.setId('map3')
layout.addLayoutItem(map3)
map.addLabelBlockingItem(map2)
map.addLabelBlockingItem(map3)
map.setMapFlags(QgsLayoutItemMap.MapItemFlags())
checker = QgsLayoutChecker('composermap_label_blockers', layout)
checker.setControlPathPrefix("composer_map")
result, message = checker.testLayout()
self.report += checker.report()
self.assertTrue(result, message)
doc = QDomDocument("testdoc")
elem = layout.writeXml(doc, QgsReadWriteContext())
l2 = QgsLayout(p)
self.assertTrue(l2.readXml(elem, doc, QgsReadWriteContext()))
map_restore = [
i for i in l2.items()
if isinstance(i, QgsLayoutItemMap) and i.id() == 'map'
][0]
map2_restore = [
i for i in l2.items()
if isinstance(i, QgsLayoutItemMap) and i.id() == 'map2'
][0]
map3_restore = [
i for i in l2.items()
if isinstance(i, QgsLayoutItemMap) and i.id() == 'map3'
][0]
self.assertTrue(map_restore.isLabelBlockingItem(map2_restore))
self.assertTrue(map_restore.isLabelBlockingItem(map3_restore))
def testClone(self):
myPath = os.path.join(unitTestDataPath('raster'),
'band1_float32_noct_epsg4326.tif')
myFileInfo = QFileInfo(myPath)
myBaseName = myFileInfo.baseName()
layer = QgsRasterLayer(myPath, myBaseName)
renderer = layer.renderer().clone()
renderer.setOpacity(33.3)
layer.setRenderer(renderer)
# clone layer
clone = layer.clone()
# generate xml from layer
layer_doc = QDomDocument("doc")
layer_elem = layer_doc.createElement("maplayer")
layer.writeLayerXml(layer_elem, layer_doc, QgsReadWriteContext())
# generate xml from clone
clone_doc = QDomDocument("doc")
clone_elem = clone_doc.createElement("maplayer")
clone.writeLayerXml(clone_elem, clone_doc, QgsReadWriteContext())
# replace id within xml of clone
clone_id_elem = clone_elem.firstChildElement("id")
clone_id_elem_patch = clone_doc.createElement("id")
clone_id_elem_patch_value = clone_doc.createTextNode(layer.id())
clone_id_elem_patch.appendChild(clone_id_elem_patch_value)
clone_elem.replaceChild(clone_id_elem_patch, clone_id_elem)
# update doc
clone_doc.appendChild(clone_elem)
layer_doc.appendChild(layer_elem)
# compare xml documents
self.assertEqual(layer_doc.toString(), clone_doc.toString())
class UiInspector:
def __init__(self):
self.ui_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), '../src/ui/*.ui'))
self.printMsg("Loading UI files " + self.ui_dir)
# list of widget classes we want to follow
self.follow = [
QWidget,
QDialog,
QCheckBox,
QComboBox,
QDial,
QPushButton,
QLabel,
QLCDNumber,
QLineEdit,
QRadioButton,
QScrollBar,
QSlider,
QSpinBox,
QTextEdit,
QDateEdit,
QTimeEdit,
QDateTimeEdit,
QListView,
QProgressBar,
QTableView,
QTabWidget,
QTextBrowser,
QDialogButtonBox,
QScrollArea,
QGroupBox,
QStackedWidget,
]
def printMsg(self, msg):
sys.stderr.write(msg + "\n")
def widgetXml(self, element, widget, level=0, label=None):
#print tostring ( element )
#self.printMsg ( "class: " + str( type ( widget ) ) )
#self.printMsg ( "objectName: " + widget.objectName() )
#self.printMsg ( "windowTitle: " + widget.windowTitle() )
if not widget.objectName():
return
lab = label
if hasattr(widget, 'text'):
lab = widget.text()
if widget.windowTitle():
label = widget.windowTitle()
if not lab:
lab = ''
subElement = self.doc.createElement('widget')
subElement.setAttribute('class', widget.__class__.__name__)
subElement.setAttribute('objectName', widget.objectName())
subElement.setAttribute('label', lab)
element.appendChild(subElement)
#print str ( widget.children () )
# tab widget label is stored in QTabWidget->QTabBarPrivate->tabList->QTab ..
if type(widget) in [QTabWidget]:
children = list({
'widget': widget.widget(i),
'label': widget.tabText(i)
} for i in range(0, widget.count()))
else:
children = list({
'widget': c,
'label': None
} for c in widget.children())
for child in children:
w = child['widget']
if w.isWidgetType() and (type(w) in self.follow):
self.widgetXml(subElement, w, level + 1, child['label'])
def xml(self):
self.doc = QDomDocument()
element = self.doc.createElement("qgiswidgets")
self.doc.appendChild(element)
for p in glob.glob(self.ui_dir):
self.printMsg("Loading " + p)
# qgsrasterlayerpropertiesbase.ui is giving: No module named qwt_plot
try:
widget = loadUi(p)
#print dir ( ui )
self.widgetXml(element, widget)
except Exception, e:
#except IOError, e:
self.printMsg(str(e))
return self.doc.toString(2)
def test_read_write_project_with_layout(self):
"""
Test saving/restoring dialog state of layout plot in project
"""
# print('read write project with layout test')
# create project and layout
project = QgsProject.instance()
layout = QgsPrintLayout(project)
layout_name = "PrintLayoutReadWrite"
layout.initializeDefaults()
layout.setName(layout_name)
layout_plot = PlotLayoutItem(layout)
layout_plot.setId('plot_item')
plot_item_id = layout_plot.id()
self.assertEqual(len(layout_plot.plot_settings), 1)
# self.assertEqual(len(layout.items()), 0)
layout.addLayoutItem(layout_plot)
# self.assertEqual(len(layout.items()), 1)
plot_dialog = PlotLayoutItemWidget(None, layout_plot)
# add second plot
plot_dialog.add_plot()
self.assertEqual(len(layout_plot.plot_settings), 2)
# edit first plot
plot_dialog.setDockMode(True)
plot_dialog.show_properties()
plot_property_panel = plot_dialog.panel
plot_property_panel.set_plot_type('violin')
self.assertEqual(plot_property_panel.ptype, 'violin')
plot_property_panel.acceptPanel()
plot_property_panel.destroy()
# edit second plot
plot_dialog.plot_list.setCurrentRow(1)
plot_dialog.show_properties()
plot_property_panel = plot_dialog.panel
plot_property_panel.set_plot_type('bar')
self.assertEqual(plot_property_panel.ptype, 'bar')
plot_property_panel.acceptPanel()
plot_property_panel.destroy()
# write xml
xml_doc = QDomDocument('layout')
element = layout.writeXml(xml_doc, QgsReadWriteContext())
layout_plot.remove_plot(0)
self.assertEqual(len(layout_plot.plot_settings), 1)
self.assertEqual(layout_plot.plot_settings[0].plot_type, 'bar')
layout_plot.remove_plot(0)
self.assertEqual(len(layout_plot.plot_settings), 0)
# read xml
layout2 = QgsPrintLayout(project)
self.assertTrue(layout2.readXml(element, xml_doc, QgsReadWriteContext()))
layout_plot2 = layout2.itemById(plot_item_id)
self.assertTrue(layout_plot2)
self.assertEqual(len(layout_plot2.plot_settings), 2)
self.assertEqual(layout_plot2.plot_settings[0].plot_type, 'violin')
self.assertEqual(layout_plot2.plot_settings[1].plot_type, 'bar')
def testPaletted(self):
""" test paletted raster renderer with raster with color table"""
path = os.path.join(unitTestDataPath('raster'), 'with_color_table.tif')
info = QFileInfo(path)
base_name = info.baseName()
layer = QgsRasterLayer(path, base_name)
self.assertTrue(layer.isValid(), 'Raster not loaded: {}'.format(path))
renderer = QgsPalettedRasterRenderer(layer.dataProvider(), 1, [
QgsPalettedRasterRenderer.Class(1, QColor(0, 255, 0), 'class 2'),
QgsPalettedRasterRenderer.Class(3, QColor(255, 0, 0), 'class 1')
])
self.assertEqual(renderer.nColors(), 2)
self.assertEqual(renderer.usesBands(), [1])
# test labels
self.assertEqual(renderer.label(1), 'class 2')
self.assertEqual(renderer.label(3), 'class 1')
self.assertFalse(renderer.label(101))
# test legend symbology - should be sorted by value
legend = renderer.legendSymbologyItems()
self.assertEqual(legend[0][0], 'class 2')
self.assertEqual(legend[1][0], 'class 1')
self.assertEqual(legend[0][1].name(), '#00ff00')
self.assertEqual(legend[1][1].name(), '#ff0000')
# test retrieving classes
classes = renderer.classes()
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'class 1')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
# test set label
# bad index
renderer.setLabel(1212, 'bad')
renderer.setLabel(3, 'new class')
self.assertEqual(renderer.label(3), 'new class')
# color ramp
r = QgsLimitedRandomColorRamp(5)
renderer.setSourceColorRamp(r)
self.assertEqual(renderer.sourceColorRamp().type(), 'random')
self.assertEqual(renderer.sourceColorRamp().count(), 5)
# clone
new_renderer = renderer.clone()
classes = new_renderer.classes()
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'new class')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
self.assertEqual(new_renderer.sourceColorRamp().type(), 'random')
self.assertEqual(new_renderer.sourceColorRamp().count(), 5)
# write to xml and read
doc = QDomDocument('testdoc')
elem = doc.createElement('qgis')
renderer.writeXml(doc, elem)
restored = QgsPalettedRasterRenderer.create(
elem.firstChild().toElement(), layer.dataProvider())
self.assertTrue(restored)
self.assertEqual(restored.usesBands(), [1])
classes = restored.classes()
self.assertTrue(classes)
self.assertEqual(classes[0].value, 1)
self.assertEqual(classes[1].value, 3)
self.assertEqual(classes[0].label, 'class 2')
self.assertEqual(classes[1].label, 'new class')
self.assertEqual(classes[0].color.name(), '#00ff00')
self.assertEqual(classes[1].color.name(), '#ff0000')
self.assertEqual(restored.sourceColorRamp().type(), 'random')
self.assertEqual(restored.sourceColorRamp().count(), 5)
# render test
layer.setRenderer(renderer)
ms = QgsMapSettings()
ms.setLayers([layer])
ms.setExtent(layer.extent())
checker = QgsRenderChecker()
checker.setControlName("expected_paletted_renderer")
checker.setMapSettings(ms)
self.assertTrue(checker.runTest("expected_paletted_renderer"),
"Paletted rendering test failed")
def rendererToSld(self, renderer, properties={}):
dom = QDomDocument()
root = dom.createElement("FakeRoot")
dom.appendChild(root)
renderer.toSld(dom, root, properties)
return dom, root
def xmlDownloaded(self):
""" populate the plugins object with the fetched data """
reply = self.sender()
reposName = reply.property('reposName')
if reply.error() != QNetworkReply.NoError: # fetching failed
self.mRepositories[reposName]["state"] = 3
self.mRepositories[reposName]["error"] = reply.errorString()
if reply.error() == QNetworkReply.OperationCanceledError:
self.mRepositories[reposName][
"error"] += "\n\n" + QCoreApplication.translate(
"QgsPluginInstaller",
"If you haven't canceled the download manually, it was most likely caused by a timeout. In this case consider increasing the connection timeout value in QGIS options window."
)
elif reply.attribute(QNetworkRequest.HttpStatusCodeAttribute) == 301:
redirectionUrl = reply.attribute(
QNetworkRequest.RedirectionTargetAttribute)
if redirectionUrl.isRelative():
redirectionUrl = reply.url().resolved(redirectionUrl)
redirectionCounter = reply.property('redirectionCounter') + 1
if redirectionCounter > 4:
self.mRepositories[reposName]["state"] = 3
self.mRepositories[reposName][
"error"] = QCoreApplication.translate(
"QgsPluginInstaller", "Too many redirections")
else:
# Fire a new request and exit immediately in order to quietly destroy the old one
self.requestFetching(reposName, redirectionUrl,
redirectionCounter)
reply.deleteLater()
return
else:
reposXML = QDomDocument()
content = reply.readAll()
# Fix lonely ampersands in metadata
a = QByteArray()
a.append("& ")
b = QByteArray()
b.append("& ")
content = content.replace(a, b)
reposXML.setContent(content)
pluginNodes = reposXML.elementsByTagName("pyqgis_plugin")
if pluginNodes.size():
for i in range(pluginNodes.size()):
fileName = pluginNodes.item(i).firstChildElement(
"file_name").text().strip()
if not fileName:
fileName = QFileInfo(
pluginNodes.item(i).firstChildElement(
"download_url").text().strip().split("?")
[0]).fileName()
name = fileName.partition(".")[0]
experimental = False
if pluginNodes.item(i).firstChildElement(
"experimental").text().strip().upper() in [
"TRUE", "YES"
]:
experimental = True
deprecated = False
if pluginNodes.item(i).firstChildElement(
"deprecated").text().strip().upper() in [
"TRUE", "YES"
]:
deprecated = True
trusted = False
if pluginNodes.item(i).firstChildElement(
"trusted").text().strip().upper() in [
"TRUE", "YES"
]:
trusted = True
icon = pluginNodes.item(i).firstChildElement(
"icon").text().strip()
if icon and not icon.startswith("http"):
icon = "http://{}/{}".format(
QUrl(self.mRepositories[reposName]["url"]).host(),
icon)
if pluginNodes.item(i).toElement().hasAttribute(
"plugin_id"):
plugin_id = pluginNodes.item(i).toElement().attribute(
"plugin_id")
else:
plugin_id = None
plugin = {
"id":
name,
"plugin_id":
plugin_id,
"name":
pluginNodes.item(i).toElement().attribute("name"),
"version_available":
pluginNodes.item(i).toElement().attribute("version"),
"description":
pluginNodes.item(i).firstChildElement(
"description").text().strip(),
"about":
pluginNodes.item(i).firstChildElement(
"about").text().strip(),
"author_name":
pluginNodes.item(i).firstChildElement(
"author_name").text().strip(),
"homepage":
pluginNodes.item(i).firstChildElement(
"homepage").text().strip(),
"download_url":
pluginNodes.item(i).firstChildElement(
"download_url").text().strip(),
"category":
pluginNodes.item(i).firstChildElement(
"category").text().strip(),
"tags":
pluginNodes.item(i).firstChildElement(
"tags").text().strip(),
"changelog":
pluginNodes.item(i).firstChildElement(
"changelog").text().strip(),
"author_email":
pluginNodes.item(i).firstChildElement(
"author_email").text().strip(),
"tracker":
pluginNodes.item(i).firstChildElement(
"tracker").text().strip(),
"code_repository":
pluginNodes.item(i).firstChildElement(
"repository").text().strip(),
"downloads":
pluginNodes.item(i).firstChildElement(
"downloads").text().strip(),
"average_vote":
pluginNodes.item(i).firstChildElement(
"average_vote").text().strip(),
"rating_votes":
pluginNodes.item(i).firstChildElement(
"rating_votes").text().strip(),
"icon":
icon,
"experimental":
experimental,
"deprecated":
deprecated,
"trusted":
trusted,
"filename":
fileName,
"installed":
False,
"available":
True,
"status":
"not installed",
"error":
"",
"error_details":
"",
"version_installed":
"",
"zip_repository":
reposName,
"library":
"",
"readonly":
False
}
qgisMinimumVersion = pluginNodes.item(i).firstChildElement(
"qgis_minimum_version").text().strip()
if not qgisMinimumVersion:
qgisMinimumVersion = "2"
qgisMaximumVersion = pluginNodes.item(i).firstChildElement(
"qgis_maximum_version").text().strip()
if not qgisMaximumVersion:
qgisMaximumVersion = qgisMinimumVersion[0] + ".99"
# if compatible, add the plugin to the list
if not pluginNodes.item(i).firstChildElement(
"disabled").text().strip().upper() in [
"TRUE", "YES"
]:
if isCompatible(pyQgisVersion(), qgisMinimumVersion,
qgisMaximumVersion):
# add the plugin to the cache
plugins.addFromRepository(plugin)
self.mRepositories[reposName]["state"] = 2
else:
# no plugin metadata found
self.mRepositories[reposName]["state"] = 3
if reply.attribute(
QNetworkRequest.HttpStatusCodeAttribute) == 200:
self.mRepositories[reposName][
"error"] = QCoreApplication.translate(
"QgsPluginInstaller",
"Server response is 200 OK, but doesn't contain plugin metatada. This is most likely caused by a proxy or a wrong repository URL. You can configure proxy settings in QGIS options."
)
else:
self.mRepositories[reposName][
"error"] = QCoreApplication.translate(
"QgsPluginInstaller",
"Status code:") + " {} {}".format(
reply.attribute(
QNetworkRequest.HttpStatusCodeAttribute),
reply.attribute(
QNetworkRequest.HttpReasonPhraseAttribute))
self.repositoryFetched.emit(reposName)
# is the checking done?
if not self.fetchingInProgress():
self.checkingDone.emit()
reply.deleteLater()
def testReadWriteXml(self):
p = QgsProject()
l = QgsPrintLayout(p)
l.setName('my layout')
l.setUnits(QgsUnitTypes.LayoutInches)
collection = l.pageCollection()
# add a page
page = QgsLayoutItemPage(l)
page.setPageSize('A6')
collection.addPage(page)
grid = l.gridSettings()
grid.setResolution(QgsLayoutMeasurement(5, QgsUnitTypes.LayoutPoints))
g1 = QgsLayoutGuide(
Qt.Horizontal,
QgsLayoutMeasurement(5, QgsUnitTypes.LayoutCentimeters),
l.pageCollection().page(0))
l.guides().addGuide(g1)
snapper = l.snapper()
snapper.setSnapTolerance(7)
# add some items
item1 = QgsLayoutItemMap(l)
item1.setId('xxyyxx')
l.addItem(item1)
item2 = QgsLayoutItemMap(l)
item2.setId('zzyyzz')
l.addItem(item2)
l.setReferenceMap(item2)
doc = QDomDocument("testdoc")
elem = l.writeXml(doc, QgsReadWriteContext())
l2 = QgsPrintLayout(p)
self.assertTrue(l2.readXml(elem, doc, QgsReadWriteContext()))
self.assertEqual(l2.name(), 'my layout')
self.assertEqual(l2.units(), QgsUnitTypes.LayoutInches)
collection2 = l2.pageCollection()
self.assertEqual(collection2.pageCount(), 1)
self.assertAlmostEqual(collection2.page(0).pageSize().width(), 105, 4)
self.assertEqual(collection2.page(0).pageSize().height(), 148)
self.assertEqual(l2.gridSettings().resolution().length(), 5.0)
self.assertEqual(l2.gridSettings().resolution().units(),
QgsUnitTypes.LayoutPoints)
self.assertEqual(l2.guides().guidesOnPage(0)[0].orientation(),
Qt.Horizontal)
self.assertEqual(l2.guides().guidesOnPage(0)[0].position().length(),
5.0)
self.assertEqual(l2.guides().guidesOnPage(0)[0].position().units(),
QgsUnitTypes.LayoutCentimeters)
self.assertEqual(l2.snapper().snapTolerance(), 7)
# check restored items
new_item1 = l2.itemByUuid(item1.uuid())
self.assertTrue(new_item1)
self.assertEqual(new_item1.id(), 'xxyyxx')
new_item2 = l2.itemByUuid(item2.uuid())
self.assertTrue(new_item2)
self.assertEqual(new_item2.id(), 'zzyyzz')
self.assertEqual(l2.referenceMap().id(), 'zzyyzz')
def testWriteReadXmlProj6(self):
# setup a context
context = QgsCoordinateTransformContext()
proj_1 = '+proj=pipeline +step +proj=axisswap +order=2,1 +step +proj=unitconvert +xy_in=deg +xy_out=rad +step +proj=push +v_3 +step +proj=cart +ellps=intl +step +proj=helmert +x=-18.944 +y=-379.364 +z=-24.063 +rx=-0.04 +ry=0.764 +rz=-6.431 +s=3.657 +convention=coordinate_frame +step +inv +proj=cart +ellps=WGS84 +step +proj=pop +v_3 +step +proj=unitconvert +xy_in=rad +xy_out=deg +step +proj=axisswap +order=2,1'
proj_2 = '+proj=pipeline +step +proj=axisswap +order=2,1 +step +proj=unitconvert +xy_in=deg +xy_out=rad +step +proj=push +v_3 +step +proj=cart +ellps=intl +step +proj=helmert +x=-150 +y=-250 +z=-1 +step +inv +proj=cart +ellps=WGS84 +step +proj=pop +v_3 +step +proj=unitconvert +xy_in=rad +xy_out=deg +step +proj=axisswap +order=2,1'
proj_3 = '+proj=pipeline +step +proj=axisswap +order=2,1'
self.assertTrue(
context.addCoordinateOperation(
QgsCoordinateReferenceSystem('EPSG:4204'),
QgsCoordinateReferenceSystem('EPSG:4326'), proj_1, True))
self.assertTrue(
context.addCoordinateOperation(
QgsCoordinateReferenceSystem('EPSG:4205'),
QgsCoordinateReferenceSystem('EPSG:4326'), proj_2, False))
# also insert a crs with no authid available
self.assertTrue(
context.addCoordinateOperation(
QgsCoordinateReferenceSystem.fromProj(
"+proj=longlat +a=6378137 +rf=298.25722356300003 +no_defs"
), QgsCoordinateReferenceSystem('EPSG:4326'), proj_3, False))
self.assertEqual(
context.coordinateOperations(), {
('EPSG:4204', 'EPSG:4326'): proj_1,
('EPSG:4205', 'EPSG:4326'): proj_2,
('', 'EPSG:4326'): proj_3
})
# save to xml
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
context.writeXml(elem, QgsReadWriteContext())
# restore from xml
context2 = QgsCoordinateTransformContext()
context2.readXml(elem, QgsReadWriteContext())
# check result
self.assertEqual(
context2.coordinateOperations(), {
('EPSG:4204', 'EPSG:4326'): proj_1,
('EPSG:4205', 'EPSG:4326'): proj_2,
('', 'EPSG:4326'): proj_3
})
self.assertEqual(
context2.calculateCoordinateOperation(
QgsCoordinateReferenceSystem.fromProj(
"+proj=longlat +a=6378137 +rf=298.25722356300003 +no_defs"
), QgsCoordinateReferenceSystem('EPSG:4326')),
'+proj=pipeline +step +proj=axisswap +order=2,1')
self.assertFalse(
context2.mustReverseCoordinateOperation(
QgsCoordinateReferenceSystem.fromProj(
"+proj=longlat +a=6378137 +rf=298.25722356300003 +no_defs"
), QgsCoordinateReferenceSystem('EPSG:4326')))
self.assertEqual(
context2.calculateCoordinateOperation(
QgsCoordinateReferenceSystem('EPSG:4326'),
QgsCoordinateReferenceSystem.fromProj(
"+proj=longlat +a=6378137 +rf=298.25722356300003 +no_defs")
), '+proj=pipeline +step +proj=axisswap +order=2,1')
self.assertTrue(
context2.mustReverseCoordinateOperation(
QgsCoordinateReferenceSystem('EPSG:4326'),
QgsCoordinateReferenceSystem.fromProj(
"+proj=longlat +a=6378137 +rf=298.25722356300003 +no_defs")
))
self.assertTrue(
context2.allowFallbackTransform(
QgsCoordinateReferenceSystem('EPSG:4204'),
QgsCoordinateReferenceSystem('EPSG:4326')))
self.assertFalse(
context2.allowFallbackTransform(
QgsCoordinateReferenceSystem('EPSG:4205'),
QgsCoordinateReferenceSystem('EPSG:4326')))
def testSaveLoadTemplate(self):
tmpfile = os.path.join(self.basetestpath, 'testTemplate.qpt')
p = QgsProject()
l = QgsLayout(p)
l.initializeDefaults()
# add some items
item1 = QgsLayoutItemLabel(l)
item1.setId('xxyyxx')
item1.attemptMove(QgsLayoutPoint(4, 8, QgsUnitTypes.LayoutMillimeters))
item1.attemptResize(
QgsLayoutSize(18, 12, QgsUnitTypes.LayoutMillimeters))
l.addItem(item1)
item2 = QgsLayoutItemLabel(l)
item2.setId('zzyyzz')
item2.attemptMove(
QgsLayoutPoint(1.4, 1.8, QgsUnitTypes.LayoutCentimeters))
item2.attemptResize(
QgsLayoutSize(2.8, 2.2, QgsUnitTypes.LayoutCentimeters))
l.addItem(item2)
# multiframe
multiframe1 = QgsLayoutItemHtml(l)
multiframe1.setHtml('mf1')
l.addMultiFrame(multiframe1)
frame1 = QgsLayoutFrame(l, multiframe1)
frame1.setId('frame1')
frame1.attemptMove(QgsLayoutPoint(4, 8,
QgsUnitTypes.LayoutMillimeters))
frame1.attemptResize(
QgsLayoutSize(18, 12, QgsUnitTypes.LayoutMillimeters))
multiframe1.addFrame(frame1)
multiframe2 = QgsLayoutItemHtml(l)
multiframe2.setHtml('mf2')
l.addMultiFrame(multiframe2)
frame2 = QgsLayoutFrame(l, multiframe2)
frame2.setId('frame2')
frame2.attemptMove(
QgsLayoutPoint(1.4, 1.8, QgsUnitTypes.LayoutCentimeters))
frame2.attemptResize(
QgsLayoutSize(2.8, 2.2, QgsUnitTypes.LayoutCentimeters))
multiframe2.addFrame(frame2)
uuids = {
item1.uuid(),
item2.uuid(),
frame1.uuid(),
frame2.uuid(),
multiframe1.uuid(),
multiframe2.uuid()
}
original_uuids = {
item1.uuid(),
item2.uuid(),
frame1.uuid(),
frame2.uuid()
}
self.assertTrue(l.saveAsTemplate(tmpfile, QgsReadWriteContext()))
l2 = QgsLayout(p)
with open(tmpfile) as f:
template_content = f.read()
doc = QDomDocument()
doc.setContent(template_content)
# adding to existing items
new_items, ok = l2.loadFromTemplate(doc, QgsReadWriteContext(), False)
self.assertTrue(ok)
self.assertEqual(len(new_items), 4)
items = l2.items()
multiframes = l2.multiFrames()
self.assertEqual(len(multiframes), 2)
self.assertTrue([i for i in items if i.id() == 'xxyyxx'])
self.assertTrue([i for i in items if i.id() == 'zzyyzz'])
self.assertTrue([i for i in items if i.id() == 'frame1'])
self.assertTrue([i for i in items if i.id() == 'frame2'])
self.assertTrue([i for i in multiframes if i.html() == 'mf1'])
self.assertTrue([i for i in multiframes if i.html() == 'mf2'])
self.assertTrue(new_items[0] in l2.items())
self.assertTrue(new_items[1] in l2.items())
self.assertTrue(new_items[2] in l2.items())
self.assertTrue(new_items[3] in l2.items())
# double check that new items have a unique uid
self.assertNotIn(new_items[0].uuid(), uuids)
uuids.add(new_items[0].uuid())
self.assertNotIn(new_items[1].uuid(), uuids)
uuids.add(new_items[1].uuid())
self.assertNotIn(new_items[2].uuid(), uuids)
uuids.add(new_items[2].uuid())
self.assertNotIn(new_items[3].uuid(), uuids)
uuids.add(new_items[3].uuid())
self.assertNotIn(
multiframes[0].uuid(),
[multiframe1.uuid(), multiframe2.uuid()])
self.assertNotIn(
multiframes[1].uuid(),
[multiframe1.uuid(), multiframe2.uuid()])
new_multiframe1 = [i for i in multiframes if i.html() == 'mf1'][0]
self.assertEqual(new_multiframe1.layout(), l2)
new_multiframe2 = [i for i in multiframes if i.html() == 'mf2'][0]
self.assertEqual(new_multiframe2.layout(), l2)
new_frame1 = sip.cast([i for i in items if i.id() == 'frame1'][0],
QgsLayoutFrame)
new_frame2 = sip.cast([i for i in items if i.id() == 'frame2'][0],
QgsLayoutFrame)
self.assertEqual(new_frame1.multiFrame(), new_multiframe1)
self.assertEqual(new_multiframe1.frames()[0].uuid(), new_frame1.uuid())
self.assertEqual(new_frame2.multiFrame(), new_multiframe2)
self.assertEqual(new_multiframe2.frames()[0].uuid(), new_frame2.uuid())
# adding to existing items
new_items2, ok = l2.loadFromTemplate(doc, QgsReadWriteContext(), False)
self.assertTrue(ok)
self.assertEqual(len(new_items2), 4)
items = l2.items()
self.assertEqual(len(items), 8)
multiframes2 = l2.multiFrames()
self.assertEqual(len(multiframes2), 4)
multiframes2 = [
m for m in l2.multiFrames() if
not m.uuid() in [new_multiframe1.uuid(),
new_multiframe2.uuid()]
]
self.assertEqual(len(multiframes2), 2)
self.assertTrue([i for i in items if i.id() == 'xxyyxx'])
self.assertTrue([i for i in items if i.id() == 'zzyyzz'])
self.assertTrue([i for i in items if i.id() == 'frame1'])
self.assertTrue([i for i in items if i.id() == 'frame2'])
self.assertTrue([i for i in multiframes2 if i.html() == 'mf1'])
self.assertTrue([i for i in multiframes2 if i.html() == 'mf2'])
self.assertTrue(new_items[0] in l2.items())
self.assertTrue(new_items[1] in l2.items())
self.assertTrue(new_items[2] in l2.items())
self.assertTrue(new_items[3] in l2.items())
self.assertTrue(new_items2[0] in l2.items())
self.assertTrue(new_items2[1] in l2.items())
self.assertTrue(new_items2[2] in l2.items())
self.assertTrue(new_items2[3] in l2.items())
self.assertNotIn(new_items2[0].uuid(), uuids)
uuids.add(new_items[0].uuid())
self.assertNotIn(new_items2[1].uuid(), uuids)
uuids.add(new_items[1].uuid())
self.assertNotIn(new_items2[2].uuid(), uuids)
uuids.add(new_items[2].uuid())
self.assertNotIn(new_items2[3].uuid(), uuids)
uuids.add(new_items[3].uuid())
self.assertNotIn(multiframes2[0].uuid(), [
multiframe1.uuid(),
multiframe2.uuid(),
new_multiframe1.uuid(),
new_multiframe2.uuid()
])
self.assertNotIn(multiframes2[1].uuid(), [
multiframe1.uuid(),
multiframe2.uuid(),
new_multiframe1.uuid(),
new_multiframe2.uuid()
])
new_multiframe1b = [i for i in multiframes2 if i.html() == 'mf1'][0]
self.assertEqual(new_multiframe1b.layout(), l2)
new_multiframe2b = [i for i in multiframes2 if i.html() == 'mf2'][0]
self.assertEqual(new_multiframe2b.layout(), l2)
new_frame1b = sip.cast([
i for i in items
if i.id() == 'frame1' and i.uuid() != new_frame1.uuid()
][0], QgsLayoutFrame)
new_frame2b = sip.cast([
i for i in items
if i.id() == 'frame2' and i.uuid() != new_frame2.uuid()
][0], QgsLayoutFrame)
self.assertEqual(new_frame1b.multiFrame(), new_multiframe1b)
self.assertEqual(new_multiframe1b.frames()[0].uuid(),
new_frame1b.uuid())
self.assertEqual(new_frame2b.multiFrame(), new_multiframe2b)
self.assertEqual(new_multiframe2b.frames()[0].uuid(),
new_frame2b.uuid())
# clearing existing items
new_items3, ok = l2.loadFromTemplate(doc, QgsReadWriteContext(), True)
new_multiframes = l2.multiFrames()
self.assertTrue(ok)
self.assertEqual(len(new_items3), 5) # includes page
self.assertEqual(len(new_multiframes), 2)
items = l2.items()
self.assertTrue([
i for i in items
if isinstance(i, QgsLayoutItem) and i.id() == 'xxyyxx'
])
self.assertTrue([
i for i in items
if isinstance(i, QgsLayoutItem) and i.id() == 'zzyyzz'
])
self.assertTrue([
i for i in items
if isinstance(i, QgsLayoutItem) and i.id() == 'frame1'
])
self.assertTrue([
i for i in items
if isinstance(i, QgsLayoutItem) and i.id() == 'frame2'
])
self.assertTrue(new_items3[0] in l2.items())
self.assertTrue(new_items3[1] in l2.items())
self.assertTrue(new_items3[2] in l2.items())
self.assertTrue(new_items3[3] in l2.items())
new_multiframe1 = [i for i in new_multiframes if i.html() == 'mf1'][0]
new_multiframe2 = [i for i in new_multiframes if i.html() == 'mf2'][0]
new_frame1 = sip.cast([
i for i in items
if isinstance(i, QgsLayoutItem) and i.id() == 'frame1'
][0], QgsLayoutFrame)
new_frame2 = sip.cast([
i for i in items
if isinstance(i, QgsLayoutItem) and i.id() == 'frame2'
][0], QgsLayoutFrame)
self.assertEqual(new_frame1.multiFrame(), new_multiframe1)
self.assertEqual(new_multiframe1.frames()[0].uuid(), new_frame1.uuid())
self.assertEqual(new_frame2.multiFrame(), new_multiframe2)
self.assertEqual(new_multiframe2.frames()[0].uuid(), new_frame2.uuid())
def makeAtlas(qptChapter,
qptDivision,
qptForm,
zl_layer,
zl_field,
di_layer,
di_field,
di_name,
scale,
form_file=None,
form=False,
project_name='',
root_out='',
pbar=False,
isTest=True):
root_code = os.path.dirname(os.path.realpath(__file__))
## getpapersize
template_file = open(qptDivision, 'r')
template_content = template_file.read()
template_file.close()
document = QDomDocument()
document.setContent(template_content)
p = QgsProject().instance()
composition = QgsLayout(p)
composition.loadFromTemplate(document, QgsReadWriteContext())
map_item = composition.itemById('mapa')
paper = [
map_item.sizeWithUnits().width(),
map_item.sizeWithUnits().height()
]
##get visible layers
visibleLayers = p.mapThemeCollection().masterVisibleLayers()
## get project srid...
crs = zl_layer.dataProvider().sourceCrs().authid()
## zones 1 layer
zvl = zl_layer.clone()
global ZVL
ZVL = zvl.id()
QgsProject.instance().addMapLayer(zvl)
#pr = zvl.dataProvider()
QgsProject.instance().mapLayer(ZVL).loadNamedStyle(
root_code + '/templates/layerstyles/zones.qml')
## divisions 1 layer
dvl = QgsVectorLayer("Polygon?crs=" + crs, "divisions_layer", "memory")
global DVL
DVL = dvl.id()
QgsProject.instance().addMapLayer(dvl)
#pr = dvl.dataProvider()
QgsProject.instance().mapLayer(DVL).startEditing()
QgsProject.instance().mapLayer(DVL).loadNamedStyle(
root_code + '/templates/layerstyles/div1.qml')
pr_dvl = QgsProject.instance().mapLayer(DVL).dataProvider()
pr_dvl.addAttributes([
QgsField('id', QVariant.String),
QgsField('name', QVariant.String),
QgsField('ang', QVariant.String),
QgsField('x', QVariant.String),
QgsField('y', QVariant.String),
])
QgsProject.instance().mapLayer(DVL).commitChanges()
## divisions 2 layer
dvl2 = QgsVectorLayer("Polygon?crs=" + crs, "divisions_layer", "memory")
global DVL2
DVL2 = dvl2.id()
QgsProject.instance().addMapLayer(dvl2)
#pr = dvl2.dataProvider()
QgsProject.instance().mapLayer(DVL2).startEditing()
QgsProject.instance().mapLayer(DVL2).loadNamedStyle(
root_code + '/templates/layerstyles/div2.qml')
pr_dvl2 = QgsProject.instance().mapLayer(DVL2).dataProvider()
pr_dvl2.addAttributes([
QgsField('id', QVariant.String),
QgsField('name', QVariant.String),
QgsField('ang', QVariant.String),
QgsField('x', QVariant.String),
QgsField('y', QVariant.String),
])
QgsProject.instance().mapLayer(DVL2).commitChanges()
debug('>> layers setted')
##makestyles::
p = QgsProject.instance()
#_zona_big
p.mapThemeCollection().removeMapTheme('_zona_big')
rec = QgsMapThemeCollection().MapThemeRecord()
recList = []
vl = visibleLayers
for v in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(v))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(zvl))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(dvl))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(dvl2))
rec.setLayerRecords(recList)
p.mapThemeCollection().insert('_zona_big', rec)
#_zona_small
p.mapThemeCollection().removeMapTheme('_zona_small')
rec = QgsMapThemeCollection().MapThemeRecord()
recList = []
vl = visibleLayers
for v in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(v))
if di_layer not in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(di_layer))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(zvl))
rec.setLayerRecords(recList)
p.mapThemeCollection().insert('_zona_small', rec)
#_szona_big
p.mapThemeCollection().removeMapTheme('_szona_big')
rec = QgsMapThemeCollection().MapThemeRecord()
recList = []
vl = visibleLayers
for v in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(v))
if di_layer not in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(di_layer))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(zvl))
rec.setLayerRecords(recList)
p.mapThemeCollection().insert('_szona_big', rec)
#_szona_small
p.mapThemeCollection().removeMapTheme('_szona_small')
rec = QgsMapThemeCollection().MapThemeRecord()
recList = []
vl = visibleLayers
for v in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(v))
if di_layer not in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(di_layer))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(zvl))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(dvl))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(dvl2))
rec.setLayerRecords(recList)
p.mapThemeCollection().insert('_szona_small', rec)
global mapL
mapLmake()
##se puede agilizar
#Lz = zl_layer #QgsProject.instance().mapLayer(mapL['zones'])
#Lb = QgsProject.instance().mapLayer(mapL['bounds'])
#Ld = QgsProject.instance().mapLayer(mapL['divisions'])
###########################################################################
x = 0
global pag
pag = 1
#for b in Lb.getFeatures():
fr = 0
zones_f = [zzz for zzz in zl_layer.getFeatures()]
if pbar:
pbar.setValue(1)
for b in zones_f:
if pbar:
pbar.setValue(100 / len(zones_f) * fr)
fr += 1
debug('>>>> chapter: ')
debug(b.attributes())
#isTest
#self.dlg.progressBar.setValue(int(10))
szs = getSubzones(b, paper, scale)
mkChapter(b, qptChapter, project_name, root_out, zl_layer, zl_field,
di_layer, di_field, di_name)
szfr = 0
for sz in szs:
szfr += 1
if pbar:
pbar.setValue(100 / len(zones_f) * fr +
100 / len(zones_f) / len(szs) * szfr)
debug('>>>> division: ')
mkDiv(sz, b.geometry(), qptDivision, project_name, root_out,
zl_layer, zl_field, di_layer, di_field, di_name)
if form:
mkForm(sz, qptForm, form_file, project_name, root_out,
zl_layer, zl_field, di_layer, di_field, di_name)
if isTest:
break
if isTest:
break
x += 1
#emptyTemp()
# #remove styles
p.mapThemeCollection().removeMapTheme('_zona_big')
p.mapThemeCollection().removeMapTheme('_zona_small')
p.mapThemeCollection().removeMapTheme('_szona_big')
p.mapThemeCollection().removeMapTheme('_szona_small')
#remove layers
QgsProject.instance().removeMapLayer(ZVL)
QgsProject.instance().removeMapLayer(DVL)
QgsProject.instance().removeMapLayer(DVL2)
debug('end')
return