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 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 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 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 btnConstruct_Click(self):
flag = FlightPlanBaseSimpleDlg.btnConstruct_Click(self)
if not flag:
return
constructionLayer = AcadHelper.createVectorLayer(SurfaceTypes.DmeTolerance, QGis.Line)
point3d1 = self.parametersPanel.pnlDME.Point3d
circleAreaList = []
# length = self.groundDistance.Metres / 5
# # rectangle = QgsRectangle(point3d1.get_X() - length / 2, point3d1.get_Y() - length / 2, point3d1.get_X() + length / 2, point3d1.get_Y() + length / 2,)
# point1 = Point3D(point3d1.get_X() - length / 2, point3d1.get_Y() + length / 2)
# point2 = Point3D(point3d1.get_X() - length / 2, point3d1.get_Y() - length / 2)
captionCircleLine = []
centerPoint = None
radius = 0.0
arc = None;
resultPoint3dArrayList = []
if (self.groundDistance.Metres > 0):
metres = self.dmeTolerance.valueMetres / 1.7;
if (self.parametersPanel.cmbConstructionType.currentIndex() != 0):
num1 = Unit.ConvertDegToRad(float(self.parametersPanel.pnlRadial.Value));
num2 = math.asin(min([1 / self.groundDistance.NauticalMiles, 1]));
num3 = num1 + num2
num4 = num1 - num2
# arc = PolylineArea()
# arc.Add(PolylineAreaPoint(point3d1, self.groundDistance.Metres))
arc = MathHelper.constructArc(point3d1, self.groundDistance.Metres, num3, num4, 30);
point3d = MathHelper.distanceBearingPoint(point3d1, num1, self.groundDistance.Metres);
captionCircleLine = [MathHelper.distanceBearingPoint(point3d, MathHelper.getBearing(point3d, point3d1) + math.pi / 2, self.groundDistance.Metres / 20), MathHelper.distanceBearingPoint(point3d, MathHelper.getBearing(point3d, point3d1) - math.pi / 2, self.groundDistance.Metres / 20)]
num = -num1;
if (self.parametersPanel.chbDrawRadial.isChecked()):
line = PolylineArea([point3d1, point3d]);
resultPoint3dArrayList.append([point3d1, point3d])
# AcadHelper.smethod_18(transaction, blockTableRecord, line, constructionLayer);
else:
arc = MathHelper.constructCircle(point3d1, self.groundDistance.Metres, 50);
circleAreaList.append(PolylineArea(None, point3d1, self.groundDistance.Metres))
centerPoint = point3d1
radius = self.groundDistance.Metres
point3d = MathHelper.distanceBearingPoint(point3d1, 0, self.groundDistance.Metres);
length = self.groundDistance.Metres / 5
# rectangle = QgsRectangle(point3d1.get_X() - length / 2, point3d1.get_Y() - length / 2, point3d1.get_X() + length / 2, point3d1.get_Y() + length / 2,)
point1 = MathHelper.distanceBearingPoint(point3d, Unit.ConvertDegToRad(270), length / 4)#Point3D(point3d.get_X() - length / 4, point3d.get_Y())
point2 = MathHelper.distanceBearingPoint(point3d, Unit.ConvertDegToRad(90), length / 4)#Point3D(point3d.get_X() + length / 4, point3d.get_Y())
captionCircleLine = [point1, point2]
num = 0;
resultPoint3dArrayList.append(arc)
# AcadHelper.smethod_18(transaction, blockTableRecord, arc, constructionLayer);
if (self.parametersPanel.chbWriteText.isChecked()):
nauticalMiles = self.groundDistance.NauticalMiles;
# DBText dBText = AcadHelper.smethod_138(string.Format("{0} DME", nauticalMiles.ToString("0.#")), point3d, metres, 1);
# dBText.set_Rotation(num);
# AcadHelper.smethod_18(transaction, blockTableRecord, dBText, constructionLayer);
if (self.parametersPanel.chbDrawDmeTol.isVisible() and self.parametersPanel.chbDrawDmeTol.isChecked() and self.dmeTolerance.IsValid() and arc != None):
offsetCurf = QgisHelper.offsetCurve(arc, self.dmeTolerance.Metres)
if self.parametersPanel.cmbConstructionType.currentIndex() == 0:
circleAreaList.append(PolylineArea(None, centerPoint, radius + self.dmeTolerance.Metres))
if (self.parametersPanel.cmbConstructionType.currentIndex() == 0):
endPoint = offsetCurf[0]
offsetCurf.append(endPoint)
resultPoint3dArrayList.append(offsetCurf)
# foreach (Entity offsetCurf in arc.GetOffsetCurves(self.dmeTolerance.Metres))
# {
# AcadHelper.smethod_19(transaction, blockTableRecord, offsetCurf, constructionLayer, 5);
# }
entity = QgisHelper.offsetCurve(arc, -(self.dmeTolerance.Metres + self.slantTolerance.Metres))
if self.parametersPanel.cmbConstructionType.currentIndex() == 0:
circleAreaList.append(PolylineArea(None, centerPoint, radius -(self.dmeTolerance.Metres + self.slantTolerance.Metres)))
if (self.parametersPanel.cmbConstructionType.currentIndex() == 0):
endPoint = entity[0]
entity.append(endPoint)
resultPoint3dArrayList.append(entity)
# foreach (Entity entity in arc.GetOffsetCurves(-(self.dmeTolerance.Metres + self.slantTolerance.Metres)))
# {
# AcadHelper.smethod_19(transaction, blockTableRecord, entity, constructionLayer, 5);
# }
# }
if (self.parametersPanel.chbDrawSlantTol.isVisible() and self.parametersPanel.chbDrawSlantTol.isChecked() and self.slantTolerance.IsValid() and arc != None):
offsetCurf1 = QgisHelper.offsetCurve(arc, -self.slantTolerance.Metres)
if self.parametersPanel.cmbConstructionType.currentIndex() == 0:
circleAreaList.append(PolylineArea(None, centerPoint, radius -self.slantTolerance.Metres))
if (self.parametersPanel.cmbConstructionType.currentIndex() == 0):
endPoint = offsetCurf1[0]
offsetCurf1.append(endPoint)
resultPoint3dArrayList.append(offsetCurf1)
# foreach (Entity offsetCurf1 in arc.GetOffsetCurves(-self.slantTolerance.Metres))
# {
# AcadHelper.smethod_19(transaction, blockTableRecord, offsetCurf1, constructionLayer, 2);
# }
# }
if (self.parametersPanel.chbInsertSymbol.isChecked()):
length = self.groundDistance.Metres / 5
rectangle = QgsRectangle(point3d1.get_X() - length / 2, point3d1.get_Y() - length / 2, point3d1.get_X() + length / 2, point3d1.get_Y() + length / 2,)
point1 = MathHelper.distanceBearingPoint(point3d1, Unit.ConvertDegToRad(315), length / 2)#Point3D(point3d1.get_X() - length / 2, point3d1.get_Y() + length / 2)
point2 = MathHelper.distanceBearingPoint(point3d1, Unit.ConvertDegToRad(225), length / 2)#Point3D(point3d1.get_X() - length / 2, point3d1.get_Y() - length / 2)
point3 = MathHelper.distanceBearingPoint(point3d1, Unit.ConvertDegToRad(135), length / 2)#Point3D(point3d1.get_X() + length / 2, point3d1.get_Y() - length / 2)
point4 = MathHelper.distanceBearingPoint(point3d1, Unit.ConvertDegToRad(45), length / 2)#Point3D(point3d1.get_X() + length / 2, point3d1.get_Y() + length / 2)
resultPoint3dArrayList.append([point1, point2, point3, point4, point1])
# Symbol symbol = new Symbol(SymbolType.Dme);
# AcadHelper.smethod_57(transaction, blockTableRecord, symbol.BlockName, symbol.BlockFileName, point3d1, new Scale3d(1), 0, constructionLayer, None);
# }
for point3dArray in resultPoint3dArrayList:
if (self.parametersPanel.cmbConstructionType.currentIndex() != 0):
bulge = MathHelper.smethod_60(point3dArray[0], point3dArray[int(len(point3dArray)/2)], point3dArray[len(point3dArray)-1])
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, point3dArray, False, {"Bulge":bulge})
if self.parametersPanel.cmbConstructionType.currentIndex() == 0:
for area in circleAreaList:
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, area)
if self.parametersPanel.chbInsertSymbol.isChecked():
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, [point1, point2, point3, point4, point1])
if (self.parametersPanel.chbWriteText.isChecked()):
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, captionCircleLine, False, {"Caption":"3DME"} )
palSetting = QgsPalLayerSettings()
palSetting.readFromLayer(constructionLayer)
palSetting.enabled = True
palSetting.fieldName = "Caption"
palSetting.isExpression = True
palSetting.placement = QgsPalLayerSettings.Line
palSetting.placementFlags = QgsPalLayerSettings.AboveLine
palSetting.setDataDefinedProperty(QgsPalLayerSettings.Size, True, True, '12', "")
palSetting.writeToLayer(constructionLayer)
QgisHelper.appendToCanvas(define._canvas, [constructionLayer], self.surfaceType, True)
QgisHelper.zoomToLayers([constructionLayer])
self.resultLayerList = [constructionLayer]
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):
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 showMarkDaSoc(self):
try:
flag = FlightPlanBaseDlg.btnConstruct_Click(self)
# if not flag:
# return
point3dThr = self.parametersPanel.pnlThrPosition.Point3d
point3dFaf = self.parametersPanel.pnlFapPosition.Point3d
inboundTrackRad = Unit.ConvertDegToRad(
self.parametersPanel.pnlInboundTrack.Value
) #MathHelper.getBearing(point3dFaf, point3dThr)
inboundTrack180Rad = MathHelper.smethod_4(inboundTrackRad +
math.pi)
estimatedAltitdeMeters = self.parametersPanel.pnlEstimatedAltitude.Value.Metres
thrAltitudeMeters = self.parametersPanel.pnlThrPosition.Altitude(
).Metres
heightLossAltitudeMeters = self.parametersPanel.pnlHeightLoss.Value.Metres
rdhAltitudeMeters = self.parametersPanel.pnlRDH.Value.Metres
vpa = Unit.ConvertDegToRad(self.getVPA())
xz = self.parametersPanel.pnlDistXz.Value.Metres
socThrDistMeters = (
(estimatedAltitdeMeters - thrAltitudeMeters -
heightLossAltitudeMeters) / math.tan(vpa)) + xz
daThrDistMeters = (estimatedAltitdeMeters - thrAltitudeMeters -
rdhAltitudeMeters) / math.tan(vpa)
sockBearing = inboundTrackRad
# if socThrDistMeters < 0:
# sockBearing = inboundTrack180Rad
# socThrDistMeters = math.fabs(socThrDistMeters)
# else:
# sockBearing = inboundTrackRad
daBearing = inboundTrack180Rad
# if daThrDistMeters < 0:
# daBearing = inboundTrackRad
# daThrDistMeters = math.fabs(daThrDistMeters)
# else:
# daBearing = inboundTrack180Rad
self.socPoint3d = MathHelper.distanceBearingPoint(
point3dThr, sockBearing,
-socThrDistMeters).smethod_167(self.calcSocAltitude())
self.daPoint3d = MathHelper.distanceBearingPoint(
point3dThr, daBearing, daThrDistMeters)
daSocLayer = AcadHelper.createVectorLayer(
"DA_SOC_" + self.surfaceType, QGis.Point)
AcadHelper.setGeometryAndAttributesInLayer(daSocLayer,
self.socPoint3d, False,
{"Caption": "SOC"})
AcadHelper.setGeometryAndAttributesInLayer(daSocLayer,
self.daPoint3d, False,
{"Caption": "DA"})
QgisHelper.appendToCanvas(define._canvas, [daSocLayer],
self.surfaceType)
palSetting = QgsPalLayerSettings()
palSetting.readFromLayer(daSocLayer)
palSetting.enabled = True
palSetting.fieldName = "Caption"
palSetting.isExpression = True
palSetting.placement = QgsPalLayerSettings.AroundPoint
palSetting.setDataDefinedProperty(QgsPalLayerSettings.Size, True,
True, '8', "")
palSetting.writeToLayer(daSocLayer)
QgisHelper.zoomToLayers([daSocLayer])
self.resultLayerList = [daSocLayer]
# # show SOC Mark
# point3d = MathHelper.distanceBearingPoint(self.socPoint3d, Unit.ConvertDegToRad(450) - 0, 100)
# point3d1 = MathHelper.distanceBearingPoint(self.socPoint3d, Unit.ConvertDegToRad(450) - math.pi / 2, 100)
# point3d2 = MathHelper.distanceBearingPoint(self.socPoint3d, Unit.ConvertDegToRad(450) - math.pi, 100)
# point3d3 = MathHelper.distanceBearingPoint(self.socPoint3d, Unit.ConvertDegToRad(450) - (math.pi * 3) / 2 , 100)
#
# if self.socRubber == None:
# self.socRubber = QgsRubberBand(define._canvas, QGis.Line)
# self.socRubber.setColor(Qt.yellow)
# else:
# self.socRubber.reset(QGis.Line)
# self.socRubber.addGeometry(QgsGeometry.fromPolyline([point3d, point3d2]), None)
# self.socRubber.addGeometry(QgsGeometry.fromPolyline([point3d1, point3d3]), None)
# circle = MathHelper.constructCircle(self.socPoint3d, 100, 16)
# self.socRubber.addGeometry(QgsGeometry.fromPolyline(circle), None)
# self.socRubber.show()
#
# self.socAnnotation.setMapPosition(self.socPoint3d)
# self.socAnnotation.show()
#
# # show DA Mark
# point3d = MathHelper.distanceBearingPoint(self.daPoint3d, Unit.ConvertDegToRad(450) - 0, 100)
# point3d1 = MathHelper.distanceBearingPoint(self.daPoint3d, Unit.ConvertDegToRad(450) - math.pi / 2, 100)
# point3d2 = MathHelper.distanceBearingPoint(self.daPoint3d, Unit.ConvertDegToRad(450) - math.pi, 100)
# point3d3 = MathHelper.distanceBearingPoint(self.daPoint3d, Unit.ConvertDegToRad(450) - (math.pi * 3) / 2 , 100)
#
# if self.daRubber == None:
# self.daRubber = QgsRubberBand(define._canvas, QGis.Line)
# self.daRubber.setColor(Qt.yellow)
# else:
# self.daRubber.reset(QGis.Line)
# self.daRubber.addGeometry(QgsGeometry.fromPolyline([point3d, point3d2]), None)
# self.daRubber.addGeometry(QgsGeometry.fromPolyline([point3d1, point3d3]), None)
# circle = MathHelper.constructCircle(self.daPoint3d, 100, 16)
# self.daRubber.addGeometry(QgsGeometry.fromPolyline(circle), None)
# self.daRubber.show()
#
# self.daAnnotation.setMapPosition(self.daPoint3d)
# self.daAnnotation.show()
self.putDistances()
return daSocLayer
except:
pass
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)
