def testQgsSvgMarkerSymbolLayerV2(self):
'''
Create a new style from a .sld file and match test
'''
mTestName = 'QgsSvgMarkerSymbolLayerV2'
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 = QgsSvgMarkerSymbolLayerV2.createFromSld(mDoc.elementsByTagName('PointSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSvgMarkerSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue,mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = u'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 getSymbolLayer(folder, svg, size):
'''
Returns a symbol layer correspoding to a given filename
'''
svg = svg + '.svg'
root = os.path.join(os.path.dirname(__file__), 'svg', folder)
filepath = None
'''
Find the file in the folder where all subsymbol SVGs are stored, from the
passed filename.
'''
for base, dirs, files in os.walk(root):
matching = fnmatch.filter(files, svg)
if matching:
filepath = os.path.join(base, matching[0])
break
'''
Create the symbol layer from the SVG file
'''
if filepath is not None:
symbolLayer = QgsSvgMarkerSymbolLayerV2()
symbolLayer.setPath(filepath)
'''
This tells QGIS that the size is expressed in pixels, so the marker
would be rendered at the same size in the screen for all zoom levels.
To have a marker that is rendered at a different size depending on the
scale, you can use QgsSymbolV2.MapUnit as the size unit.
'''
symbolLayer.setSizeUnit(QgsSymbolV2.Pixel)
symbolLayer.setSize(size)
return symbolLayer
else:
return None
def make_svg_link_sym_renderer(self, icon_name, svg_size=7, line_width=0.2):
symbol = QgsLineSymbolV2().createSimple({})
symbol.deleteSymbolLayer(0)
# Line
line_sym_lay = QgsSimpleLineSymbolLayerV2()
line_sym_lay.setWidth(line_width)
symbol.appendSymbolLayer(line_sym_lay)
# Symbol
self.marker_sym = QgsMarkerSymbolV2.createSimple({})
self.marker_sym.deleteSymbolLayer(0)
# marker_sym_lay = QgsSimpleMarkerSymbolLayerV2()
current_dir = os.path.dirname(__file__)
svg_props = dict()
svg_props['name'] = os.path.join(current_dir, icon_name)
svg_props['size'] = str(svg_size)
marker_sym_lay = QgsSvgMarkerSymbolLayerV2().create(svg_props)
self.marker_sym.appendSymbolLayer(marker_sym_lay)
marker_line_sym_lay = QgsMarkerLineSymbolLayerV2()
marker_line_sym_lay.setSubSymbol(self.marker_sym) # Causes crash !!!
marker_line_sym_lay.setPlacement(QgsMarkerLineSymbolLayerV2.CentralPoint)
symbol.appendSymbolLayer(marker_line_sym_lay)
renderer = QgsSingleSymbolRendererV2(symbol)
return renderer
def getDefaultSymbol(size):
symbol = QgsMarkerSymbolV2()
symbolLayer = QgsSvgMarkerSymbolLayerV2()
symbolLayer.setPath(
os.path.join(os.path.dirname(__file__), 'svg', 'question.svg'))
symbolLayer.setSizeUnit(3)
symbolLayer.setSize(size)
symbol.insertSymbolLayer(0, symbolLayer)
return symbol
def make_svg_node_sym_renderer(self, vlay, icon_name, size):
current_dir = os.path.dirname(__file__)
svg_style = dict()
svg_style['name'] = os.path.join(current_dir, icon_name)
svg_style['size'] = str(size)
symbol_layer = QgsSvgMarkerSymbolLayerV2.create(svg_style)
symbol = QgsSymbolV2.defaultSymbol(vlay.geometryType())
symbol.changeSymbolLayer(0, symbol_layer)
renderer = QgsSingleSymbolRendererV2(symbol)
return renderer
def getSymbolLayer(folder, svg, size):
svg = svg + '.svg'
root = os.path.join(os.path.dirname(__file__), 'svg', folder)
filepath = None
for base, dirs, files in os.walk(root):
matching = fnmatch.filter(files, svg)
if matching:
filepath = os.path.join(base, matching[0])
break
if filepath is not None:
symbolLayer = QgsSvgMarkerSymbolLayerV2()
symbolLayer.setPath(filepath)
symbolLayer.setSizeUnit(3)
symbolLayer.setSize(size)
return symbolLayer
else:
return None
def __init__(self,
iface,
layer_name,
svg_size,
attributes,
svg_resource,
group=None,
visible=True):
"..."
self.svg_path = os.path.dirname(__file__) + "/icons/"
WGS84Layer.__init__(self, iface, layer_name, "Point", visible, group)
props = self.layer.rendererV2().symbol().symbolLayer(0).properties()
svgStyle = {}
svgStyle['name'] = self.svg_path + svg_resource
svgStyle['outline'] = '#00000'
svgStyle['outline-width'] = '0'
svgStyle['size'] = svg_size
symbol_layer = QgsSvgMarkerSymbolLayerV2.create(svgStyle)
# Rotate the svg to reflect the orientation of a landmark
# admap uses a counter-clockwise orientation with radians, qgis a clockwise and degrees
dataDefinedAngle = QgsDataDefined(
True, True, '(-("Orientation" * 180 / pi()) - 90) % 360')
symbol_layer.setDataDefinedProperty('angle', dataDefinedAngle)
# Make the SVG size scalable with the zoom level of the map
# i.e. less zoom, smaller SVG
dataDefinedSize = QgsDataDefined(
True, True,
'CASE WHEN @map_scale < 500 THEN 1000 / @map_scale ELSE 2 END')
symbol_layer.setDataDefinedProperty('size', dataDefinedSize)
self.layer.rendererV2().symbols()[0].changeSymbolLayer(0, symbol_layer)
WGS84Layer.refresh_legend(self)
self.set_attributes(attributes)
def WPT2Layer(self):
mapUnits = define._canvas.mapUnits()
if define._mapCrs == None:
if mapUnits == QGis.Meters:
resultLayer = QgsVectorLayer(
"Point?crs=EPSG:32633", "WPT_" +
self.surfaceType.replace(" ", "_").replace("-", "_"),
"memory")
else:
resultLayer = QgsVectorLayer(
"Point?crs=EPSG:4326", "WPT_" +
self.surfaceType.replace(" ", "_").replace("-", "_"),
"memory")
else:
resultLayer = QgsVectorLayer(
"Point?crs=%s" % define._mapCrs.authid(),
"WPT_" + self.surfaceType.replace(" ", "_").replace("-", "_"),
"memory")
shpPath = ""
if define.obstaclePath != None:
shpPath = define.obstaclePath
elif define.xmlPath != None:
shpPath = define.xmlPath
else:
shpPath = define.appPath
er = QgsVectorFileWriter.writeAsVectorFormat(
resultLayer,
shpPath + "/" + "RnavTurningSegmentAnalyserWpt" + ".shp", "utf-8",
resultLayer.crs())
resultLayer = QgsVectorLayer(
shpPath + "/" + "RnavTurningSegmentAnalyserWpt" + ".shp",
"WPT_RnavTurningSegmentAnalyser", "ogr")
fieldName = "CATEGORY"
resultLayer.dataProvider().addAttributes(
[QgsField(fieldName, QVariant.String)])
resultLayer.startEditing()
fields = resultLayer.pendingFields()
i = 1
feature = QgsFeature()
feature.setFields(fields)
feature.setGeometry(
QgsGeometry.fromPoint(self.parametersPanel.pnlWaypoint1.Point3d))
feature.setAttribute(fieldName, "Waypoint1")
pr = resultLayer.dataProvider()
pr.addFeatures([feature])
# resultLayer.addFeature(feature)
feature.setGeometry(
QgsGeometry.fromPoint(self.parametersPanel.pnlWaypoint2.Point3d))
feature.setAttribute(fieldName, "Waypoint2")
pr = resultLayer.dataProvider()
pr.addFeatures([feature])
# resultLayer.addFeature(feature)
resultLayer.commitChanges()
renderCatFly = None
if self.parametersPanel.cmbType1.SelectedIndex == 1:
'''FlyOver'''
symbolFlyOver = QgsSymbolV2.defaultSymbol(
resultLayer.geometryType())
symbolFlyOver.deleteSymbolLayer(0)
svgSymLayer = QgsSvgMarkerSymbolLayerV2("Resource/flyover.svg",
10.0, 0.0)
symbolFlyOver.appendSymbolLayer(svgSymLayer)
renderCatFly = QgsRendererCategoryV2(0, symbolFlyOver, "Fly Over")
elif self.parametersPanel.cmbType1.SelectedIndex == 0:
'''FlyBy'''
symbolFlyBy = QgsSymbolV2.defaultSymbol(resultLayer.geometryType())
symbolFlyBy.deleteSymbolLayer(0)
svgSymLayer = QgsSvgMarkerSymbolLayerV2("Resource/flyby.svg", 10.0,
0.0)
symbolFlyBy.appendSymbolLayer(svgSymLayer)
renderCatFly = QgsRendererCategoryV2(0, symbolFlyBy, "Fly By")
else:
return None
WPT_EXPRESION = "CASE WHEN \"CATEGORY\" = 'Waypoint1' THEN 0 " + \
"END"
symRenderer = QgsCategorizedSymbolRendererV2(WPT_EXPRESION,
[renderCatFly])
resultLayer.setRendererV2(symRenderer)
return resultLayer
def run(self):
"""Run method that performs all the real work"""
#field_expression_widget.show()
self.dlg.show()
#set in combobox layer to active layer
try:
QgsMessageLog.logMessage("changing layer to selected in legend",
tag="SvgBubble")
selectedLayer = self.iface.activeLayer(
) #iface.legendInterface().selectedLayers()
self.dlg.lyrCombobox.setLayer(selectedLayer)
except:
QgsMessageLog.logMessage("cant set selected layer",
tag="SvgBubble")
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
QgsMessageLog.logMessage("Start calculate values", tag="SvgBubble")
layer = self.dlg.lyrCombobox.currentLayer()
self.iface.setActiveLayer(layer)
LAYER_NAME = layer.id() #.name()
PROJECT_PATH = QgsProject.instance().readPath("./")
QgsMessageLog.logMessage("Folder={} Layer={}".format(
PROJECT_PATH, LAYER_NAME),
tag="SvgBubble")
provider = layer.dataProvider()
#QMessageBox.information(None, "Layer info", ",".join(map(lambda x:x.currentText(),exprs)))
# Add new column to layer
idx = provider.fieldNameIndex(C_SVG_NAME)
if idx == -1:
QgsMessageLog.logMessage("Create field={}".format(C_SVG_NAME),
tag="SvgBubble")
provider.addAttributes([QgsField(C_SVG_NAME, QVariant.String)])
idx = provider.fieldNameIndex(C_SVG_RADIUS)
if idx == -1:
QgsMessageLog.logMessage(
"Create field={}".format(C_SVG_RADIUS), tag="SvgBubble")
provider.addAttributes(
[QgsField(C_SVG_RADIUS, QVariant.Double, 'double', 20, 2)])
layer.updateFields()
############## UPDATE VIRTUAL FIELD
QgsMessageLog.logMessage("Create field={}".format(C_SVG_PATH),
tag="SvgBubble")
caps_string = layer.dataProvider().capabilitiesString()
QgsMessageLog.logMessage(
"Layer capabilities={}".format(caps_string), tag="SvgBubble")
isExpPresent = False
field = QgsField(C_SVG_PATH, QVariant.String)
field_exp = "eval('@project_folder')+'/{}/'+ \"{}\"".format(
LAYER_NAME, C_SVG_NAME)
for _idx, atr in enumerate(layer.pendingFields()):
QgsMessageLog.logMessage("All fields=[{}]{}".format(
str(_idx), str(atr.name())),
tag="SvgBubble")
if atr.name() == C_SVG_PATH:
QgsMessageLog.logMessage("Old layer idx={}".format(
str(_idx)),
tag="SvgBubble")
#layer.removeExpressionField(_idx) #not work
#layer.deleteAttribute(_idx) #not work on expression
layer.updateExpressionField(_idx, field_exp)
isExpPresent = True
QgsMessageLog.logMessage(
"Field {} updated".format(C_SVG_PATH), tag="SvgBubble")
break
if not isExpPresent:
layer.addExpressionField(field_exp, field)
QgsMessageLog.logMessage("Field {} created".format(C_SVG_PATH),
tag="SvgBubble")
QgsMessageLog.logMessage("Field func={}".format(field_exp),
tag="SvgBubble")
layer.updateFields()
############# start edit layer feature
layer.startEditing()
# Set new column value
QgsMessageLog.logMessage("Start updating table data",
tag="SvgBubble")
preset_rows = self.dlg.preset_rows
svg_drawer = SvgDrawer("{}/{}".format(PROJECT_PATH, LAYER_NAME))
for f in layer.getFeatures():
#well_idx = layer.fieldNameIndex('well_id')
#QgsMessageLog.logMessage(str(f.attributes()[well_idx]), tag="SvgBubble")
#values=map(lambda x:x.evaluate(f),exp_lst)#exp.evaluate(f)
#QMessageBox.information(None, "Layer info",str(values)) #!!!!!DEBUG
preset_rows.setFeature(f)
bubles = {}
for key, presets in preset_rows.asDict().items():
bubl_parts = []
for preset in presets:
QgsMessageLog.logMessage(str(preset.exp_txt),
tag="SvgBubble",
level=3)
val = preset.execute()
QgsMessageLog.logMessage(str(val),
tag="SvgBubble",
level=3)
color = preset.color_hex
if val is None: continue
else: bubl_parts.append([color, val])
#QMessageBox.information(None, "execute info","{}:{}".format(key,str(bubl_parts))) #!!!!!DEBUG
if len(bubl_parts) > 0:
bubles[key] = bubl_parts
else:
pass
QgsMessageLog.logMessage(str(bubles), tag="SvgBubble", level=3)
svg_name, svg_size = svg_drawer.to_multibubl_svg(bubles)
QgsMessageLog.logMessage(str(svg_name),
tag="SvgBubble",
level=2)
#QMessageBox.information(None, "Execute result saved to",str(res_path)) #!!!!!DEBUG
if not svg_name is None:
layer.changeAttributeValue(
f.id(), layer.fieldNameIndex(C_SVG_NAME), svg_name)
layer.changeAttributeValue(
f.id(), layer.fieldNameIndex(C_SVG_RADIUS), svg_size)
QgsMessageLog.logMessage("End feature iterator", tag="SvgBubble")
layer.commitChanges()
# create a new rule-based renderer
# get the "root" rule
svgStyle = {}
svgStyle['name'] = '"bubbl"'
svgStyle["name_dd_active"] = "1"
svgStyle["name_dd_expression"] = ""
svgStyle['name_dd_field'] = C_SVG_PATH
svgStyle['name_dd_useexpr'] = "0"
svgStyle["offset"] = "0.0"
svgStyle["scale_method"] = "diameter"
svgStyle["size"] = "1"
svgStyle["size_dd_active"] = "1"
svgStyle["size_dd_expression"] = '"{}"/1000'.format(C_SVG_RADIUS)
svgStyle['size_dd_field'] = ''
svgStyle['size_dd_useexpr'] = "1"
svgStyle['idx'] = "bubbl_layer"
symbol_layer = QgsSvgMarkerSymbolLayerV2.create(svgStyle)
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
renderer = QgsSingleSymbolRendererV2(symbol)
QgsMessageLog.logMessage("set renderer", tag="SvgBubble")
# assign the created renderer to the layer
isSvgVisible = False
for _idx_sym, preset_sym in enumerate(
layer.rendererV2().symbols()):
for _idx_symlyr, preset_symlyr in enumerate(
preset_sym.symbolLayers()):
lyr_type = preset_symlyr.layerType()
lyr_prop = preset_symlyr.properties()
if lyr_type == "SvgMarker" and lyr_prop[
"name_dd_field"] == C_SVG_PATH:
QgsMessageLog.logMessage("symbollayer properties=" +
str(lyr_prop),
tag="SvgBubble")
QgsMessageLog.logMessage("symbollayer type=" +
str(lyr_type),
tag="SvgBubble")
#renderer.symbols()[_idx_sym].changeSymbolLayer(_idx_symlyr, symbol_layer)
isSvgVisible = True
break
if not isSvgVisible:
#layer.rendererV2().symbols()[0].appendSymbolLayer(symbol_layer)
layer.rendererV2().symbols()[0].insertSymbolLayer(
0, symbol_layer)
#renderer.symbols()[0].changeSymbolLayer(0, symbol_layer)
#if renderer is not None: layer.setRendererV2(renderer)
#layer.setRendererV2(renderer)
QgsMessageLog.logMessage("repaint", tag="SvgBubble")
layer.triggerRepaint()
QgsMessageLog.logMessage("Finished", tag="SvgBubble")
pass
