def testPartCount(self):
# Create rulebased style
sym1 = QgsFillSymbol.createSimple({
'color': '#fdbf6f',
'outline_color': 'black'
})
renderer = QgsSingleSymbolRenderer(sym1)
renderer.symbols(
QgsRenderContext())[0].symbolLayers()[0].setDataDefinedProperty(
QgsSymbolLayer.PropertyFillColor,
QgsProperty.fromExpression(
'color_rgb( (@geometry_part_count - 1) * 200, 0, 0 )'))
self.layer.setRenderer(renderer)
# Setup rendering check
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlName('expected_geometry_part_count')
result = renderchecker.runTest('part_geometry_part_count')
self.assertTrue(result)
def testSymbolColor(self):
# Create rulebased style
sym1 = QgsFillSymbol.createSimple({
'color': '#ff0000',
'outline_color': 'black'
})
renderer = QgsSingleSymbolRenderer(sym1)
renderer.symbols(
QgsRenderContext())[0].symbolLayers()[0].setDataDefinedProperty(
QgsSymbolLayer.PropertyFillColor,
QgsProperty.fromExpression(
'set_color_part( @symbol_color, \'value\', "Value" * 4)'))
self.layer.setRenderer(renderer)
# Setup rendering check
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlName('expected_symbol_color_variable')
result = renderchecker.runTest('symbol_color_variable', 50)
self.assertTrue(result)
def testGettersSetters(self):
"""
Basic getter/setter tests
"""
c = QgsRenderContext()
c.setTextRenderFormat(QgsRenderContext.TextFormatAlwaysText)
self.assertEqual(c.textRenderFormat(),
QgsRenderContext.TextFormatAlwaysText)
c.setTextRenderFormat(QgsRenderContext.TextFormatAlwaysOutlines)
self.assertEqual(c.textRenderFormat(),
QgsRenderContext.TextFormatAlwaysOutlines)
c.setMapExtent(QgsRectangle(1, 2, 3, 4))
self.assertEqual(c.mapExtent(), QgsRectangle(1, 2, 3, 4))
self.assertTrue(c.zRange().isInfinite())
c.setZRange(QgsDoubleRange(1, 10))
self.assertEqual(c.zRange(), QgsDoubleRange(1, 10))
self.assertEqual(c.symbologyReferenceScale(), -1)
c.setSymbologyReferenceScale(1000)
self.assertEqual(c.symbologyReferenceScale(), 1000)
self.assertTrue(c.outputSize().isEmpty())
c.setOutputSize(QSize(100, 200))
self.assertEqual(c.outputSize(), QSize(100, 200))
self.assertEqual(c.devicePixelRatio(), 1)
c.setDevicePixelRatio(2)
self.assertEqual(c.devicePixelRatio(), 2)
self.assertEqual(c.deviceOutputSize(), QSize(200, 400))
c.setImageFormat(QImage.Format_Alpha8)
self.assertEqual(c.imageFormat(), QImage.Format_Alpha8)
# should have an invalid mapToPixel by default
self.assertFalse(c.mapToPixel().isValid())
def __select(self):
"""
To select objects in multiples layers inside a selection rectangle
"""
searchRect = QgsRectangle(self.first, self.last)
for layer in self.canvas().layers():
if not self.identified or layer.id() not in self.disabled():
if layer.type(
) == QgsMapLayer.VectorLayer and layer.geometryType(
) in self.types:
renderer = layer.rendererV2()
context = QgsRenderContext()
if renderer:
renderer.startRender(context, layer.pendingFields())
self.request = QgsFeatureRequest()
self.request.setFilterRect(searchRect)
self.request.setFlags(QgsFeatureRequest.ExactIntersect)
fIds = []
for feature in layer.getFeatures(self.request):
try:
will = renderer.willRenderFeature(
feature, context)
except:
try:
will = renderer.willRenderFeature(feature)
except:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate(
"VDLTools", "Error"),
"will renderer still not working",
level=QgsMessageBar.CRITICAL,
duration=0)
return
if will:
fIds.append(feature.id())
renderer.stopRender(context)
layer.selectByIds(fIds)
self.selectedSignal.emit()
def testCalculateFeatureIntersectionGeometry(self):
region = QgsMapClippingRegion(QgsGeometry.fromWkt('Polygon((0 0, 1 0, 1 1, 0 1, 0 0))'))
region.setFeatureClip(QgsMapClippingRegion.FeatureClippingType.ClipToIntersection)
region2 = QgsMapClippingRegion(QgsGeometry.fromWkt('Polygon((0 0, 0.1 0, 0.1 2, 0 2, 0 0))'))
region2.setFeatureClip(QgsMapClippingRegion.FeatureClippingType.NoClipping)
region3 = QgsMapClippingRegion(QgsGeometry.fromWkt('Polygon((0 0, 0.1 0, 0.1 2, 0 2, 0 0))'))
region3.setFeatureClip(QgsMapClippingRegion.FeatureClippingType.ClipToIntersection)
rc = QgsRenderContext()
geom, should_clip = QgsMapClippingUtils.calculateFeatureIntersectionGeometry([], rc)
self.assertFalse(should_clip)
self.assertTrue(geom.isNull())
geom, should_clip = QgsMapClippingUtils.calculateFeatureIntersectionGeometry([region], rc)
geom.normalize()
self.assertTrue(should_clip)
self.assertEqual(geom.asWkt(1), 'Polygon ((0 0, 0 1, 1 1, 1 0, 0 0))')
# region2 is a Intersects type clipping region, should not apply here
geom, should_clip = QgsMapClippingUtils.calculateFeatureIntersectionGeometry([region2], rc)
self.assertFalse(should_clip)
self.assertTrue(geom.isNull())
geom, should_clip = QgsMapClippingUtils.calculateFeatureIntersectionGeometry([region, region2], rc)
self.assertTrue(should_clip)
self.assertEqual(geom.asWkt(1), 'Polygon ((0 0, 1 0, 1 1, 0 1, 0 0))')
geom, should_clip = QgsMapClippingUtils.calculateFeatureIntersectionGeometry([region, region2, region3], rc)
geom.normalize()
self.assertTrue(should_clip)
self.assertEqual(geom.asWkt(1), 'Polygon ((0 0, 0 1, 0.1 1, 0.1 0, 0 0))')
rc.setCoordinateTransform(QgsCoordinateTransform(QgsCoordinateReferenceSystem('EPSG:3857'), QgsCoordinateReferenceSystem('EPSG:4326'), QgsProject.instance()))
geom, should_clip = QgsMapClippingUtils.calculateFeatureIntersectionGeometry([region, region3], rc)
geom.normalize()
self.assertTrue(should_clip)
self.assertEqual(geom.asWkt(0), 'Polygon ((0 0, 0 111325, 11132 111325, 11132 0, 0 0))')
def testSetPainterFlags(self):
rc = QgsRenderContext()
p = QPainter()
im = QImage(1000, 600, QImage.Format_RGB32)
p.begin(im)
rc.setPainterFlagsUsingContext(p)
self.assertFalse(p.testRenderHint(QPainter.Antialiasing))
try:
self.assertFalse(p.testRenderHint(QPainter.LosslessImageRendering))
except AttributeError:
pass
rc.setPainter(p)
rc.setFlag(QgsRenderContext.Antialiasing, True)
rc.setFlag(QgsRenderContext.LosslessImageRendering, True)
rc.setPainterFlagsUsingContext(p)
self.assertTrue(p.testRenderHint(QPainter.Antialiasing))
try:
self.assertTrue(p.testRenderHint(QPainter.LosslessImageRendering))
except AttributeError:
pass
p.end()
def testGettersSetters(self):
"""
Basic getter/setter tests
"""
c = QgsRenderContext()
c.setTextRenderFormat(QgsRenderContext.TextFormatAlwaysText)
self.assertEqual(c.textRenderFormat(),
QgsRenderContext.TextFormatAlwaysText)
c.setTextRenderFormat(QgsRenderContext.TextFormatAlwaysOutlines)
self.assertEqual(c.textRenderFormat(),
QgsRenderContext.TextFormatAlwaysOutlines)
c.setMapExtent(QgsRectangle(1, 2, 3, 4))
self.assertEqual(c.mapExtent(), QgsRectangle(1, 2, 3, 4))
self.assertTrue(c.zRange().isInfinite())
c.setZRange(QgsDoubleRange(1, 10))
self.assertEqual(c.zRange(), QgsDoubleRange(1, 10))
self.assertEqual(c.symbologyReferenceScale(), -1)
c.setSymbologyReferenceScale(1000)
self.assertEqual(c.symbologyReferenceScale(), 1000)
def testItemsInBounds(self):
layer = QgsAnnotationLayer(
'test',
QgsAnnotationLayer.LayerOptions(
QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
item1uuid = layer.addItem(
QgsAnnotationPolygonItem(
QgsPolygon(
QgsLineString([
QgsPoint(12, 13),
QgsPoint(14, 13),
QgsPoint(14, 15),
QgsPoint(12, 13)
]))))
item2uuid = layer.addItem(
QgsAnnotationLineItem(
QgsLineString(
[QgsPoint(11, 13),
QgsPoint(12, 13),
QgsPoint(12, 150)])))
item3uuid = layer.addItem(QgsAnnotationMarkerItem(QgsPoint(120, 13)))
rc = QgsRenderContext()
self.assertFalse(layer.itemsInBounds(QgsRectangle(-10, -10, -9, 9),
rc))
self.assertCountEqual(
layer.itemsInBounds(QgsRectangle(12, 13, 14, 15), rc),
[item1uuid, item2uuid])
self.assertCountEqual(
layer.itemsInBounds(QgsRectangle(12, 130, 14, 150), rc),
[item2uuid])
self.assertCountEqual(
layer.itemsInBounds(QgsRectangle(110, 0, 120, 20), rc),
[item3uuid])
def on_click_Inici(self):
llistaErrors = self.controlErrorsValida()
if len(llistaErrors) != 0:
llista = "Llista d'errors:\n\n"
for i in range(0, len(llistaErrors)):
llista += ("- " + llistaErrors[i] + '\n')
QMessageBox.information(None, "Error", llista)
return
textBox = 'INICI DEL PROCÉS DE VALIDACIÓ:\n'
textBox += 'Elminació dels vertex:'
self.dlg.text_info.setText(textBox)
self.MouText()
QApplication.processEvents()
conta_errors = 0
self.barraEstat_processant()
drop = 'DROP TABLE IF EXISTS "GTC_Update"."UpdateGTC_vertices_pgr";'
try:
cur.execute(drop)
conn.commit()
except Exception as e:
print("ERROR drop vertexs GTC per actualitzar")
self.barraEstat_connectat()
print(e.message, e.args)
textBox += '...OK\n'
textBox += 'Creació d\'una nova topologia'
self.dlg.text_info.setText(textBox)
self.MouText()
QApplication.processEvents()
create = 'select pgr_createTopology(\'GTC_Update.UpdateGTC\', 0.001,clean:=true);'
try:
cur.execute(create)
vec = cur.fetchall()
conn.commit()
if vec[0][0] != 'OK':
QMessageBox.information(
None, "Error", "No s'ha creat la topologia correctament.")
print(vec)
return
except Exception as e:
self.barraEstat_connectat()
print("ERROR create vertexs GTC per actualitzar")
print(e.message, e.args)
textBox += '...OK\n'
textBox += 'Comprovació de la nova topologia'
self.dlg.text_info.setText(textBox)
self.MouText()
QApplication.processEvents()
create = 'SELECT pgr_analyzeGraph(\'GTC_Update.UpdateGTC\', 0.001);'
try:
cur.execute(create)
vec = cur.fetchall()
conn.commit()
if vec[0][0] != 'OK':
QMessageBox.information(
None, "Error", "S'ha detectat un error a la topologia.")
self.barraEstat_connectat()
return
except Exception as e:
self.barraEstat_connectat()
print("ERROR create vertexs GTC per actualitzar")
print(e.message, e.args)
textBox += '...OK\n'
textBox += 'Comprovació dels punts amb possibles errors: '
self.dlg.text_info.setText(textBox)
self.MouText()
QApplication.processEvents()
select = 'SELECT * FROM "GTC_Update"."UpdateGTC_vertices_pgr" WHERE chk = 1;'
try:
cur.execute(select)
vec = cur.fetchall()
conn.commit()
if (len(vec) != 0):
uri = QgsDataSourceUri()
try:
uri.setConnection(host1, port1, nomBD1, usuari1, contra1)
except:
print("Error a la connexio")
select = 'SELECT * FROM "GTC_Update"."UpdateGTC_vertices_pgr" WHERE chk = 1'
QApplication.processEvents()
uri.setDataSource("", "(" + select + ")", "the_geom", "", "id")
QApplication.processEvents()
'''
# 13.2 Es prepara el titol de la capa que apareixerà a la llegenda
'''
titol = "Nodes a revisar"
vlayer = QgsVectorLayer(uri.uri(False), titol, "postgres")
QApplication.processEvents()
if vlayer.isValid():
symbols = vlayer.renderer().symbols(QgsRenderContext())
symbol = symbols[0]
'''S'afegeix el color a la nova entitat'''
symbol.setColor(QColor.fromRgb(255, 0, 0))
QgsProject.instance().addMapLayer(vlayer, False)
root = QgsProject.instance().layerTreeRoot()
myLayerNode = QgsLayerTreeLayer(vlayer)
root.insertChildNode(0, myLayerNode)
myLayerNode.setCustomProperty("showFeatureCount", False)
QApplication.processEvents()
''''S'afegeix la capa a la pantalla'''
iface.mapCanvas().refresh()
#qgis.utils.iface.legendInterface().refreshLayerSymbology(vlayer)
else:
print("No s'ha carregat la capa de punts")
self.barraEstat_connectat()
QApplication.processEvents()
textBox += 'S\'ha(n) detectat ' + str(
len(vec)) + ' punt(s) amb possibles errades.\n'
self.dlg.text_info.setText(textBox)
self.MouText()
QApplication.processEvents()
return
except Exception as e:
self.barraEstat_connectat()
print("ERROR create vertexs GTC per actualitzar")
print(e.message[0].decode('utf8'), e.args)
return
textBox += 'No s\'han detectat errades.\n'
textBox += 'Detecció de trams aïllats: '
self.dlg.text_info.setText(textBox)
self.MouText()
QApplication.processEvents()
select = 'SELECT a.* FROM "GTC_Update"."UpdateGTC" a, "GTC_Update"."UpdateGTC_vertices_pgr" b, "GTC_Update"."UpdateGTC_vertices_pgr" c WHERE a.source=b.id AND b.cnt=1 AND a.target=c.id AND c.cnt=1;'
try:
cur.execute(select)
vec = cur.fetchall()
conn.commit()
if (len(vec) != 0):
uri = QgsDataSourceUri()
try:
uri.setConnection(host1, port1, nomBD1, usuari1, contra1)
except:
print("Error a la connexio")
select = 'SELECT a.* FROM "GTC_Update"."UpdateGTC" a, "GTC_Update"."UpdateGTC_vertices_pgr" b, "GTC_Update"."UpdateGTC_vertices_pgr" c WHERE a.source=b.id AND b.cnt=1 AND a.target=c.id AND c.cnt=1'
QApplication.processEvents()
uri.setDataSource("", "(" + select + ")", "the_geom", "", "id")
QApplication.processEvents()
'''
# 13.2 Es prepara el titol de la capa que apareixerà a la llegenda
'''
titol = "Trams sense connectivitat a revisar"
vlayer = QgsVectorLayer(uri.uri(False), titol, "postgres")
QApplication.processEvents()
if vlayer.isValid():
symbols = vlayer.renderer().symbols(QgsRenderContext())
symbol = symbols[0]
'''S'afegeix el color a la nova entitat'''
symbol.setColor(QColor.fromRgb(255, 0, 0))
symbol.setWidth(1)
QgsProject.instance().addMapLayer(vlayer, False)
root = QgsProject.instance().layerTreeRoot()
myLayerNode = QgsLayerTreeLayer(vlayer)
root.insertChildNode(0, myLayerNode)
myLayerNode.setCustomProperty("showFeatureCount", False)
QApplication.processEvents()
''''S'afegeix la capa a la pantalla'''
iface.mapCanvas().refresh()
#qgis.utils.iface.legendInterface().refreshLayerSymbology(vlayer)
else:
print("No s'ha carregat la capa de segments aïllats")
self.barraEstat_connectat()
QApplication.processEvents()
textBox += 'S\'ha(n) detectat ' + str(
len(vec)) + ' tram(s) aïllat(s).\n'
self.dlg.text_info.setText(textBox)
self.MouText()
QApplication.processEvents()
return
except Exception as e:
self.barraEstat_connectat()
print("ERROR Segments aillats")
print(e.message, e.args)
return
textBox += 'No s\'han detectat segments aïllats.\n'
self.dlg.text_info.setText(textBox)
self.MouText()
QApplication.processEvents()
#==============================================
# 1. LINIES AMB DOS PUNTS I CAMP SOURCE
#==============================================
self.barraEstat_processant()
sql_xarxa = 'select distinct(R.id) id,R.source Vertex, camp from (select S."the_geom",S."id",st_x(st_startpoint(S."the_geom")),S."source",\'S\' camp from "GTC_Update"."UpdateGTC" S where (st_x(st_startpoint(S."the_geom")) not in (select st_x("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr")) union '
sql_xarxa += 'select S."the_geom",S."id",st_x(st_endpoint(S."the_geom")),S."target", \'T\' camp from "GTC_Update"."UpdateGTC" S where (st_x(st_endpoint(S."the_geom")) not in (select st_x("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )) union '
sql_xarxa += 'select S."the_geom",S."id",st_y(st_startpoint(S."the_geom")),S."source",\'S\' camp from "GTC_Update"."UpdateGTC" S where (st_y(st_startpoint(S."the_geom")) not in (select st_y("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )) union '
sql_xarxa += 'select S."the_geom",S."id",st_y(st_endpoint(S."the_geom")),S."target",\'T\' camp from "GTC_Update"."UpdateGTC" S where (st_y(st_endpoint(S."the_geom")) not in (select st_y("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )))R where (ST_NPoints(R.the_geom)=2 and R.camp=\'S\') order by R.id,R.source;'
#print sql_xarxa
try:
cur.execute(sql_xarxa)
vec = cur.fetchall()
conta_errors += len(vec)
#print str(len(vec))
for x in range(0, len(vec)):
sql_1 = 'select "source","target" from "GTC_Update"."UpdateGTC" where "id"=' + str(
vec[x][0]) + ';'
cur.execute(sql_1)
vec2 = cur.fetchall()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_AddPoint(the_geom, (select "the_geom" from "GTC_Update"."UpdateGTC_vertices_pgr" where id=' + str(
vec2[0][1]) + '),1) WHERE "id"=' + str(vec[x][0]) + ';'
cur.execute(update)
conn.commit()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_RemovePoint(the_geom, 0) WHERE "id"=' + str(
vec[x][0]) + ';'
cur.execute(update)
conn.commit()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_AddPoint(the_geom, (select "the_geom" from "GTC_Update"."UpdateGTC_vertices_pgr" where id=' + str(
vec2[0][0]) + '),0) WHERE "id"=' + str(vec[x][0]) + ';'
cur.execute(update)
conn.commit()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_RemovePoint(the_geom, ST_NPoints(the_geom) - 1) WHERE "id"=' + str(
vec[x][0]) + ';'
cur.execute(update)
conn.commit()
except Exception as e:
print(e.message, e.args)
print("ERROR SQL_XARXA")
#==============================================
# 2. LINIES AMB DOS PUNTS I CAMP TARGET
#==============================================
sql_xarxa = 'select distinct(R.id) id,R.source Vertex, camp from (select S."the_geom",S."id",st_x(st_startpoint(S."the_geom")),S."source",\'S\' camp from "GTC_Update"."UpdateGTC" S where (st_x(st_startpoint(S."the_geom")) not in (select st_x("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr")) union '
sql_xarxa += 'select S."the_geom",S."id",st_x(st_endpoint(S."the_geom")),S."target", \'T\' camp from "GTC_Update"."UpdateGTC" S where (st_x(st_endpoint(S."the_geom")) not in (select st_x("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )) union '
sql_xarxa += 'select S."the_geom",S."id",st_y(st_startpoint(S."the_geom")),S."source",\'S\' camp from "GTC_Update"."UpdateGTC" S where (st_y(st_startpoint(S."the_geom")) not in (select st_y("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )) union '
sql_xarxa += 'select S."the_geom",S."id",st_y(st_endpoint(S."the_geom")),S."target",\'T\' camp from "GTC_Update"."UpdateGTC" S where (st_y(st_endpoint(S."the_geom")) not in (select st_y("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )))R where (ST_NPoints(R.the_geom)=2 and R.camp=\'T\') order by R.id,R.source;'
#print sql_xarxa
try:
cur.execute(sql_xarxa)
vec = cur.fetchall()
conta_errors += len(vec)
#print str(len(vec))
for x in range(0, len(vec)):
sql_1 = 'select "source","target" from "GTC_Update"."UpdateGTC" where "id"=' + str(
vec[x][0]) + ';'
cur.execute(sql_1)
vec2 = cur.fetchall()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_AddPoint(the_geom, (select "the_geom" from "GTC_Update"."UpdateGTC_vertices_pgr" where id=' + str(
vec2[0][0]) + '),0) WHERE "id"=' + str(vec[x][0]) + ';'
cur.execute(update)
conn.commit()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_RemovePoint(the_geom, ST_NPoints(the_geom) - 1) WHERE "id"=' + str(
vec[x][0]) + ';'
cur.execute(update)
conn.commit()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_AddPoint(the_geom, (select "the_geom" from "GTC_Update"."UpdateGTC_vertices_pgr" where id=' + str(
vec2[0][1]) + '),ST_NPoints(the_geom)) WHERE "id"=' + str(
vec[x][0]) + ';'
cur.execute(update)
conn.commit()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_RemovePoint(the_geom, 0) WHERE "id"=' + str(
vec[x][0]) + ';'
cur.execute(update)
conn.commit()
except Exception as e:
print(e.message, e.args)
print("ERROR SQL_XARXA")
#==============================================
# 3. LINIES AMB MES DE DOS PUNTS I CAMP SOURCE
#==============================================
sql_xarxa = 'select distinct(R.id) id,R.source Vertex, camp from (select S."the_geom",S."id",st_x(st_startpoint(S."the_geom")),S."source",\'S\' camp from "GTC_Update"."UpdateGTC" S where (st_x(st_startpoint(S."the_geom")) not in (select st_x("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr")) union '
sql_xarxa += 'select S."the_geom",S."id",st_x(st_endpoint(S."the_geom")),S."target", \'T\' camp from "GTC_Update"."UpdateGTC" S where (st_x(st_endpoint(S."the_geom")) not in (select st_x("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )) union '
sql_xarxa += 'select S."the_geom",S."id",st_y(st_startpoint(S."the_geom")),S."source",\'S\' camp from "GTC_Update"."UpdateGTC" S where (st_y(st_startpoint(S."the_geom")) not in (select st_y("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )) union '
sql_xarxa += 'select S."the_geom",S."id",st_y(st_endpoint(S."the_geom")),S."target",\'T\' camp from "GTC_Update"."UpdateGTC" S where (st_y(st_endpoint(S."the_geom")) not in (select st_y("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )))R where (ST_NPoints(R.the_geom)<>2 and R.camp=\'S\') order by R.id,R.source;'
#print sql_xarxa
try:
cur.execute(sql_xarxa)
vec = cur.fetchall()
conta_errors += len(vec)
#print str(len(vec))
for x in range(0, len(vec)):
sql_1 = 'select "source","target" from "GTC_Update"."UpdateGTC" where "id"=' + str(
vec[x][0]) + ';'
cur.execute(sql_1)
vec2 = cur.fetchall()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_RemovePoint(the_geom, 0) WHERE "id"=' + str(
vec[x][0]) + ';'
cur.execute(update)
conn.commit()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_AddPoint(the_geom, (select "the_geom" from "GTC_Update"."UpdateGTC_vertices_pgr" where id=' + str(
vec2[0][0]) + '),0) WHERE "id"=' + str(vec[x][0]) + ';'
cur.execute(update)
conn.commit()
except Exception as e:
print(e.message, e.args)
print("ERROR SQL_XARXA")
#==============================================
# 4. LINIES AMB MES DE DOS PUNTS I CAMP TARGET
#==============================================
sql_xarxa = 'select distinct(R.id) id,R.source Vertex, camp from (select S."the_geom",S."id",st_x(st_startpoint(S."the_geom")),S."source",\'S\' camp from "GTC_Update"."UpdateGTC" S where (st_x(st_startpoint(S."the_geom")) not in (select st_x("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr")) union '
sql_xarxa += 'select S."the_geom",S."id",st_x(st_endpoint(S."the_geom")),S."target", \'T\' camp from "GTC_Update"."UpdateGTC" S where (st_x(st_endpoint(S."the_geom")) not in (select st_x("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )) union '
sql_xarxa += 'select S."the_geom",S."id",st_y(st_startpoint(S."the_geom")),S."source",\'S\' camp from "GTC_Update"."UpdateGTC" S where (st_y(st_startpoint(S."the_geom")) not in (select st_y("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )) union '
sql_xarxa += 'select S."the_geom",S."id",st_y(st_endpoint(S."the_geom")),S."target",\'T\' camp from "GTC_Update"."UpdateGTC" S where (st_y(st_endpoint(S."the_geom")) not in (select st_y("GTC_Update"."UpdateGTC_vertices_pgr"."the_geom") from "GTC_Update"."UpdateGTC_vertices_pgr" )))R where (ST_NPoints(R.the_geom)<>2 and R.camp=\'T\') order by R.id,R.source;'
#print sql_xarxa
try:
cur.execute(sql_xarxa)
vec = cur.fetchall()
conta_errors += len(vec)
#print str(len(vec))
for x in range(0, len(vec)):
sql_1 = 'select "source","target" from "GTC_Update"."UpdateGTC" where "id"=' + str(
vec[x][0]) + ';'
cur.execute(sql_1)
vec2 = cur.fetchall()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_RemovePoint(the_geom, ST_NPoints(the_geom) - 1) WHERE "id"=' + str(
vec[x][0]) + ';'
cur.execute(update)
conn.commit()
update = 'UPDATE "GTC_Update"."UpdateGTC" SET the_geom = ST_AddPoint(the_geom, (select "the_geom" from "GTC_Update"."UpdateGTC_vertices_pgr" where id=' + str(
vec2[0][1]) + '),ST_NPoints(the_geom)) WHERE "id"=' + str(
vec[x][0]) + ';'
cur.execute(update)
conn.commit()
except Exception as e:
print(e.message, e.args)
print("ERROR SQL_XARXA")
if conta_errors != 0:
llista = "Errors trobats i reparats:"
llista += (' ' + str(conta_errors) + '\n')
else:
llista = "No s'han detectat errors\n"
textBox += llista
self.dlg.text_info.setText(textBox)
self.MouText()
#UPDATE CAMPS DE CONTROL
update = 'UPDATE "GTC_Update"."ControlActualitzacio" set modificant = false, modificat=true, "horaModificacio" = NULL, "usuariModificador" = NULL;'
try:
cur.execute(update)
conn.commit()
html = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd"><html><head><meta name="qrichtext" content="1" /><style type="text/css">p, li { white-space: pre-wrap; }</style></head><body style=" font-family:\'MS Shell Dlg 2\'; font-size:10pt; font-weight:400; font-style:normal;"><div style=\"align:center\"><span style=\"background:#00FF00;font-size:14pt\">GRAF VALIDAT!<\span><\div></body></html>'
self.dlg.text_info.insertHtml(html)
self.MouText()
except Exception as e:
print(e.message, e.args)
print(
"ERROR update Control (modificant,modificat, paraula clau, timestamp"
)
self.barraEstat_connectat()
def on_click_Carregar(self):
global cur
global conn
global nomBD1
global contra1
global host1
global port1
global usuari1
llistaErrors = self.controlErrorsCarrega()
if len(llistaErrors) != 0:
llista = "Llista d'errors:\n\n"
for i in range(0, len(llistaErrors)):
llista += ("- " + llistaErrors[i] + '\n')
QMessageBox.information(None, "Error", llista)
return
select = 'select * from "GTC_Update"."ControlActualitzacio";'
try:
cur.execute(select)
vec = cur.fetchall()
conn.commit()
except Exception as e:
print(e.message, e.args)
print("ERROR select Control")
if (vec[0][0]):
label = "Actualment s'està modificant el GTC.\nIntrodueix la paraula clau per carregar la capa."
val = self.on_click_CarregarAux(label)
if val == '':
return
comprovarParaulaClau = vec[0][3]
if (comprovarParaulaClau != val):
QMessageBox.information(None, "Error",
"La paraula clau no és la correcta.")
return
else:
label = "Actualment NO s'està modificant el GTC.\nIntrodueix la paraula clau per carregar la capa."
val = self.on_click_CarregarAux(label)
if val == '':
return
update = 'update "GTC_Update"."ControlActualitzacio" set "modificant" = true;\n'
update += 'update "GTC_Update"."ControlActualitzacio" set "usuariModificador" = \'' + val + '\';\n'
update += 'update "GTC_Update"."ControlActualitzacio" set "horaModificacio" = CURRENT_TIMESTAMP;'
try:
cur.execute(update)
conn.commit()
except Exception as e:
print(e.message, e.args)
print("ERROR update Control (modificant, paraula clau)")
if (not vec[0][1]):
create = 'drop table if exists "GTC_Update"."UpdateGTC";\n'
create += 'create table "GTC_Update"."UpdateGTC" as (select * from "SegmentsXarxaCarrers" order by id);\n'
create += 'ALTER TABLE "GTC_Update"."UpdateGTC" DROP COLUMN id;\n'
create += 'ALTER TABLE "GTC_Update"."UpdateGTC" ADD COLUMN id serial;\n'
create += 'ALTER TABLE "GTC_Update"."UpdateGTC" ADD PRIMARY KEY (id);\n'
try:
cur.execute(create)
conn.commit()
except Exception as e:
print("ERROR create GTC per actualitzar")
print(e.message.encode('utf8', 'strict'),
e.args.encode('utf8', 'strict'))
select = 'select to_char("horaModificacio", \'DD/MM/YY HH24:MI\') from "GTC_Update"."ControlActualitzacio";'
try:
cur.execute(select)
vec = cur.fetchall()
conn.commit()
except Exception as e:
print(e.message, e.args)
print("ERROR select Control")
self.dlg.text_info.setText("Data de l'inici de la modificació: " +
vec[0][0])
uri = QgsDataSourceUri()
try:
uri.setConnection(host1, port1, nomBD1, usuari1, contra1)
except Exception as e:
print(e.message, e.args)
print("Error a la connexió")
sql_total = 'select * from "GTC_Update"."UpdateGTC" order by id'
QApplication.processEvents()
uri.setDataSource("GTC_Update", "UpdateGTC", "the_geom", "", "")
QApplication.processEvents()
'''
# 13.2 Es prepara el titol de la capa que apareixerà a la llegenda
'''
titol = "UpdateGTC"
vlayer = QgsVectorLayer(uri.uri(False), titol, "postgres")
QApplication.processEvents()
if vlayer.isValid():
symbols = vlayer.renderer().symbols(QgsRenderContext())
symbol = symbols[0]
'''S'afegeix el color a la nova entitat'''
symbol.setColor(QColor.fromRgb(0, 0, 0))
QgsProject.instance().addMapLayer(vlayer, False)
root = QgsProject.instance().layerTreeRoot()
myLayerNode = QgsLayerTreeLayer(vlayer)
root.insertChildNode(0, myLayerNode)
myLayerNode.setCustomProperty("showFeatureCount", False)
QApplication.processEvents()
''''S'afegeix la capa a la pantalla'''
iface.mapCanvas().refresh()
#qgis.utils.iface.legendInterface().refreshLayerSymbology(vlayer)
else:
print("No s'ha carregat la capa")
def testTemporalState(self):
rc = QgsRenderContext()
self.assertEqual(rc.isTemporal(), False)
self.assertIsNotNone(rc.temporalRange())
def setGraduadedPalette(self, layer, field, setRender, nameLayer):
renderer = layer.renderer()
prop = QgsProperty()
# Set arrows and node icon visibility (only when layer is opened)
# Links icon visibility are assigned when style is applied in Utils
if setRender: # Just opened a layer
# SimpleSymbol (first time)
symbol = renderer.symbol()
if symbol.type() == 1: # line
self.setArrowsVisibility(symbol, layer, prop, field)
else: # point
self.setNodesVisibility(prop, symbol)
else:
# GraduatedSymbol (other times)
symbols = renderer.symbols(QgsRenderContext())
for symbol in symbols:
if symbol.type() == 1: # line
self.setArrowsVisibility(symbol, layer, prop, field)
if "Flow" in layer.name():
field = "abs(" + field + ")"
# Set graduated colors
if setRender: # Just opened a layer
# Has previous render saved?
hasRender = False
dictRend = self.Renders.get(self.Scenario)
if dictRend is None:
dictRend = self.Renders.get("Base") # default
if dictRend is not None:
ranges = dictRend.get(
self.getLayerPath(layer).replace(
"_" + self.Scenario + "_", "_Base_"))
if ranges is not None:
hasRender = True
else:
ranges = dictRend.get(self.getLayerPath(layer))
if ranges is not None:
hasRender = True
else:
dictRend = self.Renders.get("Base") # default
if dictRend is not None:
ranges = dictRend.get(
self.getLayerPath(layer).replace(
"_" + self.Scenario + "_", "_Base_"))
if ranges is not None:
hasRender = True
# Apply render
if hasRender:
renderer = QgsGraduatedSymbolRenderer(field, ranges)
else:
ranges = self.getColorClasses(symbol, nameLayer)
if len(ranges) > 0:
renderer = QgsGraduatedSymbolRenderer(field, ranges)
else:
mode = QgsGraduatedSymbolRenderer.EqualInterval # Quantile
classes = 5
ramp = {
'color1':
'0,0,255,255',
'color2':
'255,0,0,255',
'stops':
'0.25;0,255,255,255:0.50;0,255,0,255:0.75;255,255,0,255'
}
colorRamp = QgsVectorGradientColorRamp.create(ramp)
self.iface.setActiveLayer(layer)
renderer = QgsGraduatedSymbolRenderer.createRenderer(
layer, field, classes, mode, symbol, colorRamp)
myFormat = renderer.labelFormat()
myFormat.setPrecision(2)
myFormat.setTrimTrailingZeroes(True)
renderer.setLabelFormat(myFormat, True)
else:
renderer.setClassAttribute(field)
layer.setRenderer(renderer)
layer.triggerRepaint()
def updateLayerAttributes(self):
no_layer = False
self.update_attributtes = False
# get selected layer
layer = self.dlg.getCurrentLayer()
if layer not in ("", "Open a vector layer with numeric fields", "Select layer to explore..."):
if self.current_layer is None or self.current_layer.name() != layer:
self.update_attributtes = True
# disconnect eventual slots with the previous layer
if self.current_layer:
try:
self.current_layer.selectionChanged.disconnect(self.updateStats)
except:
pass
try:
self.current_layer.selectionChanged.disconnect(self.changedMapSelection)
except:
pass
# fixme: throws NoneType error occasionally when adding/removing layers. trapping it for now.
try:
self.current_layer = lfh.getLegendLayerByName(self.iface, layer)
if self.dlg.getCurrentTab() == 1:
self.current_layer.selectionChanged.connect(self.updateStats)
elif self.dlg.getCurrentTab() == 2:
self.current_layer.selectionChanged.connect(self.changedMapSelection)
except:
self.current_layer = None
# get layer attributes
if self.current_layer and self.update_attributtes:
node = QgsProject.instance().layerTreeRoot().findLayer(self.current_layer.id())
if not node.isVisible():
node.setItemVisibilityChecked(True)
if self.current_layer.type() == 0: # VectorLayer
# fixme: throws NoneType error occasionally when adding/removing layers. trapping it for now.
try:
numeric_fields, numeric_field_indices = lfh.getNumericFieldNames(self.current_layer)
except:
numeric_fields = []
numeric_field_indices = []
if len(numeric_fields) > 0:
# set min and max values of attributes
# set this layer's default display attributes
self.layer_display_settings = []
self.layer_attributes = []
for i, index in enumerate(numeric_field_indices):
max_value = self.current_layer.maximumValue(index)
min_value = self.current_layer.minimumValue(index)
# exclude columns with only NULL values
if max_value != NULL and min_value != NULL:
# set the layer's attribute info
attribute_info = dict()
attribute_info['id'] = index
attribute_info['name'] = numeric_fields[i]
attribute_info['max'] = max_value
attribute_info['min'] = min_value
self.layer_attributes.append(attribute_info)
# set default display settings
attribute_display = dict(attribute="", colour_range=0, line_width=0.25, invert_colour=0,
display_order=0,
intervals=10, interval_type=0, top_percent=100, top_value=0.0,
bottom_percent=0, bottom_value=0.0)
# update the top and bottom value of the defaults
attribute_display['attribute'] = numeric_fields[i]
attribute_display['top_value'] = max_value
attribute_display['bottom_value'] = min_value
if self.current_layer.geometryType() == 0:
attribute_display['line_width'] = 2.5
self.layer_display_settings.append(attribute_display)
# get the current display attribute
attributes = self.current_layer.renderer().usedAttributes(QgsRenderContext())
if len(attributes) > 0:
display_attribute = next(iter(attributes))
if display_attribute in numeric_fields:
current_attribute = numeric_fields.index(display_attribute)
else:
current_attribute = 0
else:
current_attribute = 0
# check for saved display settings for the given layer
self.getProjectSettings()
# update the dialog with this info
self.dlg.lockTabs(False)
self.dlg.setAttributesList(self.layer_attributes)
self.dlg.setAttributesSymbology(self.layer_display_settings)
self.dlg.setCurrentAttribute(current_attribute)
# self.updateSymbology()
else:
no_layer = True
else:
no_layer = True
else:
no_layer = True
if no_layer:
# disconnect eventual slots with the previous layer
if self.current_layer:
try:
self.current_layer.selectionChanged.disconnect(self.updateStats)
except:
pass
try:
self.current_layer.selectionChanged.disconnect(self.changedMapSelection)
except:
pass
self.current_layer = None # QgsVectorLayer()
self.dlg.setAttributesList([])
self.dlg.setAttributesSymbology([])
self.dlg.setCurrentAttribute(-1)
self.dlg.lockTabs(True)
def showRequestResult(self, items, append, last, message):
# print("showRequestResult")
if items is None or len(items) == 0:
QApplication.restoreOverrideCursor()
self.__show_status_label(StatusMessageType.LOAD_FINISHED)
self.getDataButton.setEnabled(True)
if message is None or len(message) == 0:
message = "По указанным параметрам ничего не найдено"
self._show_message(self, "Загузка завершена", message)
return
color = QColor(237, 28, 36, 200)
pjt = QgsProject.instance()
layersList = pjt.mapLayersByName(self.resultsLayerName)
if not append:
if layersList is not None and len(layersList) > 0:
pjt.removeMapLayer(layersList[0])
# print("remove results")
layersList.clear()
if not append or layersList is None or len(layersList) == 0:
# print("create layer")
layer = QgsVectorLayer("Point?crs=EPSG:4326"
"&field=coordinatesWKT:string(255)&field=shootingDateTime:string(255)"
"&field=temperature:double(7)&field=pixelSizeInDirection:double(5)"
"&field=pixelSizeAcross:double(5)&field=thermalPower:double(5)"
"&field=baseResourceId:string(255)&field=id:string(255)&field=updated:string(255)"
"&field=satellite:string(10)",
self.resultsLayerName, "memory")
else:
layer = layersList[0]
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
svg_marker = QgsSvgMarkerSymbolLayer(":/plugins/thermal_anomaly/fire.svg")
svg_marker.setSize(6.0)
symbol.changeSymbolLayer(0, svg_marker)
layer.renderer().setSymbol(symbol)
layer.startEditing()
print("all items=", len(items))
poly = QgsGeometry.fromWkt(self.polygon)
for point in items:
symbols = layer.renderer().symbols(QgsRenderContext()) # todo which context ?
symbols[0].setColor(color)
feature = QgsFeature()
coord = QgsGeometry.fromWkt(point["coordinatesWKT"])
feature.setGeometry(coord)
feature.setAttributes([point["coordinatesWKT"], point["shootingDateTime"], point["temperature"],
point["pixelSizeInDirection"], point["pixelSizeAcross"], point["thermalPower"],
point["baseResourceId"], point["id"], point["updated"], point["satellite"]])
layer.dataProvider().addFeatures([feature])
# if not poly.contains(coord):
# print("point out of poly: id =", point["id"], "coord =", point["coordinatesWKT"])
layer.commitChanges()
if not append:
pjt.addMapLayer(layer, False)
if pjt.layerTreeRoot().findGroup(self.tr(self.groupName)) is None:
pjt.layerTreeRoot().insertChildNode(0, QgsLayerTreeGroup(self.tr(self.groupName)))
group = pjt.layerTreeRoot().findGroup(self.tr(self.groupName))
group.insertLayer(0, layer)
self.iface.layerTreeView().refreshLayerSymbology(layer.id())
self.iface.mapCanvas().refresh()
if last:
QApplication.restoreOverrideCursor()
self.__show_status_label(StatusMessageType.LOAD_FINISHED)
self.getDataButton.setEnabled(True)
else:
self.__show_status_label(StatusMessageType.LOAD_STARTED, message)
def testQgsGraduatedSymbolRendererV2_1(self):
"""Test QgsGraduatedSymbolRendererV2: Basic get/set functions """
# Create a renderer
renderer = QgsGraduatedSymbolRendererV2()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
self.assertEqual(symbol.dump(),
renderer.sourceSymbol().dump(),
"Get/set renderer source symbol")
attr = '"value"*"value"'
renderer.setClassAttribute(attr)
self.assertEqual(attr, renderer.classAttribute(),
"Get/set renderer class attribute")
for m in (
QgsGraduatedSymbolRendererV2.Custom,
QgsGraduatedSymbolRendererV2.EqualInterval,
QgsGraduatedSymbolRendererV2.Quantile,
QgsGraduatedSymbolRendererV2.Jenks,
QgsGraduatedSymbolRendererV2.Pretty,
QgsGraduatedSymbolRendererV2.StdDev,
):
renderer.setMode(m)
self.assertEqual(m, renderer.mode(), "Get/set renderer mode")
format = createLabelFormat()
renderer.setLabelFormat(format)
self.assertEqual(dumpLabelFormat(format),
dumpLabelFormat(renderer.labelFormat()),
"Get/set renderer label format")
ramp = createColorRamp()
renderer.setSourceColorRamp(ramp)
self.assertEqual(dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
renderer.setInvertedColorRamp(True)
self.assertTrue(renderer.invertedColorRamp(),
"Get/set renderer inverted color ramp")
renderer.setInvertedColorRamp(False)
self.assertFalse(renderer.invertedColorRamp(),
"Get/set renderer inverted color ramp")
value = '"value"*2'
exp = QgsSymbolLayerV2Utils.fieldOrExpressionToExpression(value)
valuestr = QgsSymbolLayerV2Utils.fieldOrExpressionFromExpression(exp)
renderer.setRotationField(value)
self.assertEqual(valuestr, renderer.rotationField(),
"Get/set renderer rotation field")
value = '"value"*3'
exp = QgsSymbolLayerV2Utils.fieldOrExpressionToExpression(value)
valuestr = QgsSymbolLayerV2Utils.fieldOrExpressionFromExpression(exp)
renderer.setSizeScaleField(value)
self.assertEqual(valuestr, renderer.sizeScaleField(),
"Get/set renderer size scale field")
renderer.setSourceColorRamp(ramp)
self.assertEqual(dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
for sm in (
QgsSymbolV2.ScaleArea,
QgsSymbolV2.ScaleDiameter,
):
renderer.setScaleMethod(sm)
self.assertEqual(str(sm), str(renderer.scaleMethod()),
"Get/set renderer scale method")
# test for classificatio with varying size
renderer.setGraduatedMethod(QgsGraduatedSymbolRendererV2.GraduatedSize)
renderer.setSourceColorRamp(None)
renderer.addClassLowerUpper(0, 2)
renderer.addClassLowerUpper(2, 4)
renderer.addClassLowerUpper(4, 6)
renderer.setSymbolSizes(2, 13)
self.assertEqual(renderer.maxSymbolSize(), 13)
self.assertEqual(renderer.minSymbolSize(), 2)
refSizes = [2, (13 + 2) * .5, 13]
ctx = QgsRenderContext()
for idx, symbol in enumerate(renderer.symbols(ctx)):
self.assertEqual(symbol.size(), refSizes[idx])
def testPainterClipPath(self):
region = QgsMapClippingRegion(
QgsGeometry.fromWkt('Polygon((0 0, 1 0, 1 1, 0 1, 0 0))'))
region.setFeatureClip(
QgsMapClippingRegion.FeatureClippingType.ClipPainterOnly)
region2 = QgsMapClippingRegion(
QgsGeometry.fromWkt('Polygon((0 0, 0.1 0, 0.1 2, 0 2, 0 0))'))
region2.setFeatureClip(
QgsMapClippingRegion.FeatureClippingType.NoClipping)
region3 = QgsMapClippingRegion(
QgsGeometry.fromWkt('Polygon((0 0, 0.1 0, 0.1 2, 0 2, 0 0))'))
region3.setFeatureClip(
QgsMapClippingRegion.FeatureClippingType.ClipPainterOnly)
rc = QgsRenderContext()
for t in [
QgsMapLayerType.VectorLayer, QgsMapLayerType.RasterLayer,
QgsMapLayerType.MeshLayer, QgsMapLayerType.VectorTileLayer
]:
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion(
[], rc, t)
self.assertFalse(should_clip)
self.assertEqual(path.elementCount(), 0)
for t in [
QgsMapLayerType.VectorLayer, QgsMapLayerType.RasterLayer,
QgsMapLayerType.MeshLayer, QgsMapLayerType.VectorTileLayer
]:
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion(
[region], rc, t)
self.assertTrue(should_clip)
self.assertEqual(
QgsGeometry.fromQPolygonF(path.toFillPolygon()).asWkt(1),
'Polygon ((0 1, 1 1, 1 0, 0 0, 0 1))')
# region2 is a Intersects type clipping region, should not apply for vector layers
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion(
[region2], rc, QgsMapLayerType.VectorLayer)
self.assertFalse(should_clip)
self.assertEqual(path.elementCount(), 0)
for t in [
QgsMapLayerType.RasterLayer, QgsMapLayerType.MeshLayer,
QgsMapLayerType.VectorTileLayer
]:
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion(
[region2], rc, t)
self.assertTrue(should_clip)
self.assertEqual(
QgsGeometry.fromQPolygonF(path.toFillPolygon()).asWkt(1),
'Polygon ((0 1, 0.1 1, 0.1 -1, 0 -1, 0 1))')
for t in [
QgsMapLayerType.VectorLayer, QgsMapLayerType.RasterLayer,
QgsMapLayerType.MeshLayer, QgsMapLayerType.VectorTileLayer
]:
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion(
[region, region2, region3], rc, t)
self.assertTrue(should_clip)
self.assertEqual(
QgsGeometry.fromQPolygonF(path.toFillPolygon()).asWkt(1),
'Polygon ((0.1 1, 0 1, 0 0, 0.1 0, 0.1 1))')
rc.setMapToPixel(QgsMapToPixel(5, 10, 11, 200, 150, 0))
for t in [
QgsMapLayerType.VectorLayer, QgsMapLayerType.RasterLayer,
QgsMapLayerType.MeshLayer, QgsMapLayerType.VectorTileLayer
]:
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion(
[region, region3], rc, t)
self.assertTrue(should_clip)
self.assertEqual(
QgsGeometry.fromQPolygonF(path.toFillPolygon()).asWkt(0),
'Polygon ((98 77, 98 77, 98 77, 98 77, 98 77))')
def testQgsGraduatedSymbolRenderer_1(self):
"""Test QgsGraduatedSymbolRenderer: Basic get/set functions """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
self.assertEqual(symbol.dump(), renderer.sourceSymbol().dump(), "Get/set renderer source symbol")
attr = '"value"*"value"'
renderer.setClassAttribute(attr)
self.assertEqual(attr, renderer.classAttribute(), "Get/set renderer class attribute")
for m in (
QgsGraduatedSymbolRenderer.Custom,
QgsGraduatedSymbolRenderer.EqualInterval,
QgsGraduatedSymbolRenderer.Quantile,
QgsGraduatedSymbolRenderer.Jenks,
QgsGraduatedSymbolRenderer.Pretty,
QgsGraduatedSymbolRenderer.StdDev,
):
renderer.setMode(m)
self.assertEqual(m, renderer.mode(), "Get/set renderer mode")
format = createLabelFormat()
renderer.setLabelFormat(format)
self.assertEqual(
dumpLabelFormat(format),
dumpLabelFormat(renderer.labelFormat()),
"Get/set renderer label format")
ramp = createColorRamp()
renderer.setSourceColorRamp(ramp)
self.assertEqual(
dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
renderer.setInvertedColorRamp(True)
self.assertTrue(renderer.invertedColorRamp(),
"Get/set renderer inverted color ramp")
renderer.setInvertedColorRamp(False)
self.assertFalse(renderer.invertedColorRamp(),
"Get/set renderer inverted color ramp")
renderer.setSourceColorRamp(ramp)
self.assertEqual(
dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
# test for classificatio with varying size
renderer.setGraduatedMethod(QgsGraduatedSymbolRenderer.GraduatedSize)
renderer.setSourceColorRamp(None)
renderer.addClassLowerUpper(0, 2)
renderer.addClassLowerUpper(2, 4)
renderer.addClassLowerUpper(4, 6)
renderer.setSymbolSizes(2, 13)
self.assertEqual(renderer.maxSymbolSize(), 13)
self.assertEqual(renderer.minSymbolSize(), 2)
refSizes = [2, (13 + 2) * .5, 13]
ctx = QgsRenderContext()
for idx, symbol in enumerate(renderer.symbols(ctx)):
self.assertEqual(symbol.size(), refSizes[idx])
def test_transfer_results(self):
results = QgsRenderedItemResults()
self.assertFalse(
results.renderedAnnotationItemsInBounds(
QgsRectangle(-100000000, -100000000, 100000000, 100000000)))
rc = QgsRenderContext()
details1 = QgsRenderedAnnotationItemDetails('layer_id', 'item_id_1')
details1.setBoundingBox(QgsRectangle(1, 1, 10, 10))
details2 = QgsRenderedAnnotationItemDetails('layer_id2', 'item_id_2')
details2.setBoundingBox(QgsRectangle(1, 1, 5, 5))
details3 = QgsRenderedAnnotationItemDetails('layer_id3', 'item_id_3')
details3.setBoundingBox(QgsRectangle(4, 4, 7, 7))
results.appendResults([details1, details2, details3], rc)
results2 = QgsRenderedItemResults()
# transfer some results to results2
# first no layers specified => nothing should be transferred
results2.transferResults(results, [])
self.assertCountEqual(
[(i.layerId(), i.itemId())
for i in results.renderedAnnotationItemsInBounds(
QgsRectangle(0, 0, 10, 10))], [('layer_id', 'item_id_1'),
('layer_id2', 'item_id_2'),
('layer_id3', 'item_id_3')])
self.assertFalse(
results2.renderedAnnotationItemsInBounds(QgsRectangle(
0, 0, 10, 10)))
results2.transferResults(results, ['layer_id2', 'layer_id3'])
self.assertEqual([(i.layerId(), i.itemId())
for i in results.renderedItems()],
[('layer_id', 'item_id_1')])
self.assertCountEqual(
[(i.layerId(), i.itemId())
for i in results2.renderedAnnotationItemsInBounds(
QgsRectangle(0, 0, 10, 10))], [('layer_id2', 'item_id_2'),
('layer_id3', 'item_id_3')])
# same layers, nothing should happen
results2.transferResults(results, ['layer_id2', 'layer_id3'])
self.assertEqual([(i.layerId(), i.itemId())
for i in results.renderedItems()],
[('layer_id', 'item_id_1')])
self.assertCountEqual(
[(i.layerId(), i.itemId())
for i in results2.renderedAnnotationItemsInBounds(
QgsRectangle(0, 0, 10, 10))], [('layer_id2', 'item_id_2'),
('layer_id3', 'item_id_3')])
# remaining layer
results2.transferResults(results, ['layer_id'])
self.assertFalse([(i.layerId(), i.itemId())
for i in results.renderedItems()])
self.assertCountEqual(
[(i.layerId(), i.itemId())
for i in results2.renderedAnnotationItemsInBounds(
QgsRectangle(0, 0, 10, 10))], [('layer_id', 'item_id_1'),
('layer_id2', 'item_id_2'),
('layer_id3', 'item_id_3')])
# transfer all results
results3 = QgsRenderedItemResults()
# nothing should happen -- no results in results3 to transfer
results2.transferResults(results3)
self.assertFalse(
results3.renderedAnnotationItemsInBounds(QgsRectangle(
0, 0, 10, 10)))
self.assertCountEqual(
[(i.layerId(), i.itemId())
for i in results2.renderedAnnotationItemsInBounds(
QgsRectangle(0, 0, 10, 10))], [('layer_id', 'item_id_1'),
('layer_id2', 'item_id_2'),
('layer_id3', 'item_id_3')])
# transfer all results from results2 to results3
results3.transferResults(results2)
self.assertFalse(results2.renderedItems())
self.assertCountEqual(
[(i.layerId(), i.itemId())
for i in results3.renderedAnnotationItemsInBounds(
QgsRectangle(0, 0, 10, 10))], [('layer_id', 'item_id_1'),
('layer_id2', 'item_id_2'),
('layer_id3', 'item_id_3')])
def updateRenderer(self, layer, attribute_vals, settings):
"""
Creates a renderer for the layer based on this, and applies it
The renderer uses GradientColourRamp to calculate the symbol colours
@param layer: the selected QgsVectorLayer object
"""
geometry = layer.geometryType()
# create a colour ramp based on colour range type, inverting symbols if required
ramp_type = int(settings['colour_range'])
invert = int(settings['invert_colour'])
ramp = self.getColourRamp(ramp_type, invert)
line_width = float(settings['line_width'])
# calculate ranges: EqualInterval = 0; Quantile = 1; Jenks = 2; StdDev = 3; Pretty = 4; Custom = 5
intervals = int(settings['intervals'])
mode = int(settings['interval_type'])
attribute = attribute_vals['name']
renderer = None
if mode < 3:
# set symbol type and line width
symbol = QgsSymbol.defaultSymbol(geometry)
if symbol:
if symbol.type() == 1: # line
symbol.setWidth(line_width)
elif symbol.type() == 2: # line
symbol = QgsFillSymbol.createSimple({
'style':
'solid',
'color':
'black',
'width_border':
'%s' % line_width
})
elif symbol.type() == 0: # point
symbol.setSize(line_width)
renderer = QgsGraduatedSymbolRenderer.createRenderer(
layer, attribute, intervals, mode, symbol, ramp)
renderer.setMode(mode)
renderer.setSourceColorRamp(ramp)
else:
# calculate range values individually based on custom settings
ranges = []
max_value = float(attribute_vals['max'])
min_value = float(attribute_vals['min'])
top_value = float(settings['top_value'])
bottom_value = float(settings['bottom_value'])
# calculate number of ranges depending on top/bottom difference from max/min:
# is there really a range there? Otherwise this will calculate 1 or even 2 ranges less
calc_intervals = intervals + 1
if top_value != max_value:
calc_intervals -= 1
if bottom_value != min_value:
calc_intervals -= 1
range_steps = [
r for r in np.linspace(bottom_value, top_value, calc_intervals)
]
if top_value != max_value:
range_steps.append(max_value)
if bottom_value != min_value:
range_steps.insert(0, min_value)
for i in range(0, len(range_steps) - 1):
symbol = QgsSymbol.defaultSymbol(geometry)
if symbol:
new_colour = ramp.color(
i / (float(len(range_steps)) - 2)).getRgb()
symbol.setColor(QColor(*new_colour))
symbol.setWidth(line_width)
label = "%s - %s" % (range_steps[i], range_steps[i + 1])
this_range = QgsRendererRange(range_steps[i],
range_steps[i + 1], symbol,
label)
ranges.append(this_range)
if ranges:
renderer = QgsGraduatedSymbolRenderer(attribute, ranges)
# renderer.setMode(5)
renderer.setSourceColorRamp(ramp)
# configure symbol levels to display in specific order
# the classic "reds on top" from space syntax, or the reverse
if renderer:
display_order = int(settings['display_order'])
renderer.setUsingSymbolLevels(True)
render_pass = 0
if display_order == 0:
for symbol in renderer.symbols(QgsRenderContext()):
for i in range(0, symbol.symbolLayerCount()):
symbol.symbolLayer(i).setRenderingPass(render_pass)
render_pass += 1
else:
for symbol in reversed(renderer.symbols(QgsRenderContext())):
for i in range(0, symbol.symbolLayerCount()):
symbol.symbolLayer(i).setRenderingPass(render_pass)
render_pass += 1
# set the symbols for monochrome ramp
# varying line width, point size or polygon pattern density
# doesn't use data column because it's not scaled according to line width values
# the width is calculated linearly between min and given value
if renderer:
if ramp_type == 3:
new_width = np.linspace(0.1, line_width, intervals)
step = intervals / 8.0 # this is usd for fill patterns
# color = QColor(ramp.color(0).getRgb()) # same as above
for i in range(0, intervals):
symbol = renderer.symbols(QgsRenderContext())[i]
if invert:
if symbol.type() == 1: # line
symbol.setWidth(new_width[(intervals - 1) - i])
elif symbol.type() == 0: # point
symbol.setSize(new_width[(intervals - 1) - i])
elif symbol.type() == 2: # polygon
dense = int(i / step)
if dense == 0:
style = 'solid'
else:
style = 'dense%s' % dense
symbol = QgsFillSymbol.createSimple({
'style':
style,
'color':
'black',
'width_border':
'%s' % new_width[(intervals - 1) - i]
})
else:
if symbol.type() == 1: # line
symbol.setWidth(new_width[i])
elif symbol.type() == 0: # point
symbol.setSize(new_width[i])
elif symbol.type() == 2: # polygon
dense = int(i / step)
if dense == 7:
style = 'solid'
else:
style = 'dense%s' % (7 - dense)
symbol = QgsFillSymbol.createSimple({
'style':
style,
'color':
'black',
'width_border':
'%s' % new_width[i]
})
renderer.updateRangeSymbol(i, symbol)
return renderer
def processPointsLayer(self, feedback, layer, mapAttr, resultProj):
feedback.setProgressText("Publishing map: " +
UTILS.normalizeName(layer.name()))
clonedLayer = layer.clone()
layerRenderer = clonedLayer.renderer()
renderContext = QgsRenderContext()
renderContext.setUseAdvancedEffects(True)
renderContext.setFlags(QgsRenderContext.Flag.Antialiasing)
imageList = list()
iconField = QgsField(
'icon_url', QVariant.String,
'text') #Danilo não vou verificar se o mapa ja tem esse atributo
feedback.setProgressText("Adding a column 'icon_url'")
clonedLayer.startEditing()
addedField = clonedLayer.addAttribute(iconField)
if (addedField == False):
feedback.pushConsoleInfo(
"Warning: " + layer.name() +
" canceled failed to create a column to store the point symbol."
)
return False
clonedLayer.commitChanges()
clonedLayer.startEditing()
feedback.setProgressText("Rendering symbologies")
for feature in clonedLayer.getFeatures():
layerRenderer.startRender(renderContext, clonedLayer.fields())
symbol = layerRenderer.originalSymbolsForFeature(
feature, renderContext)
if len(symbol) <= 0:
continue
else:
if len(symbol) > 1:
feedback.pushConsoleInfo(
"Warning: Only one symbol for symbology, the others will be ignored."
)
symbol = symbol[0]
layerRenderer.stopRender(renderContext)
curImage = symbol.asImage(QSize(24, 24))
try:
imgIndex = imageList.index(curImage)
except Exception as e:
imageList.append(curImage)
imgIndex = len(imageList) - 1
feature.setAttribute("icon_url", './' + str(imgIndex) + ".png")
clonedLayer.updateFeature(feature)
clonedLayer.commitChanges()
layerCsvFolder = self.getPathForMap(layer.name(), mapAttr, 'csv')
feedback.setProgressText("Saving results")
os.makedirs(layerCsvFolder, exist_ok=True)
savedCsv = QgsVectorFileWriter.writeAsVectorFormat(
clonedLayer,
os.path.join(layerCsvFolder, 'point_layer.csv'),
'utf-8',
resultProj,
'CSV',
layerOptions=['GEOMETRY=AS_XY'])
#Saving symbology
for index in range(len(imageList)):
imageList[index].save(
os.path.join(layerCsvFolder,
str(index) + '.png'))
return savedCsv and len(imageList) > 0
from builtins import object
from PyQt5.QtCore import QSettings, QTranslator, qVersion, QCoreApplication, Qt
from PyQt5.QtWidgets import QAction, QGraphicsScene, QFileDialog
from PyQt5.QtGui import QIcon, QImage, QPainter, QColor, QPixmap, QTransform
# Initialize Qt resources from file resources.py
from .resources import *
# Import QGIS components
from qgis.gui import QgsMessageBar, QgsBlendModeComboBox
from qgis.core import QgsMapLayerProxyModel, QgsRenderContext
# Import the code for the DockWidget
from .bivariate_legend_dockwidget import BivariateLegendDockWidget
import os.path
renderContext = QgsRenderContext()
class BivariateLegend(object):
"""QGIS Plugin Implementation."""
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
def apply_masks(self, layer_bound):
layers = QgsProject.instance().mapLayers().values()
mask_dict = {}
#Creating symbol layer reference list
grid_symbol_ref_list = []
renderer = layer_bound.renderer()
grid_symbol_rule_id = renderer.rootRule().children()[0].ruleKey()
layer_id = layer_bound.id()
symbol_list = renderer.symbols(QgsRenderContext())
symbol_layer_list = symbol_list[0].symbolLayers()
for smb in range(1, len(symbol_layer_list)):
idx_list = []
idx_list.append(smb)
idx_list.append(0)
symbol_id = QgsSymbolLayerId(grid_symbol_rule_id, idx_list)
temp = QgsSymbolLayerReference(layer_id, symbol_id)
grid_symbol_ref_list.append(temp)
#Listing available label masks
for layer in layers:
if not layer.type() == QgsMapLayer.VectorLayer:
continue
labels = layer.labeling()
if not labels:
continue
providers = []
if isinstance(labels, QgsVectorLayerSimpleLabeling):
providers.append('--SINGLE--RULE--')
if isinstance(labels, QgsRuleBasedLabeling):
providers = [x.ruleKey() for x in labels.rootRule().children()]
for provider in providers:
if provider == '--SINGLE--RULE--':
label_settings = labels.settings()
else:
label_settings = labels.settings(provider)
label_format = label_settings.format()
masks = label_format.mask()
if not masks.enabled():
continue
#Applying available lable masks to grid layer symbology
mask_symbol_list = masks.maskedSymbolLayers()
new_symbol_mask = []
for item in mask_symbol_list:
if item.layerId() == layer_id:
continue
new_symbol_mask.append(item)
for item in grid_symbol_ref_list:
new_symbol_mask.append(item)
masks.setMaskedSymbolLayers(new_symbol_mask)
label_format.setMask(masks)
label_settings.setFormat(label_format)
if provider == '--SINGLE--RULE--':
labels.setSettings(label_settings)
else:
labels.setSettings(label_settings, provider)
layer.setLabeling(labels)
return
def testQgsGradientFillSymbolLayer(self):
"""Test setting and getting QgsGradientFillSymbolLayer properties.
"""
mGradientLayer = QgsGradientFillSymbolLayer()
mExpectedValue = type(QgsGradientFillSymbolLayer())
mValue = type(mGradientLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QgsGradientFillSymbolLayer.Radial
mGradientLayer.setGradientType(mExpectedValue)
mValue = mGradientLayer.gradientType()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QgsGradientFillSymbolLayer.ColorRamp
mGradientLayer.setGradientColorType(mExpectedValue)
mValue = mGradientLayer.gradientColorType()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QColor('#55aaff')
mGradientLayer.setColor2(mExpectedValue)
mValue = mGradientLayer.color2()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QgsGradientFillSymbolLayer.Viewport
mGradientLayer.setCoordinateMode(mExpectedValue)
mValue = mGradientLayer.coordinateMode()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QgsGradientFillSymbolLayer.Reflect
mGradientLayer.setGradientSpread(mExpectedValue)
mValue = mGradientLayer.gradientSpread()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QPointF(0.5, 0.8)
mGradientLayer.setReferencePoint1(mExpectedValue)
mValue = mGradientLayer.referencePoint1()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = True
mGradientLayer.setReferencePoint1IsCentroid(mExpectedValue)
mValue = mGradientLayer.referencePoint1IsCentroid()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QPointF(0.2, 0.4)
mGradientLayer.setReferencePoint2(mExpectedValue)
mValue = mGradientLayer.referencePoint2()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = True
mGradientLayer.setReferencePoint2IsCentroid(mExpectedValue)
mValue = mGradientLayer.referencePoint2IsCentroid()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 90
mGradientLayer.setAngle(mExpectedValue)
mValue = mGradientLayer.angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QPointF(10, 20)
mGradientLayer.setOffset(mExpectedValue)
mValue = mGradientLayer.offset()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QgsUnitTypes.RenderMapUnits
mGradientLayer.setOffsetUnit(mExpectedValue)
mValue = mGradientLayer.offsetUnit()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
ctx = QgsRenderContext()
self.assertCountEqual(mGradientLayer.usedAttributes(ctx), {})
def identifyLayer(self, point):
self.results[:] = []
if not self.layer.hasGeometryType():
return False
if (self.layer.hasScaleBasedVisibility() and
(self.layer.minimumScale() > self.canvas.mapSettings().scale() or
self.layer.maximumScale() <= self.canvas.mapSettings().scale())):
print 'Out of scale limits'
return False
QApplication.setOverrideCursor(Qt.WaitCursor)
featureCount = 0
featureList = []
try:
searchRadius = self.searchRadiusMU(self.canvas)
r = QgsRectangle()
r.setXMinimum(point.x() - searchRadius)
r.setXMaximum(point.x() + searchRadius)
r.setYMinimum(point.y() - searchRadius)
r.setYMaximum(point.y() + searchRadius)
r = self.toLayerCoordinates(self.layer, r)
req = QgsFeatureRequest()
req.setFilterRect(r)
req.setFlags(QgsFeatureRequest.ExactIntersect)
for f in self.layer.getFeatures(req):
featureList.append(QgsFeature(f))
except QgsCsException as cse:
print 'Caught CRS exception', cse.what()
myFilter = False
context = QgsRenderContext(
QgsRenderContext.fromMapSettings(self.canvas.mapSettings()))
renderer = self.layer.rendererV2()
if (renderer is not None and
(renderer.capabilities() | QgsFeatureRendererV2.ScaleDependent)):
renderer.startRender(context, self.layer.pendingFields())
myFilter = renderer.capabilities() and QgsFeatureRendererV2.Filter
for f in featureList:
if myFilter and not renderer.willRenderFeature(f):
continue
featureCount += 1
self.results.append((self.layer, f))
if (renderer is not None and
(renderer.capabilities() | QgsFeatureRendererV2.ScaleDependent)):
renderer.stopRender(context)
print 'Feature count on identify:', featureCount
QApplication.restoreOverrideCursor()
return featureCount > 0
def draw(self):
rb = self.tool.rb
g = rb.asGeometry()
ok = True
warning = False
errBuffer_noAtt = False
errBuffer_Vertices = False
layer = self.iface.layerTreeView().currentLayer()
if self.toolname == 'drawBuffer':
if self.bGeom is None:
warning = True
errBuffer_noAtt = True
else:
perim, ok = QInputDialog.getDouble(
self.iface.mainWindow(),
self.tr('Perimeter'),
self.tr('Give a perimeter in m:') + '\n' +
self.tr('(works only with metric crs)'),
min=0)
g = self.bGeom.buffer(perim, 40)
rb.setToGeometry(
g,
QgsVectorLayer("Polygon?crs=" + layer.crs().authid(), "",
"memory"))
if g.length() == 0 and ok:
warning = True
errBuffer_Vertices = True
if self.toolname == 'drawCopies':
if g.length() < 0:
warning = True
errBuffer_noAtt = True
if ok and not warning:
name = ''
ok = True
add = False
index = 0
layers = []
while not name.strip() and not add and ok:
dlg = QDrawLayerDialog(self.iface, self.drawShape)
name, add, index, layers, ok = dlg.getName(
self.iface, self.drawShape)
if ok and not warning:
layer = None
if add:
layer = layers[index]
if self.drawShape in ['point', 'XYpoint']:
g = g.centroid()
else:
if self.drawShape == 'point':
layer = QgsVectorLayer(
"Point?crs=" + self.iface.mapCanvas().mapSettings(
).destinationCrs().authid() + "&field=" +
self.tr('Drawings') + ":string(255)", name, "memory")
g = g.centroid() # force geometry as point
elif self.drawShape == 'XYpoint':
layer = QgsVectorLayer(
"Point?crs=" + self.XYcrs.authid() + "&field=" +
self.tr('Drawings') + ":string(255)", name, "memory")
g = g.centroid()
elif self.drawShape == 'line':
layer = QgsVectorLayer(
"LineString?crs=" + self.iface.mapCanvas().mapSettings(
).destinationCrs().authid() + "&field=" +
self.tr('Drawings') + ":string(255)", name, "memory")
# fix_print_with_import
print("LineString?crs=" + self.iface.mapCanvas(
).mapSettings().destinationCrs().authid() + "&field=" +
self.tr('Drawings') + ":string(255)")
else:
layer = QgsVectorLayer(
"Polygon?crs=" + self.iface.mapCanvas().mapSettings(
).destinationCrs().authid() + "&field=" +
self.tr('Drawings') + ":string(255)", name, "memory")
layer.startEditing()
symbols = layer.renderer().symbols(
QgsRenderContext()) # todo which context ?
symbols[0].setColor(self.settings.getColor())
feature = QgsFeature()
feature.setGeometry(g)
feature.setAttributes([name])
layer.dataProvider().addFeatures([feature])
layer.commitChanges()
if not add:
pjt = QgsProject.instance()
pjt.addMapLayer(layer, False)
if pjt.layerTreeRoot().findGroup(self.tr('Drawings')) is None:
pjt.layerTreeRoot().insertChildNode(
0, QgsLayerTreeGroup(self.tr('Drawings')))
group = pjt.layerTreeRoot().findGroup(self.tr('Drawings'))
group.insertLayer(0, layer)
self.iface.layerTreeView().refreshLayerSymbology(layer.id())
self.iface.mapCanvas().refresh()
else:
if warning:
if errBuffer_noAtt:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('You didn\'t click on a layer\'s attribute !'))
elif errBuffer_Vertices:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('You must give a non-null value for a \
point\'s or line\'s perimeter !'))
else:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('There is no selected layer, or it is not \
vector nor visible !'))
self.tool.reset()
self.resetSB()
self.bGeom = None
def getDataButtonClicked(self):
clId = self.leClientID.text()
clSecret = self.leClientSecret.text()
if len(clId) == 0 or len(clSecret) == 0:
self._show_message("Некорректные данные", "Данные пользователя не могут быть пустыми")
return
dateTimeFrom = self.dateTimeEditFrom.dateTime()
dateTimeTo = self.dateTimeEditTo.dateTime()
if dateTimeFrom >= dateTimeTo:
self._show_message("Некорректные данные", "Дата 'По' должна быть больше, чем дата 'С'")
return
pjt = QgsProject.instance()
# clear results
layersList = pjt.mapLayersByName(self.resultsLayerName)
if layersList is not None and len(layersList) > 0:
pjt.removeMapLayer(layersList[0])
self.iface.mapCanvas().refresh()
layersList = pjt.mapLayersByName(self.searchAreaLayerName)
polygonGeometry = None
if layersList is not None and len(layersList) > 0:
feat = list(layersList[0].getFeatures())[0]
if feat.hasGeometry():
polygonGeometry = self.geomTransform(
feat.geometry(),
self.iface.mapCanvas().mapSettings().destinationCrs(),
QgsCoordinateReferenceSystem(4326))
if polygonGeometry is None:
self._show_message("Некорректные данные", "Необходимо задать полигон поиска")
return
availableAreaName = "available_area"
shpLayer = QgsVectorLayer(os.path.dirname(__file__) + "/roi/ZRV.shp", availableAreaName, "ogr")
if not shpLayer.isValid():
self._show_message("Некорректные данные", "Некорректный файл с зоной охвата")
return
intersectionGeom = None
for feature in shpLayer.getFeatures():
if feature.geometry().intersects(polygonGeometry):
intersectionGeom = feature.geometry().intersection(polygonGeometry)
if intersectionGeom == None:
layersList = pjt.mapLayersByName(availableAreaName)
if layersList is not None and len(layersList) > 0:
pjt.removeMapLayer(layersList[0])
symbols = shpLayer.renderer().symbols(QgsRenderContext())
symbols[0].setColor(QColor(76, 205, 53, 84))
pjt.addMapLayer(shpLayer, False)
if pjt.layerTreeRoot().findGroup(self.tr(self.groupName)) is None:
pjt.layerTreeRoot().insertChildNode(0, QgsLayerTreeGroup(self.tr(self.groupName)))
group = pjt.layerTreeRoot().findGroup(self.tr(self.groupName))
group.addLayer(shpLayer)
self.iface.layerTreeView().refreshLayerSymbology(shpLayer.id())
geom = self.geomTransform(
list(shpLayer.getFeatures())[0].geometry(),
QgsCoordinateReferenceSystem(4326),
self.iface.mapCanvas().mapSettings().destinationCrs())
self.iface.mapCanvas().setExtent(geom.boundingBox())
self.iface.mapCanvas().refresh()
self._show_message("Некорректные данные", "Полигон поиска лежит за пределами зоны охвата")
return
self.polygon = intersectionGeom.asWkt()
# print("polygon=", self.polygon)
self.__toggle(False, True)
self.getDataButton.setEnabled(False)
QApplication.setOverrideCursor(Qt.WaitCursor)
self.__show_status_label(StatusMessageType.LOAD_STARTED)
self.dataRequest.dataRequest(clId, clSecret, dateTimeFrom, dateTimeTo, self.polygon)
def btnLaunchAction(self):
"""btnLaunch action"""
# Paramètres du web service IGN de calcul d'isochrone
x = 2.424626
y = 48.845793
location = '{},{}'.format(x, y)
method = 'time' # time distance
graphname = 'Voiture' # Voiture Pieton
time = 90 * 60 # si method time
distance = 100000 # si method distance
holes = False # True False
smoothing = True # True False
epsg = 4326
apiKey = 'choisirgeoportail'
# Paramètres de symbologie
fillRed = QColor(251, 154, 153)
fillBlue = QColor(166, 206, 227)
fillGreen = QColor(178, 223, 138)
fillColor = fillGreen
strokeRed = QColor(251, 154, 153)
strokeBlue = QColor(31, 120, 180)
strokeGreen = QColor(51, 160, 44)
strokeColor = strokeGreen
borderWidth = 0.4
opacity = 0.7
# url du service de calcul
if method == 'time':
param = 'time={}'.format(time)
elif method == 'distance':
param = 'distance={}'.format(distance)
url = '''
https://wxs.ign.fr/{}/isochrone/isochrone.xml?location={}&method={}&graphName={}&exclusions=&{}&holes={}&smoothing={}
'''.format(apiKey, location, method, graphname, param, holes,
smoothing)
print(url)
# Récupération du User-Agent QGIS
s = QgsSettings()
userAgent = s.value('/qgis/networkAndProxy/userAgent', 'Mozilla/5.0')
headers = {'User-Agent': userAgent}
# Appel du service
#xmlResponse = requests.get(url, timeout=10)
xmlResponse = requests.get(url, headers=headers)
print(xmlResponse)
# Décodage de la réponse et récupération de la géométrie
root = ElementTree.fromstring(xmlResponse.content)
wktGeometry = root.find('wktGeometry')
#print(wktGeometry.text)
if wktGeometry is not None:
# Construction de la requête sql
sql = '''
select st_geomfromtext('{}', {}) geom
'''.format(wktGeometry.text, epsg)
#print(sql)
# Construction de la couche virtuelle
if method == 'time':
libLayer = '{}_{}_minutes'.format(graphname, int(time / 60))
elif method == 'distance':
libLayer = '{}_{}_kilometres'.format(graphname,
int(distance / 1000))
vLayer = QgsVectorLayer('?query={}'.format(sql), libLayer,
'virtual')
#symbol = QgsFillSymbol()
#symbol.setColor(fillColor)
symbolLayer = QgsSimpleFillSymbolLayer()
symbolLayer.setStrokeWidth(borderWidth)
symbolLayer.setStrokeColor(strokeColor)
symbolLayer.setFillColor(fillColor)
vLayer.renderer().symbols(QgsRenderContext())[0].changeSymbolLayer(
0, symbolLayer)
vLayer.setOpacity(opacity) # Pour essai
QgsProject.instance().addMapLayer(vLayer)
else:
print('Échec de l\'appel du service')
def testMatchToSymbols(self):
"""
Test QgsCategorizedSymbolRender.matchToSymbols
"""
renderer = QgsCategorizedSymbolRenderer()
renderer.setClassAttribute('x')
symbol_a = createMarkerSymbol()
symbol_a.setColor(QColor(255, 0, 0))
renderer.addCategory(QgsRendererCategory('a', symbol_a, 'a'))
symbol_b = createMarkerSymbol()
symbol_b.setColor(QColor(0, 255, 0))
renderer.addCategory(QgsRendererCategory('b', symbol_b, 'b'))
symbol_c = createMarkerSymbol()
symbol_c.setColor(QColor(0, 0, 255))
renderer.addCategory(QgsRendererCategory('c ', symbol_c, 'c'))
matched, unmatched_cats, unmatched_symbols = renderer.matchToSymbols(
None, QgsSymbol.Marker)
self.assertEqual(matched, 0)
style = QgsStyle()
symbol_a = createMarkerSymbol()
symbol_a.setColor(QColor(255, 10, 10))
self.assertTrue(style.addSymbol('a', symbol_a))
symbol_B = createMarkerSymbol()
symbol_B.setColor(QColor(10, 255, 10))
self.assertTrue(style.addSymbol('B ', symbol_B))
symbol_b = createFillSymbol()
symbol_b.setColor(QColor(10, 255, 10))
self.assertTrue(style.addSymbol('b', symbol_b))
symbol_C = createLineSymbol()
symbol_C.setColor(QColor(10, 255, 10))
self.assertTrue(style.addSymbol('C', symbol_C))
symbol_C = createMarkerSymbol()
symbol_C.setColor(QColor(10, 255, 10))
self.assertTrue(style.addSymbol(' ----c/- ', symbol_C))
# non-matching symbol type
matched, unmatched_cats, unmatched_symbols = renderer.matchToSymbols(
style, QgsSymbol.Line)
self.assertEqual(matched, 0)
self.assertEqual(unmatched_cats, ['a', 'b', 'c '])
self.assertEqual(unmatched_symbols, [' ----c/- ', 'B ', 'C', 'a', 'b'])
# exact match
matched, unmatched_cats, unmatched_symbols = renderer.matchToSymbols(
style, QgsSymbol.Marker)
self.assertEqual(matched, 1)
self.assertEqual(unmatched_cats, ['b', 'c '])
self.assertEqual(unmatched_symbols, [' ----c/- ', 'B ', 'C', 'b'])
# make sure symbol was applied
context = QgsRenderContext()
renderer.startRender(context, QgsFields())
symbol, ok = renderer.symbolForValue2('a')
self.assertTrue(ok)
self.assertEqual(symbol.color().name(), '#ff0a0a')
renderer.stopRender(context)
# case insensitive match
matched, unmatched_cats, unmatched_symbols = renderer.matchToSymbols(
style, QgsSymbol.Marker, False)
self.assertEqual(matched, 2)
self.assertEqual(unmatched_cats, ['c '])
self.assertEqual(unmatched_symbols, [' ----c/- ', 'C', 'b'])
# make sure symbols were applied
context = QgsRenderContext()
renderer.startRender(context, QgsFields())
symbol, ok = renderer.symbolForValue2('a')
self.assertTrue(ok)
self.assertEqual(symbol.color().name(), '#ff0a0a')
symbol, ok = renderer.symbolForValue2('b')
self.assertTrue(ok)
self.assertEqual(symbol.color().name(), '#0aff0a')
renderer.stopRender(context)
# case insensitive match
matched, unmatched_cats, unmatched_symbols = renderer.matchToSymbols(
style, QgsSymbol.Marker, False)
self.assertEqual(matched, 2)
self.assertEqual(unmatched_cats, ['c '])
self.assertEqual(unmatched_symbols, [' ----c/- ', 'C', 'b'])
# make sure symbols were applied
context = QgsRenderContext()
renderer.startRender(context, QgsFields())
symbol, ok = renderer.symbolForValue2('a')
self.assertTrue(ok)
self.assertEqual(symbol.color().name(), '#ff0a0a')
symbol, ok = renderer.symbolForValue2('b')
self.assertTrue(ok)
self.assertEqual(symbol.color().name(), '#0aff0a')
renderer.stopRender(context)
# tolerant match
matched, unmatched_cats, unmatched_symbols = renderer.matchToSymbols(
style, QgsSymbol.Marker, True, True)
self.assertEqual(matched, 2)
self.assertEqual(unmatched_cats, ['b'])
self.assertEqual(unmatched_symbols, ['B ', 'C', 'b'])
# make sure symbols were applied
context = QgsRenderContext()
renderer.startRender(context, QgsFields())
symbol, ok = renderer.symbolForValue2('a')
self.assertTrue(ok)
self.assertEqual(symbol.color().name(), '#ff0a0a')
symbol, ok = renderer.symbolForValue2('c ')
self.assertTrue(ok)
self.assertEqual(symbol.color().name(), '#0aff0a')
renderer.stopRender(context)
# tolerant match, case insensitive
matched, unmatched_cats, unmatched_symbols = renderer.matchToSymbols(
style, QgsSymbol.Marker, False, True)
self.assertEqual(matched, 3)
self.assertFalse(unmatched_cats)
self.assertEqual(unmatched_symbols, ['C', 'b'])
# make sure symbols were applied
context = QgsRenderContext()
renderer.startRender(context, QgsFields())
symbol, ok = renderer.symbolForValue2('a')
self.assertTrue(ok)
self.assertEqual(symbol.color().name(), '#ff0a0a')
symbol, ok = renderer.symbolForValue2('b')
self.assertTrue(ok)
self.assertEqual(symbol.color().name(), '#0aff0a')
symbol, ok = renderer.symbolForValue2('c ')
self.assertTrue(ok)
self.assertEqual(symbol.color().name(), '#0aff0a')
renderer.stopRender(context)
def setSelectFeatures(canvas,
selectGeometry,
doContains,
doDifference,
singleSelect=None):
"""
QgsMapCanvas* canvas,
QgsGeometry* selectGeometry,
bool doContains,
bool doDifference,
bool singleSelect
"""
if selectGeometry.type() != QGis.Polygon:
return
vlayer = getCurrentVectorLayer(canvas)
if vlayer == None:
return
#toLayerCoordinates will throw an exception for any 'invalid' points in
#the rubber band.
#For example, if you project a world map onto a globe using EPSG 2163
#and then click somewhere off the globe, an exception will be thrown.
selectGeomTrans = QgsGeometry(selectGeometry)
if canvas.mapSettings().hasCrsTransformEnabled():
try:
ct = QgsCoordinateTransform(canvas.mapSettings().destinationCrs(),
vlayer.crs())
selectGeomTrans.transform(ct)
except QgsCsException as cse:
Q_UNUSED(cse)
#catch exception for 'invalid' point and leave existing selection unchanged
"""
QgsLogger::warning( "Caught CRS exception " + QString( __FILE__ ) + ": " + QString::number( __LINE__ ) );
QgisApp::instance()->messageBar()->pushMessage(
QObject::tr( "CRS Exception" ),
QObject::tr( "Selection extends beyond layer's coordinate system" ),
QgsMessageBar::WARNING,
QgisApp::instance()->messageTimeout() );
"""
return
QApplication.setOverrideCursor(Qt.WaitCursor)
"""
QgsDebugMsg( "Selection layer: " + vlayer->name() );
QgsDebugMsg( "Selection polygon: " + selectGeomTrans.exportToWkt() );
QgsDebugMsg( "doContains: " + QString( doContains ? "T" : "F" ) );
QgsDebugMsg( "doDifference: " + QString( doDifference ? "T" : "F" ) );
"""
context = QgsRenderContext().fromMapSettings(canvas.mapSettings())
r = vlayer.rendererV2()
if r:
r.startRender(context, vlayer.pendingFields())
request = QgsFeatureRequest()
request.setFilterRect(selectGeomTrans.boundingBox())
request.setFlags(QgsFeatureRequest.ExactIntersect)
if r:
request.setSubsetOfAttributes(r.usedAttributes(),
vlayer.pendingFields())
else:
request.setSubsetOfAttributes(QgsAttributeList)
fit = vlayer.getFeatures(request)
newSelectedFeatures = [] #QgsFeatureIds
f = QgsFeature()
closestFeatureId = 0 #QgsFeatureId
foundSingleFeature = False
#double closestFeatureDist = std::numeric_limits<double>::max();
closestFeatureDist = sys.float_info.max
while fit.nextFeature(f):
# make sure to only use features that are visible
if r and not r.willRenderFeature(f):
continue
g = QgsGeometry(f.geometry())
if doContains:
if not selectGeomTrans.contains(g):
continue
else:
if not selectGeomTrans.intersects(g):
continue
if singleSelect:
foundSingleFeature = True
distance = float(g.distance(selectGeomTrans))
if (distance <= closestFeatureDist):
closestFeatureDist = distance
closestFeatureId = f.id()
else:
newSelectedFeatures.insert(0, f.id())
if singleSelect and foundSingleFeature:
newSelectedFeatures.insert(0, closestFeatureId)
if r:
r.stopRender(context)
#QgsDebugMsg( "Number of new selected features: " + QString::number( newSelectedFeatures.size() )
if doDifference:
layerSelectedFeatures = vlayer.selectedFeaturesIds()
selectedFeatures = [] #QgsFeatureIds
deselectedFeatures = [] # QgsFeatureIds
# i = QgsFeatureIds.const_iterator(newSelectedFeatures.constEnd())
# while i != newSelectedFeatures.constBegin():
# i = i - 1
# if layerSelectedFeatures.contains(i):
# deselectedFeatures.insert(0, i)
# else:
# selectedFeatures.insert(0, i)
for item in newSelectedFeatures:
if item in layerSelectedFeatures:
deselectedFeatures.insert(0, item)
else:
selectedFeatures.insert(0, item)
vlayer.modifySelection(selectedFeatures, deselectedFeatures)
else:
vlayer.setSelectedFeatures(newSelectedFeatures)
QApplication.restoreOverrideCursor()
"""
