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 createBufferSettings(self): s = QgsTextBufferSettings() s.setEnabled(True) s.setSize(5) s.setSizeUnit(QgsUnitTypes.RenderPixels) s.setSizeMapUnitScale(QgsMapUnitScale(1, 2)) s.setColor(QColor(255, 0, 0)) s.setFillBufferInterior(True) s.setOpacity(0.5) s.setJoinStyle(Qt.RoundJoin) s.setBlendMode(QPainter.CompositionMode_Difference) return s
def createBufferSettings(self): s = QgsTextBufferSettings() s.setEnabled(True) s.setSize(5) s.setSizeUnit(QgsUnitTypes.RenderPixels) s.setSizeMapUnitScale(QgsMapUnitScale(1, 2)) s.setColor(QColor(255, 0, 0)) s.setFillBufferInterior(True) s.setOpacity(0.5) s.setJoinStyle(Qt.RoundJoin) s.setBlendMode(QPainter.CompositionMode_Difference) s.setPaintEffect(QgsBlurEffect.create({'blur_level': '2.0', 'blur_unit': QgsUnitTypes.encodeUnit(QgsUnitTypes.RenderMillimeters), 'enabled': '1'})) return s
def postProcessLayer(self, layer, context, feedback): _ = feedback, context layer.setLabelsEnabled(True) pal = QgsPalLayerSettings() # Expression combinant les nom d'habitat et du faciès pal.fieldName = "|| ' - ' || ".join(self.fields) pal.isExpression = True # Mais ce label est trop long # utilisation du faciès pour le label # et du nom pour le rendu pal.fieldName = self.fields[1] pal.isExpression = False pal.labelPerPart = True pal.placement = QgsPalLayerSettings.OverPoint txt_buff = QgsTextBufferSettings() txt_buff.setEnabled(True) txt_format = pal.format() txt_format.setBuffer(txt_buff) pal.setFormat(txt_format) layer.setLabeling(QgsVectorLayerSimpleLabeling(pal)) renderer = layer.renderer() symbol = renderer.symbol() symbol.setSize(6) # Symbologie à partir du champs nom de l'habitat index = layer.fields().indexOf(self.fields[0]) values = layer.uniqueValues(index) color = QgsRandomColorRamp() color.setTotalColorCount(len(values)) categories = [] for i, value in enumerate(values): symbol = QgsSymbol.defaultSymbol(QgsWkbTypes.PointGeometry) symbol.setColor(color.color(i)) symbol.setSize(5) category = QgsRendererCategory(value, symbol, value) categories.append(category) renderer = QgsCategorizedSymbolRenderer(self.fields[0], categories) layer.setRenderer(renderer) layer.triggerRepaint()
def apply_label(self): ''' apply the label of the currently selected label field to the output layer ''' layer = self.input.layer if self.input else None if not layer: return self.label_field_name = self.label_field_combo.currentData() self.label_cache[layer.id] = self.label_field_name layer = self.output.layer if self.output else None if not layer: return if not self.label_field_name: layer.setLabelsEnabled(False) layer.reload() return layer.setLabelsEnabled(True) labeling = layer.labeling() if not labeling: settings = QgsPalLayerSettings() settings.enabled = True buffer = QgsTextBufferSettings() buffer.setEnabled(True) buffer.setSize(0.8) text_format = QgsTextFormat() text_format.setBuffer(buffer) text_format.setSize(8) settings.setFormat(text_format) labeling = QgsVectorLayerSimpleLabeling(settings) settings = labeling.settings() settings.fieldName = self.label_field_name labeling.setSettings(settings) layer.setLabeling(labeling) layer.reload()
def SetDefaultPointStyle(layer): ''' Point Symbol ''' style = S.getDrawingPoint() symbol = QgsMarkerSymbol.createSimple({ 'name': style["NAME"], 'line_color': style["LINE_COLOR"], 'line_width': style["LINE_WIDTH"], 'size': style["SIZE"] }) renderer = QgsSingleSymbolRenderer(symbol) layer.setRenderer(renderer) layer_settings = QgsPalLayerSettings() text_format = QgsTextFormat() text_format.setFont(QFont(style["LABEL_FONT"], style["LABEL_FONT_SIZE"])) text_format.setColor(QColor(style["LABEL_FONT_COLOR"])) text_format.setSize(style["LABEL_SIZE"]) buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(1) buffer_settings.setColor(QColor(style["LABEL_BUFFER_COLOR"])) text_format.setBuffer(buffer_settings) layer_settings.setFormat(text_format) layer_settings.fieldName = "number" layer_settings.placement = 2 layer_settings.enabled = True layer_settings = QgsVectorLayerSimpleLabeling(layer_settings) layer.setLabelsEnabled(True) layer.setLabeling(layer_settings) return
def createRules(self, label, expression): ''' Returns a QgsRuleBasedLabeling based on label and expression ''' settings = QgsPalLayerSettings() settings.fieldName = label settings.Placement = QgsPalLayerSettings.OverPoint settings.centroidInside = True settings.isExpression = True textFormat = QgsTextFormat() textFormat.setColor(QColor(0, 0, 0, 255)) textFormat.setSize(6) textBuffer = QgsTextBufferSettings() textBuffer.setColor(QColor(255, 255, 255, 255)) textBuffer.setSize(0.4) textBuffer.setEnabled(True) textFormat.setBuffer(textBuffer) settings.setFormat(textFormat) rule = QgsRuleBasedLabeling.Rule(settings) rule.setFilterExpression(expression) rule.setActive(True) return rule
def text_symbol_to_qgstextformat( text_symbol: TextSymbol, # pylint: disable=too-many-locals,too-many-branches,too-many-statements context, reference_scale=None): """ Converts TextSymbol to QgsTextFormat """ text_format = QgsTextFormat() font = TextSymbolConverter.std_font_to_qfont(text_symbol.font) if context.unsupported_object_callback and font.family( ) not in QFontDatabase().families(): if isinstance(text_symbol, TextSymbol): context.unsupported_object_callback( 'Font {} not available on system'.format( text_symbol.font.font_name)) if Qgis.QGIS_VERSION_INT >= 30900: font.setKerning(text_symbol.kerning) conversion_factor = reference_scale * 0.000352778 if reference_scale is not None else 1 # why 5.55? why not! It's based on rendering match with ArcGIS -- there's no documentation # about what the ArcGIS character spacing value actually means! font.setLetterSpacing( QFont.AbsoluteSpacing, conversion_factor * (text_symbol.character_spacing or 0) / 5.55) # may need tweaking font.setWordSpacing(conversion_factor * ((text_symbol.word_spacing / 100) - 1)) if isinstance(text_symbol, TextSymbol): font.setCapitalization( TextSymbolConverter.CAPITALIZATION_MAP[text_symbol.case]) if Qgis.QGIS_VERSION_INT >= 31600: text_format.setCapitalization( TextSymbolConverter.TEXT_CAPITALIZATION_MAP[ text_symbol.case]) if isinstance(text_symbol, TextSymbol): text_format.setLineHeight(1 + text_symbol.leading / text_symbol.font_size) text_format.setFont(font) if reference_scale is None: text_format.setSize(text_symbol.font_size) text_format.setSizeUnit(QgsUnitTypes.RenderPoints) else: text_format.setSize(text_symbol.font_size * reference_scale * 0.000352778) # todo - use normal map units text_format.setSizeUnit(QgsUnitTypes.RenderMetersInMapUnits) if Qgis.QGIS_VERSION_INT >= 32300 and text_symbol.character_width != 100: text_format.setStretchFactor(text_symbol.character_width) opacity = 1 if isinstance(text_symbol, TextSymbol): color = ColorConverter.color_to_qcolor(text_symbol.color) # need to move opacity setting from color to dedicated setter opacity = color.alphaF() color.setAlpha(255) text_format.setColor(color) text_format.setOpacity(opacity) # shadow if text_symbol.shadow_x_offset or text_symbol.shadow_y_offset: shadow = QgsTextShadowSettings() shadow.setEnabled(True) shadow_color = ColorConverter.color_to_qcolor( text_symbol.shadow_color) # need to move opacity setting from color to dedicated setter shadow_opacity = shadow_color.alphaF() shadow_color.setAlpha(255) shadow.setColor(shadow_color) shadow.setOpacity(shadow_opacity) shadow_angle = math.degrees( math.atan2(text_symbol.shadow_y_offset, text_symbol.shadow_x_offset)) shadow_dist = math.sqrt(text_symbol.shadow_x_offset**2 + text_symbol.shadow_y_offset**2) shadow.setOffsetAngle(int(round(90 - shadow_angle))) if reference_scale is None: shadow.setOffsetDistance(context.convert_size(shadow_dist)) shadow.setOffsetUnit(context.units) else: shadow.setOffsetDistance(shadow_dist * reference_scale * 0.000352778) shadow.setOffsetUnit(QgsUnitTypes.RenderMetersInMapUnits) shadow.setBlendMode(QPainter.CompositionMode_SourceOver) # arc has no option for blurring shadows - we convert with a slight blur (because it's UGLY if we don't, # but use a lower blur then the default to give a somewhat closer match) shadow.setBlurRadius(0.5) text_format.setShadow(shadow) # halo buffer = QgsTextBufferSettings() if isinstance(text_symbol, TextSymbol): buffer.setEnabled(text_symbol.halo_enabled) else: buffer.setEnabled(bool(text_symbol.halo_symbol)) if reference_scale is None: buffer.setSize(context.convert_size(text_symbol.halo_size)) buffer.setSizeUnit(context.units) else: buffer.setSize(2 * text_symbol.halo_size * reference_scale * 0.000352778) buffer.setSizeUnit(QgsUnitTypes.RenderMetersInMapUnits) # QGIS has no option for halo symbols. Instead, we just get the color from the symbol if text_symbol.halo_symbol: from .symbols import SymbolConverter # pylint: disable=import-outside-toplevel,cyclic-import halo_symbol = SymbolConverter.Symbol_to_QgsSymbol( text_symbol.halo_symbol, context) if halo_symbol: buffer_color = halo_symbol.color() # need to move opacity setting from color to dedicated setter buffer_opacity = buffer_color.alphaF() buffer_color.setAlpha(255) buffer.setColor(buffer_color) # in ArcMap buffer inherits text opacity, shadow does not buffer.setOpacity(buffer_opacity * opacity) text_format.setBuffer(buffer) if text_symbol.background_symbol: background = TextSymbolConverter.convert_background_symbol( text_symbol.background_symbol, context, reference_scale) if background: text_format.setBackground(background) if isinstance(text_symbol, TextSymbol): if text_symbol.cjk_orientation: if Qgis.QGIS_VERSION_INT < 30900: if context.unsupported_object_callback: context.unsupported_object_callback( 'Vertical text orientation requires QGIS 3.10 or later', level=Context.WARNING) else: raise NotImplementedException( 'Vertical text orientation requires QGIS 3.10 or later' ) else: text_format.setOrientation( QgsTextFormat.VerticalOrientation) else: pass return text_format
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_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 __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 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 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()