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)
示例#3
0
    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
示例#4
0
    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 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 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
示例#8
0
    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 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 {}
示例#15
0
文件: qgis.py 项目: zyxgis/slyr
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)
示例#16
0
    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)
示例#17
0
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)
示例#18
0
    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"}
示例#20
0
 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)
示例#21
0
    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)
示例#22
0
    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)
示例#23
0
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
示例#24
0
文件: qgis.py 项目: zyxgis/slyr
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)