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