def testQgsCentroidFillSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsCentroidFillSymbolLayerV2'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsCentroidFillSymbolLayerV2.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsCentroidFillSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'regular_star'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'#55aaff'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'#00ff00'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).borderColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsSvgMarkerSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsSvgMarkerSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSvgMarkerSymbolLayer.createFromSld(mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSvgMarkerSymbolLayer(""))
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 'skull.svg'
mValue = os.path.basename(mSymbolLayer.path())
print(("VALUE", mSymbolLayer.path()))
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 12
mValue = mSymbolLayer.size()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 45
mValue = mSymbolLayer.angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsSVGFillSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsSVGFillSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSVGFillSymbolLayer.createFromSld(
mDoc.elementsByTagName('PolygonSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSVGFillSymbolLayer(""))
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 'accommodation_camping.svg'
mValue = os.path.basename(mSymbolLayer.svgFilePath())
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 6
mValue = mSymbolLayer.patternWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def 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 createEllipseSymbolLayer(self):
# No way to build it programmatically...
mTestName = 'QgsEllipseSymbolLayer'
mFilePath = QDir.toNativeSeparators(
'%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsEllipseSymbolLayer.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
return mSymbolLayer
def testQgsSimpleLineSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = "QgsSimpleLineSymbolLayerV2"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSimpleLineSymbolLayerV2.createFromSld(
mDoc.elementsByTagName("LineSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsSimpleLineSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#aa007f"
mValue = mSymbolLayer.color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 1.26
mValue = mSymbolLayer.width()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.RoundCap
mValue = mSymbolLayer.penCapStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.MiterJoin
mValue = mSymbolLayer.penJoinStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = True
mValue = mSymbolLayer.useCustomDashPattern()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = [5.0, 2.0]
mValue = mSymbolLayer.customDashVector()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsLinePatternFillSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = "QgsLinePatternFillSymbolLayer"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsLinePatternFillSymbolLayer.createFromSld(
mDoc.elementsByTagName("PolygonSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsLinePatternFillSymbolLayer())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ff55ff"
mValue = mSymbolLayer.color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 1.5
mValue = mSymbolLayer.lineWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 4
mValue = mSymbolLayer.distance()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 57
mValue = mSymbolLayer.lineAngle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
# test colors, need to make sure colors are passed/retrieved from subsymbol
mSymbolLayer.setColor(QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.color(), QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(150, 50, 100))
mSymbolLayer.subSymbol().setColor(QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.color(), QColor(250, 150, 200))
def testQgsMarkerLineSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = "QgsMarkerLineSymbolLayerV2"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsMarkerLineSymbolLayerV2.createFromSld(
mDoc.elementsByTagName("LineSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsMarkerLineSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QgsMarkerLineSymbolLayerV2.CentralPoint
mValue = mSymbolLayer.placement()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"circle"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#000000"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).borderColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ff0000"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
# test colors, need to make sure colors are passed/retrieved from subsymbol
mSymbolLayer.setColor(QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.color(), QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(150, 50, 100))
mSymbolLayer.subSymbol().setColor(QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.color(), QColor(250, 150, 200))
def testQgsPointPatternFillSymbolLayerSld(self):
"""
Create a new style from a .sld file and match test
"""
# at the moment there is an empty createFromSld implementation
# that return nulls
mTestName = "QgsPointPatternFillSymbolLayer"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsPointPatternFillSymbolLayer.createFromSld(
mDoc.elementsByTagName("PolygonSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsPointPatternFillSymbolLayer())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"triangle"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ffaa00"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ff007f"
mValue = mSymbolLayer.subSymbol().symbolLayer(0).borderColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 5
mValue = mSymbolLayer.subSymbol().symbolLayer(0).angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 3
mValue = mSymbolLayer.subSymbol().symbolLayer(0).size()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsCentroidFillSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsCentroidFillSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsCentroidFillSymbolLayer.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsCentroidFillSymbolLayer())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QgsSimpleMarkerSymbolLayerBase.Star
mValue = mSymbolLayer.subSymbol().symbolLayer(0).shape()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = '#55aaff'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = '#00ff00'
mValue = mSymbolLayer.subSymbol().symbolLayer(0).strokeColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = False
mValue = mSymbolLayer.pointOnAllParts()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
# test colors, need to make sure colors are passed/retrieved from subsymbol
mSymbolLayer.setColor(QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.color(), QColor(150, 50, 100))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(150, 50, 100))
mSymbolLayer.subSymbol().setColor(QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.subSymbol().color(), QColor(250, 150, 200))
self.assertEqual(mSymbolLayer.color(), QColor(250, 150, 200))
def testQgsEllipseSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = "QgsEllipseSymbolLayerV2"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsEllipseSymbolLayerV2.createFromSld(
mDoc.elementsByTagName("PointSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsEllipseSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"circle"
mValue = mSymbolLayer.symbolName()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ffff7f"
mValue = mSymbolLayer.fillColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#aaaaff"
mValue = mSymbolLayer.outlineColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 7
mValue = mSymbolLayer.symbolWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 5
mValue = mSymbolLayer.symbolHeight()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsFontMarkerSymbolLayerV2(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = "QgsFontMarkerSymbolLayerV2"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsFontMarkerSymbolLayerV2.createFromSld(
mDoc.elementsByTagName("PointSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsFontMarkerSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"Arial"
mValue = mSymbolLayer.fontFamily()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"M"
mValue = mSymbolLayer.character()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 6.23
mValue = mSymbolLayer.size()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 3
mValue = mSymbolLayer.angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsSimpleFillSymbolLayerV2(self):
"""Create a new style from a .sld file and match test.
"""
mTestName = "QgsSimpleFillSymbolLayerV2"
mFilePath = QDir.toNativeSeparators("%s/symbol_layer/%s.sld" % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSimpleFillSymbolLayerV2.createFromSld(
mDoc.elementsByTagName("PolygonSymbolizer").item(0).toElement()
)
mExpectedValue = type(QgsSimpleFillSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.SolidPattern
mValue = mSymbolLayer.brushStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u"#ffaa7f"
mValue = mSymbolLayer.borderColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.DotLine
mValue = mSymbolLayer.borderStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 0.26
mValue = mSymbolLayer.borderWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsLinePatternFillSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsLinePatternFillSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' % (unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsLinePatternFillSymbolLayer.createFromSld(
mDoc.elementsByTagName('PolygonSymbolizer').item(0).toElement())
mExpectedValue = type(QgsLinePatternFillSymbolLayer())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'#ff55ff'
mValue = mSymbolLayer.color().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 1.5
mValue = mSymbolLayer.lineWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 4
mValue = mSymbolLayer.distance()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 57
mValue = mSymbolLayer.lineAngle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def testQgsSvgMarkerSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsSvgMarkerSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' %
(unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSvgMarkerSymbolLayer.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSvgMarkerSymbolLayer(""))
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 'skull.svg'
mValue = os.path.basename(mSymbolLayer.path())
print(("VALUE", mSymbolLayer.path()))
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 12
mValue = mSymbolLayer.size()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 45
mValue = mSymbolLayer.angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def exportDocument(self, task, fileName, format):
"""
:type task: QUrl
:type fileName: str
:type format: self.ExportFormat
:return: bool
"""
fileOut = QFile(fileName)
if not fileOut.open(QIODevice.WriteOnly | QIODevice.Text):
return False
taskMap = self.__parseTask(task)
text = self.__documentContent(taskMap, format)
streamFileOut = QTextStream(fileOut)
streamFileOut.setCodec("UTF-8")
streamFileOut << text
streamFileOut.flush()
fileOut.close()
return True
def requestFinished(self):
if self.reply.error() != QNetworkReply.NoError:
QApplication.restoreOverrideCursor()
iface.messageBar().pushMessage(
"Lessons could not be installed:\n",
self.reply.errorString(),
QgsMessageBar.WARNING)
self.reply.deleteLater()
return
f = QFile(tempFilenameInTempFolder(os.path.basename(self.url).split(".")[0]))
f.open(QFile.WriteOnly)
f.write(self.reply.readAll())
f.close()
self.reply.deleteLater()
from lessons import installLessonsFromZipFile
installLessonsFromZipFile(f.fileName())
QApplication.restoreOverrideCursor()
iface.messageBar().pushMessage(
"Completed",
"Lessons were correctly installed",
QgsMessageBar.INFO)
def _download_file(self, url, out_path):
reply = self.__sync_request(url)
local_file = QFile(out_path)
local_file.open(QIODevice.WriteOnly)
local_file.write(reply)
local_file.close()
class FileDownloader():
"""The blueprint for downloading file from url."""
def __init__(self, url, output_path, progress_dialog=None):
"""Constructor of the class.
.. versionchanged:: 3.3 removed manager parameter.
:param url: URL of file.
:type url: str
:param output_path: Output path.
:type output_path: str
:param progress_dialog: Progress dialog widget.
:type progress_dialog: QWidget
"""
# noinspection PyArgumentList
self.manager = QgsNetworkAccessManager.instance()
self.url = QUrl(url)
self.output_path = output_path
self.progress_dialog = progress_dialog
if self.progress_dialog:
self.prefix_text = self.progress_dialog.labelText()
self.output_file = None
self.reply = None
self.downloaded_file_buffer = None
self.finished_flag = False
def download(self):
"""Downloading the file.
:returns: True if success, otherwise returns a tuple with format like
this (QNetworkReply.NetworkError, error_message)
:raises: IOError - when cannot create output_path
"""
# Prepare output path
self.output_file = QFile(self.output_path)
if not self.output_file.open(QFile.WriteOnly):
raise IOError(self.output_file.errorString())
# Prepare downloaded buffer
self.downloaded_file_buffer = QByteArray()
# Request the url
request = QNetworkRequest(self.url)
self.reply = self.manager.get(request)
self.reply.readyRead.connect(self.get_buffer)
self.reply.finished.connect(self.write_data)
self.manager.requestTimedOut.connect(self.request_timeout)
if self.progress_dialog:
# progress bar
def progress_event(received, total):
"""Update progress.
:param received: Data received so far.
:type received: int
:param total: Total expected data.
:type total: int
"""
# noinspection PyArgumentList
QgsApplication.processEvents()
self.progress_dialog.adjustSize()
human_received = humanize_file_size(received)
human_total = humanize_file_size(total)
label_text = tr(
"%s : %s of %s" %
(self.prefix_text, human_received, human_total))
self.progress_dialog.setLabelText(label_text)
self.progress_dialog.setMaximum(total)
self.progress_dialog.setValue(received)
# cancel
def cancel_action():
"""Cancel download."""
self.reply.abort()
self.reply.deleteLater()
self.reply.downloadProgress.connect(progress_event)
self.progress_dialog.canceled.connect(cancel_action)
# Wait until finished
# On Windows 32bit AND QGIS 2.2, self.reply.isFinished() always
# returns False even after finished slot is called. So, that's why we
# are adding self.finished_flag (see #864)
while not self.reply.isFinished() and not self.finished_flag:
# noinspection PyArgumentList
QgsApplication.processEvents()
result = self.reply.error()
try:
http_code = int(
self.reply.attribute(QNetworkRequest.HttpStatusCodeAttribute))
except TypeError:
# If the user cancels the request, the HTTP response will be None.
http_code = None
self.reply.abort()
self.reply.deleteLater()
if result == QNetworkReply.NoError:
return True, None
elif result == QNetworkReply.UnknownNetworkError:
return False, tr(
'The network is unreachable. Please check your internet '
'connection.')
elif http_code == 408:
msg = tr('Sorry, the server aborted your request. '
'Please try a smaller area.')
LOGGER.debug(msg)
return False, msg
elif http_code == 509:
msg = tr(
'Sorry, the server is currently busy with another request. '
'Please try again in a few minutes.')
LOGGER.debug(msg)
return False, msg
elif result == QNetworkReply.ProtocolUnknownError or \
result == QNetworkReply.HostNotFoundError:
# See http://doc.qt.io/qt-5/qurl-obsolete.html#encodedHost
encoded_host = self.url.toAce(self.url.host())
LOGGER.exception('Host not found : %s' % encoded_host)
return False, tr(
'Sorry, the server is unreachable. Please try again later.')
elif result == QNetworkReply.ContentNotFoundError:
LOGGER.exception('Path not found : %s' % self.url.path())
return False, tr('Sorry, the layer was not found on the server.')
else:
return result, self.reply.errorString()
def get_buffer(self):
"""Get buffer from self.reply and store it to our buffer container."""
buffer_size = self.reply.size()
data = self.reply.read(buffer_size)
self.downloaded_file_buffer.append(data)
def write_data(self):
"""Write data to a file."""
self.output_file.write(self.downloaded_file_buffer)
self.output_file.close()
self.finished_flag = True
def request_timeout(self):
"""The request timed out."""
if self.progress_dialog:
self.progress_dialog.hide()
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()
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
class QgsPluginInstallerInstallingDialog(QDialog, Ui_QgsPluginInstallerInstallingDialogBase):
# ----------------------------------------- #
def __init__(self, parent, plugin):
QDialog.__init__(self, parent)
self.setupUi(self)
self.plugin = plugin
self.mResult = ""
self.progressBar.setRange(0, 0)
self.progressBar.setFormat("%p%")
self.labelName.setText(plugin["name"])
self.buttonBox.clicked.connect(self.abort)
self.url = QUrl(plugin["download_url"])
self.redirectionCounter = 0
fileName = plugin["filename"]
tmpDir = QDir.tempPath()
tmpPath = QDir.cleanPath(tmpDir + "/" + fileName)
self.file = QFile(tmpPath)
self.requestDownloading()
def requestDownloading(self):
self.request = QNetworkRequest(self.url)
self.request.setAttribute(QNetworkRequest.Attribute(QgsNetworkRequestParameters.AttributeInitiatorClass), "QgsPluginInstallerInstallingDialog")
authcfg = repositories.all()[self.plugin["zip_repository"]]["authcfg"]
if authcfg and isinstance(authcfg, str):
if not QgsApplication.authManager().updateNetworkRequest(
self.request, authcfg.strip()):
self.mResult = self.tr(
"Update of network request with authentication "
"credentials FAILED for configuration '{0}'").format(authcfg)
self.request = None
if self.request is not None:
self.reply = QgsNetworkAccessManager.instance().get(self.request)
self.reply.downloadProgress.connect(self.readProgress)
self.reply.finished.connect(self.requestFinished)
self.stateChanged(4)
def exec_(self):
if self.request is None:
return QDialog.Rejected
QDialog.exec_(self)
# ----------------------------------------- #
def result(self):
return self.mResult
# ----------------------------------------- #
def stateChanged(self, state):
messages = [
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Installing…"),
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Resolving host name…"),
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Connecting…"),
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Host connected. Sending request…"),
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Downloading data…"),
self.tr("Idle"),
QCoreApplication.translate('QgsPluginInstallerInstallingDialog', "Closing connection…"),
self.tr("Error")
]
self.labelState.setText(messages[state])
# ----------------------------------------- #
def readProgress(self, done, total):
if total > 0:
self.progressBar.setMaximum(total)
self.progressBar.setValue(done)
# ----------------------------------------- #
def requestFinished(self):
reply = self.sender()
self.buttonBox.setEnabled(False)
if reply.error() != QNetworkReply.NoError:
self.mResult = reply.errorString()
if reply.error() == QNetworkReply.OperationCanceledError:
self.mResult += "<br/><br/>" + QCoreApplication.translate("QgsPluginInstaller", "If you haven't canceled the download manually, it might be caused by a timeout. In this case consider increasing the connection timeout value in QGIS options.")
self.reject()
reply.deleteLater()
return
elif reply.attribute(QNetworkRequest.HttpStatusCodeAttribute) in (301, 302):
redirectionUrl = reply.attribute(QNetworkRequest.RedirectionTargetAttribute)
self.redirectionCounter += 1
if self.redirectionCounter > 4:
self.mResult = QCoreApplication.translate("QgsPluginInstaller", "Too many redirections")
self.reject()
reply.deleteLater()
return
else:
if redirectionUrl.isRelative():
redirectionUrl = reply.url().resolved(redirectionUrl)
# Fire a new request and exit immediately in order to quietly destroy the old one
self.url = redirectionUrl
self.requestDownloading()
reply.deleteLater()
return
self.file.open(QFile.WriteOnly)
self.file.write(reply.readAll())
self.file.close()
self.stateChanged(0)
reply.deleteLater()
pluginDir = qgis.utils.home_plugin_path
tmpPath = self.file.fileName()
# make sure that the parent directory exists
if not QDir(pluginDir).exists():
QDir().mkpath(pluginDir)
# if the target directory already exists as a link, remove the link without resolving:
QFile(pluginDir + str(QDir.separator()) + self.plugin["id"]).remove()
try:
unzip(str(tmpPath), str(pluginDir)) # test extract. If fails, then exception will be raised and no removing occurs
# removing old plugin files if exist
removeDir(QDir.cleanPath(pluginDir + "/" + self.plugin["id"])) # remove old plugin if exists
unzip(str(tmpPath), str(pluginDir)) # final extract.
except:
self.mResult = self.tr("Failed to unzip the plugin package. Probably it's broken or missing from the repository. You may also want to make sure that you have write permission to the plugin directory:") + "\n" + pluginDir
self.reject()
return
try:
# cleaning: removing the temporary zip file
QFile(tmpPath).remove()
except:
pass
self.close()
# ----------------------------------------- #
def abort(self):
if self.reply.isRunning():
self.reply.finished.disconnect()
self.reply.abort()
del self.reply
self.mResult = self.tr("Aborted by user")
self.reject()
def saveTemplate(self):
"""
Creates and saves a new document template.
"""
# Validate if the user has specified the data source
if not LayoutUtils.get_stdm_data_source_for_layout(self.composition()):
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate(
"ComposerWrapper", "Please specify the "
"data source name for the document composition."))
return
# Assert if the referenced table name has been set
if not LayoutUtils.get_stdm_referenced_table_for_layout(
self.composition()):
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate(
"ComposerWrapper", "Please specify the "
"referenced table name for the selected data source."))
return
# If it is a new unsaved document template then prompt for the document name.
#template_path = self.composition().customProperty('variable_template_path', None)
template_path = self.variable_template_path
if template_path is None:
docName, ok = QInputDialog.getText(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Template Name"),
QApplication.translate("ComposerWrapper",
"Please enter the template name below"),
)
if not ok:
return
if ok and not docName:
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate("ComposerWrapper",
"Please enter a template name!"))
self.saveTemplate()
if ok and docName:
templateDir = self._composerTemplatesPath()
if templateDir is None:
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate(
"ComposerWrapper",
"Directory for document templates cannot not be found."
))
return
absPath = templateDir + "/" + docName + ".sdt"
# Check if there is an existing document with the same name
caseInsenDic = CaseInsensitiveDict(documentTemplates())
if docName in caseInsenDic:
result = QMessageBox.warning(
self.mainWindow(),
QApplication.translate("ComposerWrapper",
"Existing Template"),
"'{0}' {1}.\nDo you want to replace the "
"existing template?".format(
docName,
QApplication.translate("ComposerWrapper",
"already exists")),
QMessageBox.Yes | QMessageBox.No)
if result != QMessageBox.Yes:
return
else:
# Delete the existing template
delFile = QFile(absPath)
remove_status = delFile.remove()
if not remove_status:
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper",
"Delete Error"),
"'{0}' {1}.".format(
docName,
QApplication.translate(
"ComposerWrapper",
"template could not be removed by the system,"
" please remove it manually from the document templates directory."
)))
return
docFile = QFile(absPath)
template_path = absPath
else:
docFile = QFile(template_path)
# else:
# return
docFileInfo = QFileInfo(docFile)
if not docFile.open(QIODevice.WriteOnly):
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper",
"Save Operation Error"),
"{0}\n{1}".format(
QApplication.translate("ComposerWrapper",
"Could not save template file."),
docFile.errorString()))
return
templateDoc = QDomDocument()
template_name = docFileInfo.completeBaseName()
# Catch exception raised when writing items' elements
try:
self._writeXML(templateDoc, template_name)
except DummyException as exc:
msg = str(exc)
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Save Error"), msg)
docFile.close()
docFile.remove()
return
if docFile.write(templateDoc.toByteArray()) == -1:
QMessageBox.critical(
self.mainWindow(),
QApplication.translate("ComposerWrapper", "Save Error"),
QApplication.translate("ComposerWrapper",
"Could not save template file."))
return
else:
self.mainWindow().setWindowTitle(template_name)
self.composition().setCustomProperty('variable_template_path',
template_path)
docFile.close()
def _download_file(self, url, out_path):
reply = self.__sync_request(url)
local_file = QFile(out_path)
local_file.open(QIODevice.WriteOnly)
local_file.write(reply)
local_file.close()
class InstanceUUIDExtractor():
"""
Class constructor
"""
def __init__(self, path):
"""
Initatlize class variables
"""
self.file_path = path
self.file = None
self.new_list = []
self.doc = QDomDocument()
self.node = QDomNode()
def set_file_path(self, path):
"""
Update the path based on the new file being read
:param path:
:return:
"""
self.file_path = path
def unset_path(self):
"""Clear the current document path"""
self.file_path = None
def set_document(self):
"""
:return:
"""
self.file = QFile(self.file_path)
if self.file.open(QIODevice.ReadOnly):
self.doc.setContent(self.file)
self.file.close()
def update_document(self):
'''Update the current instance by clearing the document in the cache '''
self.doc.clear()
self.set_document()
def on_file_passed(self):
"""
Pass the raw file to an xml document object and format the its filename to GeoODK standards
:return:
"""
try:
self.set_document()
self.read_uuid_element()
self.doc.clear()
self.file.close()
self.rename_file()
except:
pass
def read_uuid_element(self):
"""
get the uuid element and text from the xml document from the mobile divice
"""
node = self.doc.elementsByTagName("meta")
for i in range(node.count()):
node = node.item(i).firstChild().toElement()
self.node = node.text()
return self.node
def document_entities(self, profile):
"""
Get entities in the document
:return:
"""
self.set_document()
node_list = []
nodes = self.doc.elementsByTagName(profile)
node = nodes.item(0).childNodes()
if node:
for j in range(node.count()):
node_val = node.item(j)
node_list.append(node_val.nodeName())
return node_list
def profile_entity_nodes(self, profile):
'''
Fetch and return QDomNodeList for entities of a
profile
:rtype: QDomNodeList
'''
self.set_document()
nodes = self.doc.elementsByTagName(profile)
return nodes.item(0).childNodes()
def document_entities_with_data(self, profile, selected_entities):
"""
Get entities in the dom document matching user
selected entities
:rtype: OrderedDict
"""
instance_data = OrderedDict()
self.set_document()
nodes = self.doc.elementsByTagName(profile)
entity_nodes = nodes.item(0).childNodes()
for attrs in range(entity_nodes.count()):
if entity_nodes.item(attrs).nodeName() in selected_entities:
name_entity = entity_nodes.item(attrs).nodeName()
attr_nodes = self.doc.elementsByTagName(name_entity)
instance_data[attr_nodes] = name_entity
return instance_data
def attribute_data_from_nodelist(self, args_list):
"""
process nodelist data before Importing attribute data into db
"""
repeat_instance_data = OrderedDict()
attribute_data = OrderedDict()
for attr_nodes, entity in args_list.items():
'''The assuption is that there are repeated entities from mobile sub forms. handle them separately'''
if attr_nodes.count() > 1:
for i in range(attr_nodes.count()):
attrib_node = attr_nodes.at(i).childNodes()
attr_list = OrderedDict()
for j in range(attrib_node.count()):
field_name = attrib_node.at(j).nodeName()
field_value = attrib_node.at(j).toElement().text()
attr_list[field_name] = field_value
repeat_instance_data['{}'.format(i) + entity] = attr_list
else:
'''Entities must appear onces in the form'''
node_list_var = OrderedDict()
attr_node = attr_nodes.at(0).childNodes()
for j in range(attr_node.count()):
field_name = attr_node.at(j).nodeName()
field_value = attr_node.at(j).toElement().text()
node_list_var[field_name] = field_value
attribute_data[entity] = node_list_var
return attribute_data, repeat_instance_data
def read_attribute_data_from_node(self, node, entity_name):
"""Read attribute data from a node item"""
node_list_var = OrderedDict()
attributes = OrderedDict()
attr_node = node.at(0).childNodes()
for j in range(attr_node.count()):
field_name = attr_node.at(j).nodeName()
field_value = attr_node.at(j).toElement().text()
node_list_var[field_name] = field_value
attributes[entity_name] = node_list_var
return attributes
def str_definition(self, instance=None):
"""
Check if the instance file has entry social tenure
:return:
"""
if instance:
self.set_file_path(instance)
self.set_document()
attributes = {}
nodes = self.doc.elementsByTagName('social_tenure')
entity_nodes = nodes.item(0).childNodes()
if entity_nodes:
for j in range(entity_nodes.count()):
node_val = entity_nodes.item(j).toElement()
attributes[node_val.nodeName()] = node_val.text().rstrip()
return attributes
def has_str_captured_in_instance(self, instance):
"""
Bool if the str inclusion is required based on whether is captured or not
:return:
"""
count = len(self.str_definition(instance))
return True if count > 1 else False
def entity_atrributes(self):
"""
Get collected data from the entity in the document
:return:
"""
pass
def uuid_element(self):
"""
Format the guuid from the file
:return:
"""
return self.node.replace(":", "")
def rename_file(self):
"""
Remane the existing instance file with Guuid from the mobile divice to conform with GeoODk naming
convention
:return:
"""
if isinstance(self.file, QFile):
dir_n, file_n = os.path.split(self.file_path)
os.chdir(dir_n)
if not file_n.startswith(UUID):
new_file_name = self.uuid_element() + ".xml"
isrenamed = self.file.setFileName(new_file_name)
os.rename(file_n, new_file_name)
self.new_list.append(new_file_name)
return isrenamed
else:
self.new_list.append(self.file.fileName())
self.file.close()
else:
return
def file_list(self):
"""
check through the list of document to ensure they are complete file path
"""
complete_file = []
for fi in self.new_list:
if os.path.isfile(fi):
complete_file.append(fi)
else:
continue
return complete_file
def close_document(self):
'''Close all the open documents and unset current paths'''
self.file_path = None
self.doc.clear()
self.new_list = None
def parse_xml(self):
"""Parse the xml file. Returns false if there is failure."""
xml_file = QFile(self._xml_path)
if not xml_file.open(QIODevice.ReadOnly):
return False
document = QDomDocument()
if not document.setContent(xml_file):
return False
xml_file.close()
document_element = document.documentElement()
if document_element.tagName() != "qgis_style":
return False
# Get all the symbols
self._symbols = []
symbols_element = document_element.firstChildElement("symbols")
symbol_element = symbols_element.firstChildElement()
context = QgsReadWriteContext()
context.setPathResolver(QgsProject.instance().pathResolver())
while not symbol_element.isNull():
if symbol_element.tagName() == "symbol":
symbol = QgsSymbolLayerUtils.loadSymbol(
symbol_element, context)
if symbol:
self._symbols.append({
"name":
symbol_element.attribute("name"),
"symbol":
symbol
})
symbol_element = symbol_element.nextSiblingElement()
# Get all the colorramps
self._colorramps = []
ramps_element = document_element.firstChildElement("colorramps")
ramp_element = ramps_element.firstChildElement()
while not ramp_element.isNull():
if ramp_element.tagName() == "colorramp":
colorramp = QgsSymbolLayerUtils.loadColorRamp(ramp_element)
if colorramp:
self._colorramps.append({
"name":
ramp_element.attribute("name"),
"colorramp":
colorramp
})
ramp_element = ramp_element.nextSiblingElement()
# Get all the TextFormats - textformats - textformat
self._textformats = []
textformats_element = document_element.firstChildElement("textformats")
textformat_element = textformats_element.firstChildElement()
while not textformat_element.isNull():
if textformat_element.tagName() == "textformat":
textformat = QgsTextFormat()
textformat.readXml(textformat_element, QgsReadWriteContext())
if textformat:
self._textformats.append({
"name":
textformat_element.attribute("name"),
"textformat":
textformat,
})
textformat_element = textformat_element.nextSiblingElement()
# Get all the LabelSettings - labelsettings - labelsetting -
# QgsPalLayerSettings.readXML?
self._labelsettings = []
labels_element = document_element.firstChildElement("labelsettings")
label_element = labels_element.firstChildElement()
while not label_element.isNull():
if label_element.tagName() == "labelsetting":
labelsettings = QgsPalLayerSettings()
labelsettings.readXml(label_element, QgsReadWriteContext())
if labelsettings:
self._labelsettings.append({
"name":
label_element.attribute("name"),
"labelsettings":
labelsettings,
})
label_element = label_element.nextSiblingElement()
return True
class QgsPluginInstallerInstallingDialog(
QDialog, Ui_QgsPluginInstallerInstallingDialogBase):
# ----------------------------------------- #
def __init__(self, parent, plugin):
QDialog.__init__(self, parent)
self.setupUi(self)
self.plugin = plugin
self.mResult = ""
self.progressBar.setRange(0, 0)
self.progressBar.setFormat("%p%")
self.labelName.setText(plugin["name"])
self.buttonBox.clicked.connect(self.abort)
url = QUrl(plugin["download_url"])
fileName = plugin["filename"]
tmpDir = QDir.tempPath()
tmpPath = QDir.cleanPath(tmpDir + "/" + fileName)
self.file = QFile(tmpPath)
self.request = QNetworkRequest(url)
authcfg = repositories.all()[plugin["zip_repository"]]["authcfg"]
if authcfg and isinstance(authcfg, basestring):
if not QgsAuthManager.instance().updateNetworkRequest(
self.request, authcfg.strip()):
self.mResult = self.tr(
"Update of network request with authentication "
"credentials FAILED for configuration '{0}'").format(
authcfg)
self.request = None
if self.request is not None:
self.reply = QgsNetworkAccessManager.instance().get(self.request)
self.reply.downloadProgress.connect(self.readProgress)
self.reply.finished.connect(self.requestFinished)
self.stateChanged(4)
def exec_(self):
if self.request is None:
return QDialog.Rejected
QDialog.exec_(self)
# ----------------------------------------- #
def result(self):
return self.mResult
# ----------------------------------------- #
def stateChanged(self, state):
messages = [
self.tr("Installing..."),
self.tr("Resolving host name..."),
self.tr("Connecting..."),
self.tr("Host connected. Sending request..."),
self.tr("Downloading data..."),
self.tr("Idle"),
self.tr("Closing connection..."),
self.tr("Error")
]
self.labelState.setText(messages[state])
# ----------------------------------------- #
def readProgress(self, done, total):
if total > 0:
self.progressBar.setMaximum(total)
self.progressBar.setValue(done)
# ----------------------------------------- #
def requestFinished(self):
reply = self.sender()
self.buttonBox.setEnabled(False)
if reply.error() != QNetworkReply.NoError:
self.mResult = reply.errorString()
if reply.error() == QNetworkReply.OperationCanceledError:
self.mResult += "<br/><br/>" + QCoreApplication.translate(
"QgsPluginInstaller",
"If you haven't cancelled the download manually, it might be caused by a timeout. In this case consider increasing the connection timeout value in QGIS options."
)
self.reject()
reply.deleteLater()
return
self.file.open(QFile.WriteOnly)
self.file.write(reply.readAll())
self.file.close()
self.stateChanged(0)
reply.deleteLater()
pluginDir = qgis.utils.home_plugin_path
tmpPath = self.file.fileName()
# make sure that the parent directory exists
if not QDir(pluginDir).exists():
QDir().mkpath(pluginDir)
# if the target directory already exists as a link, remove the link without resolving:
QFile(pluginDir + unicode(QDir.separator()) +
self.plugin["id"]).remove()
try:
unzip(
unicode(tmpPath), unicode(pluginDir)
) # test extract. If fails, then exception will be raised and no removing occurs
# removing old plugin files if exist
removeDir(QDir.cleanPath(
pluginDir + "/" +
self.plugin["id"])) # remove old plugin if exists
unzip(unicode(tmpPath), unicode(pluginDir)) # final extract.
except:
self.mResult = self.tr(
"Failed to unzip the plugin package. Probably it's broken or missing from the repository. You may also want to make sure that you have write permission to the plugin directory:"
) + "\n" + pluginDir
self.reject()
return
try:
# cleaning: removing the temporary zip file
QFile(tmpPath).remove()
except:
pass
self.close()
# ----------------------------------------- #
def abort(self):
if self.reply.isRunning():
self.reply.finished.disconnect()
self.reply.abort()
del self.reply
self.mResult = self.tr("Aborted by user")
self.reject()
class MultipartFile(QFile):
"""Wrapper class to support reading a file in chunks and post each part separately."""
def __init__(self, filename):
super().__init__(filename)
self._file = QFile(filename)
self._bytes_left = 0
self._file.readyRead.connect(self.on_readyRead)
self._file.aboutToClose.connect(self.on_aboutToClose)
self._file.bytesWritten.connect(self.on_bytesWritten)
self._file.channelBytesWritten.connect(self.on_channelBytesWritten)
self._file.channelReadyRead.connect(self.on_channelReadyRead)
self._file.readChannelFinished.connect(self.on_readChannelFinished)
def set_part_size(self, size):
self._bytes_left = size
self._original_size = size
def commitTransaction(self):
QgsMessageLog.logMessage('commitTransaction')
return self._file.commitTransaction()
def currentReadChannel(self):
QgsMessageLog.logMessage('currentReadChannel')
return self._file.currentReadChannel()
def currentWriteChannel(self):
QgsMessageLog.logMessage('currentWriteChannel')
return self._file.currentWriteChannel()
def errorString(self):
QgsMessageLog.logMessage('errorString')
return self._file.errorString()
def getChar(self):
if self._bytes_left > 0:
QgsMessageLog.logMessage('getChar')
self._bytes_left = self._bytes_left - 1
return self._file.getChar()
else:
QgsMessageLog.logMessage('getChar(no bytes left)')
return None
def isOpen(self):
QgsMessageLog.logMessage('isOpen')
return self._file.isOpen()
def isReadable(self):
QgsMessageLog.logMessage('isReadable')
return self._file.isReadable()
def isTextModeEnabled(self):
QgsMessageLog.logMessage('isTextModeEnabled')
return self._file.isTextModeEnabled()
def isTransactionStarted(self):
QgsMessageLog.logMessage('isTransactionStarted')
return self._file.isTransactionStarted()
def isWritable(self):
QgsMessageLog.logMessage('isWritable')
return self._file.isWritable()
def openMode(self):
QgsMessageLog.logMessage('openMode')
return self._file.openMode()
def peek(self, maxlen):
QgsMessageLog.logMessage('peek {0} {1}'.format(maxlen, self._bytes_left))
if maxlen > self._bytes_left:
maxlen = self._bytes_left
return self._file.peek(maxlen)
def read(self, max_size):
QgsMessageLog.logMessage('read {0}'.format(max_size))
return self._file.read(max_size)
def readAll(self):
QgsMessageLog.logMessage('readAll')
data = self._file.read(self._bytes_left)
self._bytes_left = self._bytes_left - len(data)
return data
def readChannelCount(self):
QgsMessageLog.logMessage('readChannelCount')
return self._file.readChannelCount()
def readLine(self):
QgsMessageLog.logMessage('readLine')
return None
def rollbackTransaction(self):
QgsMessageLog.logMessage('rollbackTransaction')
return self._file.rollbackTransaction()
def setCurrentReadChannel(self, channel):
QgsMessageLog.logMessage('setCurrentReadChannel {0}'.format(channel))
return self._file.setCurrentReadChannel(channel)
def setErrorString(self, errorString):
QgsMessageLog.logMessage('setErrorString {0}'.format(errorString))
return self._file.setErrorString(errorString)
def setOpenMode(self, mode):
QgsMessageLog.logMessage('setOpenMode {0}'.format(mode))
return self._file.setOpenMode(mode)
def setTextModeEnabled(self, enabled):
QgsMessageLog.logMessage('setTextModeEnabled {0}'.format(enabled))
return self._file.setTextModeenabled(enabled)
def skip(self, maxSize):
QgsMessageLog.logMessage('skip {0} {1}'.format(maxSize, self._bytes_left))
if maxSize > self._bytes_left:
maxSize = self._bytes_left
return self._file.skip(maxSize)
def startTransaction(self):
QgsMessageLog.logMessage('startTransaction')
return self._file.startTransaction()
def ungetChar(self, c):
QgsMessageLog.logMessage('ungetChar {0}'.format(c))
return None
def writeChannelCount(self):
QgsMessageLog.logMessage('writeChannelCount')
return self._file.writeChannelCount()
def atEnd(self):
QgsMessageLog.logMessage('atEnd')
if self._bytes_left == 0:
return True
else:
return self._file.atEnd()
def bytesAvailable(self):
QgsMessageLog.logMessage('bytesAvailable')
real_bytes_available = self._file.bytesAvailable()
if real_bytes_available > self._bytes_left:
return self._bytes_left
else:
return real_bytes_available
def bytesToWrite(self):
QgsMessageLog.logMessage('bytesToWrite')
return self._file.bytesToWrite()
def canReadLine(self):
QgsMessageLog.logMessage('canReadLine')
return self._file.canReadLine()
def close(self):
QgsMessageLog.logMessage('close')
return self._file.close()
def isSequential(self):
QgsMessageLog.logMessage('isSequential')
return self._file.isSequential()
def open(self, mode):
QgsMessageLog.logMessage('open')
return self._file.open(mode)
def pos(self):
QgsMessageLog.logMessage('pos')
return self._original_size - self._bytes_left
def readData(self, max_size):
if max_size > self._bytes_left:
max_size = self._bytes_left
self._bytes_left = self._bytes_left - max_size
if self._bytes_left == 0:
self.readChannelFinished.emit()
QgsMessageLog.logMessage('readData {0}'.format(max_size))
return self._file.readData(max_size)
def reset(self):
QgsMessageLog.logMessage('readData')
return True
def seek(self, pos):
QgsMessageLog.logMessage('seek {0}'.format(pos))
return True
def size(self):
file_size = self._file.size()
if file_size < self._bytes_left:
QgsMessageLog.logMessage('size(file_size) {0}'.format(file_size))
return file_size
else:
QgsMessageLog.logMessage('size(bytes_left) {0}'.format(self._bytes_left))
return self._bytes_left
def waitForReadyRead(self, msecs):
QgsMessageLog.logMessage('waitForReadyRead {0}'.format(msecs))
return self._file.waitForReadyRead(msecs)
def on_aboutToClose(self):
QgsMessageLog.logMessage('on_aboutToClose')
self.aboutToClose.emit()
def on_bytesWritten(self, bytes_written):
QgsMessageLog.logMessage('on_bytesWritten {0}'.format(bytes_written))
self.bytesWritten.emit(bytes_written)
def on_channelBytesWritten(self, channel, bytes_written):
QgsMessageLog.logMessage('on_channelBytesWritten {0} {1}'.format(channel, bytes_written))
self.channelBytesWritten.emit(channel, bytes_written)
def on_channelReadyRead(self, channel):
QgsMessageLog.logMessage('on_channelReadyRead {0}'.format(channel))
if self._bytes_left > 0:
self.channelReadyRead.emit(channel)
def on_readChannelFinished(self):
QgsMessageLog.logMessage('on_readChannelFinished')
self.readChannelFinished.emit()
def on_readyRead(self):
QgsMessageLog.logMessage('on_readyRead')
if self._bytes_left > 0:
self.readyRead.emit()
def flush(self):
QgsMessageLog.logMessage('flush')
return self._file.flush()
def fileName(self):
QgsMessageLog.logMessage('filename')
return self._file.fileName()
def exists(self):
QgsMessageLog.logMessage('exists')
return self._file.exists()
def decodeName(self, localFileName):
QgsMessageLog.logMessage('decodeName {0}'.format(localFileName))
return self._file.decodeName(localFileName)
class FileDownloader():
"""The blueprint for downloading file from url."""
def __init__(self, url, output_path, progress_dialog=None):
"""Constructor of the class.
.. versionchanged:: 3.3 removed manager parameter.
:param url: URL of file.
:type url: str
:param output_path: Output path.
:type output_path: str
:param progress_dialog: Progress dialog widget.
:type progress_dialog: QWidget
"""
# noinspection PyArgumentList
self.manager = QgsNetworkAccessManager.instance()
self.url = QUrl(url)
self.output_path = output_path
self.progress_dialog = progress_dialog
if self.progress_dialog:
self.prefix_text = self.progress_dialog.labelText()
self.output_file = None
self.reply = None
self.downloaded_file_buffer = None
self.finished_flag = False
def download(self):
"""Downloading the file.
:returns: True if success, otherwise returns a tuple with format like
this (QNetworkReply.NetworkError, error_message)
:raises: IOError - when cannot create output_path
"""
# Prepare output path
self.output_file = QFile(self.output_path)
if not self.output_file.open(QFile.WriteOnly):
raise IOError(self.output_file.errorString())
# Prepare downloaded buffer
self.downloaded_file_buffer = QByteArray()
# Request the url
request = QNetworkRequest(self.url)
self.reply = self.manager.get(request)
self.reply.readyRead.connect(self.get_buffer)
self.reply.finished.connect(self.write_data)
self.manager.requestTimedOut.connect(self.request_timeout)
if self.progress_dialog:
# progress bar
def progress_event(received, total):
"""Update progress.
:param received: Data received so far.
:type received: int
:param total: Total expected data.
:type total: int
"""
# noinspection PyArgumentList
QgsApplication.processEvents()
self.progress_dialog.adjustSize()
human_received = humanize_file_size(received)
human_total = humanize_file_size(total)
label_text = tr("%s : %s of %s" % (
self.prefix_text, human_received, human_total))
self.progress_dialog.setLabelText(label_text)
self.progress_dialog.setMaximum(total)
self.progress_dialog.setValue(received)
# cancel
def cancel_action():
"""Cancel download."""
self.reply.abort()
self.reply.deleteLater()
self.reply.downloadProgress.connect(progress_event)
self.progress_dialog.canceled.connect(cancel_action)
# Wait until finished
# On Windows 32bit AND QGIS 2.2, self.reply.isFinished() always
# returns False even after finished slot is called. So, that's why we
# are adding self.finished_flag (see #864)
while not self.reply.isFinished() and not self.finished_flag:
# noinspection PyArgumentList
QgsApplication.processEvents()
result = self.reply.error()
try:
http_code = int(self.reply.attribute(
QNetworkRequest.HttpStatusCodeAttribute))
except TypeError:
# If the user cancels the request, the HTTP response will be None.
http_code = None
self.reply.abort()
self.reply.deleteLater()
if result == QNetworkReply.NoError:
return True, None
elif result == QNetworkReply.UnknownNetworkError:
return False, tr(
'The network is unreachable. Please check your internet '
'connection.')
elif http_code == 408:
msg = tr(
'Sorry, the server aborted your request. '
'Please try a smaller area.')
LOGGER.debug(msg)
return False, msg
elif http_code == 509:
msg = tr(
'Sorry, the server is currently busy with another request. '
'Please try again in a few minutes.')
LOGGER.debug(msg)
return False, msg
elif result == QNetworkReply.ProtocolUnknownError or \
result == QNetworkReply.HostNotFoundError:
# See http://doc.qt.io/qt-5/qurl-obsolete.html#encodedHost
encoded_host = self.url.toAce(self.url.host())
LOGGER.exception('Host not found : %s' % encoded_host)
return False, tr(
'Sorry, the server is unreachable. Please try again later.')
elif result == QNetworkReply.ContentNotFoundError:
LOGGER.exception('Path not found : %s' % self.url.path())
return False, tr('Sorry, the layer was not found on the server.')
else:
return result, self.reply.errorString()
def get_buffer(self):
"""Get buffer from self.reply and store it to our buffer container."""
buffer_size = self.reply.size()
data = self.reply.read(buffer_size)
self.downloaded_file_buffer.append(data)
def write_data(self):
"""Write data to a file."""
self.output_file.write(self.downloaded_file_buffer)
self.output_file.close()
self.finished_flag = True
def request_timeout(self):
"""The request timed out."""
if self.progress_dialog:
self.progress_dialog.hide()
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
