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