def extract_layers(self, tree):
"""Return a list of RFU layers."""
# Create vector layers..
l_vertex = QgsVectorLayer(r"Point?crs=epsg:4326&index=yes",
u"Sommet RFU", r"memory")
l_edge = QgsVectorLayer(r"LineString?crs=epsg:4326&index=yes",
u"Limite RFU", r"memory")
p_vertex = l_vertex.dataProvider()
p_edge = l_edge.dataProvider()
# Define default style renderer..
renderer_vertex = QgsRuleBasedRendererV2(QgsMarkerSymbolV2())
vertex_root_rule = renderer_vertex.rootRule()
vertex_rules = (
((u"Borne, borne à puce, pierre, piquet, clou ou broche"),
(u"$id >= 0 AND \"som_nature\" IN ('Borne',"
u"'Borne à puce', 'Pierre', 'Piquet', 'Clou ou broche')"),
r"#EC0000", 2.2),
((u"Axe cours d'eau, axe fossé, haut de talus, pied de talus"),
(u"$id >= 0 AND \"som_nature\" IN ('Axe cours d\'\'eau',"
u"'Axe fossé', 'Haut de talus', 'Pied de talus')"), r"#EE8012",
2.2), ((u"Angle de bâtiment, axe de mur, angle de mur, "
u"angle de clôture, pylône et toute autre valeur"),
(u"$id >= 0 AND \"som_nature\" NOT IN ('Borne',"
u"'Borne à puce', 'Pierre', 'Piquet', 'Clou ou broche',"
u"'Axe cours d\'\'eau', 'Axe fossé', 'Haut de talus',"
u"'Pied de talus')"), r"#9784EC",
2.2), (u"Temporaire", r"$id < 0", "cyan", 2.4))
for label, expression, color, size in vertex_rules:
rule = vertex_root_rule.children()[0].clone()
rule.setLabel(label)
rule.setFilterExpression(expression)
rule.symbol().setColor(QColor(color))
rule.symbol().setSize(size)
vertex_root_rule.appendChild(rule)
vertex_root_rule.removeChildAt(0)
l_vertex.setRendererV2(renderer_vertex)
renderer_edge = QgsRuleBasedRendererV2(QgsLineSymbolV2())
edge_root_rule = renderer_edge.rootRule()
edge_rules = ((r"Limite", r"$id >= 0", "#0A0AFF", 0.5),
(r"Temporaire", r"$id < 0", "cyan", 1))
for label, expression, color, width in edge_rules:
rule = edge_root_rule.children()[0].clone()
rule.setLabel(label)
rule.setFilterExpression(expression)
rule.symbol().setColor(QColor(color))
rule.symbol().setWidth(width)
edge_root_rule.appendChild(rule)
edge_root_rule.removeChildAt(0)
l_edge.setRendererV2(renderer_edge)
# Add fields..
p_vertex.addAttributes([
QgsField(r"@id_noeud", QVariant.Int),
# QgsField(r"@changeset", QVariant.Int),
# QgsField(r"@timestamp", QVariant.Date),
QgsField(r"@version", QVariant.Int),
QgsField(r"som_ge_createur", QVariant.String),
QgsField(r"som_nature", QVariant.String),
QgsField(r"som_precision_rattachement", QVariant.Int),
QgsField(r"som_coord_est", QVariant.Double),
QgsField(r"som_coord_nord", QVariant.Double),
QgsField(r"som_representation_plane", QVariant.String),
# QgsField(r"date_creation", QVariant.Date)
])
p_edge.addAttributes([
QgsField(r"@id_arc", QVariant.Int),
# QgsField(r"@id_noeud_debut", QVariant.Int),
# QgsField(r"@id_noeud_fin", QVariant.Int),
# QgsField(r"@changeset", QVariant.Int),
# QgsField(r"@timestamp", QVariant.Date),
QgsField(r"@version", QVariant.Int),
QgsField(r"lim_ge_createur", QVariant.String),
# QgsField(r"lim_date_creation", QVariant.Date)
])
# Add features from xml tree..
# ..to vertex layer..
fts_vertex = []
for e in tree.findall(r"sommet"):
ft_vertex = QgsFeature()
ft_vertex.setGeometry(QgsGeometry.fromWkt(e.attrib[r"geometrie"]))
_id_noeud = int(e.attrib[r"id_noeud"])
# _changeset = int(e.attrib[r"changeset"])
# _timestamp = QDateTime(datetime.strptime(
# e.attrib[r"timestamp"], r"%Y-%m-%d %H:%M:%S.%f"))
_version = int(e.attrib[r"version"])
som_ge_createur = unicode(e.find(r"./som_ge_createur").text)
som_nature = unicode(e.find(r"./som_nature").text)
som_prec_rattcht = int(
e.find(r"./som_precision_rattachement").text)
som_coord_est = float(e.find(r"./som_coord_est").text)
som_coord_nord = float(e.find(r"./som_coord_nord").text)
som_repres_plane = unicode(
e.find(r"./som_representation_plane").text)
# som_date_creation = QDate(datetime.strptime(
# e.find(r"./som_date_creation").text, r"%Y-%m-%d").date())
ft_vertex.setAttributes([
_id_noeud,
# _changeset,
# _timestamp,
_version,
som_ge_createur,
som_nature,
som_prec_rattcht,
som_coord_est,
som_coord_nord,
som_repres_plane,
# som_date_creation
])
fts_vertex.append(ft_vertex)
# ..to edge layer..
fts_edge = []
for e in tree.findall(r"limite"):
ft_edge = QgsFeature()
ft_edge.setGeometry(QgsGeometry.fromWkt(e.attrib[r"geometrie"]))
_id_arc = int(e.attrib[r"id_arc"])
# _id_noeud_debut = int(e.attrib[r"id_noeud_debut"])
# _id_noeud_fin = int(e.attrib[r"id_noeud_fin"])
# _changeset = int(e.attrib[r"changeset"])
# _timestamp = QDateTime(datetime.strptime(
# e.attrib[r"timestamp"], r"%Y-%m-%d %H:%M:%S.%f"))
_version = int(e.attrib[r"version"])
lim_ge_createur = unicode(e.find(r"./lim_ge_createur").text)
# lim_date_creation = QDate(datetime.strptime(
# e.find(r"./lim_date_creation").text, r"%Y-%m-%d").date())
ft_edge.setAttributes([
_id_arc,
# _id_noeud_debut,
# _id_noeud_fin,
# _changeset,
# _timestamp,
_version,
lim_ge_createur,
# lim_date_creation
])
fts_edge.append(ft_edge)
# Add features to layers..
p_vertex.addFeatures(fts_vertex)
p_edge.addFeatures(fts_edge)
# Update fields..
l_vertex.updateFields()
l_edge.updateFields()
# Update layer's extent..
l_vertex.updateExtents()
l_edge.updateExtents()
# Check if valid..
if not l_vertex.isValid() or not l_edge.isValid():
raise Exception(
u"Une erreur est survenue lors du chargement de la couche.")
# Set labelling...
palyr = QgsPalLayerSettings()
palyr.enabled = True
# palyr.readFromLayer(l_vertex)
palyr.fieldName = r"$id" # Expression $id
palyr.placement = 1 # ::OverPoint
palyr.quadOffset = 2 # ::QuadrantAboveRight
palyr.setDataDefinedProperty(80, True, True, r"1",
"") # ::OffsetUnits -> ::MM
palyr.xOffset = 2.0
palyr.yOffset = -1.0
palyr.writeToLayer(l_vertex)
# Then return layers..
return [l_vertex, l_edge]
def exportStyles(layers, folder, clustered):
stylesFolder = os.path.join(folder, "styles")
QDir().mkpath(stylesFolder)
for count, (layer, cluster) in enumerate(zip(layers, clustered)):
sln = safeName(layer.name()) + unicode(count)
if layer.type() != layer.VectorLayer:
continue
labelsEnabled = unicode(
layer.customProperty("labeling/enabled")).lower() == "true"
if (labelsEnabled):
labelField = layer.customProperty("labeling/fieldName")
if labelField != "":
if unicode(layer.customProperty(
"labeling/isExpression")).lower() == "true":
exprFilename = os.path.join(folder, "resources",
"qgis2web_expressions.js")
fieldName = layer.customProperty("labeling/fieldName")
name = compile_to_file(fieldName, "label_%s" % sln,
"OpenLayers3", exprFilename)
js = "%s(context)" % (name)
js = js.strip()
labelText = js
else:
fieldIndex = layer.pendingFields().indexFromName(
labelField)
try:
editFormConfig = layer.editFormConfig()
editorWidget = editFormConfig.widgetType(fieldIndex)
except:
editorWidget = layer.editorWidgetV2(fieldIndex)
if (editorWidget == QgsVectorLayer.Hidden
or editorWidget == 'Hidden'):
labelField = "q2wHide_" + labelField
labelText = ('feature.get("%s")' %
labelField.replace('"', '\\"'))
else:
labelText = '""'
else:
labelText = '""'
defs = "var size = 0;\n"
try:
renderer = layer.rendererV2()
layer_alpha = layer.layerTransparency()
if isinstance(renderer, QgsSingleSymbolRendererV2):
symbol = renderer.symbol()
if cluster:
style = "var size = feature.get('features').length;\n"
else:
style = "var size = 0;\n"
style += " var style = " + getSymbolAsStyle(
symbol, stylesFolder, layer_alpha)
value = 'var value = ""'
elif isinstance(renderer, QgsCategorizedSymbolRendererV2):
defs += """function categories_%s(feature, value) {
switch(value) {""" % sln
cats = []
for cat in renderer.categories():
if (cat.value() is not None and cat.value() != ""
and not isinstance(cat.value(), QPyNullVariant)):
categoryStr = "case '%s':" % unicode(
cat.value()).replace("'", "\\'")
else:
categoryStr = "default:"
categoryStr += '''
return %s;
break;''' % (getSymbolAsStyle(cat.symbol(), stylesFolder,
layer_alpha))
cats.append(categoryStr)
defs += "\n".join(cats) + "}};"
classAttr = renderer.classAttribute()
fieldIndex = layer.pendingFields().indexFromName(classAttr)
try:
editFormConfig = layer.editFormConfig()
editorWidget = editFormConfig.widgetType(fieldIndex)
except:
editorWidget = layer.editorWidgetV2(fieldIndex)
if (editorWidget == QgsVectorLayer.Hidden
or editorWidget == 'Hidden'):
classAttr = "q2wHide_" + classAttr
value = ('var value = feature.get("%s");' % classAttr)
style = ('''var style = categories_%s(feature, value)''' %
(sln))
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
varName = "ranges_" + sln
defs += "var %s = [" % varName
ranges = []
for ran in renderer.ranges():
symbolstyle = getSymbolAsStyle(ran.symbol(), stylesFolder,
layer_alpha)
ranges.append(
'[%f, %f, %s]' %
(ran.lowerValue(), ran.upperValue(), symbolstyle))
defs += ",\n".join(ranges) + "];"
classAttr = renderer.classAttribute()
fieldIndex = layer.pendingFields().indexFromName(classAttr)
try:
editFormConfig = layer.editFormConfig()
editorWidget = editFormConfig.widgetType(fieldIndex)
except:
editorWidget = layer.editorWidgetV2(fieldIndex)
if (editorWidget == QgsVectorLayer.Hidden
or editorWidget == 'Hidden'):
classAttr = "q2wHide_" + classAttr
value = ('var value = feature.get("%s");' % classAttr)
style = '''var style = %(v)s[0][2];
for (i = 0; i < %(v)s.length; i++){
var range = %(v)s[i];
if (value > range[0] && value<=range[1]){
style = range[2];
}
}''' % {
"v": varName
}
elif isinstance(renderer, QgsRuleBasedRendererV2):
template = """
function rules_%s(feature, value) {
var context = {
feature: feature,
variables: {}
};
// Start of if blocks and style check logic
%s
else {
return %s;
}
}
var style = rules_%s(feature, value);
"""
elsejs = "[]"
js = ""
root_rule = renderer.rootRule()
rules = root_rule.children()
expFile = os.path.join(folder, "resources",
"qgis2web_expressions.js")
ifelse = "if"
for count, rule in enumerate(rules):
symbol = rule.symbol()
styleCode = getSymbolAsStyle(symbol, stylesFolder,
layer_alpha)
name = "".join((sln, "rule", unicode(count)))
exp = rule.filterExpression()
if rule.isElse():
elsejs = styleCode
continue
name = compile_to_file(exp, name, "OpenLayers3", expFile)
js += """
%s (%s(context)) {
return %s;
}
""" % (ifelse, name, styleCode)
js = js.strip()
ifelse = "else if"
value = ("var value = '';")
style = template % (sln, js, elsejs, sln)
else:
style = ""
if layer.customProperty("labeling/fontSize"):
size = float(layer.customProperty("labeling/fontSize")) * 1.3
else:
size = 10
italic = layer.customProperty("labeling/fontItalic")
bold = layer.customProperty("labeling/fontWeight")
r = layer.customProperty("labeling/textColorR")
g = layer.customProperty("labeling/textColorG")
b = layer.customProperty("labeling/textColorB")
color = "rgba(%s, %s, %s, 255)" % (r, g, b)
face = layer.customProperty("labeling/fontFamily")
palyr = QgsPalLayerSettings()
palyr.readFromLayer(layer)
sv = palyr.scaleVisibility
if sv:
min = float(palyr.scaleMin)
max = float(palyr.scaleMax)
min = 1 / ((1 / min) * 39.37 * 90.7)
max = 1 / ((1 / max) * 39.37 * 90.7)
labelRes = " && resolution > %(min)d " % {"min": min}
labelRes += "&& resolution < %(max)d" % {"max": max}
else:
labelRes = ""
buffer = palyr.bufferDraw
if buffer:
bufferColor = palyr.bufferColor.name()
bufferWidth = palyr.bufferSize
stroke = """
stroke: new ol.style.Stroke({
color: "%s",
width: %d
}),""" % (bufferColor, bufferWidth)
else:
stroke = ""
if style != "":
style = '''function(feature, resolution){
var context = {
feature: feature,
variables: {}
};
%(value)s
%(style)s;
if (%(label)s !== null%(labelRes)s) {
var labelText = String(%(label)s);
} else {
var labelText = ""
}
var key = value + "_" + labelText
if (!%(cache)s[key]){
var text = new ol.style.Text({
font: '%(size)spx \\'%(face)s\\', sans-serif',
text: labelText,
textBaseline: "center",
textAlign: "left",
offsetX: 5,
offsetY: 3,
fill: new ol.style.Fill({
color: '%(color)s'
}),%(stroke)s
});
%(cache)s[key] = new ol.style.Style({"text": text})
}
var allStyles = [%(cache)s[key]];
allStyles.push.apply(allStyles, style);
return allStyles;
}''' % {
"style": style,
"labelRes": labelRes,
"label": labelText,
"cache": "styleCache_" + sln,
"size": size,
"face": face,
"color": color,
"stroke": stroke,
"value": value
}
else:
style = "''"
except Exception, e:
style = """{
/* """ + traceback.format_exc() + " */}"
QgsMessageLog.logMessage(traceback.format_exc(),
"qgis2web",
level=QgsMessageLog.CRITICAL)
path = os.path.join(stylesFolder, sln + "_style.js")
with codecs.open(path, "w", "utf-8") as f:
f.write('''%(defs)s
var styleCache_%(name)s={}
var style_%(name)s = %(style)s;''' % {
"defs": defs,
"name": sln,
"style": style
})
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 testCreateCalloutProperty(self):
s = QgsAuxiliaryStorage()
self.assertTrue(s.isValid())
# Create a new auxiliary layer with 'pk' as key
vl = createLayer()
pkf = vl.fields().field(vl.fields().indexOf('pk'))
al = s.createAuxiliaryLayer(pkf, vl)
self.assertTrue(al.isValid())
vl.setAuxiliaryLayer(al)
# Create a new callout property on layer without labels
key = QgsCallout.DestinationX
index = QgsAuxiliaryLayer.createProperty(key, vl)
self.assertEqual(index, -1)
# Labeling, but no callouts
settings = QgsPalLayerSettings()
settings.setCallout(None)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
index = QgsAuxiliaryLayer.createProperty(key, vl)
self.assertEqual(index, -1)
# callouts
settings = QgsPalLayerSettings()
callout = QgsSimpleLineCallout()
callout.setEnabled(True)
settings.setCallout(callout)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
index = QgsAuxiliaryLayer.createProperty(key, vl)
p = QgsCallout.propertyDefinitions()[key]
afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
afIndex = vl.fields().indexOf(afName)
self.assertEqual(index, afIndex)
settings = vl.labeling().settings()
self.assertEqual(
settings.callout().dataDefinedProperties().property(key),
QgsProperty.fromField('auxiliary_storage_callouts_destinationx'))
key2 = QgsCallout.DestinationY
index = QgsAuxiliaryLayer.createProperty(key2, vl)
p = QgsCallout.propertyDefinitions()[key2]
afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
afIndex = vl.fields().indexOf(afName)
self.assertEqual(index, afIndex)
settings = vl.labeling().settings()
self.assertEqual(
settings.callout().dataDefinedProperties().property(key),
QgsProperty.fromField('auxiliary_storage_callouts_destinationx'))
self.assertEqual(
settings.callout().dataDefinedProperties().property(key2),
QgsProperty.fromField('auxiliary_storage_callouts_destinationy'))
# with existing property
key = QgsCallout.OriginX
settings = QgsPalLayerSettings()
callout = QgsSimpleLineCallout()
callout.dataDefinedProperties().setProperty(
key, QgsProperty.fromExpression('$x + 20'))
callout.setEnabled(True)
settings.setCallout(callout)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
# without overwriting existing, property should be upgraded to coalesce("aux field", 'existing expression') type
index = QgsAuxiliaryLayer.createProperty(key, vl, False)
p = QgsCallout.propertyDefinitions()[key]
afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
afIndex = vl.fields().indexOf(afName)
self.assertEqual(index, afIndex)
settings = vl.labeling().settings()
self.assertTrue(settings.callout().dataDefinedProperties().property(
key).isActive())
self.assertEqual(
settings.callout().dataDefinedProperties().property(
key).asExpression(),
'coalesce("auxiliary_storage_callouts_originx",$x + 20)')
# with overwrite existing
key = QgsCallout.OriginY
callout = QgsSimpleLineCallout()
callout.dataDefinedProperties().setProperty(
key, QgsProperty.fromExpression('$y + 20'))
settings.setCallout(callout)
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
# existing property should be discarded
index = QgsAuxiliaryLayer.createProperty(key, vl, True)
p = QgsCallout.propertyDefinitions()[key]
afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
afIndex = vl.fields().indexOf(afName)
self.assertEqual(index, afIndex)
settings = vl.labeling().settings()
self.assertTrue(settings.callout().dataDefinedProperties().property(
key).isActive())
self.assertEqual(
settings.callout().dataDefinedProperties().property(key).field(),
'auxiliary_storage_callouts_originy')
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 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):
"""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 = ReanalysisVisualizationDialog()
project = QgsProject.instance()
if not project.mapLayersByName('back'):
layer = QgsVectorLayer(
'./background/ne_110m_admin_0_countries.shp', "back", "ogr")
project.addMapLayer(layer)
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
params, variables, drawStyle, need_slideshow = self.dlg.prepare_form_data()
try:
root = QgsProject.instance().layerTreeRoot()
group = root.findGroup('contours')
if group:
group.removeAllChildren()
else:
group = root.addGroup("contours")
root.insertChildNode(-1,
QgsLayerTreeLayer(project.mapLayersByName('back')[0]))
root.removeLayer(project.mapLayersByName('back')[0])
data_grid = DataGrid(params, variables)
geojsons = Isolines(data_grid, drawStyle).get_geojsons()
for geojson in geojsons:
layer = QgsVectorLayer(
geojson['geojson'], "leadTime = " + str(geojson['leadTime']), "ogr")
layer.setOpacity(0.87)
# apply contour style properties
symbol_layer = layer.renderer().symbol().symbolLayers()[0]
symbol_layer.setDataDefinedProperty(
QgsSymbolLayer.PropertyStrokeColor, QgsProperty.fromField("stroke"))
symbol_layer.setDataDefinedProperty(
QgsSymbolLayer.PropertyFillColor, QgsProperty.fromField("fill"))
symbol_layer.setDataDefinedProperty(
QgsSymbolLayer.PropertyStrokeWidth, QgsProperty.fromField("stroke-width"))
# add labels
pal_layer = QgsPalLayerSettings()
pal_layer.fieldName = 'title'
pal_layer.enabled = True
pal_layer.placement = QgsPalLayerSettings.PerimeterCurved
pal_layer.placementFlags = QgsPalLayerSettings.OnLine
labeler = QgsVectorLayerSimpleLabeling(pal_layer)
layer.setLabeling(labeler)
layer.setLabelsEnabled(True)
# add vector layer with isolines
QgsProject.instance().addMapLayer(layer, False)
group.insertChildNode(-1, QgsLayerTreeLayer(layer))
group.setIsMutuallyExclusive(True, 0)
if need_slideshow:
slideshow = threading.Thread(
target=self.__change_active_layer, args=(group,))
slideshow.start()
except Exception as e:
error_text = ''
if (params['east'] > 180 or params['east'] < -180 or params['west'] > 180 or params['west'] < -180 or params['south'] > 90 or params['south'] < -90 or params['north'] > 90 or params['north'] < -90):
error_text += "Ошибка: Некорректно заданы координаты области"
else:
error_text += "Ошибка: \n" + str(e)
error_dialog = QErrorMessage()
error_dialog.showMessage(error_text)
error_dialog.exec_()
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 run(self):
#coloco el puntero arriba del todo
#QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint( QgsProject.instance().layerTreeRoot(), 0 )
#genero una lista con los campos de la capa selecionada
layer = iface.activeLayer()
if layer is None:
iface.messageBar().pushMessage("ATENCION",
"Selecciona una capa de puntos",
duration=10)
if layer.wkbType() == 1 or layer.wkbType() == 1001:
prov = layer.dataProvider()
field_names = [field.name() for field in prov.fields()]
self.dlg.mycomboBox.clear()
for element in field_names:
self.dlg.mycomboBox.addItem(element)
"""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
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
global index_campo_seleccionado
distanciaminima = int(self.dlg.lineEdit_distancia.text())
# "layer" is a QgsVectorLayer instance
layer = iface.activeLayer()
idx = layer.fields().indexFromName("distanc")
if idx == -1:
print("ya existe")
res = layer.dataProvider().addAttributes(
[QgsField("distanc", QVariant.String)])
#layer.addAttribute(QgsField("valido", QVariant.String))
layer.updateFields()
features = layer.getFeatures()
for feature in features:
# retrieve every feature with its geometry and attributes
#print("Feature ID: ", feature.id())
# fetch geometry
# show some information about the feature geometry
geom = feature.geometry()
geomSingleType = QgsWkbTypes.isSingleType(geom.wkbType())
if geom.type() == QgsWkbTypes.PointGeometry:
punto = geom.asPoint()
x = punto.x()
y = punto.y()
#print("analizo los puntos",x,y)
features2 = layer.getFeatures()
for feature2 in features2:
geom2 = feature2.geometry()
punto2 = geom2.asPoint()
x3 = punto2.x()
y3 = punto2.y()
d = ((x3 - x)**2 + (y3 - y)**2)**0.5
if d < distanciaminima:
if feature2.id() == feature.id():
pass
else:
layer.startEditing()
feature.setAttribute("distanc", 'no')
print(feature2.id())
layer.updateFeature(feature)
#Call commit to save the changes
layer.commitChanges()
categorias = []
sym = QgsMarkerSymbol.createSimple({
'name': 'circle',
'color': 'red',
'size': '3'
})
categoria = QgsRendererCategory("no", sym, "No cumple")
categorias.append(categoria)
sym = QgsMarkerSymbol.createSimple({
'name': 'circle',
'color': 'blue',
'size': '2'
})
categoria = QgsRendererCategory("", sym, "Cumple")
categorias.append(categoria)
renderer = QgsCategorizedSymbolRenderer("distanc", categorias)
layer.setRenderer(renderer)
# update layer's extent when new features have been added
# because change of extent in provider is not propagated to the layer
#Configure label settings
settings = QgsPalLayerSettings()
settings.fieldName = field_names[
index_campo_seleccionado] #'name'
textFormat = QgsTextFormat()
textFormat.setSize(10)
settings.setFormat(textFormat)
#create and append a new rule
root = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings())
rule = QgsRuleBasedLabeling.Rule(settings)
#rule.setDescription(fieldName)
rule.setFilterExpression(''' "distanc" = 'no' ''')
root.appendChild(rule)
#Apply label configuration
rules = QgsRuleBasedLabeling(root)
layer.setLabeling(rules)
layer.setLabelsEnabled(True)
layer.triggerRepaint()
else:
iface.messageBar().pushMessage("ATENCION",
"Selecciona una capa de puntos",
duration=10)
def save_pois_points(self,
points,
layername="Geopunt_poi",
saveToFile=None,
sender=None,
startFolder=None):
attributes = [
QgsField("id", QVariant.Int),
QgsField("thema", QVariant.String),
QgsField("categorie", QVariant.String),
QgsField("type", QVariant.String),
QgsField("naam", QVariant.String),
QgsField("telefoon", QVariant.String),
QgsField("email", QVariant.String),
#address
QgsField("straat", QVariant.String),
QgsField("huisnr", QVariant.String),
QgsField("busnr", QVariant.String),
QgsField("postcode", QVariant.String),
QgsField("gemeente", QVariant.String),
QgsField("link", QVariant.String),
QgsField("lastupdate", QVariant.String),
QgsField("owner", QVariant.String)
]
if not QgsProject.instance().mapLayer(self.poilayerid):
self.poilayer = QgsVectorLayer("Point", layername, "memory")
self.poiProvider = self.poilayer.dataProvider()
self.poiProvider.addAttributes(attributes)
self.poilayer.updateFields()
fields = self.poilayer.fields()
for point in points:
pt = QgsPointXY(
point['location']['points'][0]['Point']['coordinates'][0],
point['location']['points'][0]['Point']['coordinates'][1])
poiId = point["id"]
if "categories" in list(
point.keys()) and len(point["categories"]) > 0:
theme = point["categories"][0]['value']
else:
theme = ''
if "categories" in list(
point.keys()) and len(point["categories"]) > 1:
category = point["categories"][1]['value']
else:
category = ''
if "categories" in point and len(point["categories"]) > 2:
poiType = point["categories"][2]['value']
else:
poiType = ''
name = point["labels"][0]["value"]
if "phone" in list(point.keys()):
phone = point["phone"]
else:
phone = ""
if "email" in list(point.keys()):
email = point["email"]
else:
email = ""
#address
if "address" in list(point['location'].keys()):
if "street" in list(point['location']["address"].keys()):
straat = point['location']["address"]["street"]
else:
straat = ''
if "streetnumber" in list(point['location']["address"].keys()):
huisnr = point['location']["address"]["streetnumber"]
else:
huisnr = ''
if "boxnumber" in list(point['location']["address"].keys()):
busnr = point['location']["address"]["boxnumber"]
else:
boxnr = ''
postcode = point['location']["address"]["postalcode"]
gemeente = point['location']["address"]["municipality"]
else:
straat = ""
huisnr = ""
busnr = ""
postcode = ""
gemeente = ""
if "links" in point:
link = point["links"][0]['href']
else:
link = ""
tijd = point["updated"]
if "authors" in point:
owner = point["authors"][0]["value"]
else:
owner = ""
# add a feature
fet = QgsFeature(fields)
#set geometry
fromCrs = QgsCoordinateReferenceSystem(4326)
xform = QgsCoordinateTransform(fromCrs, self.poilayer.crs(),
QgsProject.instance())
prjPt = xform.transform(pt)
fet.setGeometry(QgsGeometry.fromPointXY(prjPt))
fet['id'] = int(poiId)
fet['thema'] = theme
fet['categorie'] = category
fet['type'] = poiType
fet['naam'] = name
fet["email"] = email
fet["telefoon"] = phone
#address
fet['straat'] = straat
fet['huisnr'] = huisnr
fet['busnr'] = busnr
fet['postcode'] = postcode
fet['gemeente'] = gemeente
fet['link'] = link
fet['lastupdate'] = tijd
fet['owner'] = owner
self.poiProvider.addFeatures([fet])
self.poilayer.updateExtents()
if saveToFile and not QgsProject.instance().mapLayer(self.poilayerid):
save = self._saveToFile(sender, startFolder)
if save:
fpath, flType = save
error, msg = QgsVectorFileWriter.writeAsVectorFormat(
self.poilayer,
fileName=fpath,
fileEncoding="utf-8",
driverName=flType)
if error == QgsVectorFileWriter.NoError:
self.poilayer = QgsVectorLayer(fpath, layername, "ogr")
self.poiProvider = self.poilayer.dataProvider()
else:
del self.poilayer, self.poiProvider
raise Exception(msg)
else:
del self.poilayer, self.poiProvider
return
# add Labels
text_format = QgsTextFormat()
text_format.setSize(12)
buffer_settings = QgsTextBufferSettings()
buffer_settings.setEnabled(True)
buffer_settings.setSize(1)
buffer_settings.setColor(QColor("white"))
palyr = QgsPalLayerSettings()
text_format.setBuffer(buffer_settings)
palyr.setFormat(text_format)
palyr.enabled = True
palyr.fieldName = 'naam'
palyr.placement = QgsPalLayerSettings.Free
self.poilayer.setLabelsEnabled(True)
self.poilayer.setLabeling(QgsVectorLayerSimpleLabeling(palyr))
# add layer if not already
QgsProject.instance().addMapLayer(self.poilayer)
# store layer id and refresh
self.poilayerid = self.poilayer.id()
self.canvas.refresh()
def getLabels(layer, safeLayerName, outputProjectFileName):
label_exp = ''
labeltext = ""
f = ''
palyr = QgsPalLayerSettings()
palyr.readFromLayer(layer)
if palyr.enabled and palyr.fieldName and palyr.fieldName != "":
bgColor = palyr.shapeFillColor.name()
borderWidth = palyr.shapeBorderWidth
borderColor = palyr.shapeBorderColor.name()
x = palyr.shapeSize.x()
y = palyr.shapeSize.y()
font = palyr.textFont
fontSize = font.pointSize()
fontFamily = font.family()
fontItalic = font.italic()
fontBold = font.bold()
fontColor = palyr.textColor.name()
fontUnderline = font.underline()
xOffset = palyr.xOffset
yOffset = palyr.yOffset
styleStart = "'<div style=\"color: %s; font-size: %dpt; " % (fontColor,
fontSize)
if palyr.shapeDraw:
styleStart += "background-color: %s; " % bgColor
styleStart += "border: %dpx solid %s; " % (borderWidth,
borderColor)
if palyr.shapeSizeType == 0:
styleStart += "padding: %dpx %dpx; " % (y, x)
if palyr.shapeSizeType == 1:
styleStart += "width: %dpx; " % x
styleStart += "height: %dpx; " % y
if fontBold:
styleStart += "font-weight: bold; "
if fontItalic:
styleStart += "font-style: italic; "
styleStart += "font-family: \\'%s\\', sans-serif;\">' + " % fontFamily
styleEnd = " + '</div>'"
if palyr.isExpression and palyr.enabled:
exprFilename = os.path.join(outputProjectFileName, "js",
"qgis2web_expressions.js")
name = compile_to_file(palyr.getLabelExpression(),
"label_%s" % safeLayerName, "Leaflet",
exprFilename)
js = "%s(context)" % (name)
js = js.strip()
f = js
else:
fn = palyr.fieldName
f = "layer.feature.properties['%s']" % handleHiddenField(layer, fn)
labeltext = ".bindTooltip((" + unicode(f)
labeltext += " !== null?String(%s%s)%s:'')" % (styleStart, unicode(f),
styleEnd)
labeltext += ", {permanent: true, offset: [-0, -16], "
labeltext += "className: 'css_%s'}" % safeLayerName
labeltext += ").openTooltip();"
labeltext = """
layer_%s.eachLayer(function(layer) {
layer%s
});""" % (safeLayerName, labeltext)
else:
labeltext = ""
return labeltext
def parse_xml(self):
"""Parse the xml file. Returns false if there is failure."""
xml_file = QFile(self._xml_path)
if not xml_file.open(QIODevice.ReadOnly):
return False
document = QDomDocument()
if not document.setContent(xml_file):
return False
xml_file.close()
document_element = document.documentElement()
if document_element.tagName() != "qgis_style":
return False
# Get all the symbols
self._symbols = []
symbols_element = document_element.firstChildElement("symbols")
symbol_element = symbols_element.firstChildElement()
context = QgsReadWriteContext()
context.setPathResolver(QgsProject.instance().pathResolver())
while not symbol_element.isNull():
if symbol_element.tagName() == "symbol":
symbol = QgsSymbolLayerUtils.loadSymbol(
symbol_element, context)
if symbol:
self._symbols.append({
"name":
symbol_element.attribute("name"),
"symbol":
symbol
})
symbol_element = symbol_element.nextSiblingElement()
# Get all the colorramps
self._colorramps = []
ramps_element = document_element.firstChildElement("colorramps")
ramp_element = ramps_element.firstChildElement()
while not ramp_element.isNull():
if ramp_element.tagName() == "colorramp":
colorramp = QgsSymbolLayerUtils.loadColorRamp(ramp_element)
if colorramp:
self._colorramps.append({
"name":
ramp_element.attribute("name"),
"colorramp":
colorramp
})
ramp_element = ramp_element.nextSiblingElement()
# Get all the TextFormats - textformats - textformat
self._textformats = []
textformats_element = document_element.firstChildElement("textformats")
textformat_element = textformats_element.firstChildElement()
while not textformat_element.isNull():
if textformat_element.tagName() == "textformat":
textformat = QgsTextFormat()
textformat.readXml(textformat_element, QgsReadWriteContext())
if textformat:
self._textformats.append({
"name":
textformat_element.attribute("name"),
"textformat":
textformat,
})
textformat_element = textformat_element.nextSiblingElement()
# Get all the LabelSettings - labelsettings - labelsetting -
# QgsPalLayerSettings.readXML?
self._labelsettings = []
labels_element = document_element.firstChildElement("labelsettings")
label_element = labels_element.firstChildElement()
while not label_element.isNull():
if label_element.tagName() == "labelsetting":
labelsettings = QgsPalLayerSettings()
labelsettings.readXml(label_element, QgsReadWriteContext())
if labelsettings:
self._labelsettings.append({
"name":
label_element.attribute("name"),
"labelsettings":
labelsettings,
})
label_element = label_element.nextSiblingElement()
return True
def utmGridlabelPlacer(self, root_rule, grid_spacing, extentsGeo,
extentsUTM, px, py, UTM_num_x, UTM_num_y, trUTMLL,
trLLUTM, dx, dy, dy0, dy1, fSize, fontType, scale,
geo_bb_or, layer_bound):
if grid_spacing > 0:
# Bottom
ruletest = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings())
ruletest = self.utm_grid_labeler(
ruletest, extentsUTM[0], extentsUTM[1], 0, extentsGeo[1],
extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, 1,
True, dx[0], dy[1], dy0[1], 0, 'UTMBotTest', fSize, fontType,
grid_spacing, scale, range(1), geo_bb_or, layer_bound)
rulechild = ruletest.children()[0]
if rulechild.settings().fieldName == 'fail':
rangeUD = range(2, UTM_num_x + 1)
else:
rangeUD = range(1, UTM_num_x + 1)
for u in rangeUD:
root_rule = self.utm_grid_labeler(
root_rule, extentsUTM[0], extentsUTM[1], 0, extentsGeo[1],
extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, u,
True, dx[0], dy[1], dy0[1] + 0.4 * (scale) * fSize / 1.5,
0, 'UTMBot' + str(u), fSize, fontType, grid_spacing, scale,
rangeUD, geo_bb_or, layer_bound)
# Upper
rangeUD = range(1, UTM_num_x + 1)
for u in rangeUD:
root_rule = self.utm_grid_labeler(
root_rule, extentsUTM[0], extentsUTM[3], 0, extentsGeo[3],
extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, u,
True, dx[1], dy[0], dy0[0] - 1.3 * (scale) * fSize / 1.5,
0, 'UTMUp' + str(u), fSize, fontType, grid_spacing, scale,
rangeUD, geo_bb_or, layer_bound)
# Left
ruletest = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings())
ruletest = self.utm_grid_labeler(
ruletest, extentsUTM[0], extentsUTM[1], extentsGeo[0], 0,
extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, 1,
False, dx[2], dy[3], dy0[3],
dy1[1], 'UTMLeftTest', fSize, fontType, grid_spacing, scale,
range(1), geo_bb_or, layer_bound)
rulechild = ruletest.children()[0]
if rulechild.settings().fieldName == 'fail':
rangeLat = range(2, UTM_num_y + 1)
else:
rangeLat = range(1, UTM_num_y + 1)
for u in rangeLat:
if u == min(rangeLat):
extra_dist = -3.2 * scale * fSize / 1.5
else:
extra_dist = 0
root_rule = self.utm_grid_labeler(
root_rule, extentsUTM[0], extentsUTM[1], extentsGeo[0], 0,
extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, u,
False, dx[2] + extra_dist, dy[3], dy0[3], dy1[1],
'UTMLeft' + str(u), fSize, fontType, grid_spacing, scale,
rangeLat, geo_bb_or, layer_bound)
# Right
rangeLat = range(1, UTM_num_y + 1)
for u in rangeLat:
root_rule = self.utm_grid_labeler(
root_rule, extentsUTM[2], extentsUTM[1], extentsGeo[2], 0,
extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, u,
False, dx[3], dy[3], dy0[3], dy1[1], 'UTMRight' + str(1),
fSize, fontType, grid_spacing, scale, rangeLat, geo_bb_or,
layer_bound)
return root_rule
def get_style(self):
"""Get map styles. Get Fill color, label font, outline color.
This function takes layer as input and configures style dictionary
which is sent as HTTP request in order to adequatly represent
map style on GIS Cloud.
"""
LOGGER.debug('Started map_styles function')
if ISQGIS3:
self.scale_pixels = \
iface.mapCanvas().mapSettings().outputDpi() / 72
else:
self.scale_pixels = \
iface.mapCanvas().mapRenderer().outputDpi() / 72
self.unit_to_px = {
"MM": 3.78 * self.scale_pixels,
"Point": 1.33 * self.scale_pixels,
"Inch": 96 * self.scale_pixels,
# these two aren't yet supported by GC rendering,
# so defaulting them to value of 1 px
"MapUnit": None,
"RenderMetersInMapUnits": None
}
layer_fromlevel = 0
layer_tolevel = 0
if self.qgis_layer.hasScaleBasedVisibility():
dpi = iface.mainWindow().physicalDpiX()
max_scale_per_pixel = 156543.04
inches_per_meter = 39.37
factor = dpi * inches_per_meter * max_scale_per_pixel
if self.qgis_layer.minimumScale() > 0:
layer_fromlevel = int(
round(
math.log((factor / self.qgis_layer.minimumScale()), 2),
0))
if self.qgis_layer.maximumScale() > 0:
layer_tolevel = int(
round(
math.log((factor / self.qgis_layer.maximumScale()), 2),
0))
if not ISQGIS3:
# QGis2 has oposite logic with min/max scales
# so we need to switch them
(layer_tolevel, layer_fromlevel) = \
(layer_fromlevel, layer_tolevel)
styles = []
tmp_dir = self.gc_api.qgis_api.tmp_dir
if ISQGIS3:
renderer = QgsRuleBasedRenderer.convertFromRenderer(
self.qgis_layer.renderer())
else:
renderer = QgsRuleBasedRendererV2.convertFromRenderer(
self.qgis_layer.rendererV2())
for rule in renderer.rootRule().children():
symbol = rule.symbol()
sym_size = 0
if self.layer.type[0] == "point":
for layer_sym in symbol.symbolLayers():
temp_style = layer_sym.properties()
self.convert_units_to_px(temp_style)
if "size" in temp_style and \
float(temp_style["size"]) > sym_size:
sym_size = float(temp_style["size"])
is_first_sym = True
index = symbol.symbolLayerCount()
while index > 0:
index = index - 1
layer_sym = symbol.symbolLayer(index)
temp_style = layer_sym.properties()
self.convert_units_to_px(temp_style)
val_label = None
# in case of multiple symbolLayers()
# labels should be set only once
if is_first_sym:
if ISQGIS3:
if self.qgis_layer.labelsEnabled():
val_label = self.qgis_layer.labeling().settings()
else:
val_label = QgsPalLayerSettings()
val_label.readFromLayer(self.qgis_layer)
style = {}
line_style = "line_style"
line_width = 0
if self.layer.type[0] == "point":
size = int(round(sym_size)) + 2
md5 = hashlib.md5()
properties = str(temp_style) + self.dump_symbol_properties(
layer_sym.subSymbol())
md5.update(properties.encode('utf-8'))
symbol_file = "{}_{}.png".format(self.layer.id,
md5.hexdigest())
style['iconsoverlap'] = 2
style['url'] = {
"full_path": tmp_dir + '/' + symbol_file,
"file": symbol_file,
"symbol": symbol.clone(),
"size": QSize(size, size)
}
elif self.layer.type[0] == "line":
LOGGER.info('entered line_type part of function')
LOGGER.info(temp_style)
try:
if u'line_color' in temp_style:
style['color'] = ','.join(
temp_style[u'line_color'].split(',')[0:3])
style['bordercolor'] = style['color']
if u'line_width' in temp_style:
style['width'] = temp_style[u'line_width']
else:
style['width'] = '1'
line_width = float(style['width'])
except Exception:
LOGGER.info(
'Failed while mapping style for line vector layer',
exc_info=True)
if ('color' or 'bordercolor') not in style:
style['color'] = '0,0,0'
style['bordercolor'] = '0,0,0'
LOGGER.info('Style is{}'.format(style))
# VectorPolygonLayer styles -> dashed line
# and offset possibilities
elif self.layer.type[0] == "polygon":
line_style = "outline_style"
has_border = not ("outline_style" in temp_style
and temp_style["outline_style"] == "no")
if layer_sym.layerType() == 'SimpleFill':
if u'outline_color' in temp_style and has_border:
style['bordercolor'] = \
','.join(
temp_style[u'outline_color']
.split(',')[0:3])
if u'outline_width' in temp_style and has_border:
style['borderwidth'] = temp_style[u'outline_width']
if u'color' in temp_style and \
"style" in temp_style and \
temp_style["style"] == "solid":
style['color'] = ','.join(
temp_style[u'color'].split(',')[0:3])
elif layer_sym.layerType() == 'SimpleLine':
if u'line_color' in temp_style:
style['bordercolor'] = \
','.join(
temp_style[u'line_color']
.split(',')[0:3])
if u'line_width' in temp_style:
style['line_width'] = temp_style[u'line_width']
elif u'color1' in temp_style:
style['color'] = ','.join(
temp_style[u'color1'].split(',')[0:3])
style['borderwidth'] = '1'
if has_border:
style['bordercolor'] = '0,0,0'
else:
style['bordercolor'] = '0,0,0'
if has_border:
style['borderwidth'] = '1'
style['color'] = '0,0,0'
if "borderwidth" in style:
line_width = float(style['borderwidth'])
if (layer_sym.layerType() != "SimpleFill" and
layer_sym.layerType() != "SimpleLine") or \
("style" in temp_style and
not temp_style["style"] in ["solid", "no"]):
if layer_sym.layerType() != "SimpleFill":
temp_symbol = symbol.clone()
tmp_sym_layer = temp_symbol.symbolLayer(index)
while temp_symbol.symbolLayerCount() > 1:
if temp_symbol.symbolLayer(0) == tmp_sym_layer:
temp_symbol.deleteSymbolLayer(1)
else:
temp_symbol.deleteSymbolLayer(0)
else:
temp_style_hatch = temp_style.copy()
temp_style_hatch["outline_style"] = "no"
if ISQGIS3:
temp_symbol = QgsFillSymbol.createSimple(
temp_style_hatch)
else:
temp_symbol = QgsFillSymbolV2.createSimple(
temp_style_hatch)
properties = self.dump_symbol_properties(temp_symbol)
md5 = hashlib.md5()
md5.update(properties.encode('utf-8'))
symbol_file = "{}_{}.png"\
.format(self.layer.id, md5.hexdigest())
style['hatchUrl'] = {
"full_path": tmp_dir + '/' + symbol_file,
"file": symbol_file,
"symbol": temp_symbol,
"size": QSize(64, 64)
}
if "use_custom_dash" in temp_style and \
temp_style["use_custom_dash"] == '1':
style['dashed'] = temp_style[u'customdash'].replace(
';', ',')
if ("dashed" not in style and line_style in temp_style
and not temp_style[line_style] in ["solid", "no"]):
process_dash_param(temp_style[line_style], line_width,
style)
if ISQGIS3:
if val_label is not None:
label_format = val_label.format()
style['fontsize'] = label_format.size()
style['labelfield'] = val_label.fieldName.lower()
style['fontcolor'] = \
rgb_int2tuple(label_format.color().rgb())
if label_format.buffer().enabled():
style['outline'] = \
rgb_int2tuple(
label_format.buffer().color().rgb())
if self.qgis_layer.geometryType() == 1:
style['labelfield'] = ''
style['textfield'] = val_label.fieldName.lower()
if str(label_format.font().family()) in \
self.supported_fonts:
style['fontname'] = label_format.font().family()
else:
style['fontname'] = 'Arial'
LOGGER.info(
("Choosen font is not supported, " +
"so every font style has been changed " +
"to {0}").format(style['fontname']))
self.setup_label_offset(val_label, style)
else:
if val_label is not None and val_label.enabled:
style['fontsize'] = val_label.textFont.pointSize()
style['labelfield'] = val_label.fieldName.lower()
style['fontcolor'] = rgb_int2tuple(
val_label.textColor.rgb())
if val_label.bufferDraw:
style['outline'] = rgb_int2tuple(
val_label.bufferColor.rgb())
if self.qgis_layer.geometryType() == 1:
style['labelfield'] = ''
style['textfield'] = val_label.fieldName.lower()
if str(val_label.textFont.family()) in \
self.supported_fonts:
style['fontname'] = val_label.textFont.family()
else:
style['fontname'] = 'Arial'
LOGGER.info("Choosen font is not supported, so " +
"every font style has been changed " +
" to {0}".format(style['fontname']))
self.setup_label_offset(val_label, style)
if rule.filterExpression():
style['expression'] = rule.filterExpression().replace(
'"', '')
expression = self.qgis_layer.subsetString().replace('"', '')
if expression and expression != '':
if 'expression' in style and style['expression'] != '':
style['expression'] = "(" + \
style['expression'] + \
") AND (" + expression + ")"
else:
style['expression'] = expression
if rule.label():
style['label'] = rule.label()
style['showlabel'] = 't' \
if val_label is not None and \
'labelfield' in style \
else 'f'
style['visible'] = '1'
if self.qgis_layer.hasScaleBasedVisibility():
factor = dpi * inches_per_meter * max_scale_per_pixel
if ISQGIS3 and rule.minimumScale() > 0:
style['fromlevel'] = \
int(round(
math.log((factor / rule.minimumScale()), 2),
0))
elif layer_fromlevel > 0:
style['fromlevel'] = layer_fromlevel
if ISQGIS3 and rule.maximumScale() > 0:
style['tolevel'] = \
int(round(
math.log((factor / rule.maximumScale()), 2),
0))
elif layer_tolevel > 0:
style['tolevel'] = layer_tolevel
if 'borderwidth' in styles and \
style['borderwidth'] and \
float(style['borderwidth']) < 1:
style['borderwidth'] = '1'
key = "hatchUrl" if "hatchUrl" in style else "url"
if key in style:
asset = style[key]
self.layer.assets.append(asset)
LOGGER.info('URL for image upload: {}'.format(
asset["file"]))
style[key] = '/{}/qgis/map{}/{}'.format(
self.gc_api.user.user_md5, self.gc_api.map.map_id,
asset["file"])
styles.append(style)
is_first_sym = False
# all point styles are merged into one as we export the symbol
# so it's not required to iterrate symbolLayers()
if self.layer.type[0] == "point":
break
LOGGER.info('Styles function output {}'.format(styles))
LOGGER.debug('Finished map_styles function')
return styles
def run_open_pli(self):
file = QFileDialog.getOpenFileName(
self.dlg, "Select pli-file ", self.directory,
'*') # .ldb,*.pol,*.pli,*.xyn,*.xyz')
# file = r'd:\projecten\11200569_Maas_G6\20171114 Deltashell2\files\dflowfm\invoer\j17_5-v1_landboundaries.ldb'
self.directory, filename = os.path.split(file)
layername, extension = os.path.splitext(filename)
print(layername)
if extension == '.xyz' or extension == '.xyn':
vl = QgsVectorLayer("Point", layername, "memory")
QgsMapLayerRegistry.instance().addMapLayer(vl)
pr = vl.dataProvider()
# add fields
if extension == 'xyz':
attribute = 'z'
else:
attribute = 'name'
pr.addAttributes([QgsField(attribute, QVariant.String)])
vl.updateFields(
) # tell the vector layer to fetch changes from the provider
with open(file) as f:
for line in f:
ls = line.strip().split('\t')
X = float(ls[0])
Y = float(ls[1])
Z = ls[2]
fet = QgsFeature()
fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(X, Y)))
fet.setAttributes([Z])
pr.addFeatures([fet])
# update layer's extent when new features have been added
# because change of extent in provider is not propagated to the layer
vl.updateExtents()
else:
D = tek.tekal(file) # initialize
D.info(file) # get file meta-data: all blocks
vl = QgsVectorLayer("LineString", layername, "memory")
QgsMapLayerRegistry.instance().addMapLayer(vl)
pr = vl.dataProvider()
attribute = "name"
# add fields
pr.addAttributes([QgsField(attribute, QVariant.String)])
vl.updateFields(
) # tell the vector layer to fetch changes from the provider
for ii in range(len(D.blocks)):
Name = D.blocks[ii].name
M = D.read(ii)
P = []
for ix in range(len(M[0])):
P.append(QgsPoint(M[0][ix], M[1][ix]))
# If line of just one points: duplicate
if ix == 0:
P.append(QgsPoint(M[0][ix] + 0.01, M[1][ix] + 0.01))
# add a feature
fet = QgsFeature()
fet.setGeometry(QgsGeometry.fromPolyline(P))
fet.setAttributes([Name])
pr.addFeatures([fet])
# update layer's extent when new features have been added
# because change of extent in provider is not propagated to the layer
vl.updateExtents()
# Enable labels
if attribute == 'name':
label = QgsPalLayerSettings()
label.readFromLayer(vl)
label.enabled = True
label.fieldName = attribute
label.writeToLayer(vl)
def getLabels(layer, safeLayerName, outputProjectFileName, vts, vtLabels):
label_exp = ''
labeltext = ""
f = ''
palyr = QgsPalLayerSettings()
palyr.readFromLayer(layer)
if palyr.enabled and palyr.fieldName and palyr.fieldName != "":
bgColor = palyr.shapeFillColor.name()
borderWidth = palyr.shapeBorderWidth
borderColor = palyr.shapeBorderColor.name()
x = palyr.shapeSize.x()
y = palyr.shapeSize.y()
font = palyr.textFont
fontSize = font.pointSize()
fontFamily = font.family()
fontItalic = font.italic()
fontBold = font.bold()
fontColor = palyr.textColor.name()
fontUnderline = font.underline()
xOffset = palyr.xOffset
yOffset = palyr.yOffset
styleStart = "'<div style=\"color: %s; font-size: %dpt; " % (fontColor,
fontSize)
if palyr.shapeDraw:
styleStart += "background-color: %s; " % bgColor
styleStart += "border: %dpx solid %s; " % (borderWidth,
borderColor)
if palyr.shapeSizeType == 0:
styleStart += "padding: %dpx %dpx; " % (y, x)
if palyr.shapeSizeType == 1:
styleStart += "width: %dpx; " % x
styleStart += "height: %dpx; " % y
if fontBold:
styleStart += "font-weight: bold; "
if fontItalic:
styleStart += "font-style: italic; "
styleStart += "font-family: \\'%s\\', sans-serif;\">' + " % fontFamily
styleEnd = " + '</div>'"
if palyr.isExpression and palyr.enabled:
exprFilename = os.path.join(outputProjectFileName, "js",
"qgis2web_expressions.js")
name = compile_to_file(palyr.getLabelExpression(),
"label_%s" % safeLayerName, "Leaflet",
exprFilename)
js = "%s(context)" % (name)
js = js.strip()
f = js
else:
fn = palyr.fieldName
f = "layer.feature.properties['%s']" % handleHiddenField(layer, fn)
labeltext = ".bindTooltip((" + unicode(f)
labeltext += " !== null?String(%s%s)%s:'')" % (styleStart, unicode(f),
styleEnd)
labeltext += ", {permanent: true, offset: [-0, -16], "
labeltext += "className: 'css_%s'}" % safeLayerName
labeltext += ");"
if vts is None:
labeltext = """
var i = 0;
layer_%s.eachLayer(function(layer) {
var context = {
feature: layer.feature,
variables: {}
};
layer%s
labels.push(layer);
totalMarkers += 1;
layer.added = true;
addLabel(layer, i);
i++;
});""" % (safeLayerName, labeltext)
else:
if palyr.isExpression and palyr.enabled:
labelVal = f
else:
labelVal = "feature.properties['%s']" % palyr.fieldName
labeltext = """
if (vtLayer.name === '%s') {
var latlng = this.vtGeometryToLatLng(feature.geometry[0],
vtLayer, tileCoords)
marker = new L.CircleMarker(latlng,
{stroke: false, fill: false});
marker.bindTooltip(%s,
{permanent: true,
direction: 'center'}).openTooltip();
this.addUserLayer(marker, tileCoords);
}""" % (layer.name(), labelVal)
if vts not in vtLabels:
vtLabels[vts] = labeltext
else:
vtLabels[vts] = vtLabels[vts] + labeltext
labeltext = ""
else:
labeltext = ""
return labeltext, vtLabels
def utmGridlabelPlacer(self, root_rule, grid_spacing, geo_bound_bb,
bound_UTM_bb, geo_number_x, geo_number_y, UTM_num_x,
UTM_num_y, trUTMLL, trLLUTM, dx, dy, dy0, dy1,
fSize, fontType, scale, utmcheck, geo_bb_or):
xmin_source = float(geo_bound_bb.split()[1])
ymin_source = float(geo_bound_bb.split()[2])
xmax_source = float(geo_bound_bb.split()[3])
ymax_source = float(geo_bound_bb.split()[4])
xmin_UTM = float(bound_UTM_bb.split()[1])
ymin_UTM = float(bound_UTM_bb.split()[2])
xmax_UTM = float(bound_UTM_bb.split()[3])
ymax_UTM = float(bound_UTM_bb.split()[4])
px = (xmax_source - xmin_source) / (geo_number_x + 1)
py = (ymax_source - ymin_source) / (geo_number_y + 1)
if grid_spacing > 0:
# Bottom
ruletest = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings())
ruletest = self.utm_grid_labeler(
ruletest, xmin_UTM, ymin_UTM, 0, ymin_source, px, py, trUTMLL,
trLLUTM, 1, True, 0, dy[1] + 0.4 * (scale) * fSize / 1.5,
dy0[1] + 0.4 * (scale) * fSize / 1.5, 0, 'Top', 'Center',
'UTMBotTest', fSize, fontType, grid_spacing, scale, utmcheck,
geo_bound_bb, range(1), geo_bb_or)
rulechild = ruletest.children()[0]
if rulechild.settings().fieldName == 'fail':
rangeUD = range(2, UTM_num_x + 1)
else:
rangeUD = range(1, UTM_num_x + 1)
for u in rangeUD:
root_rule = self.utm_grid_labeler(
root_rule, xmin_UTM, ymin_UTM, 0, ymin_source, px, py,
trUTMLL, trLLUTM, u, True, 0,
dy[1] + 0.4 * (scale) * fSize / 1.5,
dy0[1] + 0.4 * (scale) * fSize / 1.5, 0, 'Top', 'Center',
'UTMBot' + str(u), fSize, fontType, grid_spacing, scale,
utmcheck, geo_bound_bb, rangeUD, geo_bb_or)
# Upper
rangeUD = range(1, UTM_num_x + 1)
for u in rangeUD:
root_rule = self.utm_grid_labeler(
root_rule, xmin_UTM, ymax_UTM, 0, ymax_source, px, py,
trUTMLL, trLLUTM, u, True, 0,
dy[0] - 1.3 * (scale) * fSize / 1.5,
dy0[0] - 1.3 * (scale) * fSize / 1.5, 0, 'Bottom',
'Center', 'UTMUp' + str(u), fSize, fontType, grid_spacing,
scale, utmcheck, geo_bound_bb, rangeUD, geo_bb_or)
# Left
ruletest = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings())
ruletest = self.utm_grid_labeler(
ruletest, xmin_UTM, ymin_UTM, xmin_source, 0, px, py, trUTMLL,
trLLUTM, 1, False, dx[2] - 3.1 * scale * fSize / 1.5, dy[3],
dy0[3], dy1[1], 'Bottom', 'Center', 'UTMLeftTest',
fSize, fontType, grid_spacing, scale, utmcheck, geo_bound_bb,
range(1), geo_bb_or)
rulechild = ruletest.children()[0]
if rulechild.settings().fieldName == 'fail':
rangeLat = range(2, UTM_num_y + 1)
else:
rangeLat = range(1, UTM_num_y + 1)
for u in rangeLat:
if u == min(rangeLat):
extra_dist = -2.0 * scale * fSize / 1.5
else:
extra_dist = 0
root_rule = self.utm_grid_labeler(
root_rule, xmin_UTM, ymin_UTM, xmin_source, 0, px, py,
trUTMLL, trLLUTM, u, False, dx[2] + extra_dist, dy[3],
dy0[3], dy1[1], 'Bottom', 'Center', 'UTMLeft' + str(u),
fSize, fontType, grid_spacing, scale, utmcheck,
geo_bound_bb, rangeLat, geo_bb_or)
# Right
rangeLat = range(1, UTM_num_y + 1)
for u in rangeLat:
root_rule = self.utm_grid_labeler(
root_rule, xmax_UTM, ymin_UTM, xmax_source, 0, px, py,
trUTMLL, trLLUTM, u, False, dx[3], dy[3], dy0[3], dy1[1],
'', 'Center', 'UTMRight' + str(1), fSize, fontType,
grid_spacing, scale, utmcheck, geo_bound_bb, rangeLat,
geo_bb_or)
return root_rule
def getPopups(layer, safeLayerName, highlight, popupsOnHover, popup, vts):
if vts is not None:
return "", ""
palyr = QgsPalLayerSettings()
palyr.readFromLayer(layer)
fields = layer.pendingFields()
field_names = popup.keys()
field_vals = popup.values()
html_prov = False
f = palyr.fieldName
table = ""
for field in popup:
tablestart = "'<table>\\"
row = ""
for field, val in zip(field_names, field_vals):
fieldIndex = fields.indexFromName(unicode(field))
formCfg = layer.editFormConfig()
editorWidget = formCfg.widgetType(fieldIndex)
if (editorWidget == QgsVectorLayer.Hidden
or editorWidget == 'Hidden'):
continue
row += """
<tr>\\"""
if val == 'inline label':
row += """
<th scope="row">"""
row += layer.attributeDisplayName(fieldIndex)
row += """</th>\\
<td>"""
else:
row += """
<td colspan="2">"""
if val == "header label":
row += '<strong>'
row += layer.attributeDisplayName(fieldIndex)
row += '</strong><br />'
row += "' + "
row += "(feature.properties[\'" + unicode(field) + "\'] "
row += "!== null ? "
if (editorWidget == QgsVectorLayer.Photo
or editorWidget == 'Photo'):
row += "'<img src=\"images/' + "
row += "String(feature.properties['" + unicode(field)
row += "']).replace(/[\\\/:]/g, '_').trim()"
row += " + '\">' : '') + '"
else:
row += "Autolinker.link("
row += "String(feature.properties['" + unicode(field)
row += "'])) : '') + '"
row += """</td>\\
</tr>\\"""
tableend = """
</table>'"""
table = tablestart + row + tableend
if popup != 0 and table != "":
popFuncs = popFuncsScript(table)
else:
popFuncs = ""
new_pop = popupScript(safeLayerName, popFuncs, highlight, popupsOnHover)
return new_pop, popFuncs
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 convert2CartoCSS(self, layer):
"""Convert layer symbology to CartoCSS"""
renderer = layer.rendererV2()
carto_css = ''
label_css = ''
label_settings = QgsPalLayerSettings()
label_settings.readFromLayer(layer)
if label_settings.enabled:
d = {
'layername': '#' + layer.tableName(),
'field': label_settings.getLabelExpression().dump(),
# TODO Get font size
'size': 11,
'color': label_settings.textColor.name()
}
filein = open(QgisCartoDB.CartoDBPlugin.PLUGIN_DIR + '/templates/labels.less')
label_css = Template(filein.read())
label_css = label_css.substitute(d)
# qDebug('Label CSS: ' + label_css)
# CSS for single symbols
if renderer.type() == 'singleSymbol':
symbol = renderer.symbol()
carto_css = self.symbol2CartoCSS(layer, symbol, '#' + layer.tableName())
# CSS for categorized symbols
elif renderer.type() == 'categorizedSymbol':
# qDebug('Categorized: ' + renderer.classAttribute())
for cat in renderer.categories():
symbol = cat.symbol()
# qDebug("%s: %s type: %s" % (str(cat.value()), cat.label(), type(cat.value())))
if cat.value() is not None and cat.value() != '' and not isinstance(cat.value(), QPyNullVariant):
if isinstance(cat.value(), (int, float, long)) or (isinstance(cat.value(), str) and cat.value().isdecimal()):
value = unicode(cat.value())
else:
value = unicode('"' + cat.value() + '"')
value = str(value.encode('utf8', 'ignore'))
# qDebug('Value {}'.format(value))
style_name = '#{}[{}={}]'.format(layer.tableName(), renderer.classAttribute(), value).decode('utf8')
carto_css = carto_css + \
self.symbol2CartoCSS(layer, symbol, style_name)
else:
carto_css = self.symbol2CartoCSS(layer, symbol, '#' + layer.tableName()) + carto_css
# CSS for graduated symbols
elif renderer.type() == 'graduatedSymbol':
# qDebug('Graduated')
def upperValue(ran):
"""Get upper value from range"""
return ran.upperValue()
ranges = sorted(renderer.ranges(), key=upperValue, reverse=True)
for ran in ranges:
symbol = ran.symbol()
'''
qDebug("%f - %f: %s" % (
ran.lowerValue(),
ran.upperValue(),
ran.label()
))
'''
carto_css = carto_css + \
self.symbol2CartoCSS(layer, symbol, '#' + layer.tableName() + \
'[' + renderer.classAttribute() + '<=' + str(ran.upperValue()) + ']')
return '/** Styles designed from QGISCartoDB Plugin */\n\n' + carto_css + '\n' + label_css
def testCreateProperty(self):
s = QgsAuxiliaryStorage()
self.assertTrue(s.isValid())
# Create a new auxiliary layer with 'pk' as key
vl = createLayer()
pkf = vl.fields().field(vl.fields().indexOf('pk'))
al = s.createAuxiliaryLayer(pkf, vl)
self.assertTrue(al.isValid())
vl.setAuxiliaryLayer(al)
# Create a new labeling property on layer without labels
key = QgsPalLayerSettings.PositionX
index = QgsAuxiliaryLayer.createProperty(key, vl)
self.assertEqual(index, -1)
vl.setLabeling(QgsVectorLayerSimpleLabeling(QgsPalLayerSettings()))
index = QgsAuxiliaryLayer.createProperty(key, vl)
p = QgsPalLayerSettings.propertyDefinitions()[key]
afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
afIndex = vl.fields().indexOf(afName)
self.assertEqual(index, afIndex)
# with existing property
key = QgsPalLayerSettings.PositionY
settings = QgsPalLayerSettings()
settings.dataDefinedProperties().setProperty(
key, QgsProperty.fromExpression('$y + 20'))
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
# without overwriting existing, property should be upgraded to coalesce("aux field", 'existing expression') type
index = QgsAuxiliaryLayer.createProperty(key, vl, False)
p = QgsPalLayerSettings.propertyDefinitions()[key]
afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
afIndex = vl.fields().indexOf(afName)
self.assertEqual(index, afIndex)
settings = vl.labeling().settings()
self.assertTrue(
settings.dataDefinedProperties().property(key).isActive())
self.assertEqual(
settings.dataDefinedProperties().property(key).asExpression(),
'coalesce("auxiliary_storage_labeling_positiony",$y + 20)')
# with overwrite existing
key = QgsPalLayerSettings.Show
settings = QgsPalLayerSettings()
settings.dataDefinedProperties().setProperty(
key, QgsProperty.fromExpression('$y > 20'))
vl.setLabeling(QgsVectorLayerSimpleLabeling(settings))
# existing property should be discarded
index = QgsAuxiliaryLayer.createProperty(key, vl, True)
p = QgsPalLayerSettings.propertyDefinitions()[key]
afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
afIndex = vl.fields().indexOf(afName)
self.assertEqual(index, afIndex)
settings = vl.labeling().settings()
self.assertTrue(
settings.dataDefinedProperties().property(key).isActive())
self.assertEqual(
settings.dataDefinedProperties().property(key).field(),
'auxiliary_storage_labeling_show')
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 saveToLayer(self):
units = self.unitDesignator()
canvasCrs = self.canvas.mapSettings().destinationCrs()
fields = QgsFields()
fields.append(QgsField("label", QVariant.String))
fields.append(QgsField("value", QVariant.Double))
fields.append(QgsField("units", QVariant.String))
fields.append(QgsField("heading_to", QVariant.Double))
fields.append(QgsField("heading_from", QVariant.Double))
fields.append(QgsField("total_dist", QVariant.Double))
layer = QgsVectorLayer("LineString?crs={}".format(canvasCrs.authid()),
"Measurements", "memory")
dp = layer.dataProvider()
dp.addAttributes(fields)
layer.updateFields()
num = len(self.capturedPoints)
total = 0.0
for i in range(1, num):
(distance, startA,
endA) = self.calcParameters(self.capturedPoints[i - 1],
self.capturedPoints[i])
total += distance
total = self.unitDistance(total)
for i in range(1, num):
(distance, startA,
endA) = self.calcParameters(self.capturedPoints[i - 1],
self.capturedPoints[i])
pts = self.getLinePts(distance, self.capturedPoints[i - 1],
self.capturedPoints[i])
distance = self.unitDistance(distance)
feat = QgsFeature(layer.fields())
feat.setAttribute(0, "{:.2f} {}".format(distance, units))
feat.setAttribute(1, distance)
feat.setAttribute(2, units)
feat.setAttribute(3, startA)
feat.setAttribute(4, endA)
feat.setAttribute(5, total)
feat.setGeometry(QgsGeometry.fromPolylineXY(pts))
dp.addFeatures([feat])
label = QgsPalLayerSettings()
label.fieldName = 'label'
try:
label.placement = QgsPalLayerSettings.Line
except:
label.placement = QgsPalLayerSettings.AboveLine
format = label.format()
format.setColor(settings.measureTextColor)
format.setNamedStyle('Bold')
label.setFormat(format)
labeling = QgsVectorLayerSimpleLabeling(label)
layer.setLabeling(labeling)
layer.setLabelsEnabled(True)
renderer = layer.renderer()
renderer.symbol().setColor(settings.measureLineColor)
renderer.symbol().setWidth(0.5)
layer.updateExtents()
QgsProject.instance().addMapLayer(layer)
def test_line_settings(self):
"""
Test line settings
"""
settings = QgsLabelLineSettings()
settings.setPlacementFlags(QgsLabeling.LinePlacementFlag.OnLine)
self.assertEqual(settings.placementFlags(),
QgsLabeling.LinePlacementFlag.OnLine)
settings.setPlacementFlags(
QgsLabeling.LinePlacementFlag.OnLine
| QgsLabeling.LinePlacementFlag.MapOrientation)
self.assertEqual(
settings.placementFlags(), QgsLabeling.LinePlacementFlag.OnLine
| QgsLabeling.LinePlacementFlag.MapOrientation)
settings.setMergeLines(True)
self.assertTrue(settings.mergeLines())
settings.setMergeLines(False)
self.assertFalse(settings.mergeLines())
settings.setAddDirectionSymbol(True)
self.assertTrue(settings.addDirectionSymbol())
settings.setAddDirectionSymbol(False)
self.assertFalse(settings.addDirectionSymbol())
settings.setLeftDirectionSymbol('left')
self.assertEqual(settings.leftDirectionSymbol(), 'left')
settings.setRightDirectionSymbol('right')
self.assertEqual(settings.rightDirectionSymbol(), 'right')
settings.setReverseDirectionSymbol(True)
self.assertTrue(settings.reverseDirectionSymbol())
settings.setReverseDirectionSymbol(False)
self.assertFalse(settings.reverseDirectionSymbol())
settings.setDirectionSymbolPlacement(
QgsLabelLineSettings.DirectionSymbolPlacement.SymbolBelow)
self.assertEqual(
settings.directionSymbolPlacement(),
QgsLabelLineSettings.DirectionSymbolPlacement.SymbolBelow)
settings.setDirectionSymbolPlacement(
QgsLabelLineSettings.DirectionSymbolPlacement.SymbolAbove)
self.assertEqual(
settings.directionSymbolPlacement(),
QgsLabelLineSettings.DirectionSymbolPlacement.SymbolAbove)
settings.setOverrunDistance(5.6)
self.assertEqual(settings.overrunDistance(), 5.6)
settings.setOverrunDistanceUnit(QgsUnitTypes.RenderInches)
self.assertEqual(settings.overrunDistanceUnit(),
QgsUnitTypes.RenderInches)
scale = QgsMapUnitScale(1, 2)
settings.setOverrunDistanceMapUnitScale(scale)
self.assertEqual(settings.overrunDistanceMapUnitScale().minScale, 1)
self.assertEqual(settings.overrunDistanceMapUnitScale().maxScale, 2)
settings.setLineAnchorPercent(0.3)
self.assertEqual(settings.lineAnchorPercent(), 0.3)
# check that compatibility code works
pal_settings = QgsPalLayerSettings()
pal_settings.placementFlags = QgsPalLayerSettings.OnLine | QgsPalLayerSettings.MapOrientation
self.assertEqual(pal_settings.placementFlags, 9)
self.assertTrue(
pal_settings.lineSettings().placementFlags(),
QgsLabeling.LinePlacementFlag.OnLine
| QgsLabeling.LinePlacementFlag.MapOrientation)
pal_settings.mergeLines = True
self.assertTrue(pal_settings.mergeLines)
self.assertTrue(pal_settings.lineSettings().mergeLines())
pal_settings.mergeLines = False
self.assertFalse(pal_settings.mergeLines)
self.assertFalse(pal_settings.lineSettings().mergeLines())
pal_settings.addDirectionSymbol = True
self.assertTrue(pal_settings.addDirectionSymbol)
self.assertTrue(pal_settings.lineSettings().addDirectionSymbol())
pal_settings.addDirectionSymbol = False
self.assertFalse(pal_settings.addDirectionSymbol)
self.assertFalse(pal_settings.lineSettings().addDirectionSymbol())
pal_settings.leftDirectionSymbol = 'l'
self.assertEqual(pal_settings.leftDirectionSymbol, 'l')
self.assertEqual(pal_settings.lineSettings().leftDirectionSymbol(),
'l')
pal_settings.rightDirectionSymbol = 'r'
self.assertEqual(pal_settings.rightDirectionSymbol, 'r')
self.assertEqual(pal_settings.lineSettings().rightDirectionSymbol(),
'r')
pal_settings.reverseDirectionSymbol = True
self.assertTrue(pal_settings.reverseDirectionSymbol)
self.assertTrue(pal_settings.lineSettings().reverseDirectionSymbol())
pal_settings.reverseDirectionSymbol = False
self.assertFalse(pal_settings.reverseDirectionSymbol)
self.assertFalse(pal_settings.lineSettings().reverseDirectionSymbol())
pal_settings.placeDirectionSymbol = QgsPalLayerSettings.SymbolAbove
self.assertEqual(pal_settings.placeDirectionSymbol, 1)
self.assertTrue(
pal_settings.lineSettings().directionSymbolPlacement(),
QgsLabelLineSettings.DirectionSymbolPlacement.SymbolAbove)
pal_settings.overrunDistance = 4.2
self.assertEqual(pal_settings.overrunDistance, 4.2)
self.assertTrue(pal_settings.lineSettings().overrunDistance(), 4.2)
pal_settings.overrunDistanceUnit = QgsUnitTypes.RenderInches
self.assertEqual(pal_settings.overrunDistanceUnit,
QgsUnitTypes.RenderInches)
self.assertTrue(pal_settings.lineSettings().overrunDistanceUnit(),
QgsUnitTypes.RenderInches)
pal_settings.overrunDistanceMapUnitScale = scale
self.assertEqual(pal_settings.overrunDistanceMapUnitScale.minScale, 1)
self.assertEqual(pal_settings.overrunDistanceMapUnitScale.maxScale, 2)
self.assertTrue(
pal_settings.lineSettings().overrunDistanceMapUnitScale().minScale,
1)
self.assertTrue(
pal_settings.lineSettings().overrunDistanceMapUnitScale().maxScale,
2)
def writeLeaflet(cls, iface, feedback, folder, layer_list, visible,
cluster, json, params, popup):
outputProjectFileName = folder
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
legends = {}
canvas = iface.mapCanvas()
project = QgsProject.instance()
mapSettings = canvas.mapSettings()
title = project.title()
pluginDir = os.path.dirname(os.path.realpath(__file__))
stamp = datetime.now().strftime("%Y_%m_%d-%H_%M_%S_%f")
outputProjectFileName = os.path.join(outputProjectFileName,
'qgis2web_' + unicode(stamp))
outputIndex = os.path.join(outputProjectFileName, 'index.html')
mapLibLocation = params["Data export"]["Mapping library location"]
minify = params["Data export"]["Minify GeoJSON files"]
precision = params["Data export"]["Precision"]
debugLibs = params["Data export"]["Use debug libraries"]
extent = params["Scale/Zoom"]["Extent"]
minZoom = params["Scale/Zoom"]["Min zoom level"]
maxZoom = params["Scale/Zoom"]["Max zoom level"]
restrictToExtent = params["Scale/Zoom"]["Restrict to extent"]
basemapList = params["Appearance"]["Base layer"]
matchCRS = params["Appearance"]["Match project CRS"]
addressSearch = params["Appearance"]["Add address search"]
locate = params["Appearance"]["Geolocate user"]
measure = params["Appearance"]["Measure tool"]
highlight = params["Appearance"]["Highlight on hover"]
layerSearch = params["Appearance"]["Layer search"]
popupsOnHover = params["Appearance"]["Show popups on hover"]
template = params["Appearance"]["Template"]
usedFields = [ALL_ATTRIBUTES] * len(popup)
QgsApplication.initQgis()
dataStore, cssStore = writeFoldersAndFiles(
pluginDir, feedback, outputProjectFileName, cluster, measure,
matchCRS, layerSearch, canvas, mapLibLocation, addressSearch,
locate, debugLibs)
writeCSS(cssStore, mapSettings.backgroundColor().name(), feedback)
wfsLayers = ""
labelCode = ""
useMultiStyle = False
useHeat = False
useShapes = False
useOSMB = False
useWMTS = False
useRaster = False
scaleDependentLayers = ""
labelVisibility = ""
new_src = ""
crs = QgsCoordinateReferenceSystem.EpsgCrsId
exp_crs = QgsCoordinateReferenceSystem(4326, crs)
lyrCount = 0
for layer, jsonEncode, eachPopup, clst in zip(layer_list, json, popup,
cluster):
rawLayerName = layer.name()
safeLayerName = re.sub('[\W_]+', '',
rawLayerName) + "_" + unicode(lyrCount)
if layer.providerType() != 'WFS' or jsonEncode is True and layer:
if layer.type() == QgsMapLayer.VectorLayer:
feedback.showFeedback('Exporting %s to JSON...' %
layer.name())
exportVector(layer, safeLayerName, dataStore,
restrictToExtent, iface, extent, precision,
exp_crs, minify)
new_src += jsonScript(safeLayerName)
scaleDependentLabels =\
scaleDependentLabelScript(layer, safeLayerName)
labelVisibility += scaleDependentLabels
feedback.completeStep()
elif layer.type() == QgsMapLayer.RasterLayer:
if layer.dataProvider().name() != "wms":
layersFolder = os.path.join(outputProjectFileName,
"data")
exportRaster(layer, lyrCount, layersFolder, feedback,
iface, matchCRS)
if layer.hasScaleBasedVisibility():
scaleDependentLayers += scaleDependentLayerScript(
layer, safeLayerName, clst)
lyrCount += 1
if scaleDependentLayers != "":
scaleDependentLayers = scaleDependentScript(scaleDependentLayers)
crsSrc = mapSettings.destinationCrs()
crsAuthId = crsSrc.authid()
crsProj4 = crsSrc.toProj4()
middle = """
<script>"""
if highlight or popupsOnHover:
selectionColor = mapSettings.selectionColor().name()
middle += highlightScript(highlight, popupsOnHover, selectionColor)
if extent == "Canvas extent":
pt0 = canvas.extent()
crsDest = QgsCoordinateReferenceSystem(4326)
xform = QgsCoordinateTransform(crsSrc, crsDest)
pt1 = xform.transform(pt0)
bbox_canvas = [
pt1.yMinimum(),
pt1.yMaximum(),
pt1.xMinimum(),
pt1.xMaximum()
]
bounds = '[[' + unicode(pt1.yMinimum()) + ','
bounds += unicode(pt1.xMinimum()) + '],['
bounds += unicode(pt1.yMaximum()) + ','
bounds += unicode(pt1.xMaximum()) + ']]'
if matchCRS and crsAuthId != 'EPSG:4326':
middle += crsScript(crsAuthId, crsProj4)
else:
bounds = 0
if matchCRS and crsAuthId != 'EPSG:4326':
middle += crsScript(crsAuthId, crsProj4)
middle += mapScript(extent, matchCRS, crsAuthId, measure, maxZoom,
minZoom, bounds, locate)
middle += featureGroupsScript()
if (len(basemapList) == 0 or matchCRS):
basemapText = ""
else:
basemapText = basemapsScript(basemapList, maxZoom)
extentCode = extentScript(extent, restrictToExtent)
new_src += middle
new_src += basemapText
new_src += extentCode
for count, layer in enumerate(layer_list):
rawLayerName = layer.name()
safeLayerName = re.sub('[\W_]+', '',
rawLayerName) + "_" + unicode(count)
if layer.type() == QgsMapLayer.VectorLayer:
(new_src, legends, wfsLayers, labelCode, useMultiStyle,
useHeat, useShapes, useOSMB) = writeVectorLayer(
layer, safeLayerName, usedFields[count], highlight,
popupsOnHover, popup[count], outputProjectFileName,
wfsLayers, cluster[count], visible[count], json[count],
legends, new_src, canvas, count, restrictToExtent, extent,
feedback, labelCode, useMultiStyle, useHeat, useShapes,
useOSMB)
elif layer.type() == QgsMapLayer.RasterLayer:
if layer.dataProvider().name() == "wms":
feedback.showFeedback('Writing %s as WMS layer...' %
layer.name())
new_obj, useWMTS = wmsScript(layer, safeLayerName, useWMTS)
feedback.completeStep()
else:
useRaster = True
feedback.showFeedback('Writing %s as raster layer...' %
layer.name())
new_obj = rasterScript(layer, safeLayerName)
feedback.completeStep()
if visible[count]:
new_obj += """
map.addLayer(overlay_""" + safeLayerName + """);"""
new_src += new_obj
new_src += scaleDependentLayers
if title != "":
titleStart = unicode(titleSubScript(title).decode("utf-8"))
new_src += unicode(titleStart)
if addressSearch:
address_text = addressSearchScript()
new_src += address_text
if (params["Appearance"]["Add layers list"]
and params["Appearance"]["Add layers list"] != ""
and params["Appearance"]["Add layers list"] != "None"):
new_src += addLayersList(
basemapList, matchCRS, layer_list, cluster, legends,
params["Appearance"]["Add layers list"] == "Expanded")
if project.readBoolEntry("ScaleBar", "/Enabled", False)[0]:
placement = project.readNumEntry("ScaleBar", "/Placement", 0)[0]
placement = PLACEMENT[placement]
end = scaleBar(placement)
else:
end = ''
layerType = "layer"
try:
if cluster[count]:
layerType = "cluster"
except:
pass
searchLayer = "%s_%s" % (layerType,
params["Appearance"]["Search layer"])
labelList = []
for count, layer in enumerate(layer_list):
safeLayerName = re.sub('[\W_]+', '',
layer.name()) + "_" + unicode(count)
if layer.type() == QgsMapLayer.VectorLayer:
palyr = QgsPalLayerSettings()
palyr.readFromLayer(layer)
if palyr.enabled and palyr.fieldName and palyr.fieldName != "":
labelList.append("layer_%s" % safeLayerName)
labelsList = ",".join(labelList)
end += endHTMLscript(wfsLayers, layerSearch, labelCode,
labelVisibility, searchLayer, useHeat, useRaster,
labelsList)
new_src += end
try:
writeHTMLstart(outputIndex, title, cluster, addressSearch, measure,
matchCRS, layerSearch, canvas, mapLibLocation,
locate, new_src, template, feedback, debugLibs,
useMultiStyle, useHeat, useShapes, useOSMB, useWMTS)
except Exception as e:
QgsMessageLog.logMessage(traceback.format_exc(),
"qgis2web",
level=QgsMessageLog.CRITICAL)
finally:
QApplication.restoreOverrideCursor()
return outputIndex
def __init__(self):
"""Dummy assignments, intended to be overriden in subclasses"""
self.lyr = QgsPalLayerSettings()
self._TestFont = QApplication.font()
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 parse_symbol_layer(json_layer):
json_layout = json_layer['layout']
json_paint = json_layer['paint']
dd_properties = {}
TEXT_SIZE_MULTIPLIER = 2 # *2 because of high-res screen?
text_size = 16
if 'text-size' in json_layout:
json_text_size = json_layout['text-size']
if isinstance(json_text_size, (float, int)):
text_size = json_text_size
elif isinstance(json_text_size, dict):
dd_properties[
QgsPalLayerSettings.Size] = parse_interpolate_by_zoom(
json_text_size, TEXT_SIZE_MULTIPLIER)
else:
print("skipping non-float text-size", json_text_size)
# TODO: text-font
text_color = Qt.black
if 'text-color' in json_paint:
json_text_color = json_paint['text-color']
if isinstance(json_text_color, str):
text_color = parse_color(json_text_color)
else:
print("skipping non-string text-color", json_text_color)
buffer_color = QColor(0, 0, 0, 0)
if 'text-halo-color' in json_paint:
json_text_halo_color = json_paint['text-halo-color']
if isinstance(json_text_halo_color, str):
buffer_color = parse_color(json_text_halo_color)
else:
print("skipping non-string text-halo-color", json_text_halo_color)
buffer_size = 0
if 'text-halo-width' in json_paint:
json_text_halo_width = json_paint['text-halo-width']
if isinstance(json_text_halo_width, (float, int)):
buffer_size = json_text_halo_width
else:
print("skipping non-float text-halo-width", json_text_halo_width)
format = QgsTextFormat()
format.setColor(text_color)
format.setSize(text_size * TEXT_SIZE_MULTIPLIER)
format.setSizeUnit(QgsUnitTypes.RenderPixels)
#format.setFont(font)
if buffer_size > 0:
buffer_settings = QgsTextBufferSettings()
buffer_settings.setEnabled(True)
buffer_settings.setSize(buffer_size * PX_TO_MM * TEXT_SIZE_MULTIPLIER)
buffer_settings.setColor(buffer_color)
format.setBuffer(buffer_settings)
label_settings = QgsPalLayerSettings()
label_settings.fieldName = '"name:latin"' # TODO: parse field name
label_settings.isExpression = True
label_settings.placement = QgsPalLayerSettings.OverPoint
label_settings.priority = min(text_size / 3., 10.)
label_settings.setFormat(format)
if dd_properties:
for dd_key, dd_expression in dd_properties.items():
prop_collection = QgsPropertyCollection()
prop_collection.setProperty(
dd_key, QgsProperty.fromExpression(dd_expression))
label_settings.setDataDefinedProperties(prop_collection)
lb = QgsVectorTileBasicLabelingStyle()
lb.setGeometryType(QgsWkbTypes.PointGeometry)
lb.setLabelSettings(label_settings)
return lb
def 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 test_AddPALToVectorLayer(self):
"""Check if we can set a label field, verify that PAL is assigned
and that output is rendered correctly"""
# TODO: add UTM PAL-specific shps, with 4326 as on-the-fly cross-check
# setCanvasCrs(26913)
myShpFile = os.path.join(TEST_DATA_DIR, 'lines.shp')
myVectorLayer = QgsVectorLayer(myShpFile, 'Lines', 'ogr')
self._MapRegistry.addMapLayer(myVectorLayer)
myLayers = QStringList()
myLayers.append(myVectorLayer.id())
self._MapRenderer.setLayerSet(myLayers)
self._MapRenderer.setExtent(myVectorLayer.extent())
self._Canvas.zoomToFullExtent()
# check layer labeling is PAL with customProperty access
# should not be activated on layer load
myPalSet = myVectorLayer.customProperty("labeling").toString()
myMessage = '\nExpected: Empty QString\nGot: %s' % (str(myPalSet))
assert str(myPalSet) == '', myMessage
# simulate clicking checkbox, setting label field and clicking apply
self._testFont.setPointSize(20)
myPalLyr = QgsPalLayerSettings()
myPalLyr.enabled = True
myPalLyr.fieldName = 'Name'
myPalLyr.placement = QgsPalLayerSettings.Line
myPalLyr.placementFlags = QgsPalLayerSettings.AboveLine
myPalLyr.xQuadOffset = 0
myPalLyr.yQuadOffset = 0
myPalLyr.xOffset = 0
myPalLyr.yOffset = 0
myPalLyr.angleOffset = 0
myPalLyr.centroidWhole = False
myPalLyr.textFont = self._testFont
myPalLyr.textNamedStyle = QString("Medium")
myPalLyr.textColor = Qt.black
myPalLyr.textTransp = 0
myPalLyr.previewBkgrdColor = Qt.white
myPalLyr.priority = 5
myPalLyr.obstacle = True
myPalLyr.dist = 0
myPalLyr.scaleMin = 0
myPalLyr.scaleMax = 0
myPalLyr.bufferSize = 1
myPalLyr.bufferColor = Qt.white
myPalLyr.bufferTransp = 0
myPalLyr.bufferNoFill = False
myPalLyr.bufferJoinStyle = Qt.RoundJoin
myPalLyr.formatNumbers = False
myPalLyr.decimals = 3
myPalLyr.plusSign = False
myPalLyr.labelPerPart = False
myPalLyr.displayAll = True
myPalLyr.mergeLines = False
myPalLyr.minFeatureSize = 0.0
myPalLyr.vectorScaleFactor = 1.0
myPalLyr.rasterCompressFactor = 1.0
myPalLyr.addDirectionSymbol = False
myPalLyr.upsidedownLabels = QgsPalLayerSettings.Upright
myPalLyr.fontSizeInMapUnits = False
myPalLyr.bufferSizeInMapUnits = False
myPalLyr.labelOffsetInMapUnits = True
myPalLyr.distInMapUnits = False
myPalLyr.wrapChar = ""
myPalLyr.preserveRotation = True
myPalLyr.writeToLayer(myVectorLayer)
# check layer labeling is PAL with customProperty access
myPalSet = myVectorLayer.customProperty("labeling").toString()
myMessage = '\nExpected: pal\nGot: %s' % (str(myPalSet))
assert str(myPalSet) == 'pal', myMessage
# check layer labeling is PAL via engine interface
myMessage = '\nCould not get whether PAL enabled from labelingEngine'
assert self._PalEngine.willUseLayer(myVectorLayer), myMessage
#
myChecker = QgsRenderChecker()
myChecker.setControlName("expected_pal_aboveLineLabeling")
myChecker.setMapRenderer(self._MapRenderer)
myResult = myChecker.runTest("pal_aboveLineLabeling_python")
myMessage = ('\nVector layer \'above line\' label engine '
'rendering test failed')
assert myResult, myMessage
# compare against a straight rendering/save as from QgsMapCanvasMap
# unnecessary? works a bit different than QgsRenderChecker, though
# myImage = os.path.join(unicode(QDir.tempPath()),
# 'render_pal_aboveLineLabeling.png')
# self._Map.render()
# self._Canvas.saveAsImage(myImage)
# myChecker.setRenderedImage(myImage)
# myResult = myChecker.compareImages("pal_aboveLineLabeling_python")
# myMessage = ('\nVector layer \'above line\' label engine '
# 'comparison to QgsMapCanvasMap.render() test failed')
# assert myResult, myMessage
self._MapRegistry.removeMapLayer(myVectorLayer.id())
