def testSvgMarkerUnitPixels(self): symbol = QgsSvgMarkerSymbolLayer('symbols/star.svg', 10, 0) symbol.setOffset(QPointF(5, 10)) symbol.setOutputUnit(QgsUnitTypes.RenderPixels) dom, root = self.symbolToSld(symbol) # print("Svg marker unit px: " + dom.toString()) # Check the size has not been rescaled self.assertStaticSize(root, '10') self.assertStaticDisplacement(root, 5, 10)
def testSvgMarkerUnitDefault(self): symbol = QgsSvgMarkerSymbolLayer('symbols/star.svg', 10, 90) symbol.setOffset(QPointF(5, 10)) dom, root = self.symbolToSld(symbol) # print("Svg marker mm: " + dom.toString()) # Check the size has been rescaled self.assertStaticSize(root, '36') # Check rotation for good measure self.assertStaticRotation(root, '90') self.assertStaticDisplacement(root, 18, 36)
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 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 getDefaultSymbol(size): symbol = QgsMarkerSymbol() for i in range(symbol.symbolLayerCount()): symbol.takeSymbolLayer(0) symbolLayer = QgsSvgMarkerSymbolLayer( os.path.join(os.path.dirname(__file__), 'svg', 'question.svg')) symbolLayer.setSizeUnit(3) symbolLayer.setSize(size) symbol.insertSymbolLayer(0, symbolLayer) return symbol
def ned_origin_renderer(self): symbol = QgsSymbol.defaultSymbol(self.ned_origin_layer.geometryType()) svg_style = { 'fill': '# 0000ff', 'name': ':/resources/Star2.svg', 'outline': '#000000', 'outline - width': '6.8', 'size': '6' } # create svg symbol layer sym_lyr1 = QgsSvgMarkerSymbolLayer.create(svg_style) # Replace the default layer with our custom layer symbol.deleteSymbolLayer(0) symbol.appendSymbolLayer(sym_lyr1) # Replace the renderer of the current layer renderer = QgsSingleSymbolRenderer(symbol) return renderer
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) symbol = QgsSymbol.defaultSymbol(self.layer.geometryType()) svgStyle = {} svgStyle['name'] = self.svg_path + svg_resource svgStyle['outline'] = '#00000' svgStyle['outline-width'] = '0' svgStyle['size'] = svg_size symbol_layer = QgsSvgMarkerSymbolLayer.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 = QgsProperty.fromExpression( '(-("Orientation" * 180 / pi()) - 90) % 360', True) symbol_layer.setDataDefinedProperty(QgsSymbolLayer.PropertyAngle, dataDefinedAngle) # Make the SVG size scalable with the zoom level of the map # i.e. less zoom, smaller SVG dataDefinedSize = QgsProperty.fromExpression( 'CASE WHEN @map_scale < 500 THEN 1000 / @map_scale ELSE 2 END', True) symbol_layer.setDataDefinedProperty(QgsSymbolLayer.PropertySize, dataDefinedSize) if symbol_layer is not None: symbols = self.layer.renderer().symbols(QgsRenderContext()) sym = symbols[0] sym.changeSymbolLayer(0, symbol_layer) self.layer.triggerRepaint() WGS84Layer.refresh_legend(self) self.set_attributes(attributes)
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 = QgsSvgMarkerSymbolLayer(filepath) symbolLayer.setSizeUnit(3) symbolLayer.setSize(size) return symbolLayer else: return None
def testSvgMarkerUnitPixels(self): symbol = QgsSvgMarkerSymbolLayer('symbols/star.svg', 10, 0) symbol.setFillColor(QColor("blue")) symbol.setStrokeWidth(1) symbol.setStrokeColor(QColor('red')) symbol.setPath('symbols/star.svg') symbol.setOffset(QPointF(5, 10)) symbol.setOutputUnit(QgsUnitTypes.RenderPixels) dom, root = self.symbolToSld(symbol) # print("Svg marker unit px: " + dom.toString()) self.assertExternalGraphic(root, 0, 'symbols/star.svg?fill=%230000ff&fill-opacity=1&outline=%23ff0000&outline-opacity=1&outline-width=1', 'image/svg+xml') self.assertExternalGraphic(root, 1, 'symbols/star.svg', 'image/svg+xml') self.assertWellKnownMark(root, 0, 'square', '#0000ff', '#ff0000', 1) # Check the size has not been rescaled self.assertStaticSize(root, '10') self.assertStaticDisplacement(root, 5, 10)
def testSvgMarkerUnitDefault(self): symbol = QgsSvgMarkerSymbolLayer('symbols/star.svg', 10, 90) symbol.setFillColor(QColor("blue")) symbol.setStrokeWidth(1) symbol.setStrokeColor(QColor('red')) symbol.setPath('symbols/star.svg') symbol.setOffset(QPointF(5, 10)) dom, root = self.symbolToSld(symbol) # print("Svg marker mm: " + dom.toString()) self.assertExternalGraphic(root, 0, 'symbols/star.svg?fill=%230000ff&fill-opacity=1&outline=%23ff0000&outline-opacity=1&outline-width=4', 'image/svg+xml') self.assertExternalGraphic(root, 1, 'symbols/star.svg', 'image/svg+xml') self.assertWellKnownMark(root, 0, 'square', '#0000ff', '#ff0000', 4) # Check the size has been rescaled self.assertStaticSize(root, '36') # Check rotation for good measure self.assertStaticRotation(root, '90') self.assertStaticDisplacement(root, 18, 36)
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 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)
def setStyle(self, layer, name): if name == "": return stylePath = os.path.join(os.path.dirname(os.path.dirname(__file__)), "layerStyles") # user style qmlPath = os.path.join(stylePath, name + "_user.qml") if os.path.exists(qmlPath): layer.loadNamedStyle(qmlPath) return # default style qmlPath = os.path.join(stylePath, name + ".qml.bak") if os.path.exists(qmlPath): layer.loadNamedStyle(qmlPath) svgPath = os.path.join(stylePath, name + ".svg") if os.path.exists(svgPath): if layer.geometryType() == 0: # Point svg_style = dict() svg_style['name'] = svgPath svg_style['size'] = str(7) if name == "demands": svg_style['fill'] = '#9a1313' symbol_layer = QgsSvgMarkerSymbolLayer.create(svg_style) symbol = QgsSymbol.defaultSymbol(layer.geometryType()) symbol.changeSymbolLayer(0, symbol_layer) renderer = QgsSingleSymbolRenderer(symbol) else: # Line symbol = QgsLineSymbol().createSimple({}) symbol.deleteSymbolLayer(0) # Line lineSymbol = QgsSimpleLineSymbolLayer() lineSymbol.setWidthUnit(2) # Pixels lineSymbol.setWidth(1.5) if name == "pipes": lineSymbol.setColor(QColor("#0f1291")) symbol.appendSymbolLayer(lineSymbol) # Symbol marker = QgsMarkerSymbol.createSimple({}) marker.deleteSymbolLayer(0) svg_props = dict() svg_props['name'] = svgPath size = 5 if name == "pipes": size = 0 svg_props['size'] = str(size) svg_props['offset'] = '-0.5,-0.5' svg_props['offset_unit'] = 'Pixel' markerSymbol = QgsSvgMarkerSymbolLayer.create(svg_props) marker.appendSymbolLayer(markerSymbol) # Final Symbol finalMarker = QgsMarkerLineSymbolLayer() finalMarker.setSubSymbol(marker) finalMarker.setPlacement(QgsMarkerLineSymbolLayer.CentralPoint) symbol.appendSymbolLayer(finalMarker) if name == "pipes": prop = QgsProperty() prop.setExpressionString( "if(IniStatus is NULL, 0,if(IniStatus !='CV', 0,5))") symbol.symbolLayer(1).setDataDefinedProperty( 9, prop) # 9 = PropertyWidth renderer = QgsSingleSymbolRenderer(symbol) layer.setRenderer(renderer)
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 testSvgMarkerUnitDefault(self): symbol = QgsSvgMarkerSymbolLayer("symbols/star.svg", 10, 90) symbol.setFillColor(QColor("blue")) symbol.setOutlineWidth(1) symbol.setOutlineColor(QColor("red")) symbol.setPath("symbols/star.svg") symbol.setOffset(QPointF(5, 10)) dom, root = self.symbolToSld(symbol) # print("Svg marker mm: " + dom.toString()) self.assertExternalGraphic( root, 0, "symbols/star.svg?fill=%230000ff&fill-opacity=1&outline=%23ff0000&outline-opacity=1&outline-width=4", "image/svg+xml", ) self.assertExternalGraphic(root, 1, "symbols/star.svg", "image/svg+xml") self.assertWellKnownMark(root, 0, "square", "#0000ff", "#ff0000", 4) # Check the size has been rescaled self.assertStaticSize(root, "36") # Check rotation for good measure self.assertStaticRotation(root, "90") self.assertStaticDisplacement(root, 18, 36)
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 run(self): """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False self.dlg = HealthSIGDialog() # Clear the contents of the comboBox from previous runs self.dlg.comboBox.clear() # Populate the comboBox self.dlg.comboBox.addItems(["Hospitais", "ACES", "Farmácias"]) # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed and check index index = self.dlg.comboBox.currentIndex() # file directory for relative paths dirn = os.path.dirname(__file__) # escolheu unidades de saude if result and index == 1: # create layer vl = QgsVectorLayer("Point?crs=epsg:3763&index=yes", "aces", "memory") pr = vl.dataProvider() # Enter editing mode vl.startEditing() # add fields pr.addAttributes([ QgsField("ACES", QVariant.String), QgsField("ARS", QVariant.String), QgsField("Coord_X", QVariant.Double), QgsField("Coord_Y", QVariant.Double), QgsField("Num_USF", QVariant.Int) ]) vl.updateFields( ) # tell the vector layer to fetch changes from the provider # add features ---> IR BUSCAR AO JSON.... filename = os.path.join(dirn, 'unidades_saude.json') #with open("/home/skywalker/.local/share/QGIS/QGIS3/profiles/default/python/plugins/health_sig/unidades_saude.json", # "r") as read_file: with open(filename, "r") as read_file: json_file = json.load(read_file) # transformar coordenadas gps para as pretendidas crsSrc = QgsCoordinateReferenceSystem(4326) # gps crsDest = QgsCoordinateReferenceSystem(3763) # pt xform = QgsCoordinateTransform(crsSrc, crsDest, QgsProject.instance()) # addfeatures for entry in json_file: if entry["fields"]["tempo"] == "2019-01": # valores recentes x_coord = float(entry["geometry"]["coordinates"][0]) y_coord = float(entry["geometry"]["coordinates"][1]) num_usf = int( entry["fields"] ["total_usf"]) #numero de unidades de saude familiares entidade = entry["fields"]["entidade"] ars = entry["fields"]["ars"] fet = QgsFeature() fet.setGeometry(QgsGeometry().buffer( distance=num_usf * 10, segments=100).fromPointXY( xform.transform(QgsPointXY(x_coord, y_coord)))) fet.setAttributes([ QVariant(entidade), QVariant(ars), QVariant(x_coord), QVariant(y_coord), QVariant(num_usf) ]) pr.addFeatures([fet]) vl.updateExtents() vl.commitChanges() # fazer render categorizado features = vl.getFeatures() categories = [] for feat in features: f = feat.attributes()[4] # num_usf entidade = feat.attributes()[0] # entidade symbol = QgsSymbol.defaultSymbol(vl.geometryType()) svgStyle = {} path_uni = os.path.join(dirn, 'medicine.svg') svgStyle['name'] = path_uni svgStyle['size'] = str((f / 10) + 1) symbol_layer = QgsSvgMarkerSymbolLayer.create(svgStyle) if symbol_layer is not None: symbol.changeSymbolLayer(0, symbol_layer) # create renderer object category = QgsRendererCategory(f, symbol, str(entidade)) # entry for the list of category items categories.append(category) # create renderer object renderer = QgsCategorizedSymbolRenderer('Num_USF', categories) # assign the created renderer to the layer if renderer is not None: vl.setRenderer(renderer) vl.triggerRepaint() QgsProject.instance().addMapLayer(vl) # hospitais elif result and index == 0: vl = QgsVectorLayer("Point?crs=epsg:3763&index=yes", "hospitais", "memory") pr = vl.dataProvider() # Enter editing mode vl.startEditing() # add fields pr.addAttributes([ QgsField("Hospital", QVariant.String), QgsField("Morada", QVariant.String), QgsField("Coord_X", QVariant.Double), QgsField("Coord_Y", QVariant.Double) ]) vl.updateFields( ) # tell the vector layer to fetch changes from the provider # add features ---> IR BUSCAR AO JSON.... filename = os.path.join(dirn, 'hospitais.json') with open(filename, "r") as read_file: json_file = json.load(read_file) # transformar coordenadas gps para as pretendidas crsSrc = QgsCoordinateReferenceSystem(4326) # gps crsDest = QgsCoordinateReferenceSystem(3763) # pt xform = QgsCoordinateTransform(crsSrc, crsDest, QgsProject.instance()) # addfeatures for entry in json_file.keys(): x_coord = float(json_file[entry][1][1]) y_coord = float(json_file[entry][1][0]) morada = json_file[entry][0] fet = QgsFeature() fet.setGeometry(QgsGeometry().fromPointXY( xform.transform(QgsPointXY(x_coord, y_coord)))) fet.setAttributes([ QVariant(entry), QVariant(morada), QVariant(x_coord), QVariant(y_coord) ]) pr.addFeatures([fet]) vl.updateExtents() vl.commitChanges() #symbol = QgsMarkerSymbol.createSimple({'name': 'square', 'color': 'red'}) svgStyle = {} path_hosp = os.path.join(dirn, 'hospital.svg') svgStyle['name'] = path_hosp svgStyle['size'] = '6' symbol_layer = QgsSvgMarkerSymbolLayer.create(svgStyle) symbol = QgsSymbol.defaultSymbol(vl.geometryType()) #vl.renderer().setSymbol(symbol) symbol.changeSymbolLayer(0, symbol_layer) vl.renderer().setSymbol(symbol) # show the change vl.triggerRepaint() QgsProject.instance().addMapLayer(vl) # farmacias elif result and index == 2: vl = QgsVectorLayer("Point?crs=epsg:3763&index=yes", "farmacias", "memory") pr = vl.dataProvider() # Enter editing mode vl.startEditing() # add fields pr.addAttributes([ QgsField("Farmácia", QVariant.String), QgsField("Morada", QVariant.String), QgsField("Coord_X", QVariant.Double), QgsField("Coord_Y", QVariant.Double) ]) vl.updateFields( ) # tell the vector layer to fetch changes from the provider # add features ---> IR BUSCAR AO JSON.... filename = os.path.join(dirn, 'farmacias.json') with open(filename, "r") as read_file: json_file = json.load(read_file) # transformar coordenadas gps para as pretendidas crsSrc = QgsCoordinateReferenceSystem(4326) # gps crsDest = QgsCoordinateReferenceSystem(3763) # pt xform = QgsCoordinateTransform(crsSrc, crsDest, QgsProject.instance()) # addfeatures for entry in json_file.keys(): x_coord = float(json_file[entry][1][1]) y_coord = float(json_file[entry][1][0]) morada = json_file[entry][0] fet = QgsFeature() fet.setGeometry(QgsGeometry().fromPointXY( xform.transform(QgsPointXY(x_coord, y_coord)))) fet.setAttributes([ QVariant(entry), QVariant(morada), QVariant(x_coord), QVariant(y_coord) ]) pr.addFeatures([fet]) vl.updateExtents() vl.commitChanges() #symbol = QgsMarkerSymbol.createSimple({'name': 'square', 'color': 'purplet'}) #vl.renderer().setSymbol(symbol) svgStyle = {} path_farm = os.path.join(dirn, 'pharmacy.svg') svgStyle['name'] = path_farm svgStyle['size'] = '4' symbol_layer = QgsSvgMarkerSymbolLayer.create(svgStyle) symbol = QgsSymbol.defaultSymbol(vl.geometryType()) # vl.renderer().setSymbol(symbol) symbol.changeSymbolLayer(0, symbol_layer) vl.renderer().setSymbol(symbol) # show the change vl.triggerRepaint() QgsProject.instance().addMapLayer(vl)
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 saveSymbolLayerSprite(symbolLayer): sl = symbolLayer.clone() if isinstance(sl, QgsSVGFillSymbolLayer): patternWidth = sl.patternWidth() color = sl.svgFillColor() outlineColor = sl.svgOutlineColor() sl = QgsSvgMarkerSymbolLayer(sl.svgFilePath()) sl.setFillColor(color) sl.setOutlineColor(outlineColor) sl.setSize(patternWidth) sl.setOutputUnit(QgsSymbol.Pixel) sl2x = sl.clone() try: sl2x.setSize(sl2x.size() * 2) except AttributeError: return None, None newSymbol = QgsMarkerSymbol() newSymbol.appendSymbolLayer(sl) newSymbol.deleteSymbolLayer(0) newSymbol2x = QgsMarkerSymbol() newSymbol2x.appendSymbolLayer(sl2x) newSymbol2x.deleteSymbolLayer(0) img = newSymbol.asImage(QSize(sl.size(), sl.size())) img2x = newSymbol2x.asImage(QSize(sl2x.size(), sl2x.size())) return img, img2x
def append_PictureMarkerSymbolLayer(symbol, layer: PictureMarkerSymbolLayer, context: Context): """ Appends a PictureMarkerSymbolLayer to a symbol """ picture = layer.picture if issubclass(picture.__class__, StdPicture): picture = picture.picture if layer.swap_fb_gb: raise NotImplementedException('Swap FG/BG color not implemented') if issubclass(picture.__class__, EmfPicture): path = symbol_name_to_filename(context.symbol_name, context.picture_folder, 'emf') with open(path, 'wb') as f: f.write(picture.content) svg_path = symbol_name_to_filename(context.symbol_name, context.picture_folder, 'svg') emf_to_svg(path, svg_path) svg_path = context.convert_path(svg_path) else: svg = PictureUtils.to_embedded_svg( picture.content, symbol_color_to_qcolor(layer.color_foreground), symbol_color_to_qcolor(layer.color_background), symbol_color_to_qcolor(layer.color_transparent)) if context.embed_pictures: svg_base64 = base64.b64encode(svg.encode('UTF-8')).decode('UTF-8') svg_path = 'base64:{}'.format(svg_base64) else: svg_path = write_svg(svg, context.symbol_name, context.picture_folder) svg_path = context.convert_path(svg_path) out = QgsSvgMarkerSymbolLayer(svg_path, context.convert_size(layer.size), layer.angle) out.setSizeUnit(context.units) 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)