def setUp(self):
self.iface = get_iface()
polys_shp = os.path.join(TEST_DATA_DIR, 'polys.shp')
points_shp = os.path.join(TEST_DATA_DIR, 'points.shp')
lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp')
self.polys_layer = QgsVectorLayer(polys_shp, 'Polygons', 'ogr')
self.points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr')
self.lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(self.polys_layer)
QgsMapLayerRegistry.instance().addMapLayer(self.lines_layer)
QgsMapLayerRegistry.instance().addMapLayer(self.points_layer)
# Create style
sym1 = QgsFillSymbolV2.createSimple({'color': '#fdbf6f'})
sym2 = QgsLineSymbolV2.createSimple({'color': '#fdbf6f'})
sym3 = QgsMarkerSymbolV2.createSimple({'color': '#fdbf6f'})
self.polys_layer.setRendererV2(QgsSingleSymbolRendererV2(sym1))
self.lines_layer.setRendererV2(QgsSingleSymbolRendererV2(sym2))
self.points_layer.setRendererV2(QgsSingleSymbolRendererV2(sym3))
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-133, 22, -70, 52))
def addMemoryLayer(self):
'''Adds a layer to contain the feature defined by a bounding box, wkt,
digitised poly|line|point or selection from other layer.
'''
foi_type = self.foi_type.lower()
if foi_type == 'areaofinterestdefiner':
layer = QgsVectorLayer("Polygon", "Area of Interest", "memory")
if foi_type == 'lineofinterestdefiner':
layer = QgsVectorLayer("Linestring", "Line of Interest", "memory")
if foi_type == 'pointofinterestdefiner':
layer = QgsVectorLayer("Point", "Point of Interest", "memory")
if foi_type == 'areaofinterestdefiner':
sym = QgsSymbol(QGis.Polygon)
sym.setColor(QtCore.Qt.black)
sym.setFillColor(QtCore.Qt.green)
sym.setFillStyle(QtCore.Qt.Dense6Pattern)
sym.setLineWidth(0.5)
sr = QgsSingleSymbolRenderer(QGis.Polygon)
if foi_type == 'lineofinterestdefiner':
sym = QgsSymbol(QGis.Line)
sym.setColor(QtCore.Qt.black)
sym.setFillColor(QtCore.Qt.green)
sym.setFillStyle(QtCore.Qt.SolidPattern)
sym.setLineWidth(0.5)
sr = QgsSingleSymbolRenderer(QGis.Line)
if foi_type == 'pointofinterestdefiner':
sym = QgsSymbol(QGis.Point)
sym.setColor(QtCore.Qt.black)
sym.setFillColor(QtCore.Qt.green)
sym.setFillStyle(QtCore.Qt.SolidPattern)
sym.setLineWidth(0.3)
sym.setPointSize(4)
sym.setNamedPointSymbol("hard:triangle")
sr = QgsSingleSymbolRenderer(QGis.Point)
sr.addSymbol(sym)
layer.setRenderer(sr)
if not layer.isValid():
print "invalid layer"
return
ml_dp = layer.dataProvider()
ml_dp.addAttributes([QgsField("gid", QtCore.QVariant.String)])
# add layer to the registry
self.mem_layer_obj = QgsMapLayerRegistry.instance().addMapLayer(layer)
# set extent to the extent of our layer
#self.canvas.setExtent(layer.extent())
# set the map canvas layer set
cl = QgsMapCanvasLayer(layer)
self.mapCanvasLayers.insert(0, cl)
#layers = [cl]
self.canvas.setLayerSet(self.mapCanvasLayers)
print "added Layer"
def buildRenderer(self, xAttr, yAttr):
color = QColor(randint(0, 255), randint(0, 255), randint(0, 255))
symbol = QgsMarkerSymbolV2.createSimple({})
symbol.deleteSymbolLayer(0)
prop = QgsDataDefined()
prop.setField("size")
prop.setActive(True)
symbol_layer = QgsSimpleMarkerSymbolLayerV2()
symbol_layer.setColor(color)
symbol_layer.setOutputUnit(QgsSymbolV2.MapUnit)
symbol_layer.setDataDefinedProperty("size", prop)
symbol.appendSymbolLayer(symbol_layer)
symbol_layer = QgsVectorFieldSymbolLayer()
symbol_layer.setColor(color)
symbol_layer.VectorFieldType(QgsVectorFieldSymbolLayer.Cartesian)
symbol_layer.AngleUnits(QgsVectorFieldSymbolLayer.Degrees)
symbol_layer.setScale(2.0)
symbol_layer.setXAttribute(xAttr)
symbol_layer.setYAttribute(yAttr)
subSymbol = self.subRenderer(color)
symbol_layer.setSubSymbol(subSymbol)
symbol.appendSymbolLayer(symbol_layer)
renderer = QgsSingleSymbolRendererV2(symbol)
return renderer
def simple_polygon_without_brush(layer, width='0.26', color=QColor('black')):
"""Simple style to apply a border line only to a polygon layer.
:param layer: The layer to style.
:type layer: QgsVectorLayer
:param color: Color to use for the line. Default to black.
:type color: QColor
:param width: Width to use for the line. Default to '0.26'.
:type width: str
"""
registry = QgsSymbolLayerV2Registry.instance()
line_metadata = registry.symbolLayerMetadata("SimpleLine")
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
# Line layer
line_layer = line_metadata.createSymbolLayer({
'width': width,
'color': color.name(),
'offset': '0',
'penstyle': 'solid',
'use_custom_dash': '0',
'joinstyle': 'bevel',
'capstyle': 'square'
})
# Replace the default layer with our custom line
symbol.deleteSymbolLayer(0)
symbol.appendSymbolLayer(line_layer)
renderer = QgsSingleSymbolRendererV2(symbol)
layer.setRendererV2(renderer)
def __getSingleSymbolRenderer(self):
"""docstring for __getSingleSymbolRenderer"""
msclass = self.mslayer["classes"][0]
Symbol = SymbolImport(msclass, self.qgslayer, self.geom_type, self.sizeunits, \
self.mssymbols, self.symbolsetpath, self.fontset)
symbol = Symbol.getSymbol()
return QgsSingleSymbolRendererV2(symbol)
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 style_curves(self):
registry = QgsSymbolLayerV2Registry.instance()
cross = registry.symbolLayerMetadata("SimpleMarker").createSymbolLayer(
{
'name': 'cross2',
'color': '0,0,0',
'color_border': '0,0,0',
'offset': '0,0',
'size': '1.5',
'angle': '0'
})
symbol = QgsSymbolV2.defaultSymbol(self.layer.geometryType())
symbol.deleteSymbolLayer(0)
symbol.appendSymbolLayer(cross)
self._set_symbol_size(symbol)
renderer = QgsSingleSymbolRendererV2(symbol)
effect = QgsOuterGlowEffect()
effect.setSpread(0.5)
effect.setTransparency(0)
effect.setColor(QColor(255, 255, 255))
effect.setBlurLevel(1)
renderer.paintEffect().appendEffect(effect)
renderer.paintEffect().setEnabled(True)
self.layer.setRendererV2(renderer)
self.layer.setLayerTransparency(30) # percent
self.layer.triggerRepaint()
self.iface.legendInterface().refreshLayerSymbology(self.layer)
self.iface.mapCanvas().refresh()
def commitClicked(self):
feature = self.listWidget.currentItem().feature
geom = None
self.attributesTable.setRowCount(len(feature))
for idx, attrname in enumerate(feature):
value = feature[attrname]
font = QFont()
font.setBold(True)
font.setWeight(75)
item = QTableWidgetItem(attrname)
item.setFont(font)
self.attributesTable.setItem(idx, 0, item)
self.attributesTable.setItem(idx, 1, QTableWidgetItem(str(value)))
if geom is None:
try:
geom = QgsGeometry.fromWkt(value)
except:
pass
self.attributesTable.resizeRowsToContents()
self.attributesTable.horizontalHeader().setMinimumSectionSize(150)
self.attributesTable.horizontalHeader().setStretchLastSection(True)
settings = QSettings()
prjSetting = settings.value('/Projections/defaultBehaviour')
settings.setValue('/Projections/defaultBehaviour', '')
types = ["Point", "LineString", "Polygon"]
layers = []
if geom is not None:
geomtype = types[int(geom.type())]
layer = loadLayerNoCrsDialog(geomtype + "?crs=EPSG:4326", "temp",
"memory")
pr = layer.dataProvider()
feat = QgsFeature()
feat.setGeometry(geom)
pr.addFeatures([feat])
layer.updateExtents()
layer.selectAll()
layer.setExtent(layer.boundingBoxOfSelected())
layer.invertSelection()
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
symbol.setColor(Qt.green)
symbol.setAlpha(0.5)
if QGis.QGIS_VERSION_INT < 29900:
layer.setRendererV2(QgsSingleSymbolRendererV2(symbol))
else:
layer.setRenderer(QgsSingleSymbolRenderer(symbol))
self.mapCanvas.setRenderFlag(False)
self.mapCanvas.setLayerSet([QgsMapCanvasLayer(layer)])
QgsMapLayerRegistry.instance().addMapLayer(layer, False)
self.mapCanvas.setExtent(layer.extent())
self.mapCanvas.setRenderFlag(True)
layers.append(layer)
else:
self.mapCanvas.setLayerSet([])
settings.setValue('/Projections/defaultBehaviour', prjSetting)
def test_setRendererV2(self):
layer = createLayerWithOnePoint()
self.rendererChanged = False
layer.rendererChanged.connect(self.onRendererChanged)
r = QgsSingleSymbolRendererV2(QgsSymbolV2.defaultSymbol(QGis.Point))
layer.setRendererV2(r)
self.assertTrue(self.rendererChanged)
self.assertEquals(layer.rendererV2(), r)
def test_setRendererV2(self):
layer = createLayerWithOnePoint()
self.rendererChanged = False
QObject.connect(layer, SIGNAL("rendererChanged()"),
self.onRendererChanged)
r = QgsSingleSymbolRendererV2(QgsSymbolV2.defaultSymbol(QGis.Point))
layer.setRendererV2(r)
assert self.rendererChanged == True
assert layer.rendererV2() == r
def make_simple_link_sym_renderer(self, width=0.2):
symbol = QgsLineSymbolV2().createSimple({})
symbol.deleteSymbolLayer(0)
# Line
line_sym_lay = QgsSimpleLineSymbolLayerV2()
line_sym_lay.setWidth(width)
symbol.appendSymbolLayer(line_sym_lay)
renderer = QgsSingleSymbolRendererV2(symbol)
return renderer
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 make_simple_node_sym_renderer(self, size=2):
symbol = QgsMarkerSymbolV2().createSimple({})
symbol.deleteSymbolLayer(0)
# Point
sim_marker_sym_lay = QgsSimpleMarkerSymbolLayerV2()
sim_marker_sym_lay.setColor(QColor(0, 0, 0))
sim_marker_sym_lay.setFillColor(QColor(0, 0, 0))
sim_marker_sym_lay.setSize(size)
symbol.appendSymbolLayer(sim_marker_sym_lay)
renderer = QgsSingleSymbolRendererV2(symbol)
return renderer
def testPartCount(self):
# Create rulebased style
sym1 = QgsFillSymbolV2.createSimple({'color': '#fdbf6f'})
renderer = QgsSingleSymbolRendererV2(sym1)
renderer.symbols()[0].symbolLayers()[0].setDataDefinedProperty('color', 'color_rgb( (@geometry_part_count - 1) * 200, 0, 0 )')
self.layer.setRendererV2(renderer)
# Setup rendering check
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlName('expected_geometry_part_count')
result = renderchecker.runTest('part_geometry_part_count')
self.assertTrue(result)
def testSymbolColor(self):
# Create rulebased style
sym1 = QgsFillSymbolV2.createSimple({'color': '#ff0000'})
renderer = QgsSingleSymbolRendererV2(sym1)
renderer.symbols()[0].symbolLayers()[0].setDataDefinedProperty('color', 'set_color_part( @symbol_color, \'value\', "Value" * 4)')
self.layer.setRendererV2(renderer)
# Setup rendering check
renderchecker = QgsMultiRenderChecker()
renderchecker.setMapSettings(self.mapsettings)
renderchecker.setControlName('expected_symbol_color_variable')
result = renderchecker.runTest('symbol_color_variable', 50)
self.assertTrue(result)
def setUp(self):
self.iface = get_iface()
lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp')
self.lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(self.lines_layer)
# Create style
sym2 = QgsLineSymbolV2.createSimple({'color': '#fdbf6f'})
self.lines_layer.setRendererV2(QgsSingleSymbolRendererV2(sym2))
self.mapsettings = self.iface.mapCanvas().mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-113, 28, -91, 40))
self.mapsettings.setBackgroundColor(QColor("white"))
def setUp(self):
myShpFile = os.path.join(TEST_DATA_DIR, 'polys_overlapping.shp')
layer = QgsVectorLayer(myShpFile, 'Polys', 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(layer)
# Create rulebased style
sym1 = QgsFillSymbolV2.createSimple({'color': '#fdbf6f'})
self.renderer = QgsSingleSymbolRendererV2(sym1)
layer.setRendererV2(self.renderer)
rendered_layers = [layer.id()]
self.mapsettings = CANVAS.mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52))
self.mapsettings.setLayers(rendered_layers)
def symbolize(layer, oldlayer):
renderer = None
# See if we can figure out ho thick the line is to begin with:
# create a new single symbol renderer
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
renderer = QgsSingleSymbolRendererV2(symbol)
# symbol_layer = QgsSimpleLineSymbolLayerV2.create(properties)
symbol_layer = QgsSimpleLineSymbolLayerV2(random_color(), 2.0)
# assign the symbol layer to the symbol
# TODO: on windows::: 'NoneType' object has no attribute 'appendSymbolLayer'
renderer.symbol().appendSymbolLayer(symbol_layer)
# assign the renderer to the layer
layer.setRendererV2(renderer)
def createLayerGrille(uriGrille):
layerGrille = QgsVectorLayer(uriGrille, CONST_NOM_LAYER_GRILLE, "ogr")
fieldIndex = getFieldIndex(layerGrille)
if fieldIndex < 0:
caps = layerGrille.dataProvider().capabilities()
if caps & QgsVectorDataProvider.AddAttributes:
layerGrille.dataProvider().addAttributes(
[QgsField(CONST_ATTRIBUT_ID, QVariant.Int)])
layerGrille.updateFields()
# Style
props = {'color': '241,241,241,0', 'size': '1', 'color_border': '255,0,0'}
s = QgsFillSymbolV2.createSimple(props)
layerGrille.setRendererV2(QgsSingleSymbolRendererV2(s))
return layerGrille
def add_final_pts(self, pts):
center_pt_layer = QgsVectorLayer(
"Point?crs=epsg:4326&field=id_center:integer&field=role:string(80)",
"isochrone_center_{}".format(self.nb_isocr), "memory")
my_symb = QgsSymbolV2.defaultSymbol(0)
my_symb.setColor(QtGui.QColor("#e31a1c"))
my_symb.setSize(1.2)
center_pt_layer.setRendererV2(QgsSingleSymbolRendererV2(my_symb))
features = []
for nb, pt in enumerate(pts):
xo, yo = pt["point"]
fet = QgsFeature()
fet.setGeometry(
QgsGeometry.fromPoint(QgsPoint(float(xo), float(yo))))
fet.setAttributes([nb, 'Origin'])
features.append(fet)
center_pt_layer.dataProvider().addFeatures(features)
QgsMapLayerRegistry.instance().addMapLayer(center_pt_layer)
def create_virtual_layer(self, virtual_layer_name):
sql = ("SELECT value FROM " + self.controller.schema_name + ".config_param_user"
" WHERE cur_user = current_user AND parameter = 'virtual_layer_polygon'")
row = self.controller.get_row(sql)
if not row:
sql = ("INSERT INTO "+self.schema_name + ".config_param_user (parameter, value, cur_user) "
" VALUES ('virtual_layer_polygon', '"+virtual_layer_name+"', current_user)")
self.controller.execute_sql(sql)
srid = self.controller.plugin_settings_value('srid')
uri = "Polygon?crs=epsg:" + str(srid)
virtual_layer = QgsVectorLayer(uri, virtual_layer_name, "memory")
props = {'color': '0, 0, 0', 'style': 'no', 'style_border': 'solid', 'color_border': '255, 0, 0'}
s = QgsFillSymbolV2.createSimple(props)
virtual_layer.setRendererV2(QgsSingleSymbolRendererV2(s))
virtual_layer.updateExtents()
QgsProject.instance().setSnapSettingsForLayer(virtual_layer.id(), True, 2, 0, 1.0, False)
QgsMapLayerRegistry.instance().addMapLayer(virtual_layer)
self.iface.mapCanvas().refresh()
def testInitialSizeSymbolMapUnits(self):
"""Test initial size of legend with a symbol size in map units"""
point_path = os.path.join(TEST_DATA_DIR, 'points.shp')
point_layer = QgsVectorLayer(point_path, 'points', 'ogr')
QgsMapLayerRegistry.instance().addMapLayers([point_layer])
marker_symbol = QgsMarkerSymbolV2.createSimple({
'color': '#ff0000',
'outline_style': 'no',
'size': '5',
'size_unit': 'MapUnit'
})
point_layer.setRendererV2(QgsSingleSymbolRendererV2(marker_symbol))
s = QgsMapSettings()
s.setLayers([point_layer.id()])
s.setCrsTransformEnabled(False)
composition = QgsComposition(s)
composition.setPaperSize(297, 210)
composer_map = QgsComposerMap(composition, 20, 20, 80, 80)
composer_map.setFrameEnabled(True)
composition.addComposerMap(composer_map)
composer_map.setNewExtent(point_layer.extent())
legend = QgsComposerLegend(composition)
legend.setSceneRect(QRectF(120, 20, 80, 80))
legend.setFrameEnabled(True)
legend.setFrameOutlineWidth(2)
legend.setBackgroundColor(QColor(200, 200, 200))
legend.setTitle('')
composition.addComposerLegend(legend)
legend.setComposerMap(composer_map)
checker = QgsCompositionChecker('composer_legend_mapunits',
composition)
checker.setControlPathPrefix("composer_legend")
result, message = checker.testComposition()
self.assertTrue(result, message)
QgsMapLayerRegistry.instance().removeMapLayers([point_layer.id()])
def test_point_ordered_symbol_bound_offset(self):
# Test ordered placements for point using symbol bounds offset
self.layer = TestQgsPalLabeling.loadFeatureLayer(
'point_ordered_placement')
# Make a big symbol
symbol = QgsMarkerSymbolV2.createSimple({
u'color': u'31,120,180,255',
u'outline_color': u'0,0,0,0',
u'outline_style': u'solid',
u'size': u'10',
u'name': u'rectangle',
u'size_unit': u'MM'
})
renderer = QgsSingleSymbolRendererV2(symbol)
self.layer.setRendererV2(renderer)
self._TestMapSettings = self.cloneMapSettings(self._MapSettings)
self.lyr.placement = QgsPalLayerSettings.OrderedPositionsAroundPoint
self.lyr.dist = 2
self.lyr.offsetType = QgsPalLayerSettings.FromSymbolBounds
self.checkTest()
self.removeMapLayer(self.layer)
self.layer = None
def setSimpleStyle(vl, **kwargs):
""" set a simple style """
symbolV2 = QgsSymbolV2.defaultSymbol(vl.geometryType())
if 'color' in kwargs:
symbolV2.setColor(kwargs['color'])
size = kwargs.get('size', None)
if 'size' in kwargs:
symbolV2.setSize(kwargs['size'])
# in QGis > 1.8 QgsMarkerSymbolV2 has 2 scale methods: ScaleArea and ScaleDiameter
if 'sizeScaleMethod' in kwargs and hasattr(symbolV2, 'setScaleMethod'):
symbolV2.setScaleMethod(kwargs['sizeScaleMethod'])
# create the renderer
renderer = QgsSingleSymbolRendererV2(symbolV2)
# set size scale field
if 'sizeScaleField' in kwargs:
renderer.setSizeScaleField(kwargs['sizeScaleField'])
# set the renderer for the layer
vl.setRendererV2(renderer)
Utils.iface.legendInterface().refreshLayerSymbology(vl)
def prepare_ordered_marker(self, coords, idx):
"""
Try to display nice marker on a point layer, showing the order of
the path computed by OSRM.
"""
self.tsp_marker_lr = QgsVectorLayer(
"Point?crs=epsg:4326&field=id:integer"
"&field=TSP_nb:integer(20)&field=Origin_nb:integer(20)",
"tsp_markers_osrm{}".format(self.nb_route), "memory")
symbol = QgsSymbolV2.defaultSymbol(self.tsp_marker_lr.geometryType())
symbol.setSize(4.5)
symbol.setColor(QtGui.QColor("yellow"))
ordered_pts = \
[coords[i["waypoint_index"]] for i in self.parsed['waypoints']]
print("ordered_pts : ", ordered_pts)
features = []
for nb, pt in enumerate(ordered_pts):
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(pt)))
ft.setAttributes([nb, nb + 1, coords.index(pt)])
features.append(ft)
self.tsp_marker_lr.dataProvider().addFeatures(features)
pal_lyr = QgsPalLayerSettings()
pal_lyr.readFromLayer(self.tsp_marker_lr)
pal_lyr.enabled = True
pal_lyr.fieldName = 'TSP_nb'
pal_lyr.placement = QgsPalLayerSettings.OverPoint
pal_lyr.setDataDefinedProperty(QgsPalLayerSettings.Size, True, True,
'12', '')
pal_lyr.writeToLayer(self.tsp_marker_lr)
self.tsp_marker_lr.setRendererV2(QgsSingleSymbolRendererV2(symbol))
QgsMapLayerRegistry.instance().addMapLayer(self.tsp_marker_lr)
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
def showNodes(self):
"""
Parse the geometry of a selected layer and show its vertices (nodes)
"""
mr = self.layerRegistry
# Get the selected layer for which to show nodes
selectedIndex = self.dlg.comboLayers.currentIndex()
selectedLayer = self.dlg.comboLayers.itemData(selectedIndex)
registeredLayers = self.layerRegistry.mapLayersByName('Noeuds')
featuresCount = int(selectedLayer.featureCount())
# Remove the node layer if already existing
if mr.mapLayersByName('Noeuds'):
mr.removeMapLayer(mr.mapLayersByName('Noeuds')[0].id())
# Create memory layer to display nodes
self.nodeLayer = QgsVectorLayer("Point?crs=EPSG:2056", "Noeuds",
"memory")
self.nodeLayerProvider = self.nodeLayer.dataProvider()
# Create rendering style
nodeSymbol = QgsMarkerSymbolV2.defaultSymbol(
self.nodeLayer.geometryType())
nodeSymbol.setColor(QColor('#CC3300'))
nodeSymbol.setSize(2.0)
nodeRenderer = QgsSingleSymbolRendererV2(nodeSymbol)
self.nodeLayer.setRendererV2(nodeRenderer)
# Select features visible in current map canvas extent
if self.dlg.chkSelectByCanvasExtent.checkState():
extent = self.canvas.extent()
rect = QgsRectangle(extent.xMinimum(), extent.yMinimum(),
extent.xMaximum(), extent.yMaximum())
request = QgsFeatureRequest()
request.setFilterRect(rect)
featureIterator = selectedLayer.getFeatures(request)
# Select all features
else:
featureIterator = selectedLayer.getFeatures()
# Create progress bar
progressMessageBar = self.messageBar.createMessage(
unicode("Création des noeuds...", "utf-8"))
progress = QProgressBar()
progress.setMinimum(0)
progress.setMaximum(featuresCount)
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.messageBar.pushWidget(progressMessageBar,
self.iface.messageBar().INFO)
# Iterate over feature
k = 0
for feature in featureIterator:
k += 1
progress.setValue(k)
geom = feature.geometry()
feat = QgsFeature()
# Adapt procedure for each geometry type
if (geom):
type = geom.wkbType()
# LineString
if type == QGis.WKBLineString:
for point in geom.asPolyline():
feat.setGeometry(QgsGeometry.fromPoint(point))
self.nodeLayerProvider.addFeatures([feat])
# MultiLineString
elif type == QGis.WKBMultiLineString:
for line in geom.asMultiPolyline():
for vertex in line:
feat.setGeometry(
QgsGeometry.fromPoint(
QgsPoint(vertex[0], vertex[1])))
self.nodeLayerProvider.addFeatures([feat])
# Polygon
elif type == QGis.WKBPolygon:
polygons = geom.asPolygon()
for polygon in polygons:
for vertex in polygon:
feat.setGeometry(
QgsGeometry.fromPoint(
QgsPoint(vertex[0], vertex[1])))
self.nodeLayerProvider.addFeatures([feat])
# MultiPolygon
elif type == QGis.WKBMultiPolygon:
multiPoly = geom.asMultiPolygon()
for polygons in multiPoly:
for polygon in polygons:
for vertex in polygon:
feat.setGeometry(
QgsGeometry.fromPoint(
QgsPoint(vertex[0], vertex[1])))
self.nodeLayerProvider.addFeatures([feat])
else:
self.messageBar.pushMessage(
"Cartotools : ",
unicode("Type de géométrie non" + "supporté: " + str(type),
"utf-8"),
level=QgsMessageBar.CRITICAL)
self.messageBar.clearWidgets()
self.layerRegistry.addMapLayer(self.nodeLayer)
def setBasemapStyle(vl):
# set the basemap layer color
if not vl.isUsingRendererV2():
vl.setRendererV2(QgsSingleSymbolRendererV2())
vl.rendererV2().symbol().setColor(QColor("#FFF1B7")) # beige
def get_route(self):
"""
Main method to prepare the request and display the result on the
QGIS canvas.
"""
try:
self.host = check_host(self.lineEdit_host.text())
profile = check_profile_name(self.lineEdit_profileName.text())
except (ValueError, AssertionError) as err:
print(err)
self.iface.messageBar().pushMessage(
"Error",
"Please provide a valid non-empty URL and profile name",
duration=10)
return
origin = self.lineEdit_xyO.text()
interm = self.lineEdit_xyI.text()
destination = self.lineEdit_xyD.text()
try:
assert match('^[^a-zA-Z]+$', origin) \
and 46 > len(origin) > 4
assert match('^[^a-zA-Z]+$', destination) \
and 46 > len(destination) > 4
xo, yo = eval(origin)
xd, yd = eval(destination)
except:
self.iface.messageBar().pushMessage("Error",
"Invalid coordinates !",
duration=10)
return -1
if interm:
try:
assert match('^[^a-zA-Z]+$', interm) \
and 150 > len(interm) > 4
interm = eval(''.join(['[', interm, ']']))
tmp = ';'.join(['{},{}'.format(xi, yi) for xi, yi in interm])
url = ''.join([
"http://", self.host, "/route/", profile, "/",
"{},{};".format(xo, yo), tmp, ";{},{}".format(xd, yd),
"?overview=full&alternatives={}".format(
str(self.checkBox_alternative.isChecked()).lower())
])
except:
self.iface.messageBar().pushMessage(
"Error", "Invalid intemediates coordinates", duration=10)
else:
url = ''.join([
"http://", self.host, "/route/", profile, "/", "polyline(",
encode_to_polyline([(yo, xo), (yd, xd)]), ")",
"?overview=full&alternatives={}".format(
str(self.checkBox_alternative.isChecked()).lower())
])
try:
self.parsed = self.query_url(url)
assert "code" in self.parsed
except Exception as err:
self.display_error(err, 1)
return
if 'Ok' not in self.parsed['code']:
self.display_error(self.parsed['code'], 1)
return
try:
enc_line = self.parsed['routes'][0]["geometry"]
line_geom = decode_geom(enc_line)
except KeyError:
self.iface.messageBar().pushMessage(
"Error",
"No route found between {} and {}".format(origin, destination),
duration=5)
return
self.nb_route += 1
osrm_route_layer = QgsVectorLayer(
"Linestring?crs=epsg:4326&field=id:integer"
"&field=total_time:integer(20)&field=distance:integer(20)",
"route_osrm{}".format(self.nb_route), "memory")
my_symb = prepare_route_symbol(self.nb_route)
osrm_route_layer.setRendererV2(QgsSingleSymbolRendererV2(my_symb))
provider = osrm_route_layer.dataProvider()
fet = QgsFeature()
fet.setGeometry(line_geom)
fet.setAttributes([
0, self.parsed['routes'][0]['duration'],
self.parsed['routes'][0]['distance']
])
provider.addFeatures([fet])
OD_layer = self.make_OD_markers(self.nb_route, xo, yo, xd, yd, interm)
QgsMapLayerRegistry.instance().addMapLayer(OD_layer)
osrm_route_layer.updateExtents()
QgsMapLayerRegistry.instance().addMapLayer(osrm_route_layer)
self.iface.setActiveLayer(osrm_route_layer)
self.iface.zoomToActiveLayer()
put_on_top(OD_layer.id(), osrm_route_layer.id())
# if self.checkBox_instruction.isChecked():
# pr_instruct, instruct_layer = self.prep_instruction()
# QgsMapLayerRegistry.instance().addMapLayer(instruct_layer)
# self.iface.setActiveLayer(instruct_layer)
if self.checkBox_alternative.isChecked() \
and 'alternative_geometries' in self.parsed:
self.nb_alternative = len(self.parsed['routes'] - 1)
self.get_alternatives(provider)
# if self.dlg.checkBox_instruction.isChecked():
# for i in range(self.nb_alternative):
# pr_instruct, instruct_layer = \
# self.prep_instruction(
# i + 1, pr_instruct, instruct_layer)
return
def testCase(self):
self.TEST_DATA_DIR = unitTestDataPath()
tmppath = tempfile.mkdtemp()
for file in glob.glob(
os.path.join(self.TEST_DATA_DIR, 'france_parts.*')):
shutil.copy(os.path.join(self.TEST_DATA_DIR, file), tmppath)
vectorFileInfo = QFileInfo(tmppath + "/france_parts.shp")
mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(),
vectorFileInfo.completeBaseName(), "ogr")
QgsMapLayerRegistry.instance().addMapLayers([mVectorLayer])
# create composition with composer map
self.mapSettings = QgsMapSettings()
layerStringList = []
layerStringList.append(mVectorLayer.id())
self.mapSettings.setLayers(layerStringList)
self.mapSettings.setCrsTransformEnabled(True)
self.mapSettings.setMapUnits(QGis.Meters)
# select epsg:2154
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(2154)
self.mapSettings.setDestinationCrs(crs)
self.mComposition = QgsComposition(self.mapSettings)
self.mComposition.setPaperSize(297, 210)
# fix the renderer, fill with green
props = {"color": "0,127,0"}
fillSymbol = QgsFillSymbolV2.createSimple(props)
renderer = QgsSingleSymbolRendererV2(fillSymbol)
mVectorLayer.setRendererV2(renderer)
# the atlas map
self.mAtlasMap = QgsComposerMap(self.mComposition, 20, 20, 130, 130)
self.mAtlasMap.setFrameEnabled(True)
self.mComposition.addComposerMap(self.mAtlasMap)
# the atlas
self.mAtlas = self.mComposition.atlasComposition()
self.mAtlas.setCoverageLayer(mVectorLayer)
self.mAtlas.setEnabled(True)
self.mComposition.setAtlasMode(QgsComposition.ExportAtlas)
# an overview
mOverview = QgsComposerMap(self.mComposition, 180, 20, 50, 50)
mOverview.setFrameEnabled(True)
mOverview.setOverviewFrameMap(self.mAtlasMap.id())
self.mComposition.addComposerMap(mOverview)
nextent = QgsRectangle(49670.718, 6415139.086, 699672.519, 7065140.887)
mOverview.setNewExtent(nextent)
# set the fill symbol of the overview map
props2 = {"color": "127,0,0,127"}
fillSymbol2 = QgsFillSymbolV2.createSimple(props2)
mOverview.setOverviewFrameMapSymbol(fillSymbol2)
# header label
self.mLabel1 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel1)
self.mLabel1.setText("[% \"NAME_1\" %] area")
self.mLabel1.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel1.adjustSizeToText()
self.mLabel1.setSceneRect(QRectF(150, 5, 60, 15))
qWarning(
"header label font: %s exactMatch:%s" %
(self.mLabel1.font().toString(), self.mLabel1.font().exactMatch()))
# feature number label
self.mLabel2 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel2)
self.mLabel2.setText("# [%$feature || ' / ' || $numfeatures%]")
self.mLabel2.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel2.adjustSizeToText()
self.mLabel2.setSceneRect(QRectF(150, 200, 60, 15))
qWarning(
"feature number label font: %s exactMatch:%s" %
(self.mLabel2.font().toString(), self.mLabel2.font().exactMatch()))
self.filename_test()
self.autoscale_render_test()
self.autoscale_render_test_old_api()
self.fixedscale_render_test()
self.predefinedscales_render_test()
self.hidden_render_test()
self.legend_test()
shutil.rmtree(tmppath, True)
def run_tsp(self):
"""
Main method, preparing the query and displaying the result on
the canvas.
"""
layer = self.comboBox_layer.currentLayer()
coords, _ = get_coords_ids(
layer, '', on_selected=self.checkBox_selec_features.isChecked())
if len(coords) < 2:
return -1
try:
self.host = check_host(self.lineEdit_host.text())
profile = check_profile_name(self.lineEdit_profileName.text())
except (ValueError, AssertionError) as err:
print(err)
self.iface.messageBar().pushMessage(
"Error",
"Please provide a valid non-empty URL and profile name",
duration=10)
return
query = ''.join([
"http://", self.host, "/trip/", profile, "/",
";".join(["{},{}".format(c[0], c[1]) for c in coords])
])
try:
self.parsed = self.query_url(query)
except Exception as err:
self.iface.messageBar().pushMessage(
"Error", "An error occured when trying to contact the OSRM "
"instance (see QGis log for error traceback)",
duration=10)
QgsMessageLog.logMessage(
'OSRM-plugin error report :\n {}'.format(err),
level=QgsMessageLog.WARNING)
return
try:
line_geoms = \
[decode_geom(self.parsed['trips'][i]['geometry'])
for i in range(len(self.parsed['trips']))]
except KeyError:
self.iface.messageBar().pushMessage("Error", "?...", duration=5)
return
tsp_route_layer = QgsVectorLayer(
"Linestring?crs=epsg:4326&field=id:integer"
"&field=total_time:integer(20)&field=distance:integer(20)",
"tsp_solution_osrm{}".format(self.nb_route), "memory")
my_symb = prepare_route_symbol(self.nb_route)
tsp_route_layer.setRendererV2(QgsSingleSymbolRendererV2(my_symb))
features = []
for idx, feature in enumerate(self.parsed['trips']):
ft = QgsFeature()
ft.setGeometry(line_geoms[idx])
ft.setAttributes([idx, feature['distance'], feature['duration']])
features.append(ft)
self.prepare_ordered_marker(coords, idx)
tsp_route_layer.dataProvider().addFeatures(features)
tsp_route_layer.updateExtents()
QgsMapLayerRegistry.instance().addMapLayer(tsp_route_layer)
self.iface.setActiveLayer(tsp_route_layer)
self.iface.zoomToActiveLayer()
put_on_top(self.tsp_marker_lr.id(), tsp_route_layer.id())
self.nb_route += 1
