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 pintaLabels(self, campEtiqueta):
"""Pinta sobre el canvas les etiquetas de la capa activa, segons campEtiqueta.
Arguments:
campEtiqueta {[String]} -- És el nom del camp del que volem pintar etiquetes.
"""
# layer=self.llegenda.currentLayer()
layer_settings = QgsPalLayerSettings()
text_format = QgsTextFormat()
text_format.setFont(QvConstants.FONTTEXT)
text_format.setSize(12)
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)
layer_settings.fieldName = campEtiqueta
layer_settings.placement = 0
layer_settings.enabled = True
print("layer settings:" + layer_settings.fieldName)
labeling = QgsVectorLayerSimpleLabeling(layer_settings)
self.layer.setLabelsEnabled(True)
self.layer.setLabeling(labeling)
self.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)
def set_label(layer, field_label):
"""Function that sets the label to a field value. Inspiration found at:
https://gis.stackexchange.com/questions/277106/loading-labels-from-python-script-in-qgis
Parameters
----------
layer: QgsVectorLayer
valid qgis layer.
field_label: str
The label of the field
"""
layer_settings = QgsPalLayerSettings()
text_format = QgsTextFormat()
text_format.setFont(QFont("Arial", 12))
text_format.setSize(12)
buffer_settings = QgsTextBufferSettings()
buffer_settings.setEnabled(True)
buffer_settings.setSize(0.10)
buffer_settings.setColor(QColor("black"))
text_format.setBuffer(buffer_settings)
layer_settings.setFormat(text_format)
layer_settings.fieldName = field_label
layer_settings.placement = 4
layer_settings.enabled = True
layer_settings = QgsVectorLayerSimpleLabeling(layer_settings)
layer.setLabelsEnabled(True)
layer.setLabeling(layer_settings)
layer.triggerRepaint()
def createProfileLayers(heightSource):
lyrCrs = heightSource.spatialRef.authid()
pointA = heightSource.getFirstPoint()
pointE = heightSource.getLastPoint()
# Create profile layer
surveyLineLayer = QgsVectorLayer('Linestring?crs=' + lyrCrs,
tr('Felddaten-Profil'), 'memory')
pr = surveyLineLayer.dataProvider()
feature = QgsFeature()
feature.setGeometry(
QgsGeometry.fromPolyline(
[QgsPoint(*tuple(pointA)),
QgsPoint(*tuple(pointE))]))
pr.addFeatures([feature])
surveyLineLayer.updateExtents()
QgsProject.instance().addMapLayers([surveyLineLayer])
# Create survey point layer
surveyPointLayer = QgsVectorLayer('Point?crs=' + lyrCrs,
tr('Felddaten-Messpunkte'), 'memory')
pr = surveyPointLayer.dataProvider()
pr.addAttributes([QgsField("nr", QVariant.String)])
surveyPointLayer.updateFields()
features = []
# TODO: Survey points are NOT rounded
for x, y, nr, notes in zip(heightSource.x, heightSource.y, heightSource.nr,
heightSource.plotNotes):
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(x, y)))
feature.setId(int(nr + 1))
labelText = f"{nr}{':' if notes else ''} {notes if len(notes) <= 25 else notes[:22] + '...'}"
feature.setAttributes([labelText])
features.append(feature)
pr.addFeatures(features)
surveyPointLayer.updateExtents()
QgsProject.instance().addMapLayers([surveyPointLayer])
# Add Labels for point layer
layer_settings = QgsPalLayerSettings()
text_format = QgsTextFormat()
text_format.setFont(QFont("Arial", 12))
text_format.setSize(12)
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)
layer_settings.fieldName = "nr"
layer_settings.placement = 2
layer_settings.enabled = True
layer_settings = QgsVectorLayerSimpleLabeling(layer_settings)
surveyPointLayer.setLabelsEnabled(True)
surveyPointLayer.setLabeling(layer_settings)
surveyPointLayer.triggerRepaint()
return surveyLineLayer, surveyPointLayer
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())
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 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 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()
