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 test_draw_text_format(self): r = QgsGradientColorRamp(QColor(200, 0, 0, 100), QColor(0, 200, 0, 200)) # need a layer in order to make legend nodes layer = QgsVectorLayer('dummy', 'test', 'memory') layer_tree_layer = QgsLayerTreeLayer(layer) settings = QgsColorRampLegendNodeSettings() tf = QgsTextFormat() tf.setFont(QgsFontUtils.getStandardTestFont('Bold', 18)) tf.setSize(30) tf.setColor(QColor(200, 100, 50)) settings.setTextFormat(tf) node = QgsColorRampLegendNode(layer_tree_layer, r, settings, 5, 10) ls = QgsLegendSettings() item_style = ls.style(QgsLegendStyle.SymbolLabel) item_style.setFont(QgsFontUtils.getStandardTestFont('Bold', 18)) ls.setStyle(QgsLegendStyle.SymbolLabel, item_style) item_context = QgsLayerTreeModelLegendNode.ItemContext() image = QImage(400, 250, QImage.Format_ARGB32) image.fill(QColor(255, 255, 255)) p = QPainter(image) ms = QgsMapSettings() ms.setExtent(QgsRectangle(1, 10, 1, 10)) ms.setOutputSize(image.size()) context = QgsRenderContext.fromMapSettings(ms) context.setPainter(p) context.setScaleFactor(150 / 25.4) # 150 DPI p.scale(context.scaleFactor(), context.scaleFactor()) item_context.context = context item_context.painter = p item_context.top = 1 item_context.columnLeft = 3 item_context.columnRight = 30 item_context.patchSize = QSizeF(12, 40) symbol_size = node.drawSymbol(ls, item_context, 0) node.drawSymbolText(ls, item_context, symbol_size) p.end() self.assertTrue( self.imageCheck('color_ramp_legend_node_text_format_draw', 'color_ramp_legend_node_text_format_draw', image))
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 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
def createFormatSettings(self): s = QgsTextFormat() s.setBuffer(self.createBufferSettings()) 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 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 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 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 setLayerLabels(self, layer, fieldName): firstCondition = layer.geometryType( ) == 0 and self.cbNodeLabels.isChecked() secondCondition = layer.geometryType( ) != 0 and self.cbLinkLabels.isChecked() if firstCondition or secondCondition: layer_settings = QgsPalLayerSettings() text_format = QgsTextFormat() text_format.setFont(QFont("Arial", 10)) color = "black" if secondCondition: color = "blue" text_format.setColor(QColor(color)) layer_settings.setFormat(text_format) layer_settings.fieldName = fieldName layer_settings.placement = QgsPalLayerSettings.Line layer_settings.enabled = True labels = QgsVectorLayerSimpleLabeling(layer_settings) layer.setLabeling(labels) layer.setLabelsEnabled(True) layer.triggerRepaint()
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): 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)
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 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 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 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 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 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 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.values(): txt_format.setFont(QFont("Arial")) txt_format.setColor(QColor(0, 0, 0)) elif names in ssnr.values(): txt_format.setFont(QFont("Xerox Sans Serif Narrow")) txt_format.setColor(QColor(0, 0, 0)) elif names in swi.values(): 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.values(): txt_format.setFont(QFont("Times New Roman")) txt_format.setColor(QColor(0, 0, 0)) pass lyr_settings.setFormat(txt_format) lyr_settings.setDataDefinedProperties(pc) lyr_settings.enabled = True if names == "rel_ponto_cotado_altimetrico_p": lyr_settings.fieldName = "cota" else: lyr_settings.fieldName = "legenda" lyr_settings = QgsVectorLayerSimpleLabeling(lyr_settings) lyr.setLabelsEnabled(True) lyr.setLabeling(lyr_settings) lyr.triggerRepaint()
def run(self): print("paso por el run") vl = iface.activeLayer() if vl.wkbType() == QgsWkbTypes.Polygon or vl.wkbType( ) == QgsWkbTypes.MultiPolygon: vl.startEditing() fields = vl.fields() idx = fields.indexFromName('hectareas') if idx == -1: myField = QgsField('hectareas', QVariant.Double) vl.dataProvider().addAttributes([myField]) vl.updateFields() for f in vl.getFeatures(): f.setAttribute(f.fieldNameIndex('hectareas'), f.geometry().area() / 10000) #f[idx] = '"$area"*1000' vl.updateFeature(f) vl.commitChanges() #coloco el puntero arriba del todo #QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint( QgsProject.instance().layerTreeRoot(), 0 ) #defino simbologia sym1 = QgsFillSymbol.createSimple({ 'style': 'vertical', 'color': '0,0,0,0', 'outline_color': 'red' }) renderer = QgsSingleSymbolRenderer(sym1) #defino formato etiquetas 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) # defino etiquetas layer_settings.fieldName = '''concat(format_number("hectareas",2),' ha.')''' layer_settings.isExpression = True layer_settings.enabled = True layer_settings = QgsVectorLayerSimpleLabeling(layer_settings) vl.setLabelsEnabled(True) vl.setLabeling(layer_settings) vl.triggerRepaint() vl.setRenderer(renderer) #QgsProject.instance().addMapLayer(v1) #QgsProject.instance().removeMapLayer(layer) #canvas.freeze(False) vl.updateExtents() vl.commitChanges() vl.updateExtents() #canvas.setExtent(lyr9.extent()) """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
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)