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 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 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 createFormatSettings(self):
s = QgsTextFormat()
s.setBuffer(self.createBufferSettings())
s.setMask(self.createMaskSettings())
s.setBackground(self.createBackgroundSettings())
s.setShadow(self.createShadowSettings())
font = getTestFont()
font.setKerning(False)
s.setFont(font)
s.setNamedStyle('Roman')
s.setSize(5)
s.setSizeUnit(QgsUnitTypes.RenderPoints)
s.setSizeMapUnitScale(QgsMapUnitScale(1, 2))
s.setColor(QColor(255, 0, 0))
s.setOpacity(0.5)
s.setBlendMode(QPainter.CompositionMode_Difference)
s.setLineHeight(5)
s.setOrientation(QgsTextFormat.VerticalOrientation)
s.setPreviewBackgroundColor(QColor(100, 150, 200))
s.setAllowHtmlFormatting(True)
return s
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 setCollectionSettings(self):
lyrids, lyrnames = self.lyrPair()
coll = self.setFieldsCollection()
arial = self.setArialDict()
ssnr = self.setSsnrDict()
swi = self.setSwiDict()
times = self.setTimesDict()
for names in lyrnames.values():
lyr = QgsProject.instance().mapLayersByName(names)[0]
iface.setActiveLayer(lyr)
pc = QgsPropertyCollection('qpc')
lyr_settings = QgsPalLayerSettings()
txt_format = QgsTextFormat()
txt_format.setSizeUnit(QgsUnitTypes.RenderPoints)
for nColl, fColl in coll.items():
x = QgsProperty()
x.setField(fColl)
pc.setProperty(nColl, x)
pc.setProperty(31, '/')
pc.setProperty(32, 0.8)
if names in arial:
txt_format.setFont(QFont("Arial"))
txt_format.setColor(QColor(0, 0, 0))
elif names in ssnr:
txt_format.setFont(QFont("Xerox Sans Serif Narrow"))
txt_format.setColor(QColor(0, 0, 0))
elif names in swi:
txt_format.setFont(QFont("Xerox Serif Wide"))
if re.search(r"\Bcotado", names):
txt_format.setColor(QColor(140, 58, 61))
elif re.search(r"\Bcurva", names):
txt_format.setColor(QColor(140, 58, 61))
else:
txt_format.setColor(QColor(0, 119, 189))
elif names in times:
txt_format.setFont(QFont("Times New Roman"))
txt_format.setColor(QColor(0, 0, 0))
lyr_settings.setFormat(txt_format)
lyr_settings.setDataDefinedProperties(pc)
lyr_settings.enabled = True
lyr_settings.fieldName = "legenda"
lyr_settings = QgsVectorLayerSimpleLabeling(lyr_settings)
lyr.setLabelsEnabled(True)
lyr.setLabeling(lyr_settings)
lyr.triggerRepaint()
def testReadWrite(self):
p = QgsProjectStyleSettings()
line = QgsSymbol.defaultSymbol(QgsWkbTypes.LineGeometry)
p.setDefaultSymbol(Qgis.SymbolType.Line, line)
ramp = QgsGradientColorRamp(QColor(255, 255, 255), QColor(255, 0, 0))
p.setDefaultColorRamp(ramp)
textFormat = QgsTextFormat()
textFormat.setFont(QFont())
p.setDefaultTextFormat(textFormat)
p.setRandomizeDefaultSymbolColor(False)
p.setDefaultSymbolOpacity(0.25)
p.setStyleDatabasePaths([
unitTestDataPath() + '/style1.db',
unitTestDataPath() + '/style2.db'
])
doc = QDomDocument("testdoc")
elem = p.writeXml(doc, QgsReadWriteContext())
p2 = QgsProjectStyleSettings()
self.assertTrue(p2.readXml(elem, QgsReadWriteContext()))
self.assertFalse(p2.defaultSymbol(Qgis.SymbolType.Marker))
self.assertTrue(p2.defaultSymbol(Qgis.SymbolType.Line))
self.assertFalse(p2.defaultSymbol(Qgis.SymbolType.Fill))
self.assertTrue(p2.defaultColorRamp())
self.assertTrue(p2.defaultTextFormat().isValid())
self.assertFalse(p2.randomizeDefaultSymbolColor())
self.assertEqual(p2.defaultSymbolOpacity(), 0.25)
self.assertEqual(p2.styleDatabasePaths(), [
unitTestDataPath() + '/style1.db',
unitTestDataPath() + '/style2.db'
])
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 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 __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 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 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 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 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 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 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 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 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)
