def save_adres_point(self, point, address, typeAddress='', layername="Geopunt_adres", saveToFile=False, sender=None, startFolder=None ): attributes = [QgsField("adres", QVariant.String), QgsField("type", QVariant.String)] mapcrs = self.getGetMapCrs(self.iface) if not QgsProject.instance().mapLayer(self.adreslayerid): self.adreslayer = QgsVectorLayer("Point", layername, "memory") self.adresProvider = self.adreslayer.dataProvider() self.adresProvider.addAttributes(attributes) self.adreslayer.updateFields() # add a feature fields= self.adreslayer.fields() fet = QgsFeature(fields) #set geometry and project from mapCRS xform = QgsCoordinateTransform( mapcrs, self.adreslayer.crs(), QgsProject.instance() ) prjPoint = xform.transform( point ) fet.setGeometry(QgsGeometry.fromPointXY(prjPoint)) #populate fields fet['adres'] = address fet['type'] = typeAddress self.adresProvider.addFeatures([ fet ]) "" # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer self.adreslayer.updateExtents() # save memoryLAYER to file and replace all references if saveToFile and not QgsProject.instance().mapLayer(self.adreslayerid): save = self._saveToFile( sender, startFolder ) if save: fpath, flType = save error, msg = QgsVectorFileWriter.writeAsVectorFormat(self.adreslayer, fileName=fpath, fileEncoding="utf-8", driverName=flType) if error == QgsVectorFileWriter.NoError: self.adreslayer = QgsVectorLayer( fpath, layername, "ogr") self.adresProvider = self.adreslayer.dataProvider() else: del self.adreslayer, self.adresProvider return else: del self.adreslayer, self.adresProvider return # add to map QgsProject.instance().addMapLayer(self.adreslayer) #labels text_format = QgsTextFormat() text_format.setSize(12) buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(1) buffer_settings.setColor(QColor("white")) palyr = QgsPalLayerSettings() text_format.setBuffer(buffer_settings) palyr.setFormat(text_format) palyr.enabled = True palyr.fieldName = 'adres' palyr.placement = QgsPalLayerSettings.Free self.adreslayer.setLabelsEnabled(True) self.adreslayer.setLabeling( QgsVectorLayerSimpleLabeling(palyr) ) # store layer id and refresh self.adreslayerid = self.adreslayer.id() self.canvas.refresh()
def checkLabeledLayerWithBlendModesCannotBeCached(self, job_type): """ any labeled layer utilising blending modes cannot be cached""" layer = QgsVectorLayer("Point?field=fldtxt:string", "layer1", "memory") labelSettings = QgsPalLayerSettings() labelSettings.fieldName = "fldtxt" layer.setLabeling(QgsVectorLayerSimpleLabeling(labelSettings)) layer.setLabelsEnabled(True) layer2 = QgsVectorLayer("Point?field=fldtxt:string", "layer2", "memory") labelSettings2 = QgsPalLayerSettings() labelSettings2.fieldName = "fldtxt" format2 = QgsTextFormat() format2.setBlendMode(QPainter.CompositionMode_SourceIn) labelSettings2.setFormat(format2) layer2.setLabeling(QgsVectorLayerSimpleLabeling(labelSettings2)) layer2.setLabelsEnabled(True) settings = QgsMapSettings() settings.setExtent(QgsRectangle(5, 25, 25, 45)) settings.setOutputSize(QSize(600, 400)) settings.setLayers([layer, layer2]) # with cache - cache should not be populated! cache = QgsMapRendererCache() job = job_type(settings) job.setCache(cache) job.start() job.waitForFinished() self.assertFalse(job.usedCachedLabels()) self.assertFalse(cache.hasCacheImage('_labels_')) self.assertTrue(job.takeLabelingResults()) # second job should also not be able to use label cache job = job_type(settings) job.setCache(cache) job.start() job.waitForFinished() # shouldn't use cache self.assertFalse(job.usedCachedLabels()) # and results should not have been cached self.assertFalse(cache.hasCacheImage('_labels_')) self.assertTrue(job.takeLabelingResults())
def testSetGetFormat(self): button = QgsFontButton() s = QgsTextFormat() s.setFont(getTestFont()) s.setNamedStyle('Italic') s.setSize(5) s.setColor(QColor(255, 0, 0)) s.setOpacity(0.5) signal_spy = QSignalSpy(button.changed) button.setTextFormat(s) self.assertEqual(len(signal_spy), 1) r = button.textFormat() self.assertEqual(r.font().family(), 'QGIS Vera Sans') self.assertEqual(r.namedStyle(), 'Italic') self.assertEqual(r.size(), 5) self.assertEqual(r.color(), QColor(255, 0, 0)) self.assertEqual(r.opacity(), 0.5)
def testPartialLabels(self): """ Test rendering map item with a show partial labels flag """ format = QgsTextFormat() format.setFont(QgsFontUtils.getStandardTestFont("Bold")) format.setSize(20) format.setNamedStyle("Bold") format.setColor(QColor(0, 0, 0)) settings = QgsPalLayerSettings() settings.setFormat(format) settings.fieldName = "'X'" settings.isExpression = True settings.placement = QgsPalLayerSettings.OverPoint vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl", "memory") vl.setRenderer(QgsNullSymbolRenderer()) f = QgsFeature(vl.fields(), 1) for x in range(15): for y in range(15): f.setGeometry(QgsPoint(x, y)) vl.dataProvider().addFeature(f) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) vl.setLabelsEnabled(True) p = QgsProject() engine_settings = QgsLabelingEngineSettings() engine_settings.setFlag(QgsLabelingEngineSettings.UsePartialCandidates, False) engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly, True) p.setLabelingEngineSettings(engine_settings) p.addMapLayer(vl) layout = QgsLayout(p) layout.initializeDefaults() p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.setFrameEnabled(True) map.zoomToExtent(vl.extent()) map.setLayers([vl]) layout.addLayoutItem(map) # default should always be to hide partial labels self.assertFalse(map.mapFlags() & QgsLayoutItemMap.ShowPartialLabels) # hiding partial labels (the default) map.setMapFlags(QgsLayoutItemMap.MapItemFlags()) checker = QgsLayoutChecker('composermap_label_nomargin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) # showing partial labels map.setMapFlags(QgsLayoutItemMap.ShowPartialLabels) checker = QgsLayoutChecker('composermap_show_partial_labels', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message)
def testBlockingItems(self): """ Test rendering map item with blocking items """ format = QgsTextFormat() format.setFont(QgsFontUtils.getStandardTestFont("Bold")) format.setSize(20) format.setNamedStyle("Bold") format.setColor(QColor(0, 0, 0)) settings = QgsPalLayerSettings() settings.setFormat(format) settings.fieldName = "'X'" settings.isExpression = True settings.placement = QgsPalLayerSettings.OverPoint vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl", "memory") vl.setRenderer(QgsNullSymbolRenderer()) f = QgsFeature(vl.fields(), 1) for x in range(15): for y in range(15): f.setGeometry(QgsPoint(x, y)) vl.dataProvider().addFeature(f) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) vl.setLabelsEnabled(True) p = QgsProject() engine_settings = QgsLabelingEngineSettings() engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly, True) p.setLabelingEngineSettings(engine_settings) p.addMapLayer(vl) layout = QgsLayout(p) layout.initializeDefaults() p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.setFrameEnabled(True) map.zoomToExtent(vl.extent()) map.setLayers([vl]) map.setId('map') layout.addLayoutItem(map) map2 = QgsLayoutItemMap(layout) map2.attemptSetSceneRect(QRectF(0, 5, 50, 80)) map2.setFrameEnabled(True) map2.setBackgroundEnabled(False) map2.setId('map2') layout.addLayoutItem(map2) map3 = QgsLayoutItemMap(layout) map3.attemptSetSceneRect(QRectF(150, 160, 50, 50)) map3.setFrameEnabled(True) map3.setBackgroundEnabled(False) map3.setId('map3') layout.addLayoutItem(map3) map.addLabelBlockingItem(map2) map.addLabelBlockingItem(map3) map.setMapFlags(QgsLayoutItemMap.MapItemFlags()) checker = QgsLayoutChecker('composermap_label_blockers', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) doc = QDomDocument("testdoc") elem = layout.writeXml(doc, QgsReadWriteContext()) l2 = QgsLayout(p) self.assertTrue(l2.readXml(elem, doc, QgsReadWriteContext())) map_restore = [ i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map' ][0] map2_restore = [ i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map2' ][0] map3_restore = [ i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map3' ][0] self.assertTrue(map_restore.isLabelBlockingItem(map2_restore)) self.assertTrue(map_restore.isLabelBlockingItem(map3_restore))
def createFormatSettings(self): s = QgsTextFormat() s.setBuffer(self.createBufferSettings()) s.setMask(self.createMaskSettings()) s.setBackground(self.createBackgroundSettings()) s.setShadow(self.createShadowSettings()) font = getTestFont() font.setKerning(False) s.setFont(font) s.setNamedStyle('Roman') s.setSize(5) s.setSizeUnit(QgsUnitTypes.RenderPoints) s.setSizeMapUnitScale(QgsMapUnitScale(1, 2)) s.setColor(QColor(255, 0, 0)) s.setOpacity(0.5) s.setBlendMode(QPainter.CompositionMode_Difference) s.setLineHeight(5) s.setOrientation(QgsTextFormat.VerticalOrientation) s.setPreviewBackgroundColor(QColor(100, 150, 200)) return s
def run(self): print("paso por el run") #coloco el puntero arriba del todo QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint( QgsProject.instance().layerTreeRoot(), 0) def haceelcruce(x1, y1, ang1, x2, y2, ang2): #saco las pendientes m1 = (1 / math.tan(math.radians(ang1 + 0.000001))) m2 = (1 / math.tan(math.radians(ang2 + 0.000001))) #print ("m1") #print (m1) #print("m2") #print (m2) #saco las coordenadas de x e y x = ((y2 - y1) + (m1 * x1) - (m2 * x2)) / ((m1 - m2) + 0.000001) y = m1 * x + y1 - m1 * x1 #compruebo que el cruce no es erroneo if ang1 > 0 and ang1 < 180 and x < x1: iface.messageBar().pushMessage( "OJO: LAS VISUALES NO SE CRUZAN", qgisCore.Qgis.Info, 5) x, y, error = 0, 0, 0 if ang1 > 180 and ang1 < 360 and x > x1: iface.messageBar().pushMessage( "OJO: LAS VISUALES NO SE CRUZAN", qgisCore.Qgis.Info, 5) x, y, error = 0, 0, 0 if ang1 > 0 and ang1 < 90 and y < y1: iface.messageBar().pushMessage( "OJO: LAS VISUALES NO SE CRUZAN", qgisCore.Qgis.Info, 5) x, y, error = 0, 0, 0 if ang1 > 270 and ang1 < 360 and y < y1: iface.messageBar().pushMessage( "OJO: LAS VISUALES NO SE CRUZAN", qgisCore.Qgis.Info, 5) x, y, error = 0, 0, 0 if ang1 > 90 and ang1 < 270 and y > y1: iface.messageBar().pushMessage( "OJO: LAS VISUALES NO SE CRUZAN", qgisCore.Qgis.Info, 5) x, y, error = 0, 0, 9999999999999999999999999 else: #calculo el error d1a = math.sqrt((x - x1)**2 + (y - y1)**2) d2a = math.sqrt((x - x2)**2 + (y - y2)**2) d12 = math.sqrt((x2 - x1)**2 + (y2 - y1)**2) A = math.acos((d1a**2 + d2a**2 - d12**2) / (2 * d1a * d2a)) if math.degrees(A) > 90: A = math.pi - A distancias = [d1a, d2a] distancias.sort(reverse=True) mayordistancia = distancias[0] error = mayordistancia * erroralidada / (math.sin(A / 2) + 0.000001) #print (ang1,ang2) #print (x,y,error) return x, y, error def generapunto(x, y): #creo una capa de puntos temporal con los resultados # create layer vl = QgsVectorLayer("Point?crs=epsg:25830", "Pto_Cruce", "memory") pr = vl.dataProvider() #print ("ok creada la capa") vl.startEditing() # add fields pr.addAttributes([ QgsField("error", QVariant.Int), QgsField("x", QVariant.Int), QgsField("y", QVariant.Double) ]) vl.updateFields() # tell the vector layer to fetch changes from the provider #print ("ok creados los campos") # add a feature fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(x, y))) fet.setAttributes([error, x, y]) pr.addFeatures([fet]) #print ("ok, anadido el elemento con error "+str(error)) #cambio la simbologia symbol = QgsMarkerSymbol.createSimple({ 'name': 'circle', 'color': 'orange', 'size': '5', }) vl.renderer().setSymbol(symbol) # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer #vl.updateExtents() vl.commitChanges() #vl.updateExtents() # show the point if x != 0 and y != 0: QgsProject.instance().addMapLayers([vl]) canvas = self.iface.mapCanvas() #canvas.setExtent(vl.extent()) #vl.updateFieldMap() def generalinea(x, y, angulo): m = (1 / math.tan(math.radians(angulo + 0.000001))) x1 = x + 100000 * math.sin(math.radians(angulo + 0.0000001)) y1 = y - m * (x - x1) line_start = QgsPoint(x, y) line_end = QgsPoint(x1, y1) #print (m) # create a new memory layer v_layer = QgsVectorLayer("LineString?crs=epsg:25830", "visual", "memory") pr = v_layer.dataProvider() # create a new feature seg = QgsFeature() # add the geometry to the feature, seg.setGeometry(QgsGeometry.fromPolyline([line_start, line_end])) # add the geometry to the layer pr.addFeatures([seg]) # update extent of the layer (not necessary) v_layer.updateExtents() #cambio la simbologia symbol3 = QgsLineSymbol.createSimple({ 'penstyle': 'solid', 'color': 'yellow', 'width': '2' }) v_layer.renderer().setSymbol(symbol3) # show the line QgsProject.instance().addMapLayers([v_layer]) def deg_to_dms(deg, type='lat'): decimals, number = math.modf(deg) d = int(number) m = int(decimals * 60) s = (deg - d - m / 60) * 3600.00 compass = {'lat': ('N', 'S'), 'lon': ('E', 'W')} compass_str = compass[type][0 if d >= 0 else 1] return '{}º{}\'{:.2f}"{}'.format(abs(d), abs(m), abs(s), compass_str) erroralidada = 1 #selecciono la capa de las torretas global rutapuestosvigiancia layer = QgsVectorLayer(rutapuestosvigiancia, '42_Puestos_vigilancia_etrs89', 'ogr') time.sleep(1) #layer = iface.activeLayer() ## ojo comprobar que layer existe """if layer is None or (layer.type() == RasterLayer): iface.messageBar().pushMessage("Warning:", u"Seleciona la capa de los puestos de vigilancia", QgsMessageBar.WARNING, 10) """ #genero una lista con las torres y ls coordenadas misdatos = [] feats = [feat for feat in layer.getFeatures()] for feature in feats: if feature.geometry().type( ) != 0: #0 es ptos, 1 lineas y 2 poligonos QGis.Point: iface.messageBar().pushMessage( "Warning:", u"Debe selecionar una capa de puntos", QgsMessageBar.WARNING, 10) point = [] idTM = layer.dataProvider().fieldNameIndex('Nombre') idx = layer.dataProvider().fieldNameIndex('x') idy = layer.dataProvider().fieldNameIndex('y') point = [ feature.attributes()[idTM], feature.attributes()[idx], feature.attributes()[idy] ] misdatos.append(point) #trato de rellenar el desplegable con las torretas #self.dlg.cb1.clear() #ordeno por el primer elemento misdatos.sort(key=lambda x: x[0]) #anado un elemneto enblanco en el desplegable self.dlg.cb1.clear() self.dlg.cb2.clear() self.dlg.cb3.clear() self.dlg.cb4.clear() self.dlg.cb1.addItem("") self.dlg.cb2.addItem("") self.dlg.cb3.addItem("") self.dlg.cb4.addItem("") for element in misdatos: self.dlg.cb1.addItem(element[0]) self.dlg.cb2.addItem(element[0]) self.dlg.cb3.addItem(element[0]) self.dlg.cb4.addItem(element[0]) #count vertices if there is layer in project in order to show it when dialog is loaded #layer = self.dlg.cb1.itemData(self.cb1.currentIndex()) """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False #self.dlg = SilvilidarDialog() #la siguiente linea inicia el boton de cargar carpetas, peta al cerrar el qgis, deberia poner algun close o algo #self.dlg.pushButton_select_path.clicked.connect(self.select_laz_folder) #print("inicio el boton en el gui") #self.dlg.pushButton_select_path.setEnabled(True) #print ("pone le boton como habiltado") # show the dialog self.dlg.show() #self.dlg.pushButton_select_path.clicked.connect(self.select_laz_folder) # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Do something useful here - delete the line containing pass and # substitute with your code. #print ("lo imprime si le doy a aceptar en el dialogo") #la carpeta la he cogido al pulsar el boton de la carpeta #meto aqui variables que luego deberan estar en la cajita OJO torret1 = self.dlg.cb1.currentIndex() torret2 = self.dlg.cb2.currentIndex() torret3 = self.dlg.cb3.currentIndex() torret4 = self.dlg.cb4.currentIndex() angulo1 = self.dlg.ang1.text() ##displayText() angulo2 = self.dlg.ang2.text() ##displayText() angulo3 = self.dlg.ang3.text() ##displayText() angulo4 = self.dlg.ang4.text() ##displayText() if angulo2 == "": angulo2 = 9999 if angulo3 == "": angulo3 = 9999 if angulo4 == "": angulo4 = 9999 try: ang1 = float(angulo1) ang2 = float(angulo2) ang3 = float(angulo3) ang4 = float(angulo4) except: pass #print (misdatos) torre1 = misdatos[int(torret1) - 1][0] x1 = float(misdatos[int(torret1) - 1][1]) y1 = float(misdatos[int(torret1) - 1][2]) torre2 = misdatos[int(torret2) - 1][0] x2 = float(misdatos[int(torret2) - 1][1]) y2 = float(misdatos[int(torret2) - 1][2]) torre3 = misdatos[int(torret3) - 1][0] x3 = float(misdatos[int(torret3) - 1][1]) y3 = float(misdatos[int(torret3) - 1][2]) torre4 = misdatos[int(torret4) - 1][0] x4 = float(misdatos[int(torret4) - 1][1]) y4 = float(misdatos[int(torret4) - 1][2]) #print (angulo1, angulo2, angulo3, angulo4) #print (torret1) #print (torre1, x1, y1) #print (torret2) #print (torre2, x2, y2) #print (torret3) #print (torret4) generalinea(x1, y1, ang1) resultado = [] if angulo2 != 9999: generalinea(x2, y2, ang2) x, y, error = haceelcruce(x1, y1, ang1, x2, y2, ang2) #print ("hecho el cruce") #print (x,y, error) generapunto(x, y) resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) if angulo3 != 9999: generalinea(x3, y3, ang3) x, y, error = haceelcruce(x1, y1, ang1, x3, y3, ang3) generapunto(x, y) if error < resultado[2]: resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) x, y, error = haceelcruce(x2, y2, ang2, x3, y3, ang3) generapunto(x, y) if error < resultado[2]: resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) if angulo4 != 9999: generalinea(x4, y4, ang4) #print ("empiezo el angulo4") x, y, error = haceelcruce(x1, y1, ang1, x4, y4, ang4) generapunto(x, y) if error < resultado[2]: resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) x, y, error = haceelcruce(x2, y2, ang2, x4, y4, ang4) generapunto(x, y) if error < resultado[2]: resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) x, y, error = haceelcruce(x3, y3, ang3, x4, y4, ang4) generapunto(x, y) if error < resultado[2]: resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) #hago una nueva capa con el mejor resultado if resultado != []: x, y, error = resultado[0], resultado[1], resultado[2] if x != 0 and y != 0: #creo una capa temporal con los resultados # create layer vl2 = QgsVectorLayer("Point?crs=epsg:25830", "MejorResultado", "memory") pr2 = vl2.dataProvider() #print ("ok creada la capa resultado final") vl2.startEditing() #calculo las coordenadas geograficas huso = 30 origenProj = pyproj.Proj(proj="utm", zone=huso, ellps="WGS84", units="m") destinoProj = pyproj.Proj(proj='longlat', ellps='WGS84', datum='WGS84') xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y) xx = (deg_to_dms(xxx, 'lon')) yy = (deg_to_dms(yyy)) # add fields pr2.addAttributes([ QgsField("error", QVariant.Int), QgsField("x", QVariant.Double), QgsField("y", QVariant.Double), QgsField("xx", QVariant.String), QgsField("yy", QVariant.String) ]) vl2.updateFields() # tell the vector layer to fetch changes from the provider #print ("ok creados los campos") #$add a feature fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(x, y))) fet.setAttributes([error, x, y, xx, yy]) pr2.addFeatures([fet]) print("MEJOR RESULTADO") print(int(resultado[0]), int(resultado[1])) #print ("ok, creda la capa con el resultado final") #cambio la simbologia symbol = QgsMarkerSymbol.createSimple({ 'name': 'circle', 'color': 'red', 'size': '10', }) vl2.renderer().setSymbol(symbol) #etiqueto con la x e y layer_settings = QgsPalLayerSettings() text_format = QgsTextFormat() text_format.setFont(QFont("Arial", 12)) text_format.setSize(12) text_format.setColor(QColor("Orange")) # meto un buffer a la etiqueta buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(1) buffer_settings.setColor(QColor("white")) text_format.setBuffer(buffer_settings) layer_settings.setFormat(text_format) #myexp=QgsExpression('''concat('X: ',"X",' Y: ',"Y")''') layer_settings.fieldName = '''concat('X: ',round("X",0),' Y: ',round("Y",0),'\n','Lat: ',"yy",' Lon: ',"xx")''' layer_settings.isExpression = True #layer_settings.placement = 7 #layer_settings.quadOffset = QgsPalLayerSettings.QuadrantBelow #layer_settings.yOffset = 1 layer_settings.enabled = True layer_settings = QgsVectorLayerSimpleLabeling( layer_settings) vl2.setLabelsEnabled(True) vl2.setLabeling(layer_settings) vl2.triggerRepaint() # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer vl2.updateExtents() vl2.commitChanges() vl2.updateExtents() canvas = self.iface.mapCanvas() canvas.setExtent(vl2.extent()) self.iface.mapCanvas().zoomScale(100000) #QgsProject.instance().addMapLayer(vl) QgsProject.instance().addMapLayer(vl2) pass
def parse_xml(self): """Parse the xml file. Returns false if there is failure.""" xml_file = QFile(self._xml_path) if not xml_file.open(QIODevice.ReadOnly): return False document = QDomDocument() if not document.setContent(xml_file): return False xml_file.close() document_element = document.documentElement() if document_element.tagName() != "qgis_style": return False # Get all the symbols self._symbols = [] symbols_element = document_element.firstChildElement("symbols") symbol_element = symbols_element.firstChildElement() context = QgsReadWriteContext() context.setPathResolver(QgsProject.instance().pathResolver()) while not symbol_element.isNull(): if symbol_element.tagName() == "symbol": symbol = QgsSymbolLayerUtils.loadSymbol( symbol_element, context) if symbol: self._symbols.append({ "name": symbol_element.attribute("name"), "symbol": symbol }) symbol_element = symbol_element.nextSiblingElement() # Get all the colorramps self._colorramps = [] ramps_element = document_element.firstChildElement("colorramps") ramp_element = ramps_element.firstChildElement() while not ramp_element.isNull(): if ramp_element.tagName() == "colorramp": colorramp = QgsSymbolLayerUtils.loadColorRamp(ramp_element) if colorramp: self._colorramps.append({ "name": ramp_element.attribute("name"), "colorramp": colorramp }) ramp_element = ramp_element.nextSiblingElement() # Get all the TextFormats - textformats - textformat self._textformats = [] textformats_element = document_element.firstChildElement("textformats") textformat_element = textformats_element.firstChildElement() while not textformat_element.isNull(): if textformat_element.tagName() == "textformat": textformat = QgsTextFormat() textformat.readXml(textformat_element, QgsReadWriteContext()) if textformat: self._textformats.append({ "name": textformat_element.attribute("name"), "textformat": textformat, }) textformat_element = textformat_element.nextSiblingElement() # Get all the LabelSettings - labelsettings - labelsetting - # QgsPalLayerSettings.readXML? self._labelsettings = [] labels_element = document_element.firstChildElement("labelsettings") label_element = labels_element.firstChildElement() while not label_element.isNull(): if label_element.tagName() == "labelsetting": labelsettings = QgsPalLayerSettings() labelsettings.readXml(label_element, QgsReadWriteContext()) if labelsettings: self._labelsettings.append({ "name": label_element.attribute("name"), "labelsettings": labelsettings, }) label_element = label_element.nextSiblingElement() return True
def grid_labeler(self, coord_base_x, coord_base_y, px, py, u, t, dx, dy, desc, fSize, fontType, expression_str, trLLUTM, llcolor, layer_bound, trUTMLL): pgrid = QgsPoint(coord_base_x + px * u, coord_base_y + py * t) pgrid.transform(trLLUTM) pgrid = QgsPoint(pgrid.x() + dx, pgrid.y() + dy) if layer_bound.crs().isGeographic() == True: pgrid.transform(trUTMLL) #Label Format Settings settings = QgsPalLayerSettings() settings.placement = 1 settings.isExpression = True textprop = QgsTextFormat() textprop.setColor(llcolor) textprop.setSizeUnit(4) textprop.setSize(fSize * 2.8346) textprop.setFont(QFont(fontType)) textprop.setLineHeight(1) settings.setFormat(textprop) settings.fieldName = expression_str #Label Position settings.geometryGeneratorEnabled = True settings.geometryGenerator = ("make_point({}, {})".format( pgrid.x(), pgrid.y())) datadefined = QgsPropertyCollection() datadefined.property(20).setExpressionString('True') datadefined.property(20).setActive(True) datadefined.property(15).setExpressionString('True') datadefined.property(15).setActive(True) datadefined.property(77).setExpressionString('2') datadefined.property(77).setActive(True) #Creating and Activating Labeling Rule settings.setDataDefinedProperties(datadefined) rule = QgsRuleBasedLabeling.Rule(settings) rule.setDescription(desc) rule.setActive(True) return rule
def test_settings(self): settings = QgsColorRampLegendNodeSettings() settings.setDirection(QgsColorRampLegendNodeSettings.MaximumToMinimum) self.assertEqual(settings.direction(), QgsColorRampLegendNodeSettings.MaximumToMinimum) settings.setMinimumLabel('min') self.assertEqual(settings.minimumLabel(), 'min') settings.setMaximumLabel('max') self.assertEqual(settings.maximumLabel(), 'max') settings.setPrefix('pref') self.assertEqual(settings.prefix(), 'pref') settings.setSuffix('suff') self.assertEqual(settings.suffix(), 'suff') self.assertEqual(settings.orientation(), Qt.Vertical) settings.setOrientation(Qt.Horizontal) self.assertEqual(settings.orientation(), Qt.Horizontal) # Test default self.assertTrue(settings.useContinuousLegend()) settings.setUseContinuousLegend(False) self.assertFalse(settings.useContinuousLegend()) self.assertFalse(settings.textFormat().isValid()) tf = QgsTextFormat() tf.setSize(13) settings.setTextFormat(tf) self.assertEqual(settings.textFormat().size(), 13) self.assertIsNotNone(settings.numericFormat()) settings.setNumericFormat(QgsBearingNumericFormat()) self.assertIsInstance(settings.numericFormat(), QgsBearingNumericFormat) settings2 = QgsColorRampLegendNodeSettings(settings) self.assertEqual(settings2.direction(), QgsColorRampLegendNodeSettings.MaximumToMinimum) self.assertEqual(settings2.minimumLabel(), 'min') self.assertEqual(settings2.maximumLabel(), 'max') self.assertIsInstance(settings2.numericFormat(), QgsBearingNumericFormat) self.assertEqual(settings2.prefix(), 'pref') self.assertEqual(settings2.suffix(), 'suff') self.assertEqual(settings2.textFormat().size(), 13) self.assertEqual(settings2.orientation(), Qt.Horizontal) settings2.setTextFormat(QgsTextFormat()) settings2a = QgsColorRampLegendNodeSettings(settings2) self.assertFalse(settings2a.textFormat().isValid()) doc = QDomDocument("testdoc") elem = doc.createElement('test') settings.writeXml(doc, elem, QgsReadWriteContext()) settings3 = QgsColorRampLegendNodeSettings() settings3.readXml(elem, QgsReadWriteContext()) self.assertEqual(settings3.direction(), QgsColorRampLegendNodeSettings.MaximumToMinimum) self.assertEqual(settings3.minimumLabel(), 'min') self.assertEqual(settings3.maximumLabel(), 'max') self.assertIsInstance(settings3.numericFormat(), QgsBearingNumericFormat) self.assertEqual(settings3.prefix(), 'pref') self.assertEqual(settings3.suffix(), 'suff') self.assertEqual(settings3.textFormat().size(), 13) self.assertEqual(settings3.orientation(), Qt.Horizontal) self.assertFalse(settings3.useContinuousLegend()) # no text format elem = doc.createElement('test2') settings2.writeXml(doc, elem, QgsReadWriteContext()) settings3a = QgsColorRampLegendNodeSettings() settings3a.readXml(elem, QgsReadWriteContext()) self.assertFalse(settings3a.textFormat().isValid())
def defaultLayerSettings(self): lyr = QgsPalLayerSettings() lyr.fieldName = 'text' # default in test data sources font = self.getTestFont() font.setPointSize(32) format = QgsTextFormat() format.setFont(font) format.setColor(QColor(0, 0, 0)) format.setNamedStyle('Roman') format.setSize(32) format.setSizeUnit(QgsUnitTypes.RenderPoints) format.buffer().setJoinStyle(Qt.BevelJoin) lyr.setFormat(format) return lyr
def run(self): global almacen #coloco el puntero arriba del todo QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint( QgsProject.instance().layerTreeRoot(), 0) #genero una lista con los sistemas de referencia misdatos = [["Etrs89 Zona30 (25830)", "25830"], ["Etrs89 Zona29 (25829)", "25829"], ["ED50 Zona30 (23030)", "23030"], ["ED50_Zona29 (23029)", "23029"], ["WGS84 geograficas sexagesimales(4326)", "4326"], ["WGS84 geograficas centesimales(4326)", "4258"]] self.dlg.comboBox_src.clear() for element in misdatos: self.dlg.comboBox_src.addItem(element[0]) """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False #leo la cache rutacache = os.path.join(QgsApplication.qgisSettingsDirPath(), r"python\plugins\zoomSigmena\cache.txt") if os.path.isfile(rutacache) == True: filecache = open(rutacache, "r") filecacheleido = filecache.readlines() try: import ast almacen = ast.literal_eval((filecacheleido[0].replace( '\n', '')).replace(" [[", "[[").replace("]] ", "]]")) #.split(',')) cache_utm = int(almacen[0]) cache_geo = int(almacen[1]) cache_escala = almacen[2] print(cache_escala) print(almacen) #miscomarcas=(filecacheleido[3].replace('\n','')).strip('][').split(',') #convierto una str en una list #mismunicipios=ast.literal_eval((filecacheleido[4].replace('\n','')).replace(" [[","[[").replace("]] ","]]"))#.split(',')) #convierto una str en una list filecache.close() except: print("esta no encuentra el file cache") self.dlg.lineEdit_escala.setText(str(cache_escala)) self.dlg.checkBox_utm.setChecked(cache_utm) self.dlg.checkBox_geo.setChecked(cache_geo) # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Do something useful here - delete the line containing pass and # substitute with your code. def deg_to_dms(deg, type='lat'): decimals, number = math.modf(deg) d = int(number) m = int(decimals * 60) s = (deg - d - m / 60) * 3600.00 compass = {'lat': ('N', 'S'), 'lon': ('E', 'W')} compass_str = compass[type][0 if d >= 0 else 1] return '{}º{}\'{:.2f}"{}'.format(abs(d), abs(m), abs(s), compass_str) #saco de aqui variables que estan en las cajitas src_seleccionado = self.dlg.comboBox_src.currentIndex() # Get the coordinates and scale factor from the dialog x = self.dlg.XX.text() ##displayText() y = self.dlg.YY.text() ##displayText() escala = self.dlg.lineEdit_escala.text() x = x.replace(',', '.') y = y.replace(',', '.') escala = int(escala.replace('.', '')) src = misdatos[int(src_seleccionado)][1] if src == "4326": latext = y longtext = x lag = float(latext.split()[0]) lam = float(latext.split()[1]) las = float(latext.split()[2]) log = float(longtext.split()[0]) lom = float(longtext.split()[1]) los = float(longtext.split()[2]) lon = -1 * (log + (lom / 60) + (los / 3600)) lat = lag + (lam / 60) + (las / 3600) x = float(lon) y = float(lat) print(x) print(y) huso = 30 destinoProj = pyproj.Proj(proj="utm", zone=huso, ellps="WGS84", units="m") origenProj = pyproj.Proj(proj='longlat', ellps='WGS84', datum='WGS84') UTM_X, UTM_Y = pyproj.transform(origenProj, destinoProj, lon, lat) if src == "4258": print("por el camino adecuado") lat = float(y) lonn = float(x) lon = -1.0 * lonn print(lat) print(lon) huso = 30 destinoProj = pyproj.Proj(proj="utm", zone=huso, ellps="WGS84", units="m") origenProj = pyproj.Proj(proj='longlat', ellps='WGS84', datum='WGS84') UTM_X, UTM_Y = pyproj.transform(origenProj, destinoProj, lon, lat) print(UTM_X) print(UTM_Y) x = lon y = lat #creo una capa temporal con las coordenadas # create layer vl2 = QgsVectorLayer("Point?crs=EPSG:" + src, "Zoom", "memory") pr2 = vl2.dataProvider() vl2.startEditing() # add fields pr2.addAttributes([ QgsField("x", QVariant.Double), QgsField("y", QVariant.Double), QgsField("xx", QVariant.String), QgsField("yy", QVariant.String), QgsField("xxx", QVariant.Double), QgsField("yyy", QVariant.Double) ]) vl2.updateFields() # tell the vector layer to fetch changes from the provider #$add a feature fet = QgsFeature() print("punto") print(x) print(y) fet.setGeometry( QgsGeometry.fromPointXY(QgsPointXY(float(x), float(y)))) if src == "25830": huso = 30 origenProj = pyproj.Proj(proj="utm", zone=huso, ellps="WGS84", units="m") destinoProj = pyproj.Proj(proj='longlat', ellps='WGS84', datum='WGS84') xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y) xx = (deg_to_dms(xxx, 'lon')) yy = (deg_to_dms(yyy)) if src == "25829": huso = 29 origenProj = pyproj.Proj(proj="utm", zone=huso, ellps="WGS84", units="m") destinoProj = pyproj.Proj(proj='longlat', ellps='WGS84', datum='WGS84') xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y) xx = (deg_to_dms(xxx, 'lon')) yy = (deg_to_dms(yyy)) if src == "23030": huso = 30 origenProj = pyproj.Proj(proj="utm", zone=huso, ellps="intl", units="m") destinoProj = pyproj.Proj(proj='longlat', ellps='WGS84', datum='WGS84') xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y) xx = (deg_to_dms(xxx, 'lon')) yy = (deg_to_dms(yyy)) if src == "23029": huso = 29 origenProj = pyproj.Proj(proj="utm", zone=huso, ellps="intl", units="m") destinoProj = pyproj.Proj(proj='longlat', ellps='WGS84', datum='WGS84') xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y) xx = (deg_to_dms(xxx, 'lon')) yy = (deg_to_dms(yyy)) #para que lo pase a utms en pantalla if src == "4326": x = int(UTM_X) y = int(UTM_Y) #xx=longtext #yy=latext huso = 30 origenProj = pyproj.Proj(proj="utm", zone=huso, ellps="intl", units="m") destinoProj = pyproj.Proj(proj='longlat', ellps='WGS84', datum='WGS84') xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y) xx = (deg_to_dms(xxx, 'lon')) yy = (deg_to_dms(yyy)) #para que lo pase a utms en pantalla if src == "4258": x = int(UTM_X) y = int(UTM_Y) xxx = lon yyy = lat xx = (deg_to_dms(xxx, 'lon')) yy = (deg_to_dms(yyy)) fet.setAttributes( [float(x), float(y), str(xx), str(yy), float(xxx), float(yyy)]) pr2.addFeatures([fet]) #cambio la simbologia symbol = QgsMarkerSymbol.createSimple({ 'name': 'circle', 'color': 'red', 'size': '3', }) vl2.renderer().setSymbol(symbol) # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer layer_settings = QgsPalLayerSettings() text_format = QgsTextFormat() text_format.setFont(QFont("Arial", 12)) text_format.setSize(12) text_format.setColor(QColor("Orange")) layer_settings.setFormat(text_format) layer_settings.placement = 1 layer_settings.xOffset = 0.0 layer_settings.yOffset = 10.0 mostrar = True if self.dlg.checkBox_utm.isChecked( ) and self.dlg.checkBox_geo.isChecked(): layer_settings.fieldName = '''concat('X: ',"X",' Y: ',"Y",'\n','Lon: ',"xx",' Lat: ',"yy" )''' almacen = [1, 1] else: if self.dlg.checkBox_utm.isChecked(): layer_settings.fieldName = '''concat('X: ',"X",' Y: ',"Y" )''' almacen = [1, 0] print("caso1") if self.dlg.checkBox_geo.isChecked(): layer_settings.fieldName = '''concat('Lon: ',"xx",' Lat: ',"yy" )''' almacen = [0, 1] print("caso2") if not self.dlg.checkBox_utm.isChecked( ) and not self.dlg.checkBox_geo.isChecked(): mostrar = False almacen = [0, 0] print("caso3") print("almacen despues de etiquetar", almacen) layer_settings.isExpression = True print(mostrar) layer_settings.enabled = mostrar layer_settings = QgsVectorLayerSimpleLabeling(layer_settings) vl2.setLabelsEnabled(True) vl2.setLabeling(layer_settings) vl2.triggerRepaint() # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer vl2.updateExtents() vl2.commitChanges() vl2.updateExtents() canvas = self.iface.mapCanvas() canvas.setExtent(vl2.extent()) crsSrc = QgsCoordinateReferenceSystem('EPSG:' + str(src)) crsDest = QgsProject.instance().crs() if crsSrc != crsDest: xform = QgsCoordinateTransform(crsSrc, crsDest, QgsProject.instance()) canvas.setExtent(xform.transform(vl2.extent())) self.iface.mapCanvas().zoomScale(escala) #self.limpiar_pressed() almacen.append(escala) #lo escribo en el txt, mavhacando lo que ya tenia f = open(rutacache, "w") escribir = str(almacen) f.write(escribir) f.close() print(almacen) QgsProject.instance().addMapLayer(vl2)
class CentroidDecorator(QgsMapCanvasItem): """ Decorates centroids of features with population statistics """ def __init__(self, canvas: QgsMapCanvas, electorate_layer: QgsVectorLayer, meshblock_layer: QgsVectorLayer, task: str, quota: int): """ Constructor :param canvas: map canvas :param electorate_layer: electorates layer :param meshblock_layer: meshblocks layer :param task: current task :param quota: target quota """ super().__init__(canvas) self.canvas = canvas self.electorate_layer = electorate_layer self.meshblock_layer = meshblock_layer self.task = task self.text_format = QgsTextFormat() # self.text_format.shadow().setEnabled(True) self.text_format.background().setEnabled(True) self.text_format.background().setSize(QSizeF(1, 0)) self.text_format.background().setOffset(QPointF(0, -0.7)) self.text_format.background().setRadii(QSizeF(1, 1)) self.image = None self.quota = quota self.original_populations = {} self.new_populations = {} def redraw(self, handler): """ Forces a redraw of the cached image """ self.image = None if not self.original_populations: # first run, get initial estimates request = QgsFeatureRequest() request.setFilterExpression(QgsExpression.createFieldEqualityExpression('type', self.task)) request.setFlags(QgsFeatureRequest.NoGeometry) for f in self.electorate_layer.getFeatures(request): estimated_pop = f.attribute(handler.stats_nz_pop_field_index) if estimated_pop is None or estimated_pop == NULL: # otherwise just use existing estimated pop as starting point estimated_pop = f.attribute(handler.estimated_pop_idx) self.original_populations[f.id()] = estimated_pop # step 1: get all electorate features corresponding to affected electorates electorate_features = {f[handler.electorate_layer_field]: f for f in handler.get_affected_districts( [handler.electorate_layer_field, handler.stats_nz_pop_field, 'estimated_pop'], needs_geometry=False)} self.new_populations = {} for district in handler.pending_affected_districts.keys(): # pylint: disable=consider-iterating-dictionary # use stats nz pop as initial estimate, if available estimated_pop = electorate_features[district].attribute(handler.stats_nz_pop_field_index) if estimated_pop is None or estimated_pop == NULL: # otherwise just use existing estimated pop as starting point estimated_pop = electorate_features[district].attribute(handler.estimated_pop_idx) # add new bits estimated_pop = handler.grow_population_with_added_meshblocks(district, estimated_pop) # minus lost bits estimated_pop = handler.shrink_population_by_removed_meshblocks(district, estimated_pop) self.new_populations[electorate_features[district].id()] = estimated_pop def paint(self, painter, option, widget): # pylint: disable=missing-docstring, unused-argument, too-many-locals if self.image is not None: painter.drawImage(0, 0, self.image) return image_size = self.canvas.mapSettings().outputSize() self.image = QImage(image_size.width(), image_size.height(), QImage.Format_ARGB32) self.image.fill(0) image_painter = QPainter(self.image) render_context = QgsRenderContext.fromQPainter(image_painter) image_painter.setRenderHint(QPainter.Antialiasing, True) rect = self.canvas.mapSettings().visibleExtent() request = QgsFeatureRequest() request.setFilterRect(rect) request.setFilterExpression(QgsExpression.createFieldEqualityExpression('type', self.task)) for f in self.electorate_layer.getFeatures(request): # pole, dist = f.geometry().clipped(rect).poleOfInaccessibility(rect.width() / 30) pixel = self.toCanvasCoordinates(f.geometry().clipped(rect).centroid().asPoint()) estimated_pop = self.new_populations[f.id()] if f.id() in self.new_populations else \ self.original_populations[f.id()] variance = LinzElectoralDistrictRegistry.get_variation_from_quota_percent(self.quota, estimated_pop) text_string = ['{}'.format(f['name']), '{}'.format(int(estimated_pop)), '{}{}%'.format('+' if variance > 0 else '', variance)] QgsTextRenderer().drawText(QPointF(pixel.x(), pixel.y()), 0, QgsTextRenderer.AlignCenter, text_string, render_context, self.text_format) image_painter.end() painter.drawImage(0, 0, self.image)
def testLabelMargin(self): """ Test rendering map item with a label margin set """ format = QgsTextFormat() format.setFont(QgsFontUtils.getStandardTestFont("Bold")) format.setSize(20) format.setNamedStyle("Bold") format.setColor(QColor(0, 0, 0)) settings = QgsPalLayerSettings() settings.setFormat(format) settings.fieldName = "'X'" settings.isExpression = True settings.placement = QgsPalLayerSettings.OverPoint vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl", "memory") vl.setRenderer(QgsNullSymbolRenderer()) f = QgsFeature(vl.fields(), 1) for x in range(15): for y in range(15): f.setGeometry(QgsPoint(x, y)) vl.dataProvider().addFeature(f) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) vl.setLabelsEnabled(True) p = QgsProject() engine_settings = QgsLabelingEngineSettings() engine_settings.setFlag(QgsLabelingEngineSettings.UsePartialCandidates, False) engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly, True) p.setLabelingEngineSettings(engine_settings) p.addMapLayer(vl) layout = QgsLayout(p) layout.initializeDefaults() p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.setFrameEnabled(True) map.zoomToExtent(vl.extent()) map.setLayers([vl]) layout.addLayoutItem(map) checker = QgsLayoutChecker('composermap_label_nomargin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) map.setLabelMargin(QgsLayoutMeasurement(15, QgsUnitTypes.LayoutMillimeters)) checker = QgsLayoutChecker('composermap_label_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) map.setLabelMargin(QgsLayoutMeasurement(3, QgsUnitTypes.LayoutCentimeters)) checker = QgsLayoutChecker('composermap_label_cm_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) map.setMapRotation(45) map.zoomToExtent(vl.extent()) map.setScale(map.scale() * 1.2) checker = QgsLayoutChecker('composermap_rotated_label_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) # data defined map.setMapRotation(0) map.zoomToExtent(vl.extent()) map.dataDefinedProperties().setProperty(QgsLayoutObject.MapLabelMargin, QgsProperty.fromExpression('1+3')) map.refresh() checker = QgsLayoutChecker('composermap_dd_label_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message)
def testBlockingItems(self): """ Test rendering map item with blocking items """ format = QgsTextFormat() format.setFont(QgsFontUtils.getStandardTestFont("Bold")) format.setSize(20) format.setNamedStyle("Bold") format.setColor(QColor(0, 0, 0)) settings = QgsPalLayerSettings() settings.setFormat(format) settings.fieldName = "'X'" settings.isExpression = True settings.placement = QgsPalLayerSettings.OverPoint vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl", "memory") vl.setRenderer(QgsNullSymbolRenderer()) f = QgsFeature(vl.fields(), 1) for x in range(15): for y in range(15): f.setGeometry(QgsPoint(x, y)) vl.dataProvider().addFeature(f) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) vl.setLabelsEnabled(True) p = QgsProject() engine_settings = QgsLabelingEngineSettings() engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly, True) p.setLabelingEngineSettings(engine_settings) p.addMapLayer(vl) layout = QgsLayout(p) layout.initializeDefaults() p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.setFrameEnabled(True) map.zoomToExtent(vl.extent()) map.setLayers([vl]) map.setId('map') layout.addLayoutItem(map) map2 = QgsLayoutItemMap(layout) map2.attemptSetSceneRect(QRectF(0, 5, 50, 80)) map2.setFrameEnabled(True) map2.setBackgroundEnabled(False) map2.setId('map2') layout.addLayoutItem(map2) map3 = QgsLayoutItemMap(layout) map3.attemptSetSceneRect(QRectF(150, 160, 50, 50)) map3.setFrameEnabled(True) map3.setBackgroundEnabled(False) map3.setId('map3') layout.addLayoutItem(map3) map.addLabelBlockingItem(map2) map.addLabelBlockingItem(map3) map.setMapFlags(QgsLayoutItemMap.MapItemFlags()) checker = QgsLayoutChecker('composermap_label_blockers', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) doc = QDomDocument("testdoc") elem = layout.writeXml(doc, QgsReadWriteContext()) l2 = QgsLayout(p) self.assertTrue(l2.readXml(elem, doc, QgsReadWriteContext())) map_restore = [i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map'][0] map2_restore = [i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map2'][0] map3_restore = [i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map3'][0] self.assertTrue(map_restore.isLabelBlockingItem(map2_restore)) self.assertTrue(map_restore.isLabelBlockingItem(map3_restore))
def setCollectionSettings(self): lyrids, lyrnames = self.lyrPair() coll = self.setFieldsCollection() arial = self.setArialDict() ssnr = self.setSsnrDict() swi = self.setSwiDict() times = self.setTimesDict() for names in lyrnames.values(): lyr = QgsProject.instance().mapLayersByName(names)[0] iface.setActiveLayer(lyr) pc = QgsPropertyCollection('qpc') lyr_settings = QgsPalLayerSettings() txt_format = QgsTextFormat() txt_format.setSizeUnit(QgsUnitTypes.RenderPoints) for nColl, fColl in coll.items(): x = QgsProperty() x.setField(fColl) pc.setProperty(nColl, x) pc.setProperty(31, '/') pc.setProperty(32, 0.8) if names in arial: txt_format.setFont(QFont("Arial")) txt_format.setColor(QColor(0, 0, 0)) elif names in ssnr: txt_format.setFont(QFont("Xerox Sans Serif Narrow")) txt_format.setColor(QColor(0, 0, 0)) elif names in swi: txt_format.setFont(QFont("Xerox Serif Wide")) if re.search(r"\Bcotado", names): txt_format.setColor(QColor(140, 58, 61)) elif re.search(r"\Bcurva", names): txt_format.setColor(QColor(140, 58, 61)) else: txt_format.setColor(QColor(0, 119, 189)) elif names in times: txt_format.setFont(QFont("Times New Roman")) txt_format.setColor(QColor(0, 0, 0)) lyr_settings.setFormat(txt_format) lyr_settings.setDataDefinedProperties(pc) lyr_settings.enabled = True lyr_settings.fieldName = "legenda" lyr_settings = QgsVectorLayerSimpleLabeling(lyr_settings) lyr.setLabelsEnabled(True) lyr.setLabeling(lyr_settings) lyr.triggerRepaint()
def testClippingHideClipSource(self): """ When an item is set to be the clip source, it shouldn't render anything itself """ format = QgsTextFormat() format.setFont(QgsFontUtils.getStandardTestFont("Bold")) format.setSize(30) format.setNamedStyle("Bold") format.setColor(QColor(0, 0, 0)) settings = QgsPalLayerSettings() settings.setFormat(format) settings.fieldName = "'XXXX'" settings.isExpression = True settings.placement = QgsPalLayerSettings.OverPoint vl = QgsVectorLayer("Polygon?crs=epsg:4326&field=id:integer", "vl", "memory") props = { "color": "127,255,127", 'outline_style': 'solid', 'outline_width': '1', 'outline_color': '0,0,255' } fillSymbol = QgsFillSymbol.createSimple(props) renderer = QgsSingleSymbolRenderer(fillSymbol) vl.setRenderer(renderer) f = QgsFeature(vl.fields(), 1) for x in range(0, 15, 3): for y in range(0, 15, 3): f.setGeometry(QgsGeometry(QgsPoint(x, y)).buffer(1, 3)) vl.dataProvider().addFeature(f) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) vl.setLabelsEnabled(True) p = QgsProject() p.addMapLayer(vl) layout = QgsLayout(p) layout.initializeDefaults() p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.setFrameEnabled(False) map.zoomToExtent(vl.extent()) map.setLayers([vl]) layout.addLayoutItem(map) shape = QgsLayoutItemShape(layout) layout.addLayoutItem(shape) shape.setShapeType(QgsLayoutItemShape.Ellipse) shape.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.itemClippingSettings().setEnabled(True) map.itemClippingSettings().setSourceItem(shape) map.itemClippingSettings().setForceLabelsInsideClipPath(False) map.itemClippingSettings().setFeatureClippingType( QgsMapClippingRegion.FeatureClippingType.ClipToIntersection) checker = QgsLayoutChecker('composermap_itemclip_nodrawsource', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() TestQgsLayoutMap.report += checker.report() self.assertTrue(result, message)
def save_pois_points(self, points, layername="Geopunt_poi", saveToFile=None, sender=None, startFolder=None): attributes = [ QgsField("id", QVariant.Int), QgsField("thema", QVariant.String), QgsField("categorie", QVariant.String), QgsField("type", QVariant.String), QgsField("naam", QVariant.String), QgsField("telefoon", QVariant.String), QgsField("email", QVariant.String), #address QgsField("straat", QVariant.String), QgsField("huisnr", QVariant.String), QgsField("busnr", QVariant.String), QgsField("postcode", QVariant.String), QgsField("gemeente", QVariant.String), QgsField("link", QVariant.String), QgsField("lastupdate", QVariant.String), QgsField("owner", QVariant.String) ] if not QgsProject.instance().mapLayer(self.poilayerid): self.poilayer = QgsVectorLayer("Point", layername, "memory") self.poiProvider = self.poilayer.dataProvider() self.poiProvider.addAttributes(attributes) self.poilayer.updateFields() fields = self.poilayer.fields() for point in points: pt = QgsPointXY( point['location']['points'][0]['Point']['coordinates'][0], point['location']['points'][0]['Point']['coordinates'][1]) poiId = point["id"] if "categories" in list( point.keys()) and len(point["categories"]) > 0: theme = point["categories"][0]['value'] else: theme = '' if "categories" in list( point.keys()) and len(point["categories"]) > 1: category = point["categories"][1]['value'] else: category = '' if "categories" in point and len(point["categories"]) > 2: poiType = point["categories"][2]['value'] else: poiType = '' name = point["labels"][0]["value"] if "phone" in list(point.keys()): phone = point["phone"] else: phone = "" if "email" in list(point.keys()): email = point["email"] else: email = "" #address if "address" in list(point['location'].keys()): if "street" in list(point['location']["address"].keys()): straat = point['location']["address"]["street"] else: straat = '' if "streetnumber" in list(point['location']["address"].keys()): huisnr = point['location']["address"]["streetnumber"] else: huisnr = '' if "boxnumber" in list(point['location']["address"].keys()): busnr = point['location']["address"]["boxnumber"] else: boxnr = '' postcode = point['location']["address"]["postalcode"] gemeente = point['location']["address"]["municipality"] else: straat = "" huisnr = "" busnr = "" postcode = "" gemeente = "" if "links" in point: link = point["links"][0]['href'] else: link = "" tijd = point["updated"] if "authors" in point: owner = point["authors"][0]["value"] else: owner = "" # add a feature fet = QgsFeature(fields) #set geometry fromCrs = QgsCoordinateReferenceSystem(4326) xform = QgsCoordinateTransform(fromCrs, self.poilayer.crs(), QgsProject.instance()) prjPt = xform.transform(pt) fet.setGeometry(QgsGeometry.fromPointXY(prjPt)) fet['id'] = int(poiId) fet['thema'] = theme fet['categorie'] = category fet['type'] = poiType fet['naam'] = name fet["email"] = email fet["telefoon"] = phone #address fet['straat'] = straat fet['huisnr'] = huisnr fet['busnr'] = busnr fet['postcode'] = postcode fet['gemeente'] = gemeente fet['link'] = link fet['lastupdate'] = tijd fet['owner'] = owner self.poiProvider.addFeatures([fet]) self.poilayer.updateExtents() if saveToFile and not QgsProject.instance().mapLayer(self.poilayerid): save = self._saveToFile(sender, startFolder) if save: fpath, flType = save error, msg = QgsVectorFileWriter.writeAsVectorFormat( self.poilayer, fileName=fpath, fileEncoding="utf-8", driverName=flType) if error == QgsVectorFileWriter.NoError: self.poilayer = QgsVectorLayer(fpath, layername, "ogr") self.poiProvider = self.poilayer.dataProvider() else: del self.poilayer, self.poiProvider raise Exception(msg) else: del self.poilayer, self.poiProvider return # add Labels text_format = QgsTextFormat() text_format.setSize(12) buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(1) buffer_settings.setColor(QColor("white")) palyr = QgsPalLayerSettings() text_format.setBuffer(buffer_settings) palyr.setFormat(text_format) palyr.enabled = True palyr.fieldName = 'naam' palyr.placement = QgsPalLayerSettings.Free self.poilayer.setLabelsEnabled(True) self.poilayer.setLabeling(QgsVectorLayerSimpleLabeling(palyr)) # add layer if not already QgsProject.instance().addMapLayer(self.poilayer) # store layer id and refresh self.poilayerid = self.poilayer.id() self.canvas.refresh()
def test_replacements(self): manager = QgsApplication.fontManager() format = QgsTextFormat() font = QFont('original family') format.setFont(font) self.assertEqual(format.font().family(), 'original family') doc = QDomDocument() context = QgsReadWriteContext() elem = format.writeXml(doc, context) parent = doc.createElement("settings") parent.appendChild(elem) t2 = QgsTextFormat() t2.readXml(parent, context) self.assertFalse(t2.fontFound()) self.assertEqual(context.takeMessages()[0].message(), 'Font “original family” not available on system') # with a font replacement in place test_font = getTestFont() manager.addFontFamilyReplacement('original Family', test_font.family()) t3 = QgsTextFormat() t3.readXml(parent, context) self.assertTrue(t3.fontFound()) self.assertEqual(t3.font().family(), 'QGIS Vera Sans')
def save_pois_points(self, points, layername="Geopunt_poi", saveToFile=None, sender=None, startFolder=None ): attributes = [ QgsField("id", QVariant.Int), QgsField("thema", QVariant.String), QgsField("categorie", QVariant.String), QgsField("type", QVariant.String), QgsField("naam", QVariant.String), QgsField("telefoon", QVariant.String), QgsField("email", QVariant.String) , #address QgsField("straat", QVariant.String), QgsField("huisnr", QVariant.String), QgsField("busnr", QVariant.String), QgsField("postcode", QVariant.String), QgsField("gemeente", QVariant.String), QgsField("link", QVariant.String), QgsField("lastupdate", QVariant.String), QgsField("owner", QVariant.String) ] if not QgsProject.instance().mapLayer(self.poilayerid) : self.poilayer = QgsVectorLayer("Point", layername, "memory") self.poiProvider = self.poilayer.dataProvider() self.poiProvider.addAttributes(attributes) self.poilayer.updateFields() fields=self.poilayer.fields() for point in points: pt = QgsPointXY( point['location']['points'][0]['Point']['coordinates'][0], point['location']['points'][0]['Point']['coordinates'][1] ) poiId = point["id"] if "categories" in list(point.keys()) and len(point["categories"]) > 0: theme = point["categories"][0]['value'] else: theme = '' if "categories" in list(point.keys()) and len(point["categories"]) > 1: category = point["categories"][1]['value'] else: category = '' if "categories" in point and len(point["categories"]) > 2: poiType = point["categories"][2]['value'] else: poiType = '' name = point["labels"][0]["value"] if "phone" in list(point.keys()): phone = point["phone"] else: phone= "" if "email" in list(point.keys()): email = point["email"] else: email= "" #address if "address" in list(point['location'].keys()): if "street" in list(point['location']["address"].keys()): straat = point['location']["address"]["street"] else: straat = '' if "streetnumber" in list(point['location']["address"].keys()): huisnr = point['location']["address"]["streetnumber"] else: huisnr = '' if "boxnumber" in list(point['location']["address"].keys()): busnr = point['location']["address"]["boxnumber"] else: boxnr = '' postcode = point['location']["address"]["postalcode"] gemeente = point['location']["address"]["municipality"] else: straat = "" huisnr = "" busnr = "" postcode = "" gemeente = "" if "links" in point: link = point["links"][0]['href'] else: link = "" tijd = point["updated"] if "authors" in point: owner = point["authors"][0]["value"] else: owner= "" # add a feature fet = QgsFeature(fields) #set geometry fromCrs = QgsCoordinateReferenceSystem(4326) xform = QgsCoordinateTransform( fromCrs, self.poilayer.crs(), QgsProject.instance() ) prjPt = xform.transform( pt ) fet.setGeometry(QgsGeometry.fromPointXY(prjPt)) fet['id'] = int( poiId ) fet['thema'] = theme fet['categorie'] = category fet['type'] = poiType fet['naam'] = name fet["email"] = email fet["telefoon"] = phone #address fet['straat'] = straat fet['huisnr'] = huisnr fet['busnr'] = busnr fet['postcode'] = postcode fet['gemeente'] = gemeente fet['link'] = link fet['lastupdate'] = tijd fet['owner'] = owner self.poiProvider.addFeatures([ fet ]) self.poilayer.updateExtents() if saveToFile and not QgsProject.instance().mapLayer(self.poilayerid): save = self._saveToFile( sender, startFolder ) if save: fpath, flType = save error, msg = QgsVectorFileWriter.writeAsVectorFormat(self.poilayer,fileName=fpath, fileEncoding="utf-8", driverName=flType ) if error == QgsVectorFileWriter.NoError: self.poilayer = QgsVectorLayer( fpath , layername, "ogr") self.poiProvider = self.poilayer.dataProvider() else: del self.poilayer, self.poiProvider raise Exception( msg ) else: del self.poilayer, self.poiProvider return # add Labels text_format = QgsTextFormat() text_format.setSize(12) buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(1) buffer_settings.setColor(QColor("white")) palyr = QgsPalLayerSettings() text_format.setBuffer(buffer_settings) palyr.setFormat(text_format) palyr.enabled = True palyr.fieldName = 'naam' palyr.placement = QgsPalLayerSettings.Free self.poilayer.setLabelsEnabled(True) self.poilayer.setLabeling( QgsVectorLayerSimpleLabeling(palyr) ) # add layer if not already QgsProject.instance().addMapLayer(self.poilayer) # store layer id and refresh self.poilayerid = self.poilayer.id() self.canvas.refresh()
def testSetColor(self): button = QgsFontButton() s = QgsTextFormat() s.setFont(getTestFont()) s.setNamedStyle('Italic') s.setSize(5) s.setColor(QColor(255, 0, 0)) s.setOpacity(0.5) button.setTextFormat(s) signal_spy = QSignalSpy(button.changed) button.setColor(QColor(0, 255, 0)) self.assertEqual(len(signal_spy), 1) r = button.textFormat() self.assertEqual(r.font().family(), 'QGIS Vera Sans') self.assertEqual(r.namedStyle(), 'Italic') self.assertEqual(r.size(), 5) self.assertEqual(r.color().name(), QColor(0, 255, 0).name()) self.assertEqual(r.opacity(), 0.5) # set same color, should not emit signal button.setColor(QColor(0, 255, 0)) self.assertEqual(len(signal_spy), 1) # color with transparency - should be stripped button.setColor(QColor(0, 255, 0, 100)) r = button.textFormat() self.assertEqual(r.color(), QColor(0, 255, 0))
def run(self): #coloco el puntero arriba del todo #QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint( QgsProject.instance().layerTreeRoot(), 0 ) #genero una lista con los campos de la capa selecionada layer = iface.activeLayer() if layer is None: iface.messageBar().pushMessage("ATENCION", "Selecciona una capa de puntos", duration=10) if layer.wkbType() == 1 or layer.wkbType() == 1001: prov = layer.dataProvider() field_names = [field.name() for field in prov.fields()] self.dlg.mycomboBox.clear() for element in field_names: self.dlg.mycomboBox.addItem(element) """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: global index_campo_seleccionado distanciaminima = int(self.dlg.lineEdit_distancia.text()) # "layer" is a QgsVectorLayer instance layer = iface.activeLayer() idx = layer.fields().indexFromName("distanc") if idx == -1: print("ya existe") res = layer.dataProvider().addAttributes( [QgsField("distanc", QVariant.String)]) #layer.addAttribute(QgsField("valido", QVariant.String)) layer.updateFields() features = layer.getFeatures() for feature in features: # retrieve every feature with its geometry and attributes #print("Feature ID: ", feature.id()) # fetch geometry # show some information about the feature geometry geom = feature.geometry() geomSingleType = QgsWkbTypes.isSingleType(geom.wkbType()) if geom.type() == QgsWkbTypes.PointGeometry: punto = geom.asPoint() x = punto.x() y = punto.y() #print("analizo los puntos",x,y) features2 = layer.getFeatures() for feature2 in features2: geom2 = feature2.geometry() punto2 = geom2.asPoint() x3 = punto2.x() y3 = punto2.y() d = ((x3 - x)**2 + (y3 - y)**2)**0.5 if d < distanciaminima: if feature2.id() == feature.id(): pass else: layer.startEditing() feature.setAttribute("distanc", 'no') print(feature2.id()) layer.updateFeature(feature) #Call commit to save the changes layer.commitChanges() categorias = [] sym = QgsMarkerSymbol.createSimple({ 'name': 'circle', 'color': 'red', 'size': '3' }) categoria = QgsRendererCategory("no", sym, "No cumple") categorias.append(categoria) sym = QgsMarkerSymbol.createSimple({ 'name': 'circle', 'color': 'blue', 'size': '2' }) categoria = QgsRendererCategory("", sym, "Cumple") categorias.append(categoria) renderer = QgsCategorizedSymbolRenderer("distanc", categorias) layer.setRenderer(renderer) # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer #Configure label settings settings = QgsPalLayerSettings() settings.fieldName = field_names[ index_campo_seleccionado] #'name' textFormat = QgsTextFormat() textFormat.setSize(10) settings.setFormat(textFormat) #create and append a new rule root = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings()) rule = QgsRuleBasedLabeling.Rule(settings) #rule.setDescription(fieldName) rule.setFilterExpression(''' "distanc" = 'no' ''') root.appendChild(rule) #Apply label configuration rules = QgsRuleBasedLabeling(root) layer.setLabeling(rules) layer.setLabelsEnabled(True) layer.triggerRepaint() else: iface.messageBar().pushMessage("ATENCION", "Selecciona una capa de puntos", duration=10)
def createFormatSettings(self): s = QgsTextFormat() s.setBuffer(self.createBufferSettings()) s.setBackground(self.createBackgroundSettings()) s.setShadow(self.createShadowSettings()) s.setFont(getTestFont()) s.setNamedStyle('Roman') s.setSize(5) s.setSizeUnit(QgsUnitTypes.RenderPoints) s.setSizeMapUnitScale(QgsMapUnitScale(1, 2)) s.setColor(QColor(255, 0, 0)) s.setOpacity(0.5) s.setBlendMode(QPainter.CompositionMode_Difference) s.setLineHeight(5) return s
class CentroidDecorator(QgsMapCanvasItem): """ Decorates centroids of features with population statistics """ def __init__(self, canvas: QgsMapCanvas, electorate_layer: QgsVectorLayer, meshblock_layer: QgsVectorLayer, task: str): """ Constructor :param canvas: map canvas :param electorate_layer: electorates layer :param meshblock_layer: meshblocks layer :param task: current task """ super().__init__(canvas) self.canvas = canvas self.electorate_layer = electorate_layer self.meshblock_layer = meshblock_layer self.task = task self.text_format = QgsTextFormat() # self.text_format.shadow().setEnabled(True) self.text_format.background().setEnabled(True) self.text_format.background().setSize(QSizeF(1, 0)) self.text_format.background().setOffset(QPointF(0, -0.7)) self.text_format.background().setRadii(QSizeF(1, 1)) self.image = None def redraw(self): """ Forces a redraw of the cached image """ self.image = None def paint(self, painter, option, widget): # pylint: disable=missing-docstring, unused-argument, too-many-locals if self.image is not None: painter.drawImage(0, 0, self.image) return image_size = self.canvas.mapSettings().outputSize() self.image = QImage(image_size.width(), image_size.height(), QImage.Format_ARGB32) self.image.fill(0) image_painter = QPainter(self.image) render_context = QgsRenderContext.fromQPainter(image_painter) image_painter.setRenderHint(QPainter.Antialiasing, True) rect = self.canvas.mapSettings().visibleExtent() request = QgsFeatureRequest() request.setFilterRect(rect) request.setFilterExpression( QgsExpression.createFieldEqualityExpression('type', self.task)) for f in self.electorate_layer.getFeatures(request): # pole, dist = f.geometry().clipped(rect).poleOfInaccessibility(rect.width() / 30) pixel = self.toCanvasCoordinates( f.geometry().clipped(rect).centroid().asPoint()) calc = QgsAggregateCalculator(self.meshblock_layer) calc.setFilter('staged_electorate={}'.format(f['electorate_id'])) estimated_pop, ok = calc.calculate(QgsAggregateCalculator.Sum, 'offline_pop_{}'.format( self.task.lower())) # pylint: disable=unused-variable text_string = [ '{}'.format(f['name']), '{}'.format(int(estimated_pop)) ] QgsTextRenderer().drawText(QPointF(pixel.x(), pixel.y()), 0, QgsTextRenderer.AlignCenter, text_string, render_context, self.text_format) image_painter.end() painter.drawImage(0, 0, self.image)
def testLabelMargin(self): """ Test rendering map item with a label margin set """ format = QgsTextFormat() format.setFont(QgsFontUtils.getStandardTestFont("Bold")) format.setSize(20) format.setNamedStyle("Bold") format.setColor(QColor(0, 0, 0)) settings = QgsPalLayerSettings() settings.setFormat(format) settings.fieldName = "'X'" settings.isExpression = True settings.placement = QgsPalLayerSettings.OverPoint vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl", "memory") vl.setRenderer(QgsNullSymbolRenderer()) f = QgsFeature(vl.fields(), 1) for x in range(15): for y in range(15): f.setGeometry(QgsPoint(x, y)) vl.dataProvider().addFeature(f) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) vl.setLabelsEnabled(True) p = QgsProject() engine_settings = QgsLabelingEngineSettings() engine_settings.setFlag(QgsLabelingEngineSettings.UsePartialCandidates, False) engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly, True) p.setLabelingEngineSettings(engine_settings) p.addMapLayer(vl) layout = QgsLayout(p) layout.initializeDefaults() p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.setFrameEnabled(True) map.zoomToExtent(vl.extent()) map.setLayers([vl]) layout.addLayoutItem(map) checker = QgsLayoutChecker('composermap_label_nomargin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) map.setLabelMargin( QgsLayoutMeasurement(15, QgsUnitTypes.LayoutMillimeters)) checker = QgsLayoutChecker('composermap_label_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) map.setLabelMargin( QgsLayoutMeasurement(3, QgsUnitTypes.LayoutCentimeters)) checker = QgsLayoutChecker('composermap_label_cm_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) map.setMapRotation(45) map.zoomToExtent(vl.extent()) map.setScale(map.scale() * 1.2) checker = QgsLayoutChecker('composermap_rotated_label_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) # data defined map.setMapRotation(0) map.zoomToExtent(vl.extent()) map.dataDefinedProperties().setProperty( QgsLayoutObject.MapLabelMargin, QgsProperty.fromExpression('1+3')) map.refresh() checker = QgsLayoutChecker('composermap_dd_label_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message)
def testDataDefinedTicksAndAnnotationDisplay(self): layout = QgsLayout(QgsProject.instance()) layout.initializeDefaults() map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(40, 20, 200, 100)) map.setFrameEnabled(True) map.setBackgroundColor(QColor(150, 100, 100)) layout.addLayoutItem(map) myRectangle = QgsRectangle(0.5, -5.5, 10.5, 0.5) map.setExtent(myRectangle) map.setMapRotation(45) map.grid().setEnabled(True) map.grid().setIntervalX(1) map.grid().setIntervalY(1) map.grid().setAnnotationEnabled(True) map.grid().setGridLineColor(QColor(0, 255, 0)) map.grid().setGridLineWidth(0.5) map.grid().setFrameStyle(QgsLayoutItemMapGrid.ExteriorTicks) map.grid().setFrameWidth(4) map.grid().setFramePenSize(1) map.grid().setFramePenColor(QColor(0, 0, 255)) map.grid().setAnnotationFrameDistance(5) format = QgsTextFormat.fromQFont(getTestFont('Bold', 20)) format.setColor(QColor(255, 0, 0)) format.setOpacity(150 / 255) map.grid().setAnnotationTextFormat(format) map.grid().setAnnotationPrecision(0) map.grid().setRotatedTicksEnabled(True) map.grid().setRotatedAnnotationsEnabled(True) map.grid().setAnnotationDirection(QgsLayoutItemMapGrid.OnTick) map.grid().dataDefinedProperties().setProperty( QgsLayoutObject.MapGridAnnotationDisplayLeft, QgsProperty.fromValue("x_only")) map.grid().dataDefinedProperties().setProperty( QgsLayoutObject.MapGridAnnotationDisplayRight, QgsProperty.fromValue("Y_ONLY")) map.grid().dataDefinedProperties().setProperty( QgsLayoutObject.MapGridAnnotationDisplayTop, QgsProperty.fromValue("disabled")) map.grid().dataDefinedProperties().setProperty( QgsLayoutObject.MapGridAnnotationDisplayBottom, QgsProperty.fromValue("ALL")) map.grid().dataDefinedProperties().setProperty( QgsLayoutObject.MapGridFrameDivisionsLeft, QgsProperty.fromValue("X_ONLY")) map.grid().dataDefinedProperties().setProperty( QgsLayoutObject.MapGridFrameDivisionsRight, QgsProperty.fromValue("y_only")) map.grid().dataDefinedProperties().setProperty( QgsLayoutObject.MapGridFrameDivisionsTop, QgsProperty.fromValue("DISABLED")) map.grid().dataDefinedProperties().setProperty( QgsLayoutObject.MapGridFrameDivisionsBottom, QgsProperty.fromValue("all")) map.grid().refresh() checker = QgsLayoutChecker( 'composermap_datadefined_ticksandannotationdisplay', layout) checker.setControlPathPrefix("composer_mapgrid") myTestResult, myMessage = checker.testLayout() self.report += checker.report() self.assertTrue(myTestResult, myMessage)
def testDynamicInterval(self): layout = QgsLayout(QgsProject.instance()) layout.initializeDefaults() map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(20, 20, 200, 100)) map.setFrameEnabled(True) map.setBackgroundColor(QColor(150, 100, 100)) layout.addLayoutItem(map) myRectangle = QgsRectangle(781662.375, 3339523.125, 793062.375, 3345223.125) map.setExtent(myRectangle) map.grid().setEnabled(True) map.grid().setUnits(QgsLayoutItemMapGrid.DynamicPageSizeBased) map.grid().setMinimumIntervalWidth(50) map.grid().setMaximumIntervalWidth(100) map.grid().setAnnotationEnabled(True) map.grid().setGridLineColor(QColor(0, 255, 0)) map.grid().setGridLineWidth(0.5) format = QgsTextFormat.fromQFont(getTestFont('Bold', 20)) format.setColor(QColor(255, 0, 0)) format.setOpacity(150 / 255) map.grid().setAnnotationTextFormat(format) map.grid().setAnnotationPrecision(0) map.grid().setAnnotationDisplay(QgsLayoutItemMapGrid.HideAll, QgsLayoutItemMapGrid.Left) map.grid().setAnnotationPosition(QgsLayoutItemMapGrid.OutsideMapFrame, QgsLayoutItemMapGrid.Right) map.grid().setAnnotationDisplay(QgsLayoutItemMapGrid.HideAll, QgsLayoutItemMapGrid.Top) map.grid().setAnnotationPosition(QgsLayoutItemMapGrid.OutsideMapFrame, QgsLayoutItemMapGrid.Bottom) map.grid().setAnnotationDirection(QgsLayoutItemMapGrid.Horizontal, QgsLayoutItemMapGrid.Right) map.grid().setAnnotationDirection(QgsLayoutItemMapGrid.Horizontal, QgsLayoutItemMapGrid.Bottom) map.grid().setBlendMode(QPainter.CompositionMode_Overlay) map.updateBoundingRect() map.grid().refresh() checker = QgsLayoutChecker('composermap_dynamic_5_10', layout) checker.setControlPathPrefix("composer_mapgrid") myTestResult, myMessage = checker.testLayout() self.report += checker.report() self.assertTrue(myTestResult, myMessage) map.setScale(map.scale() * 1.1) checker = QgsLayoutChecker('composermap_dynamic_5_10_2', layout) checker.setControlPathPrefix("composer_mapgrid") myTestResult, myMessage = checker.testLayout() self.report += checker.report() self.assertTrue(myTestResult, myMessage) map.setScale(map.scale() * 1.8) checker = QgsLayoutChecker('composermap_dynamic_5_10_3', layout) checker.setControlPathPrefix("composer_mapgrid") myTestResult, myMessage = checker.testLayout() self.report += checker.report() self.assertTrue(myTestResult, myMessage) map.grid().setMinimumIntervalWidth(10) map.grid().setMaximumIntervalWidth(40) map.grid().refresh() checker = QgsLayoutChecker('composermap_dynamic_5_10_4', layout) checker.setControlPathPrefix("composer_mapgrid") myTestResult, myMessage = checker.testLayout() self.report += checker.report() self.assertTrue(myTestResult, myMessage)
def __init__(self): QMainWindow.__init__(self) #self.setWindowFlags(Qt.CustomizeWindowHint) #self.setWindowFlags(Qt.WindowMinMaxButtonsHint) # creating map canvas, which draws the maplayers # setting up features like canvas color self.canvas = QgsMapCanvas() self.canvas.setMinimumSize(550, 700) self.canvas.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) self.canvas.setCanvasColor(Qt.white) self.canvas.setSelectionColor(QColor(255,255,26,200)) self.canvas.enableAntiAliasing(True) self.canvas.setParallelRenderingEnabled(True) # empty list for selected polygons self.selected_features = [] # setting up label settings: object below houses all of them self.label_settings = QgsPalLayerSettings() # object for text settings text_format = QgsTextFormat() text_format.setFont(QFont("Helvetica", 12)) text_format.setSize(7) # setting up a white buffer around the labels buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(0.65) buffer_settings.setColor(Qt.white) text_format.setBuffer(buffer_settings) # label settings: # fieldName = which field is shown as the label (currently Finnish name) # placement = labels can be placed differently in relation to one another # - see documentation for details self.label_settings.setFormat(text_format) self.label_settings.fieldName = "namefin" self.label_settings.placement = 0 self.label_settings.enabled = True # Qmainwindow requires a central widget. Canvas is placed self.setCentralWidget(self.canvas) # creating each desired action self.actionGet = QAction("Return selected and close", self) self.actionPan = QAction("Pan tool", self) self.actionSelect = QAction("Select tool", self) self.actionClear = QAction("Clear selection", self) self.actionCancel = QAction("Cancel and close", self) # these two function as on/off. the rest are clickable self.actionPan.setCheckable(True) self.actionSelect.setCheckable(True) # when actions are clicked, do corresponding function self.actionPan.triggered.connect(self.pan) self.actionSelect.triggered.connect(self.select) self.actionClear.triggered.connect(self.clearSelection) self.actionGet.triggered.connect(self.finishedSelection) self.actionCancel.triggered.connect(self.cancel) # toolbar at the top of the screen: houses actions as buttons # change order here to change their placement on window self.toolbar = self.addToolBar("Canvas actions") self.toolbar.setContextMenuPolicy(Qt.PreventContextMenu) self.toolbar.setMovable(False) self.toolbar.addAction(self.actionGet) self.toolbar.addAction(self.actionPan) self.toolbar.addAction(self.actionSelect) self.toolbar.addAction(self.actionClear) self.toolbar.addAction(self.actionCancel) # link actions to premade map tools self.toolPan = QgsMapToolPan(self.canvas) self.toolPan.setAction(self.actionPan) self.toolSelect = QgsMapToolIdentifyFeature(self.canvas) self.toolSelect.setAction(self.actionSelect) self.toolSelect.featureIdentified.connect(self.selectFeature) self.blocks_flag = False self.selection_rectangle = False # set select tool as default self.select()
def parse_symbol_layer(json_layer): json_layout = json_layer['layout'] json_paint = json_layer['paint'] dd_properties = {} TEXT_SIZE_MULTIPLIER = 2 # *2 because of high-res screen? text_size = 16 if 'text-size' in json_layout: json_text_size = json_layout['text-size'] if isinstance(json_text_size, (float, int)): text_size = json_text_size elif isinstance(json_text_size, dict): dd_properties[ QgsPalLayerSettings.Size] = parse_interpolate_by_zoom( json_text_size, TEXT_SIZE_MULTIPLIER) else: print("skipping non-float text-size", json_text_size) # TODO: text-font text_color = Qt.black if 'text-color' in json_paint: json_text_color = json_paint['text-color'] if isinstance(json_text_color, str): text_color = parse_color(json_text_color) else: print("skipping non-string text-color", json_text_color) buffer_color = QColor(0, 0, 0, 0) if 'text-halo-color' in json_paint: json_text_halo_color = json_paint['text-halo-color'] if isinstance(json_text_halo_color, str): buffer_color = parse_color(json_text_halo_color) else: print("skipping non-string text-halo-color", json_text_halo_color) buffer_size = 0 if 'text-halo-width' in json_paint: json_text_halo_width = json_paint['text-halo-width'] if isinstance(json_text_halo_width, (float, int)): buffer_size = json_text_halo_width else: print("skipping non-float text-halo-width", json_text_halo_width) format = QgsTextFormat() format.setColor(text_color) format.setSize(text_size * TEXT_SIZE_MULTIPLIER) format.setSizeUnit(QgsUnitTypes.RenderPixels) #format.setFont(font) if buffer_size > 0: buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(buffer_size * PX_TO_MM * TEXT_SIZE_MULTIPLIER) buffer_settings.setColor(buffer_color) format.setBuffer(buffer_settings) label_settings = QgsPalLayerSettings() label_settings.fieldName = '"name:latin"' # TODO: parse field name label_settings.isExpression = True label_settings.placement = QgsPalLayerSettings.OverPoint label_settings.priority = min(text_size / 3., 10.) label_settings.setFormat(format) if dd_properties: for dd_key, dd_expression in dd_properties.items(): prop_collection = QgsPropertyCollection() prop_collection.setProperty( dd_key, QgsProperty.fromExpression(dd_expression)) label_settings.setDataDefinedProperties(prop_collection) lb = QgsVectorTileBasicLabelingStyle() lb.setGeometryType(QgsWkbTypes.PointGeometry) lb.setLabelSettings(label_settings) return lb
def grid_labeler(self, coord_base_x, coord_base_y, px, py, u, t, dx, dy, vAlign, hAlign, desc, fSize, fontType, expression_str, trLLUTM, trUTMLL, llcolor, utmcheck, scale): if utmcheck: pgrid = QgsPoint(coord_base_x + px * u, coord_base_y + py * t) pgrid.transform(trLLUTM) pgrid = QgsPoint(pgrid.x() + dx, pgrid.y() + dy) else: pgrid = QgsPoint(coord_base_x + px * u + dx, coord_base_y + py * t + dy) #Label Format Settings settings = QgsPalLayerSettings() settings.Placement = QgsPalLayerSettings.Free settings.isExpression = True textprop = QgsTextFormat() textprop.setColor(llcolor) textprop.setSizeUnit(1) textprop.setSize(fSize * scale * 1.324) textprop.setFont(QFont(fontType)) textprop.setLineHeight(1) settings.setFormat(textprop) settings.fieldName = expression_str #Label Name and Position datadefined = QgsPropertyCollection() datadefined.setProperty(9, pgrid.x()) datadefined.setProperty(10, pgrid.y()) if not (hAlign == ''): datadefined.setProperty(11, hAlign) if not (vAlign == ''): datadefined.setProperty(12, vAlign) datadefined.setProperty(20, 1) #Creating and Activating Labeling Rule settings.setDataDefinedProperties(datadefined) rule = QgsRuleBasedLabeling.Rule(settings) rule.setDescription(desc) rule.setActive(True) return rule
def run(self): print ("paso por el run") #coloco el puntero arriba del todo QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint( QgsProject.instance().layerTreeRoot(), 0 ) """Run method that performs all the real work""" #genero una lista con las columnas de la capa de puntos vl2=iface.activeLayer() if vl2 is None: iface.messageBar().pushMessage("ATENCION", "Selecciona una capa de puntos", duration=10) #if vl2.wkbType()< 1 or vl2.wkbType() > 1: #iface.messageBar().pushMessage("ATENCION", "Selecciona una capa de puntos", duration=10) #else: if vl2.wkbType()== 1 or vl2.wkbType()==1001: misdatos=[] misdatos = [f.name() for f in vl2.fields()] #trato de rellenar el desplegable con las columnas #anado un elemneto en blanco en el desplegable self.dlg.cb1.clear() self.dlg.cb1.addItem( "") for element in misdatos: self.dlg.cb1.addItem( element) # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: column = self.dlg.cb1.currentIndex() columna=misdatos[int(column)-1] #parece que lo mejor sera la seleccion de una capa y dentro de ella de los elementos en ella seleccionados solo. Para ello habria que crear una capa temporal con solo los seleccioandos #if vl2.wkbType()== 1 or vl2.wkbType()==1001: selection = vl2.selectedFeatures() elementosseleccionados=len(selection) if elementosseleccionados ==0: vl2.selectAll() if elementosseleccionados ==1 or elementosseleccionados ==2: iface.messageBar().pushMessage("ATENCION", "Tienes algun elemento seleccionado pero no los suficientes para crear un poligono", duration=10) #onlySelectedFeatures results0=processing.run("native:saveselectedfeatures", {'INPUT':vl2,'OUTPUT':'memory:puntos_seleccionados_ptos2pol'}) result_layer0 = results0['OUTPUT'] entrada=result_layer0 QgsProject.instance().addMapLayer(result_layer0) #hay que hacer que cree una columna con el orden el solo por si por defecto no se pone ninguna params={'INPUT':entrada,'GROUP_FIELD':None,'ORDER_FIELD':columna,'DATE_FORMAT':'', 'OUTPUT':'memory:lineas_ptos2pol'} results=processing.run("qgis:pointstopath", params) result_layer = results['OUTPUT'] QgsProject.instance().addMapLayer(result_layer) params={'INPUT':result_layer,'OUTPUT':'memory:poligono_ptos2pol '} results2=processing.run("qgis:linestopolygons", params ) result_layer2 = results2['OUTPUT'] #por el mismo precio calculo la superficie #ADDING NEW FIELD layer_provider=result_layer2.dataProvider() layer_provider.addAttributes([QgsField("hectarea",QVariant.Double, "double", 10, 4)]) result_layer2.updateFields() #UPDATING/ADD ATTRIBUTE VALUE result_layer2.startEditing() features = result_layer2.getFeatures() for f in features: id=f.id() area=f.geometry().area()/10000 fieldindex = result_layer2.dataProvider().fieldNameIndex("hectarea") attr_value={fieldindex:area}#fieldindex, antes era 2 layer_provider.changeAttributeValues({id:attr_value}) result_layer2.commitChanges() #tendra que etiquetar la superficie con dos decimales y cambiar la simbologia, ya que estamos. sym1 = QgsFillSymbol.createSimple({'style': 'vertical','color': '0,0,0,0', 'outline_color': 'red'}) renderer=QgsSingleSymbolRenderer(sym1) #etiqueto layer_settings = QgsPalLayerSettings() text_format = QgsTextFormat() text_format.setFont(QFont("Arial", 12)) text_format.setSize(12) text_format.setColor(QColor("Red")) layer_settings.setFormat(text_format) layer_settings.fieldName = '''concat(round("hectarea",2),' ha.')''' layer_settings.isExpression = True layer_settings.enabled = True layer_settings = QgsVectorLayerSimpleLabeling(layer_settings) result_layer2.setLabelsEnabled(True) result_layer2.setLabeling(layer_settings) result_layer2.triggerRepaint() result_layer2.setRenderer(renderer) QgsProject.instance().addMapLayer(result_layer2) else: print(vl2.wkbType()) iface.messageBar().pushMessage("ATENCION", "Selecciona una capa de puntos", duration=10)