def testQgsSvgMarkerSymbolLayer(self):
"""
Create a new style from a .sld file and match test
"""
mTestName = 'QgsSvgMarkerSymbolLayer'
mFilePath = QDir.toNativeSeparators('%s/symbol_layer/%s.sld' %
(unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSvgMarkerSymbolLayer.createFromSld(
mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSvgMarkerSymbolLayer(""))
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 'skull.svg'
mValue = os.path.basename(mSymbolLayer.path())
print(("VALUE", mSymbolLayer.path()))
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 12
mValue = mSymbolLayer.size()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 45
mValue = mSymbolLayer.angle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def showRequestResult(self, items, append, last, message):
# print("showRequestResult")
if items is None or len(items) == 0:
QApplication.restoreOverrideCursor()
self.__show_status_label(StatusMessageType.LOAD_FINISHED)
self.getDataButton.setEnabled(True)
if message is None or len(message) == 0:
message = "По указанным параметрам ничего не найдено"
self._show_message(self, "Загузка завершена", message)
return
color = QColor(237, 28, 36, 200)
pjt = QgsProject.instance()
layersList = pjt.mapLayersByName(self.resultsLayerName)
if not append:
if layersList is not None and len(layersList) > 0:
pjt.removeMapLayer(layersList[0])
# print("remove results")
layersList.clear()
if not append or layersList is None or len(layersList) == 0:
# print("create layer")
layer = QgsVectorLayer("Point?crs=EPSG:4326"
"&field=coordinatesWKT:string(255)&field=shootingDateTime:string(255)"
"&field=temperature:double(7)&field=pixelSizeInDirection:double(5)"
"&field=pixelSizeAcross:double(5)&field=thermalPower:double(5)"
"&field=baseResourceId:string(255)&field=id:string(255)&field=updated:string(255)"
"&field=satellite:string(10)",
self.resultsLayerName, "memory")
else:
layer = layersList[0]
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
svg_marker = QgsSvgMarkerSymbolLayer(":/plugins/thermal_anomaly/fire.svg")
svg_marker.setSize(6.0)
symbol.changeSymbolLayer(0, svg_marker)
layer.renderer().setSymbol(symbol)
layer.startEditing()
print("all items=", len(items))
poly = QgsGeometry.fromWkt(self.polygon)
for point in items:
symbols = layer.renderer().symbols(QgsRenderContext()) # todo which context ?
symbols[0].setColor(color)
feature = QgsFeature()
coord = QgsGeometry.fromWkt(point["coordinatesWKT"])
feature.setGeometry(coord)
feature.setAttributes([point["coordinatesWKT"], point["shootingDateTime"], point["temperature"],
point["pixelSizeInDirection"], point["pixelSizeAcross"], point["thermalPower"],
point["baseResourceId"], point["id"], point["updated"], point["satellite"]])
layer.dataProvider().addFeatures([feature])
# if not poly.contains(coord):
# print("point out of poly: id =", point["id"], "coord =", point["coordinatesWKT"])
layer.commitChanges()
if not append:
pjt.addMapLayer(layer, False)
if pjt.layerTreeRoot().findGroup(self.tr(self.groupName)) is None:
pjt.layerTreeRoot().insertChildNode(0, QgsLayerTreeGroup(self.tr(self.groupName)))
group = pjt.layerTreeRoot().findGroup(self.tr(self.groupName))
group.insertLayer(0, layer)
self.iface.layerTreeView().refreshLayerSymbology(layer.id())
self.iface.mapCanvas().refresh()
if last:
QApplication.restoreOverrideCursor()
self.__show_status_label(StatusMessageType.LOAD_FINISHED)
self.getDataButton.setEnabled(True)
else:
self.__show_status_label(StatusMessageType.LOAD_STARTED, message)
def processAlgorithm(self, parameters, context, feedback):
t_file = self.parameterAsVectorLayer(
parameters,
self.FILE_TABLE,
context
)
t_troncon = self.parameterAsVectorLayer(
parameters,
self.SEGMENTS_TABLE,
context
)
t_obs = self.parameterAsVectorLayer(
parameters,
self.OBSERVATIONS_TABLE,
context
)
t_regard = self.parameterAsVectorLayer(
parameters,
self.MANHOLES_TABLE,
context
)
g_regard = self.parameterAsVectorLayer(
parameters,
self.GEOM_MANHOLES,
context
)
g_troncon = self.parameterAsVectorLayer(
parameters,
self.GEOM_SEGMENT,
context
)
g_obs = self.parameterAsVectorLayer(
parameters,
self.GEOM_OBSERVATION,
context
)
v_regard = self.parameterAsVectorLayer(
parameters,
self.VIEW_MANHOLES_GEOLOCALIZED,
context
)
# define variables
variables = context.project().customVariables()
variables['itv_rerau_t_file'] = t_file.id()
variables['itv_rerau_t_troncon'] = t_troncon.id()
variables['itv_rerau_t_obs'] = t_obs.id()
variables['itv_rerau_t_regard'] = t_regard.id()
variables['itv_rerau_g_regard'] = g_regard.id()
variables['itv_rerau_g_troncon'] = g_troncon.id()
variables['itv_rerau_g_obs'] = g_obs.id()
context.project().setCustomVariables(variables)
# define relations
relations = [
{
'id': 'fk_obs_id_file',
'name': tr('Link File - Observation'),
'referencingLayer': t_obs.id(),
'referencingField': 'id_file',
'referencedLayer': t_file.id(),
'referencedField': 'id'
}, {
'id': 'fk_regard_id_file',
'name': tr('Link File - Manhole'),
'referencingLayer': t_regard.id(),
'referencingField': 'id_file',
'referencedLayer': t_file.id(),
'referencedField': 'id'
}, {
'id': 'fk_troncon_id_file',
'name': tr('Link File - Pipe segment'),
'referencingLayer': t_troncon.id(),
'referencingField': 'id_file',
'referencedLayer': t_file.id(),
'referencedField': 'id'
}, {
'id': 'fk_obs_id_troncon',
'name': tr('Link Pipe segment - Observation'),
'referencingLayer': t_obs.id(),
'referencingField': 'id_troncon',
'referencedLayer': t_troncon.id(),
'referencedField': 'id'
}, {
'id': 'fk_regard_id_geom_regard',
'name': tr('Link Manhole inspection - Reference'),
'referencingLayer': t_regard.id(),
'referencingField': 'id_geom_regard',
'referencedLayer': g_regard.id(),
'referencedField': 'id'
}, {
'id': 'fk_troncon_id_geom_trononc',
'name': tr('Link Pipe segment inspection - Reference'),
'referencingLayer': t_troncon.id(),
'referencingField': 'id_geom_troncon',
'referencedLayer': g_troncon.id(),
'referencedField': 'id'
}
]
relation_manager = context.project().relationManager()
for rel_def in relations:
feedback.pushInfo(
'Link: {}'.format(rel_def['name'])
)
rel = QgsRelation()
rel.setId(rel_def['id'])
rel.setName(rel_def['name'])
rel.setReferencingLayer(rel_def['referencingLayer'])
rel.setReferencedLayer(rel_def['referencedLayer'])
rel.addFieldPair(
rel_def['referencingField'],
rel_def['referencedField']
)
rel.setStrength(QgsRelation.Association)
relation_manager.addRelation(rel)
feedback.pushInfo(
'Count relations {}'.format(
len(relation_manager.relations())
)
)
joins = [
{
'layer': t_obs,
'targetField': 'id_troncon',
'joinLayer': t_troncon,
'joinField': 'id',
'fieldNamesSubset': ['ack']
}, {
'layer': g_obs,
'targetField': 'id',
'joinLayer': t_obs,
'joinField': 'id',
'fieldNamesSubset': []
}
]
for j_def in joins:
layer = j_def['layer']
join = QgsVectorLayerJoinInfo()
join.setJoinFieldName(j_def['joinField'])
join.setJoinLayerId(j_def['joinLayer'].id())
join.setTargetFieldName(j_def['targetField'])
if j_def['fieldNamesSubset']:
join.setJoinFieldNamesSubset(j_def['fieldNamesSubset'])
join.setUsingMemoryCache(False)
join.setPrefix('')
join.setEditable(False)
join.setCascadedDelete(False)
join.setJoinLayer(j_def['joinLayer'])
layer.addJoin(join)
layer.updateFields()
# load styles
styles = [
{
'layer': t_file,
'namedStyles': [
{
'file': 'itv_file_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_file_actions.qml',
'type': QgsMapLayer.Actions
}
]
}, {
'layer': t_troncon,
'namedStyles': [
{
'file': 'itv_troncon_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_troncon_table.qml',
'type': QgsMapLayer.AttributeTable
}
]
}, {
'layer': t_obs,
'namedStyles': [
{
'file': 'itv_obs_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_obs_table.qml',
'type': QgsMapLayer.AttributeTable
}
]
}, {
'layer': t_regard,
'namedStyles': [
{
'file': 'itv_regard_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_regard_forms.qml',
'type': QgsMapLayer.Forms
}, {
'file': 'itv_regard_table.qml',
'type': QgsMapLayer.AttributeTable
}
]
}, {
'layer': g_regard,
'namedStyles': [
{
'file': 'itv_geom_regard_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_geom_regard_symbology.qml',
'type': QgsMapLayer.Symbology
}
]
}, {
'layer': g_troncon,
'namedStyles': [
{
'file': 'itv_geom_troncon_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_geom_troncon_symbology.qml',
'type': QgsMapLayer.Symbology
}, {
'file': 'itv_geom_troncon_actions.qml',
'type': QgsMapLayer.Actions
}
]
}, {
'layer': g_obs,
'namedStyles': [
{
'file': 'itv_geom_obs_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_geom_obs_symbology.qml',
'type': QgsMapLayer.Symbology
}
]
}, {
'layer': v_regard,
'namedStyles': [
{
'file': 'itv_view_regard_fields.qml',
'type': QgsMapLayer.Fields
}, {
'file': 'itv_view_regard_symbology.qml',
'type': QgsMapLayer.Symbology
}, {
'file': 'itv_view_regard_labeling.qml',
'type': QgsMapLayer.Labeling
}
]
}
]
for style in styles:
layer = style['layer']
for n_style in style['namedStyles']:
layer.loadNamedStyle(
resources_path('styles', n_style['file']),
categories=n_style['type']
)
# layer.saveStyleToDatabase('style', 'default style', True, '')
layer.triggerRepaint()
# Creation de la symbologie g_obs
g_obs_rules = (
'BAA', 'BAB', 'BAC', 'BAD', 'BAE', 'BAF', 'BAG', 'BAH',
'BAI', 'BAJ', 'BAK', 'BAL', 'BAM', 'BAN', 'BAO', 'BAP',
'BBA', 'BBB', 'BBC', 'BBD', 'BBE', 'BBF', 'BBG', 'BBH',
'BCA', 'BCB', 'BCC', 'BDA', 'BDB', 'BDC', 'BDD', 'BDE',
'BDF', 'BDG'
)
g_obs_rule_descs = {
'BAA': 'Déformation',
'BAB': 'Fissure',
'BAC': 'Rupture/Effondrement',
'BAD': 'Elt maçonnerie',
'BAE': 'Mortier manquant',
'BAF': 'Dégradation de surface',
'BAG': 'Branchement pénétrant',
'BAH': 'Raccordement défectueux',
'BAI': 'Joint étanchéité apparent',
'BAJ': 'Déplacement d\'assemblage',
'BAK': 'Défaut de révêtement',
'BAL': 'Réparation défectueuse',
'BAM': 'Défaut soudure',
'BAN': 'Conduite poreuse',
'BAO': 'Sol visible',
'BAP': 'Trou visible',
'BBA': 'Racines',
'BBB': 'Dépots Adhérents',
'BBC': 'Dépôts',
'BBD': 'Entrée de terre',
'BBE': 'Autres obstacles',
'BBF': 'Infiltration',
'BBG': 'Exfiltration',
'BBH': 'Vermine',
'BCA': 'Raccordement',
'BCB': 'Réparation',
'BCC': 'Courbure de collecteur',
'BDA': 'Photographie générale',
'BDB': 'Remarque générale',
'BDC': 'Inspection abandonnée',
'BDD': 'Niveau d\'eau',
'BDE': 'Ecoulement dans une canlisation entrante',
'BDF': 'Atmosphère canalisation',
'BDG': 'Perte de visibilité'
}
g_obs_rootrule = QgsRuleBasedRenderer.Rule(None)
rendering_pass_idx = len(g_obs_rules)
for rule in g_obs_rules:
# get svg path
svg_path = resources_path('styles', 'img_obs', rule + '.svg')
# create svg symbol layer
svg_symbol_layer = QgsSvgMarkerSymbolLayer(svg_path)
svg_symbol_layer.setRenderingPass(rendering_pass_idx)
# create white square symbol layer for the backend
simple_symbol_layer = QgsSimpleMarkerSymbolLayer(
shape=QgsSimpleMarkerSymbolLayerBase.Circle,
size=svg_symbol_layer.size(),
color=QColor('white'),
strokeColor=QColor('white')
)
simple_symbol_layer.setRenderingPass(rendering_pass_idx)
# create marker
svg_marker = QgsMarkerSymbol()
# set the backend symbol layer
svg_marker.changeSymbolLayer(0, simple_symbol_layer)
# add svg symbol layer
svg_marker.appendSymbolLayer(svg_symbol_layer)
# create rule
svg_rule = QgsRuleBasedRenderer.Rule(
svg_marker, 0, 10000,
QgsExpression.createFieldEqualityExpression('a', rule),
rule
)
if rule in g_obs_rule_descs:
svg_rule.setLabel(g_obs_rule_descs[rule])
svg_rule.setDescription('{}: {}'.format(
rule,
g_obs_rule_descs[rule]
))
# add rule
g_obs_rootrule.appendChild(svg_rule)
rendering_pass_idx -= 1
g_obs_rootrule.appendChild(
QgsRuleBasedRenderer.Rule(
QgsMarkerSymbol.createSimple(
{
'name': 'circle',
'color': '#0000b2',
'outline_color': '#0000b2',
'size': '1'
}
),
0, 10000, 'ELSE', 'Autres'
)
)
g_obs.setRenderer(QgsRuleBasedRenderer(g_obs_rootrule))
feedback.pushInfo('Project has been setup')
return {}
def generateIsochrones(point,
profile,
costingOptions,
intervals,
colors,
basename,
overwrite=True):
response = valhalla.isochrones(point, profile, costingOptions, intervals,
colors)
features = getFeaturesFromResponse(response)
if costingOptions.get("shortest"):
suffix = "km"
else:
suffix = "min"
for interval, feature in zip(intervals[::-1], features):
# FIXME: we should use the 'contour' property in the feature to be sure of the contour line that we are
# drawing, but due to a bug in qgis json parser, this property appears to be always set to '0'
layername = "{} {} - {}".format(interval, suffix, basename)
try:
# FIXME: we do not consider if there are several layers with the same name here
existinglayer = QgsProject.instance().mapLayersByName(layername)[0]
if overwrite:
QgsProject.instance().removeMapLayer(existinglayer.id())
else:
raise OverwriteError(
tr("layer {layername} already exists and overwrite is {overwrite}"
).format(layername=layername, overwrite=overwrite))
except IndexError:
LOG.debug("this layer was not found: {}".format(layername))
layer = QgsVectorLayer(
"Polygon?crs=epsg:4326&field=centerx:double&field=centery:double&field=interval:double",
layername,
"memory",
)
pr = layer.dataProvider()
qgsfeature = QgsFeature()
qgsfeature.setAttributes([point.x(), point.y(), interval])
qgsfeature.setGeometry(feature.geometry())
pr.addFeatures([qgsfeature])
layer.updateExtents()
QgsProject.instance().addMapLayer(layer)
outlineColor = QColor(0, 0, 0)
# Set opacity to 40% or 66 in hex (65% transparency)
fillColor = QColor("#66" + feature["color"][1:])
renderer = QgsSingleSymbolRenderer.defaultRenderer(
QgsWkbTypes.PolygonGeometry)
symbol = renderer.symbol()
symbol.setColor(fillColor)
symbol.symbolLayer(0).setStrokeColor(outlineColor)
layer.setRenderer(renderer)
# Add center of reachability
center_point_layer_name = tr("Center of {basename}").format(
basename=basename)
try:
existinglayer = QgsProject.instance().mapLayersByName(
center_point_layer_name)[0]
if overwrite:
QgsProject.instance().removeMapLayer(existinglayer.id())
else:
raise OverwriteError(
tr("layer {layername} already exists and overwrite is {overwrite}"
).format(layername=center_point_layer_name,
overwrite=overwrite))
except IndexError:
LOG.debug(
"this layer was not found: {}".format(center_point_layer_name))
center_point = QgsVectorLayer(
"Point?crs=epsg:4326",
center_point_layer_name,
"memory",
)
pr = center_point.dataProvider()
qgsfeature = QgsFeature()
qgsfeature.setGeometry(QgsGeometry.fromPointXY(point))
pr.addFeatures([qgsfeature])
# symbology
path = ":/kadas/icons/pin_red"
symbol = QgsSvgMarkerSymbolLayer(path)
symbol.setSize(10)
symbol.setVerticalAnchorPoint(QgsMarkerSymbolLayer.Bottom)
center_point.renderer().symbol().changeSymbolLayer(0, symbol)
QgsProject.instance().addMapLayer(center_point)
def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
#vector layer given by the user
input_layer = self.parameterAsVectorLayer(parameters, self.INPUT,
context)
#the field within previous layer. Should contain numeral codes
#that identify each traffic sign
value_field = self.parameterAsString(parameters, self.SIGN_CODE_FIELD,
context)
speed_field = self.parameterAsString(parameters,
self.SPEED_LIMIT_FIELD, context)
old_or_new_selection = self.parameterAsString(parameters,
self.OLD_OR_NEW, context)
size_selection = self.parameterAsBool(parameters, self.MODIFY_SIZE,
context)
# read user selection on whether to use old or new signs
# transform this into a usable string
if old_or_new_selection == "1":
old_or_new_selection = "new"
else:
old_or_new_selection = "old"
#if the SVG's are installed via Resource sharing, they should be here
path1 = (QgsApplication.qgisSettingsDirPath() +
"resource_sharing/collections/Väylävirasto" +
" {} traffic signs (Finnish Transport Infra Agency"
).format(old_or_new_selection)
path2 = "\'s Repository)/svg/\'"
#Windows path hijinks
resource_path = path1.replace("\\", "/")
# creating a dummy symbol layer, which will be styled later
svg_layer = QgsSvgMarkerSymbolLayer("circle")
# creating two expressions, one for defining the path to each SVG image
# the other for scaling image size based on current map scale
# the syntax of these strings is the one used in QGIS's Expression bulder
if (speed_field and old_or_new_selection == "old"):
path_exp = (
"CASE WHEN \"{1}\"=361 AND \"{2}\"=50 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'-1.svg\')"
+
" WHEN \"{1}\"=361 AND \"{2}\"=20 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'-2.svg\')"
+
" WHEN \"{1}\"=361 AND \"{2}\"=70 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'-3.svg\')"
+
" WHEN \"{1}\"=361 AND \"{2}\"=80 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'-4.svg\')"
+
" WHEN \"{1}\"=361 AND \"{2}\"=100 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'-5.svg\')"
+
" WHEN \"{1}\"=361 AND \"{2}\"=120 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'-6.svg\')"
+
" WHEN \"{1}\"=361 AND \"{2}\"=30 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'-7.svg\')"
+
" WHEN \"{1}\"=361 AND \"{2}\"=40 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'-8.svg\')"
+
" WHEN \"{1}\"=361 AND \"{2}\"=40 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'-8.svg\')"
+ " ELSE concat(\'{0}\', char(39), {3}, \"{1}\", \'.svg\') END"
).format(resource_path, value_field, speed_field, path2)
elif (speed_field and old_or_new_selection == "new"):
path_exp = (
"CASE WHEN \"{1}\"= \'C32\' AND \"{2}\"=20 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_2.svg\')"
+
" WHEN \"{1}\"=\'C32\' AND \"{2}\"=30 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_3.svg\')"
+
" WHEN \"{1}\"=\'C32\'AND \"{2}\"=40 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_4.svg\')"
+
" WHEN \"{1}\"=\'C32\' AND \"{2}\"=50 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_5.svg\')"
+
" WHEN \"{1}\"=\'C32\' AND \"{2}\"=70 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_6.svg\')"
+
" WHEN \"{1}\"=\'C32\' AND \"{2}\"=80 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_7.svg\')"
+
" WHEN \"{1}\"=\'C32\' AND \"{2}\"=100 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_8.svg\')"
+
" WHEN \"{1}\"=\'C32\' AND \"{2}\"=120 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_9.svg\')"
+
" WHEN \"{1}\"=\'C33\' AND \"{2}\"=20 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_2.svg\')"
+
" WHEN \"{1}\"=\'C33\' AND \"{2}\"=30 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_3.svg\')"
+
" WHEN \"{1}\"=\'C33\' AND \"{2}\"=50 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_4.svg\')"
+
" WHEN \"{1}\"=\'C33\' AND \"{2}\"=60 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_5.svg\')"
+
" WHEN \"{1}\"=\'C33\' AND \"{2}\"=70 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_6.svg\')"
+
" WHEN \"{1}\"=\'C34\' AND \"{2}\"=30 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_2.svg\')"
+
" WHEN \"{1}\"=\'C34\' AND \"{2}\"=50 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_3.svg\')"
+
" WHEN \"{1}\"=\'C35\' AND \"{2}\"=30 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_2.svg\')"
+
" WHEN \"{1}\"=\'C35\' AND \"{2}\"=50 THEN concat(\'{0}\', char(39), {3}, \"{1}\", \'_3.svg\')"
+ " ELSE concat(\'{0}\', char(39), {3}, \"{1}\", \'.svg\') END"
).format(resource_path, value_field, speed_field, path2)
else:
path_exp = "concat(\'{0}\', char(39), {2}, \"{1}\", \'.svg\')".format(
resource_path, value_field, path2)
size_exp = (
"CASE WHEN @map_scale < 10000 THEN 7 WHEN @map_scale < 50000 THEN 5.5"
+
" WHEN @map_scale < 100000 THEN 5 WHEN @map_scale < 150000 THEN 4.5 WHEN @map_scale < 500000"
+ " THEN 3.5 ELSE 2.5 END")
# taking a version of the renderer, which houses the symbol layers
rend = input_layer.renderer().clone()
rend.symbol().changeSymbolLayer(0, svg_layer)
# defining the image path expression
rend.symbol().symbolLayer(0).setDataDefinedProperty(
QgsSymbolLayer.PropertyName, QgsProperty.fromExpression(path_exp))
if size_selection:
rend.symbol().symbolLayer(0).setDataDefinedProperty(
QgsSymbolLayer.PropertySize,
QgsProperty.fromExpression(size_exp))
# setting the new renderer to layer
input_layer.setRenderer(rend)
# updating so that the results are shown to the user
input_layer.triggerRepaint()
return {"Styling": "complete"}
def simbolo (self, capa):
categorias=[]
tipos=capa.uniqueValues(0)
basepath = os.path.dirname(os.path.realpath(__file__))
#Definir el símbolo svg para cada tipo de elemento
for elemento in tipos:
if elemento=="Acometida":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/acometida.svg")
self.categoria (symbol, symbol_layer, elemento, categorias)
elif elemento=="Contador":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/contador.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Valvula":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/valvula.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Ventosa":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/ventosa.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Otro":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/otro.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Aliviadero":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/aliviadero.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Imbornal":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/imbornal.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Pozo de registro":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/pozo.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Generador":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/generador.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Interruptor":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/interruptor.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Transformador":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/transformador.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Torre":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/torre.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Llave":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/llave.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
elif elemento=="Toma de presión":
symbol = QgsSymbol.defaultSymbol(capa.geometryType())
symbol_layer = QgsSvgMarkerSymbolLayer(str(basepath)+"/svg_icon/presion.svg")
self.categoria(symbol, symbol_layer, elemento, categorias)
renderer = QgsCategorizedSymbolRenderer('Elemento', categorias)
if renderer is not None:
capa.setRenderer(renderer)
def append_CharacterMarkerSymbolLayerAsSvg(symbol, layer, context: Context): # pylint: disable=too-many-locals
"""
Appends a CharacterMarkerSymbolLayer to a symbol, rendering the font character
to an SVG file.
"""
font_family = layer.font
character = chr(layer.unicode)
color = symbol_color_to_qcolor(layer.color)
angle = convert_angle(layer.angle)
font = QFont(font_family)
font.setPointSizeF(layer.size)
# Using the rect of a painter path gives better results then using font metrics
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.addText(0, 0, font, character)
rect = path.boundingRect()
font_bounding_rect = QFontMetricsF(font).boundingRect(character)
# adjust size -- marker size in esri is the font size, svg marker size in qgis is the svg rect size
scale = rect.width() / font_bounding_rect.width()
gen = QSvgGenerator()
svg_path = symbol_name_to_filename(context.symbol_name,
context.picture_folder, 'svg')
gen.setFileName(svg_path)
gen.setViewBox(rect)
painter = QPainter(gen)
painter.setFont(font)
# todo -- size!
if context.parameterise_svg:
painter.setBrush(QBrush(QColor(255, 0, 0)))
else:
painter.setBrush(QBrush(color))
painter.setPen(Qt.NoPen)
painter.drawPath(path)
painter.end()
if context.parameterise_svg:
with open(svg_path, 'r') as f:
t = f.read()
t = t.replace('#ff0000', 'param(fill)')
t = t.replace('fill-opacity="1" ',
'fill-opacity="param(fill-opacity)"')
t = t.replace(
'stroke="none"',
'stroke="param(outline)" stroke-opacity="param(outline-opacity) 1" stroke-width="param(outline-width) 0"'
)
with open(svg_path, 'w') as f:
f.write(t)
svg_path = context.convert_path(svg_path)
out = QgsSvgMarkerSymbolLayer(svg_path)
out.setSizeUnit(context.units)
out.setSize(context.convert_size(scale * rect.width()))
out.setAngle(angle)
out.setFillColor(color)
out.setStrokeWidth(0)
out.setEnabled(layer.enabled)
out.setLocked(layer.locked)
out.setOffset(
adjust_offset_for_rotation(
QPointF(context.convert_size(layer.x_offset),
-context.convert_size(layer.y_offset)), layer.angle))
out.setOffsetUnit(context.units)
symbol.appendSymbolLayer(out)
