def on_btnSave_clicked(self):
fileName, _ = QFileDialog.getSaveFileName(
None, self.tr("Export Colors and elevations as XML"), QDir.homePath(), self.tr("XML files (*.xml *.XML)")
)
if fileName == "":
return
if not fileName.lower().endswith(".xml"):
fileName += ".xml"
doc = QDomDocument()
colorsElem = doc.createElement("ReliefColors")
doc.appendChild(colorsElem)
colors = self.reliefColors()
for c in colors:
elem = doc.createElement("ReliefColor")
elem.setAttribute("MinElevation", str(c.minElevation))
elem.setAttribute("MaxElevation", str(c.maxElevation))
elem.setAttribute("red", str(c.color.red()))
elem.setAttribute("green", str(c.color.green()))
elem.setAttribute("blue", str(c.color.blue()))
colorsElem.appendChild(elem)
with codecs.open(fileName, "w", encoding="utf-8") as f:
f.write(doc.toString(2))
def on_btnSave_clicked(self):
fileName, _ = QFileDialog.getSaveFileName(None,
self.tr('Export Colors and elevations as XML'),
QDir.homePath(),
self.tr('XML files (*.xml *.XML)'))
if fileName == '':
return
if not fileName.lower().endswith('.xml'):
fileName += '.xml'
doc = QDomDocument()
colorsElem = doc.createElement('ReliefColors')
doc.appendChild(colorsElem)
colors = self.reliefColors()
for c in colors:
elem = doc.createElement('ReliefColor')
elem.setAttribute('MinElevation', str(c.minElevation))
elem.setAttribute('MaxElevation', str(c.maxElevation))
elem.setAttribute('red', str(c.color.red()))
elem.setAttribute('green', str(c.color.green()))
elem.setAttribute('blue', str(c.color.blue()))
colorsElem.appendChild(elem)
with codecs.open(fileName, 'w', encoding='utf-8') as f:
f.write(doc.toString(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 createSimpleMemorial(self):
tempDoc = QDomDocument()
simple = QFile(self.simpleMemorial)
simple.open(QIODevice.ReadOnly)
loaded = tempDoc.setContent(simple)
simple.close()
element = tempDoc.documentElement()
nodes = element.elementsByTagName("table")
table = nodes.item(0).toElement()
tr = tempDoc.createElement("tr")
tr.appendChild(self.createCellElement(tempDoc, u"MEMORIAL DESCRITIVO SINTÉTICO", 7, 0))
table.appendChild(tr)
tr = tempDoc.createElement("tr")
tr.appendChild(self.createCellElement(tempDoc, u"VÉRTICE", 0, 2))
tr.appendChild(self.createCellElement(tempDoc, "COORDENADAS", 2, 0))
tr.appendChild(self.createCellElement(tempDoc, "LADO", 0, 2))
tr.appendChild(self.createCellElement(tempDoc, "AZIMUTES", 2, 0))
tr.appendChild(self.createCellElement(tempDoc, u"DISTÂNCIA", 0, 0))
table.appendChild(tr)
tr = tempDoc.createElement("tr")
tr.appendChild(self.createCellElement(tempDoc, "E", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "N", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "PLANO", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "REAL", 0, 0))
tr.appendChild(self.createCellElement(tempDoc, "(m)", 0, 0))
table.appendChild(tr)
convergence = float(self.convergenciaEdit.text())
rowCount = self.tableWidget.rowCount()
for i in range(0,rowCount):
lineElement = tempDoc.createElement("tr")
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,0).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,1).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,2).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,3).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,4).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,5).text(), 0, 0))
lineElement.appendChild(self.createCellElement(tempDoc, self.tableWidget.item(i,6).text(), 0, 0))
table.appendChild(lineElement)
simple = open(self.simpleMemorial, "w", encoding='utf-8')
simple.write(tempDoc.toString())
simple.close()
def testSaveRestore(self):
# test that properties are restored correctly from XML
composition = QgsComposition(QgsProject.instance())
composition.setName('test composition')
doc = QDomDocument("testdoc")
elem = doc.createElement("qgis")
doc.appendChild(elem)
elem = doc.createElement("composer")
self.assertTrue(composition.writeXml(elem, doc))
composition2 = QgsComposition(QgsProject.instance())
self.assertTrue(composition2.readXml(elem, doc))
self.assertEqual(composition.name(), 'test composition')
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 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 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 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 testLayerDataSourceReset(self):
"""When adding a layer with the same id to the store make sure
the data source is also updated in case the layer validity has
changed from False to True"""
p = QgsProject()
store = p.layerStore()
vl1 = createLayer('valid')
vl2 = QgsVectorLayer('/not_a_valid_path.shp', 'invalid', 'ogr')
self.assertTrue(vl1.isValid())
self.assertFalse(vl2.isValid())
store.addMapLayers([vl1, vl2])
self.assertEqual(store.validCount(), 1)
self.assertEqual(len(store.mapLayers()), 2)
# Re-add the bad layer
store.addMapLayers([vl2])
self.assertEqual(store.validCount(), 1)
self.assertEqual(len(store.mapLayers()), 2)
doc = QDomDocument()
doc.setContent('<maplayer><provider encoding="UTF-8">ogr</provider><layername>fixed</layername><id>%s</id></maplayer>' % vl2.id())
layer_node = QDomNode(doc.firstChild())
self.assertTrue(vl2.writeXml(layer_node, doc, QgsReadWriteContext()))
datasource_node = doc.createElement("datasource")
datasource_node.appendChild(doc.createTextNode(os.path.join(TEST_DATA_DIR, 'points.shp')))
layer_node.appendChild(datasource_node)
p.readLayer(layer_node)
self.assertEqual(store.validCount(), 2)
self.assertEqual(len(store.mapLayers()), 2)
self.assertEqual(store.mapLayers()[vl2.id()].name(), 'fixed')
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 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):
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 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 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 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 _change_data_source(self, new_data_source):
"""
Changes the datasource string of the layer
"""
context = QgsReadWriteContext()
document = QDomDocument("style")
map_layers_element = document.createElement("maplayers")
map_layer_element = document.createElement("maplayer")
self.layer.writeLayerXml(map_layer_element, document, context)
# modify DOM element with new layer reference
map_layer_element.firstChildElement("datasource").firstChild().setNodeValue(new_data_source)
map_layers_element.appendChild(map_layer_element)
document.appendChild(map_layers_element)
# reload layer definition
self.layer.readLayerXml(map_layer_element, context)
self.layer.reload()
def updateSqlLayer(self):
with OverrideCursor(Qt.WaitCursor):
layer = self._getSqlLayer(self.filter)
if layer is None:
return
# self.layer.dataProvider().setDataSourceUri(layer.dataProvider().dataSourceUri())
# self.layer.dataProvider().reloadData()
XMLDocument = QDomDocument("style")
XMLMapLayers = XMLDocument.createElement("maplayers")
XMLMapLayer = XMLDocument.createElement("maplayer")
self.layer.writeLayerXML(XMLMapLayer, XMLDocument)
XMLMapLayer.firstChildElement("datasource").firstChild().setNodeValue(layer.source())
XMLMapLayers.appendChild(XMLMapLayer)
XMLDocument.appendChild(XMLMapLayers)
self.layer.readLayerXML(XMLMapLayer)
self.layer.reload()
self.iface.actionDraw().trigger()
self.iface.mapCanvas().refresh()
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 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 testMissingTransforms(self):
# 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')
transformElem.setAttribute("sourceTransform", 'not valid')
transformElem.setAttribute("destTransform", 'not valid 2')
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', 'not valid 2'])
def testReadWriteXml(self):
p = QgsProject()
l = QgsLayout(p)
l.initializeDefaults()
snapper = l.snapper()
snapper.setSnapToGrid(True)
snapper.setSnapTolerance(1)
snapper.setSnapToGuides(True)
snapper.setSnapToItems(True)
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
self.assertTrue(snapper.writeXml(elem, doc, QgsReadWriteContext()))
l2 = QgsLayout(p)
l2.initializeDefaults()
snapper2 = l2.snapper()
self.assertTrue(snapper2.readXml(elem.firstChildElement(), doc, QgsReadWriteContext()))
self.assertTrue(snapper2.snapToGrid())
self.assertEqual(snapper2.snapTolerance(), 1)
self.assertTrue(snapper2.snapToGuides())
self.assertTrue(snapper2.snapToItems())
snapper.setSnapToGrid(False)
snapper.setSnapTolerance(1)
snapper.setSnapToGuides(False)
snapper.setSnapToItems(False)
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
self.assertTrue(snapper.writeXml(elem, doc, QgsReadWriteContext()))
self.assertTrue(snapper2.readXml(elem.firstChildElement(), doc, QgsReadWriteContext()))
self.assertFalse(snapper2.snapToGrid())
self.assertFalse(snapper2.snapToGuides())
self.assertFalse(snapper2.snapToItems())
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())
def testSimpleMarkerSymbolLayer(self):
symbol = QgsSimpleMarkerSymbolLayer(
'star', QColor(255, 0, 0), QColor(0, 255, 0), 10)
symbol.setAngle(50)
dom = QDomDocument()
root = dom.createElement("FakeRoot")
dom.appendChild(root)
symbol.toSld(dom, root, {})
# print "This is the dom: " + dom.toString()
# Check the rotation element is a literal, not a
rotation = root.elementsByTagName('se:Rotation').item(0)
literal = rotation.firstChild()
self.assertEquals("ogc:Literal", literal.nodeName())
self.assertEquals('50', literal.firstChild().nodeValue())
def testSaveReadFromXml(self):
"""
Test saving and reading metadata from a XML.
"""
# save metadata to XML
m = self.createTestMetadata()
doc = QDomDocument("testdoc")
elem = doc.createElement("metadata")
self.assertTrue(m.writeMetadataXml(elem, doc))
# read back from XML and check result
m2 = TestMetadata()
m2.readMetadataXml(elem)
self.checkExpectedMetadata(m2)
def testSaveReadFromXml(self):
"""
Test saving and reading metadata from a XML.
"""
vl = QgsVectorLayer('Point', 'test', 'memory')
self.assertTrue(vl.isValid())
# save metadata to XML
m = self.createTestMetadata()
doc = QDomDocument("testdoc")
elem = doc.createElement("metadata")
self.assertTrue(m.writeMetadataXml(elem, doc))
# read back from XML and check result
m2 = QgsLayerMetadata()
m2.readMetadataXml(elem)
self.checkExpectedMetadata(m2)
def testReadWriteXml(self):
p = QgsProject()
l = QgsLayout(p)
s = QgsLayoutGridSettings(l)
s.setResolution(QgsLayoutMeasurement(5, QgsUnitTypes.LayoutPoints))
s.setOffset(QgsLayoutPoint(6, 7, QgsUnitTypes.LayoutPixels))
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
self.assertTrue(s.writeXml(elem, doc, QgsReadWriteContext()))
s2 = QgsLayoutGridSettings(l)
self.assertTrue(s2.readXml(elem.firstChildElement(), doc, QgsReadWriteContext()))
self.assertEqual(s2.resolution().length(), 5.0)
self.assertEqual(s2.resolution().units(), QgsUnitTypes.LayoutPoints)
self.assertEqual(s2.offset().x(), 6.0)
self.assertEqual(s2.offset().y(), 7.0)
self.assertEqual(s2.offset().units(), QgsUnitTypes.LayoutPixels)
def testReadExtentOnView(self):
# vector layer based on view
vl0 = QgsVectorLayer(self.dbconn + ' sslmode=disable key=\'pk\' srid=4326 type=POLYGON table="qgis_test"."some_poly_data_view" (geom) sql=', 'test', 'postgres')
self.assertTrue(vl0.isValid())
self.assertFalse(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 be used because we have a view
vl2 = QgsVectorLayer()
vl2.setReadExtentFromXml(True)
vl2.readLayerXml(elem, QgsReadWriteContext())
self.assertTrue(vl2.isValid())
self.assertEqual(vl2.extent(), customExtent)
# but a force update on extent should allow retrieveing the data
# provider extent
vl2.updateExtents()
vl2.readLayerXml(elem, QgsReadWriteContext())
self.assertEqual(vl2.extent(), customExtent)
vl2.updateExtents(force=True)
vl2.readLayerXml(elem, QgsReadWriteContext())
self.assertEqual(vl2.extent(), originalExtent)
def testPercentageFormat(self):
""" test percentage formatter """
f = QgsPercentageNumericFormat()
f.setInputValues(QgsPercentageNumericFormat.ValuesArePercentage)
context = QgsNumericFormatContext()
self.assertEqual(f.formatDouble(0, context), '0%')
self.assertEqual(f.formatDouble(5, context), '5%')
self.assertEqual(f.formatDouble(5.5, context), '5.5%')
self.assertEqual(f.formatDouble(-5, context), '-5%')
self.assertEqual(f.formatDouble(-5.5, context), '-5.5%')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-55,555,555.5%')
context.setDecimalSeparator('x')
self.assertEqual(f.formatDouble(0, context), '0%')
self.assertEqual(f.formatDouble(-5.5, context), '-5x5%')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-55,555,555x5%')
context.setThousandsSeparator('y')
self.assertEqual(f.formatDouble(-5.5, context), '-5x5%')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-55y555y555x5%')
f.setShowThousandsSeparator(False)
self.assertEqual(f.formatDouble(-5.5, context), '-5x5%')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555x5%')
context.setDecimalSeparator('.')
f.setNumberDecimalPlaces(0)
self.assertEqual(f.formatDouble(0, context), '0%')
self.assertEqual(f.formatDouble(5.5, context), '6%')
self.assertEqual(f.formatDouble(55555555.5, context), '55555556%')
self.assertEqual(f.formatDouble(55555555.123456, context), '55555555%')
self.assertEqual(f.formatDouble(-5.5, context), '-6%')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555556%')
f.setNumberDecimalPlaces(3)
self.assertEqual(f.formatDouble(0, context), '0%')
self.assertEqual(f.formatDouble(5.5, context), '5.5%')
self.assertEqual(f.formatDouble(55555555.5, context), '55555555.5%')
self.assertEqual(f.formatDouble(55555555.123456, context),
'55555555.123%')
self.assertEqual(f.formatDouble(-5.5, context), '-5.5%')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555.5%')
f.setShowTrailingZeros(True)
self.assertEqual(f.formatDouble(0, context), '0.000%')
self.assertEqual(f.formatDouble(5, context), '5.000%')
self.assertEqual(f.formatDouble(-5, context), '-5.000%')
self.assertEqual(f.formatDouble(5.5, context), '5.500%')
self.assertEqual(f.formatDouble(55555555.5, context), '55555555.500%')
self.assertEqual(f.formatDouble(55555555.123456, context),
'55555555.123%')
self.assertEqual(f.formatDouble(-5.5, context), '-5.500%')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-55555555.500%')
f.setShowPlusSign(True)
self.assertEqual(f.formatDouble(0, context), '0.000%')
self.assertEqual(f.formatDouble(5, context), '+5.000%')
self.assertEqual(f.formatDouble(-5, context), '-5.000%')
self.assertEqual(f.formatDouble(5.5, context), '+5.500%')
self.assertEqual(f.formatDouble(55555555.5, context), '+55555555.500%')
self.assertEqual(f.formatDouble(55555555.123456, context),
'+55555555.123%')
self.assertEqual(f.formatDouble(-5.5, context), '-5.500%')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-55555555.500%')
f = QgsPercentageNumericFormat()
f.setInputValues(QgsPercentageNumericFormat.ValuesAreFractions)
context = QgsNumericFormatContext()
self.assertEqual(f.formatDouble(0, context), '0%')
self.assertEqual(f.formatDouble(5, context), '500%')
self.assertEqual(f.formatDouble(5.5, context), '550%')
self.assertEqual(f.formatDouble(-5, context), '-500%')
self.assertEqual(f.formatDouble(-5.5, context), '-550%')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-5,555,555,550%')
context.setDecimalSeparator('x')
self.assertEqual(f.formatDouble(0, context), '0%')
self.assertEqual(f.formatDouble(-5.5, context), '-550%')
self.assertEqual(f.formatDouble(-0.005, context), '-0x5%')
context.setThousandsSeparator('y')
self.assertEqual(f.formatDouble(-5.5, context), '-550%')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-5y555y555y550%')
f.setShowThousandsSeparator(False)
self.assertEqual(f.formatDouble(-5.5, context), '-550%')
self.assertEqual(f.formatDouble(-55555555.5, context), '-5555555550%')
context.setDecimalSeparator('.')
f.setNumberDecimalPlaces(0)
self.assertEqual(f.formatDouble(0, context), '0%')
self.assertEqual(f.formatDouble(5.5, context), '550%')
self.assertEqual(f.formatDouble(55555555.5, context), '5555555550%')
self.assertEqual(f.formatDouble(0.123456, context), '12%')
self.assertEqual(f.formatDouble(-5.5, context), '-550%')
self.assertEqual(f.formatDouble(-0.123456, context), '-12%')
f.setNumberDecimalPlaces(3)
self.assertEqual(f.formatDouble(0, context), '0%')
self.assertEqual(f.formatDouble(5.5, context), '550%')
self.assertEqual(f.formatDouble(55555555.5, context), '5555555550%')
self.assertEqual(f.formatDouble(0.123456, context), '12.346%')
self.assertEqual(f.formatDouble(-5.5, context), '-550%')
self.assertEqual(f.formatDouble(-0.123456, context), '-12.346%')
f.setShowTrailingZeros(True)
self.assertEqual(f.formatDouble(0, context), '0.000%')
self.assertEqual(f.formatDouble(5, context), '500.000%')
self.assertEqual(f.formatDouble(-5, context), '-500.000%')
self.assertEqual(f.formatDouble(0.5, context), '50.000%')
self.assertEqual(f.formatDouble(55555555.5, context),
'5555555550.000%')
self.assertEqual(f.formatDouble(0.123456, context), '12.346%')
self.assertEqual(f.formatDouble(-5.5, context), '-550.000%')
self.assertEqual(f.formatDouble(-1234.5, context), '-123450.000%')
f.setShowPlusSign(True)
self.assertEqual(f.formatDouble(0, context), '0.000%')
self.assertEqual(f.formatDouble(5, context), '+500.000%')
self.assertEqual(f.formatDouble(-5, context), '-500.000%')
self.assertEqual(f.formatDouble(5.5, context), '+550.000%')
self.assertEqual(f.formatDouble(-5.5, context), '-550.000%')
context.setPercent('p')
self.assertEqual(f.formatDouble(0, context), '0.000p')
self.assertEqual(f.formatDouble(5, context), '+500.000p')
self.assertEqual(f.formatDouble(-5, context), '-500.000p')
f2 = f.clone()
self.assertIsInstance(f2, QgsPercentageNumericFormat)
self.assertEqual(f2.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f2.showPlusSign(), f.showPlusSign())
self.assertEqual(f2.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f2.showThousandsSeparator(),
f.showThousandsSeparator())
self.assertEqual(f2.inputValues(), f.inputValues())
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
f2.writeXml(elem, doc, QgsReadWriteContext())
f3 = QgsNumericFormatRegistry().createFromXml(elem,
QgsReadWriteContext())
self.assertIsInstance(f3, QgsPercentageNumericFormat)
self.assertEqual(f3.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f3.showPlusSign(), f.showPlusSign())
self.assertEqual(f3.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f3.showThousandsSeparator(),
f.showThousandsSeparator())
self.assertEqual(f3.inputValues(), f.inputValues())
def testScientificFormat(self):
""" test scientific formatter """
f = QgsScientificNumericFormat()
context = QgsNumericFormatContext()
self.assertEqual(f.formatDouble(0, context), '0e+00')
self.assertEqual(f.formatDouble(5, context), '5e+00')
self.assertEqual(f.formatDouble(5.5, context), '5.5e+00')
self.assertEqual(f.formatDouble(-5, context), '-5e+00')
self.assertEqual(f.formatDouble(-5.5, context), '-5.5e+00')
self.assertEqual(f.formatDouble(-55555555.5, context), '-5.555556e+07')
context.setDecimalSeparator('x')
self.assertEqual(f.formatDouble(0, context), '0e+00')
self.assertEqual(f.formatDouble(-5.5, context), '-5x5e+00')
self.assertEqual(f.formatDouble(-55555555.5, context), '-5x555556e+07')
context.setDecimalSeparator('.')
# places must be at least 1 for scientific notation!
f.setNumberDecimalPlaces(0)
self.assertEqual(f.numberDecimalPlaces(), 1)
self.assertEqual(f.formatDouble(0, context), '0e+00')
self.assertEqual(f.formatDouble(5.5, context), '5.5e+00')
self.assertEqual(f.formatDouble(55555555.5, context), '5.6e+07')
self.assertEqual(f.formatDouble(55555555.123456, context), '5.6e+07')
self.assertEqual(f.formatDouble(-5.5, context), '-5.5e+00')
self.assertEqual(f.formatDouble(-55555555.5, context), '-5.6e+07')
f.setNumberDecimalPlaces(3)
self.assertEqual(f.formatDouble(0, context), '0e+00')
self.assertEqual(f.formatDouble(5.5, context), '5.5e+00')
self.assertEqual(f.formatDouble(55555555.5, context), '5.556e+07')
self.assertEqual(f.formatDouble(55555555.123456, context), '5.556e+07')
self.assertEqual(f.formatDouble(-5.5, context), '-5.5e+00')
self.assertEqual(f.formatDouble(-55555555.5, context), '-5.556e+07')
f.setShowTrailingZeros(True)
self.assertEqual(f.formatDouble(0, context), '0.000e+00')
self.assertEqual(f.formatDouble(5, context), '5.000e+00')
self.assertEqual(f.formatDouble(-5, context), '-5.000e+00')
self.assertEqual(f.formatDouble(5.5, context), '5.500e+00')
self.assertEqual(f.formatDouble(55555555.5, context), '5.556e+07')
self.assertEqual(f.formatDouble(55555555.123456, context), '5.556e+07')
self.assertEqual(f.formatDouble(-5.5, context), '-5.500e+00')
self.assertEqual(f.formatDouble(-55555555.5, context), '-5.556e+07')
f.setShowPlusSign(True)
self.assertEqual(f.formatDouble(0, context), '0.000e+00')
self.assertEqual(f.formatDouble(5, context), '+5.000e+00')
self.assertEqual(f.formatDouble(-5, context), '-5.000e+00')
self.assertEqual(f.formatDouble(5.5, context), '+5.500e+00')
self.assertEqual(f.formatDouble(55555555.5, context), '+5.556e+07')
self.assertEqual(f.formatDouble(55555555.123456, context),
'+5.556e+07')
self.assertEqual(f.formatDouble(-5.5, context), '-5.500e+00')
self.assertEqual(f.formatDouble(-55555555.5, context), '-5.556e+07')
f2 = f.clone()
self.assertIsInstance(f2, QgsScientificNumericFormat)
self.assertEqual(f2.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f2.showPlusSign(), f.showPlusSign())
self.assertEqual(f2.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f2.showThousandsSeparator(),
f.showThousandsSeparator())
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
f2.writeXml(elem, doc, QgsReadWriteContext())
f3 = QgsNumericFormatRegistry().createFromXml(elem,
QgsReadWriteContext())
self.assertIsInstance(f3, QgsScientificNumericFormat)
self.assertEqual(f3.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f3.showPlusSign(), f.showPlusSign())
self.assertEqual(f3.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f3.showThousandsSeparator(),
f.showThousandsSeparator())
def testBasicFormat(self):
""" test basic formatter """
f = QgsBasicNumericFormat()
context = QgsNumericFormatContext()
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(5, context), '5')
self.assertEqual(f.formatDouble(5.5, context), '5.5')
self.assertEqual(f.formatDouble(-5, context), '-5')
self.assertEqual(f.formatDouble(-5.5, context), '-5.5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55,555,555.5')
context.setDecimalSeparator('☕')
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(-5.5, context), '-5☕5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55,555,555☕5')
context.setThousandsSeparator('⚡')
self.assertEqual(f.formatDouble(-5.5, context), '-5☕5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55⚡555⚡555☕5')
f.setShowThousandsSeparator(False)
self.assertEqual(f.formatDouble(-5.5, context), '-5☕5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555☕5')
context.setDecimalSeparator('.')
f.setDecimalSeparator('⛹')
self.assertEqual(f.formatDouble(-5.5, context), '-5⛹5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555⛹5')
f.setNumberDecimalPlaces(0)
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(5.5, context), '6')
self.assertEqual(f.formatDouble(55555555.5, context), '55555556')
self.assertEqual(f.formatDouble(55555555.123456, context), '55555555')
self.assertEqual(f.formatDouble(-5.5, context), '-6')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555556')
f.setNumberDecimalPlaces(3)
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(5.5, context), '5⛹5')
self.assertEqual(f.formatDouble(55555555.5, context), '55555555⛹5')
self.assertEqual(f.formatDouble(55555555.123456, context),
'55555555⛹123')
self.assertEqual(f.formatDouble(-5.5, context), '-5⛹5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555⛹5')
f.setShowTrailingZeros(True)
self.assertEqual(f.formatDouble(0, context), '0⛹000')
self.assertEqual(f.formatDouble(5, context), '5⛹000')
self.assertEqual(f.formatDouble(-5, context), '-5⛹000')
self.assertEqual(f.formatDouble(5.5, context), '5⛹500')
self.assertEqual(f.formatDouble(55555555.5, context), '55555555⛹500')
self.assertEqual(f.formatDouble(55555555.123456, context),
'55555555⛹123')
self.assertEqual(f.formatDouble(-5.5, context), '-5⛹500')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555⛹500')
f.setShowPlusSign(True)
self.assertEqual(f.formatDouble(0, context), '0⛹000')
self.assertEqual(f.formatDouble(5, context), '+5⛹000')
self.assertEqual(f.formatDouble(-5, context), '-5⛹000')
self.assertEqual(f.formatDouble(5.5, context), '+5⛹500')
self.assertEqual(f.formatDouble(55555555.5, context), '+55555555⛹500')
self.assertEqual(f.formatDouble(55555555.123456, context),
'+55555555⛹123')
self.assertEqual(f.formatDouble(-5.5, context), '-5⛹500')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555⛹500')
context.setPositiveSign('w')
self.assertEqual(f.formatDouble(5, context), 'w5⛹000')
self.assertEqual(f.formatDouble(-5, context), '-5⛹000')
self.assertEqual(f.formatDouble(5.5, context), 'w5⛹500')
f.setShowPlusSign(False)
f.setRoundingType(QgsBasicNumericFormat.SignificantFigures)
self.assertEqual(f.formatDouble(0, context), '0⛹00')
self.assertEqual(f.formatDouble(5, context), '5⛹00')
self.assertEqual(f.formatDouble(-5, context), '-5⛹00')
self.assertEqual(f.formatDouble(5.5, context), '5⛹50')
self.assertEqual(f.formatDouble(1231.23123123123123, context), '1230')
self.assertEqual(f.formatDouble(123.123123123123123, context), '123')
self.assertEqual(f.formatDouble(12.3123123123123123, context), '12⛹3')
self.assertEqual(f.formatDouble(1.23123123123123123, context), '1⛹23')
self.assertEqual(f.formatDouble(-1231.23123123123123, context),
'-1230')
self.assertEqual(f.formatDouble(-123.123123123123123, context), '-123')
self.assertEqual(f.formatDouble(-12.3123123123123123, context),
'-12⛹3')
self.assertEqual(f.formatDouble(-1.23123123123123123, context),
'-1⛹23')
self.assertEqual(f.formatDouble(100, context), '100')
self.assertEqual(f.formatDouble(1000, context), '1000')
self.assertEqual(f.formatDouble(1001, context), '1000')
self.assertEqual(f.formatDouble(9999, context), '10000')
self.assertEqual(f.formatDouble(10, context), '10⛹0')
self.assertEqual(f.formatDouble(1, context), '1⛹00')
self.assertEqual(f.formatDouble(0.00000123456, context), '0⛹00000123')
self.assertEqual(f.formatDouble(55555555.5, context), '55600000')
self.assertEqual(f.formatDouble(55555555.123456, context), '55600000')
self.assertEqual(f.formatDouble(-5.5, context), '-5⛹50')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55600000')
f.setThousandsSeparator('✅')
f.setShowThousandsSeparator(True)
self.assertEqual(f.formatDouble(-55555555.5, context), '-55✅600✅000')
f.setShowThousandsSeparator(False)
f.setShowPlusSign(True)
f2 = f.clone()
self.assertIsInstance(f2, QgsBasicNumericFormat)
self.assertEqual(f2.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f2.showPlusSign(), f.showPlusSign())
self.assertEqual(f2.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f2.showThousandsSeparator(),
f.showThousandsSeparator())
self.assertEqual(f2.roundingType(), f.roundingType())
self.assertEqual(f2.thousandsSeparator(), f.thousandsSeparator())
self.assertEqual(f2.decimalSeparator(), f.decimalSeparator())
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
f2.writeXml(elem, doc, QgsReadWriteContext())
f3 = QgsNumericFormatRegistry().createFromXml(elem,
QgsReadWriteContext())
self.assertIsInstance(f3, QgsBasicNumericFormat)
self.assertEqual(f3.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f3.showPlusSign(), f.showPlusSign())
self.assertEqual(f3.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f3.showThousandsSeparator(),
f.showThousandsSeparator())
self.assertEqual(f3.roundingType(), f.roundingType())
self.assertEqual(f3.thousandsSeparator(), f.thousandsSeparator())
self.assertEqual(f3.decimalSeparator(), f.decimalSeparator())
def testFractionFormat(self):
""" test fraction formatter """
f = QgsFractionNumericFormat()
f.setUseUnicodeSuperSubscript(False)
context = QgsNumericFormatContext()
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(5, context), '5')
self.assertEqual(f.formatDouble(5.5, context), '5 1/2')
self.assertEqual(f.formatDouble(-5, context), '-5')
self.assertEqual(f.formatDouble(-5.5, context), '-5 1/2')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-55,555,555 1/2')
context.setThousandsSeparator('⚡')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-55⚡555⚡555 1/2')
f.setShowThousandsSeparator(False)
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555 1/2')
f.setShowPlusSign(True)
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(5, context), '+5')
self.assertEqual(f.formatDouble(-5, context), '-5')
self.assertEqual(f.formatDouble(5.5, context), '+5 1/2')
self.assertEqual(f.formatDouble(-5.5, context), '-5 1/2')
self.assertEqual(f.formatDouble(55555555.5, context), '+55555555 1/2')
self.assertEqual(f.formatDouble(55555555.123456, context),
'+55555555 5797/46956')
self.assertEqual(f.formatDouble(-5.5, context), '-5 1/2')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555 1/2')
context.setPositiveSign('w')
self.assertEqual(f.formatDouble(5, context), 'w5')
self.assertEqual(f.formatDouble(-5, context), '-5')
self.assertEqual(f.formatDouble(5.5, context), 'w5 1/2')
f.setShowPlusSign(False)
f.setUseDedicatedUnicodeCharacters(True)
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(5, context), '5')
self.assertEqual(f.formatDouble(5.5, context), '5 ½')
self.assertEqual(f.formatDouble(-5, context), '-5')
self.assertEqual(f.formatDouble(-5.5, context), '-5 ½')
self.assertEqual(
f.formatDouble(5.333333333333333333333333333, context), '5 ⅓')
self.assertEqual(
f.formatDouble(5.666666666666666666666666666, context), '5 ⅔')
self.assertEqual(f.formatDouble(5.25, context), '5 ¼')
self.assertEqual(f.formatDouble(5.75, context), '5 ¾')
self.assertEqual(f.formatDouble(5.2, context), '5 ⅕')
self.assertEqual(f.formatDouble(5.4, context), '5 ⅖')
self.assertEqual(f.formatDouble(5.6, context), '5 ⅗')
self.assertEqual(f.formatDouble(5.8, context), '5 ⅘')
self.assertEqual(
f.formatDouble(5.1666666666666666666666666666666666, context),
'5 ⅙')
self.assertEqual(
f.formatDouble(5.8333333333333333333333333333333333, context),
'5 ⅚')
self.assertEqual(f.formatDouble(5.14285714285714285, context), '5 ⅐')
self.assertEqual(f.formatDouble(5.125, context), '5 ⅛')
self.assertEqual(f.formatDouble(5.375, context), '5 ⅜')
self.assertEqual(f.formatDouble(5.625, context), '5 ⅝')
self.assertEqual(f.formatDouble(5.875, context), '5 ⅞')
self.assertEqual(f.formatDouble(5.1111111111111111, context), '5 ⅑')
self.assertEqual(f.formatDouble(5.1, context), '5 ⅒')
self.assertEqual(f.formatDouble(5.13131313133, context), '5 13/99')
f.setUseUnicodeSuperSubscript(True)
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(5, context), '5')
self.assertEqual(f.formatDouble(5.5, context), '5 ½')
self.assertEqual(f.formatDouble(-5, context), '-5')
self.assertEqual(f.formatDouble(-5.5, context), '-5 ½')
self.assertEqual(f.formatDouble(5.55555555, context),
'5 ¹¹¹¹¹¹¹¹/₂₀₀₀₀₀₀₀')
self.assertEqual(f.formatDouble(-5.55555555, context),
'-5 ¹¹¹¹¹¹¹¹/₂₀₀₀₀₀₀₀')
self.assertEqual(f.formatDouble(0.555, context), '¹¹¹/₂₀₀')
f.setShowPlusSign(True)
f.setUseUnicodeSuperSubscript(False)
f2 = f.clone()
self.assertIsInstance(f2, QgsFractionNumericFormat)
self.assertEqual(f2.showPlusSign(), f.showPlusSign())
self.assertEqual(f2.showThousandsSeparator(),
f.showThousandsSeparator())
self.assertEqual(f2.thousandsSeparator(), f.thousandsSeparator())
self.assertEqual(f2.useDedicatedUnicodeCharacters(),
f.useDedicatedUnicodeCharacters())
self.assertEqual(f2.useUnicodeSuperSubscript(),
f.useUnicodeSuperSubscript())
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
f2.writeXml(elem, doc, QgsReadWriteContext())
f3 = QgsNumericFormatRegistry().createFromXml(elem,
QgsReadWriteContext())
self.assertIsInstance(f3, QgsFractionNumericFormat)
self.assertEqual(f3.showPlusSign(), f.showPlusSign())
self.assertEqual(f3.showThousandsSeparator(),
f.showThousandsSeparator())
self.assertEqual(f3.thousandsSeparator(), f.thousandsSeparator())
self.assertEqual(f3.useDedicatedUnicodeCharacters(),
f.useDedicatedUnicodeCharacters())
self.assertEqual(f3.useUnicodeSuperSubscript(),
f.useUnicodeSuperSubscript())
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 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 testCurrencyFormat(self):
""" test currency formatter """
f = QgsCurrencyNumericFormat()
f.setPrefix('$')
context = QgsNumericFormatContext()
f.setShowTrailingZeros(False)
self.assertEqual(f.formatDouble(0, context), '$0')
self.assertEqual(f.formatDouble(5, context), '$5')
self.assertEqual(f.formatDouble(5.5, context), '$5.5')
self.assertEqual(f.formatDouble(-5, context), '-$5')
self.assertEqual(f.formatDouble(-5.5, context), '-$5.5')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-$55,555,555.5')
context.setDecimalSeparator('x')
self.assertEqual(f.formatDouble(0, context), '$0')
self.assertEqual(f.formatDouble(-5.5, context), '-$5x5')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-$55,555,555x5')
context.setThousandsSeparator('y')
self.assertEqual(f.formatDouble(-5.5, context), '-$5x5')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-$55y555y555x5')
f.setShowThousandsSeparator(False)
self.assertEqual(f.formatDouble(-5.5, context), '-$5x5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-$55555555x5')
context.setDecimalSeparator('.')
f.setNumberDecimalPlaces(0)
self.assertEqual(f.formatDouble(0, context), '$0')
self.assertEqual(f.formatDouble(5.5, context), '$6')
self.assertEqual(f.formatDouble(55555555.5, context), '$55555556')
self.assertEqual(f.formatDouble(55555555.123456, context), '$55555555')
self.assertEqual(f.formatDouble(-5.5, context), '-$6')
self.assertEqual(f.formatDouble(-55555555.5, context), '-$55555556')
f.setNumberDecimalPlaces(3)
self.assertEqual(f.formatDouble(0, context), '$0')
self.assertEqual(f.formatDouble(5.5, context), '$5.5')
self.assertEqual(f.formatDouble(55555555.5, context), '$55555555.5')
self.assertEqual(f.formatDouble(55555555.123456, context),
'$55555555.123')
self.assertEqual(f.formatDouble(-5.5, context), '-$5.5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-$55555555.5')
f.setShowTrailingZeros(True)
self.assertEqual(f.formatDouble(0, context), '$0.000')
self.assertEqual(f.formatDouble(5, context), '$5.000')
self.assertEqual(f.formatDouble(-5, context), '-$5.000')
self.assertEqual(f.formatDouble(5.5, context), '$5.500')
self.assertEqual(f.formatDouble(55555555.5, context), '$55555555.500')
self.assertEqual(f.formatDouble(55555555.123456, context),
'$55555555.123')
self.assertEqual(f.formatDouble(-5.5, context), '-$5.500')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-$55555555.500')
f.setShowPlusSign(True)
self.assertEqual(f.formatDouble(0, context), '$0.000')
self.assertEqual(f.formatDouble(5, context), '+$5.000')
self.assertEqual(f.formatDouble(-5, context), '-$5.000')
self.assertEqual(f.formatDouble(5.5, context), '+$5.500')
self.assertEqual(f.formatDouble(55555555.5, context), '+$55555555.500')
self.assertEqual(f.formatDouble(55555555.123456, context),
'+$55555555.123')
self.assertEqual(f.formatDouble(-5.5, context), '-$5.500')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-$55555555.500')
f.setSuffix('AUD')
self.assertEqual(f.formatDouble(0, context), '$0.000AUD')
self.assertEqual(f.formatDouble(5, context), '+$5.000AUD')
self.assertEqual(f.formatDouble(-5, context), '-$5.000AUD')
self.assertEqual(f.formatDouble(5.5, context), '+$5.500AUD')
self.assertEqual(f.formatDouble(55555555.5, context),
'+$55555555.500AUD')
self.assertEqual(f.formatDouble(55555555.123456, context),
'+$55555555.123AUD')
self.assertEqual(f.formatDouble(-5.5, context), '-$5.500AUD')
self.assertEqual(f.formatDouble(-55555555.5, context),
'-$55555555.500AUD')
f2 = f.clone()
self.assertIsInstance(f2, QgsCurrencyNumericFormat)
self.assertEqual(f2.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f2.showPlusSign(), f.showPlusSign())
self.assertEqual(f2.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f2.showThousandsSeparator(),
f.showThousandsSeparator())
self.assertEqual(f2.prefix(), f.prefix())
self.assertEqual(f2.suffix(), f.suffix())
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
f2.writeXml(elem, doc, QgsReadWriteContext())
f3 = QgsNumericFormatRegistry().createFromXml(elem,
QgsReadWriteContext())
self.assertIsInstance(f3, QgsCurrencyNumericFormat)
self.assertEqual(f3.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f3.showPlusSign(), f.showPlusSign())
self.assertEqual(f3.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f3.showThousandsSeparator(),
f.showThousandsSeparator())
self.assertEqual(f3.prefix(), f.prefix())
self.assertEqual(f3.suffix(), f.suffix())
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 rendererToSld(self, renderer, properties={}):
dom = QDomDocument()
root = dom.createElement("FakeRoot")
dom.appendChild(root)
renderer.toSld(dom, root, properties)
return dom, root
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 symbolToSld(self, symbolLayer):
dom = QDomDocument()
root = dom.createElement("FakeRoot")
dom.appendChild(root)
symbolLayer.toSld(dom, root, {})
return dom, root
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 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 testBearingFormat(self):
""" test bearing formatter """
f = QgsBearingNumericFormat()
f.setDirectionFormat(
QgsBearingNumericFormat.UseRange0To180WithEWDirectionalSuffix)
context = QgsNumericFormatContext()
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(90, context), '90°E')
self.assertEqual(f.formatDouble(180, context), '180°')
self.assertEqual(f.formatDouble(270, context), '90°W')
self.assertEqual(f.formatDouble(300, context), '60°W')
self.assertEqual(f.formatDouble(5, context), '5°E')
self.assertEqual(f.formatDouble(5.5, context), '5.5°E')
self.assertEqual(f.formatDouble(-5, context), '5°W')
self.assertEqual(f.formatDouble(-5.5, context), '5.5°W')
context.setDecimalSeparator('x')
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(-5.5, context), '5x5°W')
self.assertEqual(f.formatDouble(180, context), '180°')
context.setDecimalSeparator('.')
f.setNumberDecimalPlaces(0)
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(5.5, context), '6°E')
self.assertEqual(f.formatDouble(-5.5, context), '6°W')
self.assertEqual(f.formatDouble(180, context), '180°')
f.setNumberDecimalPlaces(3)
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(5.5, context), '5.5°E')
self.assertEqual(f.formatDouble(-5.5, context), '5.5°W')
self.assertEqual(f.formatDouble(180, context), '180°')
f.setShowTrailingZeros(True)
self.assertEqual(f.formatDouble(0, context),
'0.000°E') # todo - fix and avoid E
self.assertEqual(f.formatDouble(5, context), '5.000°E')
self.assertEqual(f.formatDouble(-5, context), '5.000°W')
self.assertEqual(f.formatDouble(5.5, context), '5.500°E')
self.assertEqual(f.formatDouble(-5.5, context), '5.500°W')
self.assertEqual(f.formatDouble(180, context),
'180.000°E') # todo fix and avoid E
f = QgsBearingNumericFormat()
f.setDirectionFormat(
QgsBearingNumericFormat.UseRangeNegative180ToPositive180)
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(90, context), '90°')
self.assertEqual(f.formatDouble(180, context), '180°')
self.assertEqual(f.formatDouble(270, context), '-90°')
self.assertEqual(f.formatDouble(5, context), '5°')
self.assertEqual(f.formatDouble(5.5, context), '5.5°')
self.assertEqual(f.formatDouble(-5, context), '-5°')
self.assertEqual(f.formatDouble(-5.5, context), '-5.5°')
context.setDecimalSeparator('x')
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(-5.5, context), '-5x5°')
self.assertEqual(f.formatDouble(180, context), '180°')
context.setDecimalSeparator('.')
f.setNumberDecimalPlaces(0)
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(5.5, context), '6°')
self.assertEqual(f.formatDouble(-5.5, context), '-6°')
self.assertEqual(f.formatDouble(180, context), '180°')
f.setNumberDecimalPlaces(3)
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(5.5, context), '5.5°')
self.assertEqual(f.formatDouble(-5.5, context), '-5.5°')
self.assertEqual(f.formatDouble(180, context), '180°')
f.setShowTrailingZeros(True)
self.assertEqual(f.formatDouble(0, context), '0.000°')
self.assertEqual(f.formatDouble(5, context), '5.000°')
self.assertEqual(f.formatDouble(-5, context), '-5.000°')
self.assertEqual(f.formatDouble(5.5, context), '5.500°')
self.assertEqual(f.formatDouble(-5.5, context), '-5.500°')
self.assertEqual(f.formatDouble(180, context), '180.000°')
f = QgsBearingNumericFormat()
f.setDirectionFormat(QgsBearingNumericFormat.UseRange0To360)
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(90, context), '90°')
self.assertEqual(f.formatDouble(180, context), '180°')
self.assertEqual(f.formatDouble(270, context), '270°')
self.assertEqual(f.formatDouble(5, context), '5°')
self.assertEqual(f.formatDouble(5.5, context), '5.5°')
self.assertEqual(f.formatDouble(-5, context), '355°')
self.assertEqual(f.formatDouble(-5.5, context), '354.5°')
context.setDecimalSeparator('x')
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(-5.5, context), '354x5°')
self.assertEqual(f.formatDouble(180, context), '180°')
context.setDecimalSeparator('.')
f.setNumberDecimalPlaces(0)
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(5.5, context), '6°')
self.assertEqual(f.formatDouble(-5.4, context), '355°')
self.assertEqual(f.formatDouble(180, context), '180°')
f.setNumberDecimalPlaces(3)
self.assertEqual(f.formatDouble(0, context), '0°')
self.assertEqual(f.formatDouble(5.5, context), '5.5°')
self.assertEqual(f.formatDouble(-5.5, context), '354.5°')
self.assertEqual(f.formatDouble(180, context), '180°')
f.setShowTrailingZeros(True)
self.assertEqual(f.formatDouble(0, context), '0.000°')
self.assertEqual(f.formatDouble(5, context), '5.000°')
self.assertEqual(f.formatDouble(-5, context), '355.000°')
self.assertEqual(f.formatDouble(5.5, context), '5.500°')
self.assertEqual(f.formatDouble(-5.5, context), '354.500°')
self.assertEqual(f.formatDouble(180, context), '180.000°')
f2 = f.clone()
self.assertIsInstance(f2, QgsBearingNumericFormat)
self.assertEqual(f2.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f2.showPlusSign(), f.showPlusSign())
self.assertEqual(f2.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f2.showThousandsSeparator(),
f.showThousandsSeparator())
self.assertEqual(f2.directionFormat(), f.directionFormat())
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
f2.writeXml(elem, doc, QgsReadWriteContext())
f3 = QgsNumericFormatRegistry().createFromXml(elem,
QgsReadWriteContext())
self.assertIsInstance(f3, QgsBearingNumericFormat)
self.assertEqual(f3.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f3.showPlusSign(), f.showPlusSign())
self.assertEqual(f3.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f3.showThousandsSeparator(),
f.showThousandsSeparator())
self.assertEqual(f3.directionFormat(), f.directionFormat())
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')))
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']:
print('Translating layer: {0}'.format(layer.name()))
def createAndParseSld(qgisLayerItem):
document = QDomDocument()
header = document.createProcessingInstruction(
'xml', 'version=\'1.0\' encoding=\'UTF-8\'')
document.appendChild(header)
root = document.createElementNS('http://www.opengis.net/sld',
'StyledLayerDescriptor')
root.setAttribute('version', '1.0.0')
root.setAttribute('xmlns:ogc', 'http://www.opengis.net/ogc')
root.setAttribute('xmlns:sld', 'http://www.opengis.net/sld')
root.setAttribute('xmlns:gml', 'http://www.opengis.net/gml')
document.appendChild(root)
namedLayerNode = document.createElement('sld:NamedLayer')
root.appendChild(namedLayerNode)
qgisLayerItem.layer.writeSld(namedLayerNode, document, '')
nameNode = namedLayerNode.firstChildElement('se:Name')
oldNameText = nameNode.firstChild()
newname = qgisLayerItem.parentShogunLayer.source['layerNames']
newNameText = document.createTextNode(newname)
nameNode.appendChild(newNameText)
nameNode.removeChild(oldNameText)
userStyleNode = namedLayerNode.firstChildElement('UserStyle')
userStyleNameNode = userStyleNode.firstChildElement('se:Name')
userStyleNameText = userStyleNameNode.firstChild()
userStyleNameNode.removeChild(userStyleNameText)
userStyleNameNode.appendChild(
document.createTextNode(qgisLayerItem.stylename))
titleNode = document.createElement('sld:Title')
title = document.createTextNode('A QGIS-Style for ' +
qgisLayerItem.layer.name())
titleNode.appendChild(title)
userStyleNode.appendChild(titleNode)
defaultNode = document.createElement('sld:IsDefault')
defaultNode.appendChild(document.createTextNode('1'))
userStyleNode.appendChild(defaultNode)
featureTypeStyleNode = userStyleNode.firstChildElement(
'se:FeatureTypeStyle')
featureTypeStyleNameNode = document.createElement('sld:Name')
featureTypeStyleNameNode.appendChild(document.createTextNode('name'))
featureTypeStyleNode.appendChild(featureTypeStyleNameNode)
rules = featureTypeStyleNode.elementsByTagName('se:Rule')
for x in range(rules.length()):
rule = rules.at(x)
rule.removeChild(rule.firstChildElement('se:Description'))
# Check if custom icons are used in symbology and replace the text:
# search if tag 'se:OnlineResource' is in the sld document
listOfGraphics = rule.toElement().elementsByTagName('se:OnlineResource')
if not listOfGraphics.isEmpty():
for x in range(listOfGraphics.length()):
graphicNode = listOfGraphics.at(x)
currentIcon = graphicNode.attributes().namedItem(
'xlink:href').nodeValue()
iconUrl = qgisLayerItem.ressource.prepareIconForUpload(currentIcon)
graphicNode.toElement().setAttribute('xlink:href', iconUrl)
graphicNode.toElement().setAttribute(
'xmlns:xlink', 'http://www.w3.org/1999/xlink')
sld = document.toString()
# in qgis3 layer.writeSld() also incluedes labeling in the output sld,
# whereas in qgis2 we have to do this manually by using this module's function
# getLabelingAsSld
## TODO: The automatic sld labeling from QGIS 3 produces an extra rule for
# every labeling style, thus leading to a less beautiful viewe in the
# shogun2-webapp styler - is this a problem?
if qgisLayerItem.layer.labelsEnabled() and PYTHON_VERSION < 3:
labelSld = getLabelingAsSld(qgisLayerItem.layer)
sld = sld.replace('</se:Rule>', labelSld + '</se:Rule>')
sld = sld.replace('ogc:Filter xmlns:ogc="http://www.opengis.net/ogc"',
'ogc:Filter')
# the following fixes weird problems with the sld compability with the
# shogun webapp
sld = sld.replace('<ogc:And>', '')
sld = sld.replace('</ogc:And>', '')
sld = sld.replace('<se:Name> ', '<se:Name>')
sld = sld.replace(' </se:Name>', '</se:Name>')
sld = sld.replace('StyledLayerDescriptor', 'sld:StyledLayerDescriptor')
sld = sld.replace('UserStyle', 'sld:UserStyle')
sld = sld.replace('se:', 'sld:')
sld = sld.replace('SvgParameter', 'CssParameter')
sld = sld.replace('\n', '')
sld = sld.replace('\t', '')
return sld
def testBasicFormat(self):
""" test basic formatter """
f = QgsBasicNumericFormat()
context = QgsNumericFormatContext()
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(5, context), '5')
self.assertEqual(f.formatDouble(5.5, context), '5.5')
self.assertEqual(f.formatDouble(-5, context), '-5')
self.assertEqual(f.formatDouble(-5.5, context), '-5.5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55,555,555.5')
context.setDecimalSeparator('x')
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(-5.5, context), '-5x5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55,555,555x5')
context.setThousandsSeparator('y')
self.assertEqual(f.formatDouble(-5.5, context), '-5x5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55y555y555x5')
f.setShowThousandsSeparator(False)
self.assertEqual(f.formatDouble(-5.5, context), '-5x5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555x5')
context.setDecimalSeparator('.')
f.setNumberDecimalPlaces(0)
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(5.5, context), '6')
self.assertEqual(f.formatDouble(55555555.5, context), '55555556')
self.assertEqual(f.formatDouble(55555555.123456, context), '55555555')
self.assertEqual(f.formatDouble(-5.5, context), '-6')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555556')
f.setNumberDecimalPlaces(3)
self.assertEqual(f.formatDouble(0, context), '0')
self.assertEqual(f.formatDouble(5.5, context), '5.5')
self.assertEqual(f.formatDouble(55555555.5, context), '55555555.5')
self.assertEqual(f.formatDouble(55555555.123456, context),
'55555555.123')
self.assertEqual(f.formatDouble(-5.5, context), '-5.5')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555.5')
f.setShowTrailingZeros(True)
self.assertEqual(f.formatDouble(0, context), '0.000')
self.assertEqual(f.formatDouble(5, context), '5.000')
self.assertEqual(f.formatDouble(-5, context), '-5.000')
self.assertEqual(f.formatDouble(5.5, context), '5.500')
self.assertEqual(f.formatDouble(55555555.5, context), '55555555.500')
self.assertEqual(f.formatDouble(55555555.123456, context),
'55555555.123')
self.assertEqual(f.formatDouble(-5.5, context), '-5.500')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555.500')
f.setShowPlusSign(True)
self.assertEqual(f.formatDouble(0, context), '0.000')
self.assertEqual(f.formatDouble(5, context), '+5.000')
self.assertEqual(f.formatDouble(-5, context), '-5.000')
self.assertEqual(f.formatDouble(5.5, context), '+5.500')
self.assertEqual(f.formatDouble(55555555.5, context), '+55555555.500')
self.assertEqual(f.formatDouble(55555555.123456, context),
'+55555555.123')
self.assertEqual(f.formatDouble(-5.5, context), '-5.500')
self.assertEqual(f.formatDouble(-55555555.5, context), '-55555555.500')
context.setPositiveSign('w')
self.assertEqual(f.formatDouble(5, context), 'w5.000')
self.assertEqual(f.formatDouble(-5, context), '-5.000')
self.assertEqual(f.formatDouble(5.5, context), 'w5.500')
f2 = f.clone()
self.assertIsInstance(f2, QgsBasicNumericFormat)
self.assertEqual(f2.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f2.showPlusSign(), f.showPlusSign())
self.assertEqual(f2.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f2.showThousandsSeparator(),
f.showThousandsSeparator())
doc = QDomDocument("testdoc")
elem = doc.createElement("test")
f2.writeXml(elem, doc, QgsReadWriteContext())
f3 = QgsNumericFormatRegistry().createFromXml(elem,
QgsReadWriteContext())
self.assertIsInstance(f3, QgsBasicNumericFormat)
self.assertEqual(f3.showTrailingZeros(), f.showTrailingZeros())
self.assertEqual(f3.showPlusSign(), f.showPlusSign())
self.assertEqual(f3.numberDecimalPlaces(), f.numberDecimalPlaces())
self.assertEqual(f3.showThousandsSeparator(),
f.showThousandsSeparator())
def adjust(self):
""" Export data to GNU Gama xml, adjust the network and read result
:returns: result list of adjusment from GNU Gama
"""
# fix = 0 free network
fix = 0
adj = 0
for p, s in self.points:
if s == 'FIX':
fix += 1
else:
adj += 1
if adj == 0 or len(self.observations) == 0:
# no unknowns or observations
return None
doc = QDomDocument()
doc.appendChild(
doc.createComment(
'Gama XML created by SurveyingCalculation plugin for QGIS'))
gama_local = doc.createElement('gama-local')
gama_local.setAttribute('version', '2.0')
doc.appendChild(gama_local)
network = doc.createElement('network')
network.setAttribute('axes-xy', 'ne')
network.setAttribute('angles', 'left-handed')
gama_local.appendChild(network)
description = doc.createElement('description')
if self.dimension == 1:
description.appendChild(doc.createTextNode('GNU Gama 1D network'))
elif self.dimension == 2:
description.appendChild(doc.createTextNode('GNU Gama 2D network'))
elif self.dimension == 3:
description.appendChild(doc.createTextNode('GNU Gama 3D network'))
network.appendChild(description)
parameters = doc.createElement('parameters')
parameters.setAttribute('sigma-apr', '1')
parameters.setAttribute('conf-pr', str(self.probability))
parameters.setAttribute('tol-abs', '1000')
parameters.setAttribute('sigma-act', 'aposteriori')
parameters.setAttribute('update-constrained-coordinates', 'yes')
network.appendChild(parameters)
points_observations = doc.createElement('points-observations')
points_observations.setAttribute(
'distance-stdev',
str(self.stdev_dist) + ' ' + str(self.stdev_dist1))
points_observations.setAttribute('direction-stdev',
str(self.stdev_angle))
points_observations.setAttribute('angle-stdev',
str(math.sqrt(self.stdev_angle * 2)))
points_observations.setAttribute('zenith-angle-stdev',
str(self.stdev_angle))
network.appendChild(points_observations)
for p, s in self.points:
if self.dimension == 1:
tmp = doc.createElement('point')
tmp.setAttribute('id', p.id)
if p.z is not None:
tmp.setAttribute('z', str(p.z))
if s == 'FIX':
tmp.setAttribute('fix', 'z')
else:
if fix == 0:
tmp.setAttribute('adj', 'Z')
else:
tmp.setAttribute('adj', 'z')
points_observations.appendChild(tmp)
elif self.dimension == 2:
tmp = doc.createElement('point')
tmp.setAttribute('id', p.id)
if p.e is not None and p.n is not None:
tmp.setAttribute('y', str(p.e))
tmp.setAttribute('x', str(p.n))
if s == 'FIX':
tmp.setAttribute('fix', 'xy')
else:
if fix == 0:
# free network
tmp.setAttribute('adj', 'XY')
else:
tmp.setAttribute('adj', 'xy')
points_observations.appendChild(tmp)
elif self.dimension == 3:
tmp = doc.createElement('point')
tmp.setAttribute('id', p.id)
if p.e is not None and p.n is not None:
tmp.setAttribute('y', str(p.e))
tmp.setAttribute('x', str(p.n))
if p.z is not None:
tmp.setAttribute('z', str(p.z))
if s == 'FIX':
tmp.setAttribute('fix', 'xyz')
else:
if fix == 0:
tmp.setAttribute('adj', 'XYZ')
else:
tmp.setAttribute('adj', 'xyz')
points_observations.appendChild(tmp)
if self.dimension == 1:
hd = doc.createElement('height-differences')
points_observations.appendChild(hd)
for o in self.observations:
if o.station == 'station':
# station record
st_id = o.point_id
if o.th is None:
ih = 0
else:
ih = o.th
if self.dimension in [2, 3]:
sta = doc.createElement('obs')
sta.setAttribute('from', o.point_id)
points_observations.appendChild(sta)
else:
# observation
if self.dimension == 2:
# horizontal network
if o.hz is not None:
tmp = doc.createElement('direction')
tmp.setAttribute('to', o.point_id)
tmp.setAttribute('val', str(o.hz.get_angle('GON')))
sta.appendChild(tmp)
if o.d is not None:
# horizontal distance
hd = o.horiz_dist()
if hd is not None:
tmp = doc.createElement('distance')
tmp.setAttribute('to', o.point_id)
tmp.setAttribute('val', str(hd))
sta.appendChild(tmp)
elif self.dimension == 1:
# elevations only 1d
if o.th is None:
th = 0
else:
th = o.th
if o.d is not None and o.v is not None:
tmp = doc.createElement('dh')
tmp.setAttribute('from', st_id)
tmp.setAttribute('to', o.point_id)
# TODO hibaterjedes
tmp.setAttribute('stdev', '1')
sz = math.sin(o.v.get_angle())
w = self.stdev_dist + self.stdev_dist1 * o.d.d / 1000
ro_cc = 200 * 100 * 100 / math.pi
if o.d.mode == 'SD':
cz = math.cos(o.v.get_angle())
tmp.setAttribute('val', str(o.d.d * cz + ih - th))
tmp.setAttribute(
'stdev',
str(
math.sqrt(cz**2 * w**2 +
(o.d.d * 1000)**2 * sz**2 *
(self.stdev_angle / RO_CC)**2)))
else:
tz = math.tan(o.v.get_angle())
tmp.setAttribute(
'val',
str(o.d.d / math.tan(o.v.get_angle()) + ih -
th))
tmp.setAttribute(
'stdev',
str(
math.sqrt((1 / tz)**2 * w**2 +
(o.d.d * 1000)**2 *
(o.d.d * 1000)**2 *
(1 / sz**2)**2 *
(self.stdev_angle / RO_CC)**2)))
hd.appendChild(tmp)
elif self.dimension == 3:
# 3d
if o.th is None:
th = 0
else:
th = o.th
if o.hz is not None:
tmp = doc.createElement('direction')
tmp.setAttribute('to', o.point_id)
tmp.setAttribute('val', str(o.hz.get_angle('GON')))
sta.appendChild(tmp)
if o.d is not None:
if o.d.mode == 'SD':
tmp = doc.createElement('s-distance')
tmp.setAttribute('val', str(o.d.d))
tmp.setAttribute('from_dh', str(ih))
tmp.setAttribute('to_dh', str(th))
else:
tmp = doc.createElement('distance')
tmp.setAttribute('val', str(o.d.d))
tmp.setAttribute('to', o.point_id)
sta.appendChild(tmp)
if o.v is not None:
tmp = doc.createElement('z-angle')
tmp.setAttribute('to', o.point_id)
tmp.setAttribute('val', str(o.v.get_angle('GON')))
tmp.setAttribute('from_dh', str(ih))
tmp.setAttribute('to_dh', str(th))
sta.appendChild(tmp)
else:
# unknown dimension
return None
# generate temp file name
tmpf = QTemporaryFile(QDir.temp().absoluteFilePath('w'))
tmpf.open(QIODevice.WriteOnly)
tmpf.close()
tmp_name = tmpf.fileName()
f = QFile(tmp_name + '.xml')
if f.open(QIODevice.WriteOnly):
f.write(doc.toByteArray())
f.close()
# run gama-local
if self.gama_prog is None:
return None
status = QProcess.execute(self.gama_prog, [
tmp_name + '.xml', '--angles', '360', '--text', tmp_name + '.txt',
'--xml', tmp_name + 'out.xml'
])
if status != 0:
return None
xmlParser = QXmlSimpleReader()
xmlFile = QFile(tmp_name + 'out.xml')
xmlInputSource = QXmlInputSource(xmlFile)
doc.setContent(xmlInputSource, xmlParser)
f_txt = QFile(tmp_name + '.txt')
f_txt.open(QIODevice.ReadOnly)
res = f_txt.readAll().data()
f_txt.close()
# store coordinates
adj_nodes = doc.elementsByTagName('adjusted')
if adj_nodes.count() < 1:
return res
adj_node = adj_nodes.at(0)
for i in range(len(adj_node.childNodes())):
pp = adj_node.childNodes().at(i)
if pp.nodeName() == 'point':
for ii in range(len(pp.childNodes())):
ppp = pp.childNodes().at(ii)
if ppp.nodeName() == 'id':
p = Point(ppp.firstChild().nodeValue())
elif ppp.nodeName() == 'Y' or ppp.nodeName() == 'y':
p.e = float(ppp.firstChild().nodeValue())
elif ppp.nodeName() == 'X' or ppp.nodeName() == 'x':
p.n = float(ppp.firstChild().nodeValue())
elif ppp.nodeName() == 'Z' or ppp.nodeName() == 'z':
p.z = float(ppp.firstChild().nodeValue())
ScPoint(p).store_coord(self.dimension)
# remove input xml and output xml
tmpf.remove()
f_txt.remove()
f.remove()
xmlFile.remove()
return res
class XFORMDocument:
"""
class to generate an Xml file that is needed for data collection
using mobile device. The class creates the file and QDOM sections
for holding data once the file is called
"""
def __init__(self, fname):
"""
Initalize the class so that we have a new file
everytime document generation method is called
"""
self.dt_text = QDate()
self.file_handler = FilePaths()
self.doc = QDomDocument()
self.form = None
self.fname = fname
self.doc_with_entities = []
self.supports_doc = self.document()
def document(self):
"""
use the globally defined Document name for supporting document
:return:
"""
global DOCUMENT
return DOCUMENT
def form_name(self):
"""
Format the name for the new file to be created. We need to ensure it is
.xml file.
:return:
"""
if len(self.fname.split(".")) > 1:
return self.fname
else:
return self.fname + "{}".format(DOCEXTENSION)
def set_form_name(self, local_name):
"""
Allow the user to update the name of the file. This method
will be called to return a new file with the local_name given
:param local_name: string
:return: QFile
"""
self.fname = local_name + "{}".format(DOCEXTENSION)
self.form.setFileName(self.fname)
self.create_form()
return self.fname
def create_form(self):
"""
Create an XML file that will be our XFORM Document for reading and writing
We want a new file when everytime we are creating XForm
type: file
:return: file
"""
self.form = QFile(os.path.join(FORM_HOME,
self.form_name()))
if not QFileInfo(self.form).suffix() == DOCEXTENSION:
self.form_name()
if not self.form.open(QIODevice.ReadWrite | QIODevice.Truncate |
QIODevice.Text):
return self.form.OpenError
def create_node(self, name):
"""
Create a XML element node
:param name:
:return: node
:rtype: QelementNode
"""
return self.doc.createElement(name)
def create_text_node(self, text):
"""
Create an XML text node
:param text:
:return:
"""
return self.doc.createTextNode(text)
def create_node_attribute(self, node, key, value):
"""
Create an attribute and attach it to the node
:param node: Qnode
:param key: Qnode name
:param value: Qnode value
:return: QNode
"""
return node.setAttribute(key, value)
def xform_document(self):
"""
:return: QDomDocument
"""
return self.doc
def write_to_form(self):
"""
Write data to xml file from the base calling class to an output file created earlier
:return:
"""
if isinstance(self.form, QFile):
self.form.write(self.doc.toByteArray())
self.form.close()
self.doc.clear()
else:
return None
def update_form_data(self):
"""
Update the xml file with changes that the user has made.
Particular section of the document will be deleted or added
:return:
"""
pass
