Example #1
0
    def add_symbology(self):
        categories = []
        for lisaCategory, (color, label) in list(self.lisa.items()):
            sym = QgsSymbol.defaultSymbol(self.output_layer.geometryType())
            sym.setColor(QColor(color))
            category = QgsRendererCategory(lisaCategory, sym, label)
            categories.append(category)

        self.newlayer = QgsVectorLayer(
            self.output_layer.source(),
            self.output_layer.name() + " significance test",
            self.output_layer.providerType())
        self.output_layer.setOpacity(0.4)
        QgsProject.instance().addMapLayer(self.newlayer)

        # noinspection PyArgumentList
        renderer = QgsCategorizedSymbolRenderer('LISA_Q', categories)

        self.output_layer.setRenderer(renderer)

        symbol = QgsSymbol.defaultSymbol(
            QgsWkbTypes.geometryType(QgsWkbTypes.Polygon))

        color_ramp = QgsGradientColorRamp(QColor(0, 0, 0), QColor(255, 0, 0))
        # noinspection PyArgumentList

        renderer = QgsGraduatedSymbolRenderer.createRenderer(
            self.newlayer, 'LISA_C', 4, QgsGraduatedSymbolRenderer.Jenks,
            symbol, color_ramp)

        self.newlayer.setRenderer(renderer)
        #The input val of seOPacity is 0-1 not 0-100 as setLyerTransvarency
        #https://gis.stackexchange.com/questions/150858/setting-transparency-of-layer-group-with-python-in-qgis
        self.newlayer.setOpacity(0.4)
Example #2
0
    def postProcessLayer(self, layer, context, feedback):
        """Run the coloring process"""
        _ = context

        layer_type = layer.wkbType()
        feedback.pushInfo('Creating the style from OSM data "colour".')
        index = self.fields.index('colour')
        if index != -1:
            colors = layer.uniqueValues(index)
            categories = []
            for value in colors:
                if str(value) == 'None':
                    value = ''
                if layer_type in [self.layer_type_dict['lines'], self.layer_type_dict['multilinestrings']]:
                    symbol = QgsSymbol.defaultSymbol(QgsWkbTypes.LineGeometry)
                elif layer_type == self.layer_type_dict['point']:
                    symbol = QgsSymbol.defaultSymbol(QgsWkbTypes.PointGeometry)
                elif layer_type == self.layer_type_dict['multipolygons']:
                    symbol = QgsSymbol.defaultSymbol(QgsWkbTypes.PolygonGeometry)
                else:
                    break
                symbol.setColor(QColor(value))
                category = QgsRendererCategory(str(value), symbol, str(value))
                categories.append(category)

            renderer = QgsCategorizedSymbolRenderer("colour", categories)
            layer.setRenderer(renderer)

            layer.triggerRepaint()
Example #3
0
 def __init__(self, Layer, hinderAttr='hinder'):
     '1: in hinderAttr is veel hinder, 0: in hinderAttr is weinig hinder'
     hinderSymbol =  QgsSymbol.defaultSymbol( 0 ) #0=point
     noHinderSymbol =  QgsSymbol.defaultSymbol( 0 ) #Layer.geometryType()
     hinderSymbol.setColor(QColor('#FF0000'))
     noHinderSymbol.setColor(QColor('#FFFF00'))
     noHinder= QgsRendererCategory(0, noHinderSymbol ,'weinig hinder')
     hinder= QgsRendererCategory(1, hinderSymbol ,'veel hinder')
     self.render =  QgsCategorizedSymbolRenderer(hinderAttr,[noHinder,hinder])
Example #4
0
 def __init__(self, Layer, hinderAttr='hinder'):
     '1: in hinderAttr is veel hinder, 0: in hinderAttr is weinig hinder'
     hinderSymbol =  QgsSymbol.defaultSymbol( 0 ) #0=point
     noHinderSymbol =  QgsSymbol.defaultSymbol( 0 ) #Layer.geometryType()
     hinderSymbol.setColor(QColor('#FF0000'))
     noHinderSymbol.setColor(QColor('#FFFF00'))
     noHinder= QgsRendererCategory(0, noHinderSymbol ,'weinig hinder')
     hinder= QgsRendererCategory(1, hinderSymbol ,'veel hinder')
     self.render =  QgsCategorizedSymbolRenderer(hinderAttr,[noHinder,hinder])
Example #5
0
def load_file_as_layer(file_name, layer_name, group_name=None, min_val=None, max_val=None, mean_val=None, value_color=None, area=None, attribute=None):
    layer = QgsRasterLayer(file_name, layer_name)
    if layer.isValid():
        # generate legend with min/max values
        create_legend(layer, max_val, min_val, mean_val, value_color, area)
    else:
        layer = QgsVectorLayer(file_name, layer_name)
        # add_id_attribute_to_layer(layer)
        if layer.isValid():
            renderer = layer.renderer()
            print(layer.geometryType())
            if renderer and layer.geometryType() == 2:  # make fill of shapes invisible
                mySymbol1 = QgsFillSymbol.createSimple({'color': '#00ff00ff'})
                renderer.setSymbol(mySymbol1)
                layer.triggerRepaint()
            elif renderer and layer.geometryType() == 0 and min_val and max_val:
                print(layer.geometryType())
                ranges = []
                center = round((max_val - min_val) / 2, 0)
                range_1 = round((center - min_val) / 2, 0)
                range_2 = round(((max_val - center) / 2) + center, 0)
                print(min_val, range_1, center, range_2, max_val)

                symbol = QgsSymbol.defaultSymbol(layer.geometryType())
                symbol.setColor(QColor("#0005ae"))
                myRange = QgsRendererRange(min_val - 0.001, range_1, symbol, str(round(min_val,2)) + " - " + str(range_1) + " (MWh/point)")
                ranges.append(myRange)

                symbol = QgsSymbol.defaultSymbol(layer.geometryType())
                symbol.setColor(QColor("#fda000"))
                myRange = QgsRendererRange(range_1, range_2, symbol, str(range_1) + " - " + str(range_2) + " (MWh/point)")
                ranges.append(myRange)

                symbol = QgsSymbol.defaultSymbol(layer.geometryType())
                symbol.setColor(QColor("#ff0000"))
                myRange = QgsRendererRange(range_2, max_val + 0.001, symbol, str(range_2) + " - " + str(round(max_val,2)) + " (MWh/point)")
                ranges.append(myRange)

                expression = attribute  # field name
                renderer = QgsGraduatedSymbolRenderer(expression, ranges)
                layer.setRenderer(renderer)
        else:
            QMessageBox.information(None, "Error", "file " + file_name + " could not be loaded")

    if group_name is None:
        QgsProject.instance().addMapLayer(layer)
    else:
        QgsProject.instance().addMapLayer(layer, False)
        root = QgsProject.instance().layerTreeRoot()
        group = root.findGroup(group_name)
        if group is None:
            group = root.insertGroup(0, group_name)
        group.addLayer(layer)
    return layer
Example #6
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 _make_vector_renderer(layer, class_field, class_map):
        category_map = {}

        colors = ['Blue', 'Red', 'Green', 'Yellow']

        for i, class_item in enumerate(class_map.get_items()):
            name = class_item.name
            color = class_item.color
            if color is None:
                color = colors[i % len(colors)]
            category_map[name] = (color, name)

        categories = []
        for name, (color, label) in category_map.items():
            symbol = QgsSymbol.defaultSymbol(layer.geometryType())
            symbol_layer = QgsSimpleLineSymbolLayer()
            symbol_layer.setWidth(0.5)
            symbol.changeSymbolLayer(0, symbol_layer)
            symbol.setColor(QColor(color))

            category = QgsRendererCategory(label, symbol, name)
            categories.append(category)

        renderer = QgsCategorizedSymbolRenderer(class_field, categories)
        return renderer
    def categoryze_layer(self, layer, cat_field, size):
        """
        :param layer: QgsVectorLayer to be categorized (QgsVectorLayer)
        :param cat_field: Field to categorize (string)
        :param size: Size of feature (integer)
        """

        # get unique values
        fields = layer.fields()
        fni = fields.indexOf(cat_field)
        unique_values = layer.dataProvider().uniqueValues(fni)
        categories = []
        color_values={'NEW':QColor(0, 255, 0), 'DUPLICATED':QColor(255, 0, 0), 'EXISTS':QColor(240, 150, 0)}
        for unique_value in unique_values:
            # initialize the default symbol for this geometry type
            symbol = QgsSymbol.defaultSymbol(layer.geometryType())
            if type(symbol) in (QgsLineSymbol, ):
                symbol.setWidth(size)
            else:
                symbol.setSize(size)

            # configure a symbol layer
            # layer_style = {}
            # layer_style['color'] = '%d, %d, %d' % (randrange(0, 256), randrange(0, 256), randrange(0, 256))
            # layer_style['color'] = '255,0,0'
            # layer_style['outline'] = '#000000'
            try:
                color = color_values.get(unique_value)
                symbol.setColor(color)
            except:
                color = QColor(randrange(0, 256), randrange(0, 256), randrange(0, 256))
                symbol.setColor(color)
            # layer_style['horizontal_anchor_point'] = '6'
            # layer_style['offset_map_unit_scale'] = '6'
            # layer_style['outline_width'] = '6'
            # layer_style['outline_width_map_unit_scale'] = '6'
            # layer_style['size'] = '6'
            # layer_style['size_map_unit_scale'] = '6'
            # layer_style['vertical_anchor_point'] = '6'

            # symbol_layer = QgsSimpleFillSymbolLayer.create(layer_style)
            # print(f"Symbollaye --> {symbol_layer}")
            # # replace default symbol layer with the configured one
            # if symbol_layer is not None:
            #     symbol.changeSymbolLayer(0, symbol_layer)

            # create renderer object
            category = QgsRendererCategory(unique_value, symbol, str(unique_value))
            # entry for the list of category items
            categories.append(category)

            # create renderer object
        renderer = QgsCategorizedSymbolRenderer(cat_field, categories)

        # assign the created renderer to the layer
        if renderer is not None:
            layer.setRenderer(renderer)

        layer.triggerRepaint()
        self.iface.layerTreeView().refreshLayerSymbology(layer.id())
Example #9
0
def prepare_route_symbol(nb_route):
    colors = ['#1f78b4', '#ffff01', '#ff7f00', '#fb9a99', '#b2df8a', '#e31a1c']
    p = nb_route % len(colors)
    my_symb = QgsSymbol.defaultSymbol(1)
    my_symb.setColor(QColor(colors[p]))
    my_symb.setWidth(1.2)
    return my_symb
Example #10
0
 def setStyleIcon(self, svg):
     #Dato il path di un'icona svg la setta come stile per le sole features selezionate nel layer dei beni
     vlayer = self.getLayerBeni()
     if len(vlayer.selectedFeatures()) == 1:
         svgStyle = {
             "name": svg,
             "outline": "#000000",
             "size": "15",
         }
         svgLayer = QgsSvgMarkerSymbolLayer.create(svgStyle)
         svgSymbol = QgsMarkerSymbol()
         svgSymbol.changeSymbolLayer(0, svgLayer)
         symbol = QgsSymbol.defaultSymbol(vlayer.geometryType())
         symbol.setColor(QColor("Blue"))
         centroid = QgsCentroidFillSymbolLayer()
         centroid.setSubSymbol(svgSymbol)
         selectedSymbol = QgsFillSymbol()
         selectedSymbol.changeSymbolLayer(0, centroid)
         renderer = QgsRuleBasedRenderer(symbol)
         rule = QgsRuleBasedRenderer.Rule(selectedSymbol,
                                          label="Selected",
                                          filterExp="is_selected()")
         renderer.rootRule().appendChild(rule)
         vlayer.setRenderer(renderer)
         vlayer.triggerRepaint()
Example #11
0
def simple_polygon_without_brush(layer, width='0.26', color=QColor('black')):
    """Simple style to apply a border line only to a polygon layer.

    :param layer: The layer to style.
    :type layer: QgsVectorLayer

    :param color: Color to use for the line. Default to black.
    :type color: QColor

    :param width: Width to use for the line. Default to '0.26'.
    :type width: str
    """
    registry = QgsApplication.symbolLayerRegistry()
    line_metadata = registry.symbolLayerMetadata("SimpleLine")
    symbol = QgsSymbol.defaultSymbol(layer.geometryType())

    # Line layer
    line_layer = line_metadata.createSymbolLayer({
        'width': width,
        'color': color.name(),
        'offset': '0',
        'penstyle': 'solid',
        'use_custom_dash': '0',
        'joinstyle': 'bevel',
        'capstyle': 'square'
    })

    # Replace the default layer with our custom line
    symbol.deleteSymbolLayer(0)
    symbol.appendSymbolLayer(line_layer)

    renderer = QgsSingleSymbolRenderer(symbol)
    layer.setRenderer(renderer)
Example #12
0
    def set_style_mapzones(self):

        extras = f'"mapzones":""'
        body = self.create_body(extras=extras)

        # self.controller.log_info(f"SELECT gw_fct_getstylemapzones ({body})")
        json_return = self.controller.get_json('gw_fct_getstylemapzones', body)
        if not json_return:
            return False

        for mapzone in json_return['body']['data']['mapzones']:

            # self.controller.log_info(f"Mapzone: ({mapzone})")
            # Loop for each mapzone returned on json
            lyr = self.controller.get_layer_by_tablename(mapzone['layer'])
            categories = []
            status = mapzone['status']
            if status == 'Disable':
                pass

            if lyr:
                # Loop for each id returned on json
                for id in mapzone['values']:
                    # initialize the default symbol for this geometry type
                    symbol = QgsSymbol.defaultSymbol(lyr.geometryType())
                    symbol.setOpacity(float(mapzone['opacity']))

                    # Setting simp
                    R = random.randint(0, 255)
                    G = random.randint(0, 255)
                    B = random.randint(0, 255)
                    if status == 'Stylesheet':
                        try:
                            R = id['stylesheet']['color'][0]
                            G = id['stylesheet']['color'][1]
                            B = id['stylesheet']['color'][2]
                        except TypeError:
                            R = random.randint(0, 255)
                            G = random.randint(0, 255)
                            B = random.randint(0, 255)

                    elif status == 'Random':
                        R = random.randint(0, 255)
                        G = random.randint(0, 255)
                        B = random.randint(0, 255)

                    # Setting sytle
                    layer_style = {'color': '{}, {}, {}'.format(int(R), int(G), int(B))}
                    symbol_layer = QgsSimpleFillSymbolLayer.create(layer_style)

                    if symbol_layer is not None:
                        symbol.changeSymbolLayer(0, symbol_layer)
                    category = QgsRendererCategory(id['id'], symbol, str(id['id']))
                    categories.append(category)

                    # apply symbol to layer renderer
                    lyr.setRenderer(QgsCategorizedSymbolRenderer(mapzone['idname'], categories))

                    # repaint layer
                    lyr.triggerRepaint()
Example #13
0
    def styleMap(self):
        categories = []
        for cat in range(0, self.districts + 1):
            symbol = QgsSymbol.defaultSymbol(self.activeLayer.geometryType())
            layer_style = {}
            layer_style['color'] = '%d, %d, %d' % (randrange(
                0, 256), randrange(0, 256), randrange(0, 256))
            layer_style['outline'] = '#000000'
            symbol_layer = QgsSimpleFillSymbolLayer.create(layer_style)

            # replace default symbol layer with the configured one
            if symbol_layer is not None:
                symbol.changeSymbolLayer(0, symbol_layer)

            # create renderer object
            if cat == 0:
                category = QgsRendererCategory("", symbol, "")
            else:
                category = QgsRendererCategory(districtName[cat], symbol,
                                               str(districtName[cat]))
            # entry for the list of category items
            categories.append(category)
        renderer = QgsCategorizedSymbolRenderer(self.distfield, categories)
        # assign the created renderer to the layer
        if renderer is not None:
            self.activeLayer.setRenderer(renderer)

        self.activeLayer.triggerRepaint()
Example #14
0
def create_elimlyr(canvas):
    elim_lyr = QgsVectorLayer(r"LineString?crs=epsg:4326&index=yes",
                                elimedge_lname, r"memory")
    p_elimedge = elim_lyr.dataProvider()
    QgsProject.instance().addMapLayer(elim_lyr, True)
    # Case of only one color (elimedge_mono set in global_vars)
    if elimedge_mono:
        rend_symb=QgsSymbol.defaultSymbol(elim_lyr.geometryType())
        rend_symb.setWidth(elimedge_wdt)
        rend_symb.setColor(QColor(elimedge_col))
        rend_symb.setOpacity(elimedge_opc)
        rend_elimedge = QgsSingleSymbolRenderer(rend_symb)
    # Case of multiple colors depending on the type of elimination
    else:
        rend_elimedge = QgsRuleBasedRenderer(QgsLineSymbol())
        edge_root_rule = rend_elimedge.rootRule()
        edge_rules = ((inter_rfu, "\"pb_type\" = '" + inter_rfu + "'", elimedge_col, elimedge_wdt),
                      (inter_new, "\"pb_type\" = '" + inter_new + "'", elimedge_col2, elimedge_wdt))
        for label, expression, color, width in edge_rules:
            rule = edge_root_rule.children()[0].clone()
            rule.setLabel(label)
            rule.setFilterExpression(expression)
            rule.symbol().setColor(QColor(color))
            rule.symbol().setWidth(width)
            rule.symbol().setOpacity(elimedge_opc)
            edge_root_rule.appendChild(rule)
        edge_root_rule.removeChildAt(0)
    elim_lyr.setRenderer(rend_elimedge)
    p_elimedge.addAttributes(elimlyr_atts)
    elim_lyr.updateFields()
    # Refresh the canvas
    elim_lyr.triggerRepaint()
    return elim_lyr
Example #15
0
    def setupBackgroundLayer(self, stateLayer):
        '''
        Sets symbol rules for background layer in localization component
        '''
        symbol = QgsSymbol.defaultSymbol(stateLayer.geometryType())
        registry = QgsSymbolLayerRegistry()
        fillMeta = registry.symbolLayerMetadata("SimpleFill")
        fillSymbolLayer = fillMeta.createSymbolLayer({
            'color': '201,201,201',
            'outline_width': 0.1
        })
        # Replace the default style
        symbol.deleteSymbolLayer(0)
        symbol.appendSymbolLayer(fillSymbolLayer)

        renderer = QgsRuleBasedRenderer(symbol)
        rootRule = renderer.rootRule()
        for state in self.estados:
            # Appends the rule to the rootRule
            rule = self.createStateRule(rootRule, state)
            rootRule.appendChild(rule)
        # Delete the default rule
        rootRule.removeChildAt(0)
        # Apply the renderer to the layer
        stateLayer.setRenderer(renderer)
        stateLayer.triggerRepaint()
    def setRenderer(layer):
        from qgis.core import QgsSymbol, QgsRendererCategory, QgsCategorizedSymbolRenderer, QgsMarkerSymbol
        from PyQt5.QtGui import QColor
        waste_level = {
            '0': ('green', 'clean'),
            '1': ('orange', 'medium'),
            '2': ('red', 'high'),
            '': ('grey', 'unknown')
        }
        # Symbols
        default_station = QgsMarkerSymbol.createSimple({'name': 'circle', 'color': 'green', 'size':'5'})
        clean_station = QgsMarkerSymbol.createSimple({'name': 'circle', 'color': 'lightgreen', 'size':'4'})
        medium_station = QgsMarkerSymbol.createSimple({'name': 'circle', 'color': 'orange', 'size':'6'})
        dirty_station = QgsMarkerSymbol.createSimple({'name': 'circle', 'color': 'red', 'size':'9'})
        symbols = {'0': clean_station, '1': medium_station,'2': dirty_station,'': default_station}
        categories = []
        for wastelevel, (color, label) in waste_level.items():
            symbol = QgsSymbol.defaultSymbol(layer.geometryType())
            symbol.setColor(QColor(color))
            category = QgsRendererCategory(wastelevel, symbols[wastelevel], label)
            categories.append(category)

        expression = 'wastelevel'  # field name
        renderer = QgsCategorizedSymbolRenderer(expression, categories)
        layer.setRenderer(renderer)
        return True
Example #17
0
    def colorChange(self, layer, updated_attribute_table=False):
        # layer = iface.acitiveLayer() # load the layer as you want

        # define the lookup >> value : (color, label)

        if (updated_attribute_table):
            self.updated_attribute_table(layer)

        colors = {
            1: ('red', 'Won'),
            0: ('light grey', 'Lost'),
            -1: ('white', 'Undecided')
        }
        # create a category for each item in your layer
        categories = []
        for unique_id, (color, label) in colors.items():
            symbol = QgsSymbol.defaultSymbol(layer.geometryType())
            symbol.setColor(QColor(color))
            category = QgsRendererCategory(unique_id, symbol, label)
            categories.append(category)

        # create the renderer and assign it to the layer
        expression = self.attrName
        renderer = QgsCategorizedSymbolRenderer(expression, categories)

        # for cat in renderer.categories():
        #     print("{}: {} :: {}".format(cat.value(), cat.label(), cat.symbol()))
        renderer = QgsCategorizedSymbolRenderer(expression, categories)
        layer.setRenderer(renderer)
        layer.triggerRepaint()
 def set_rule_based_layer_style(layer: QgsVectorLayer,
                                rules: List['StyleRule']) -> None:
     """Sets the rule based layer style."""
     # Create a new rule-based renderer.
     symbol = QgsSymbol.defaultSymbol(layer.geometryType())
     renderer = QgsRuleBasedRenderer(symbol)
     # Get the "root" rule.
     root_rule = renderer.rootRule()
     for r in rules:
         # Create a clone (i.e. a copy) of the default rule.
         rule = root_rule.children()[0].clone()
         # Set the label, expression and color.
         rule.setLabel(r.label)
         rule.setFilterExpression(r.expression)
         rule.symbol().setColor(QColor(r.color_name))
         rule.symbol().setOpacity(r.opacity)
         # Set the scale limits if they have been specified.
         if r.scale_min_denom is not None and r.scale_max_denom is not None:
             rule.setScaleMinDenom(r.scale_min_denom)
             rule.setScaleMaxDenom(r.scale_max_denom)
         # Append the rule to the list of rules.
         root_rule.appendChild(rule)
     # Delete the default rule.
     root_rule.removeChildAt(0)
     # Apply the renderer to the layer.
     layer.setRenderer(renderer)
Example #19
0
    def create_rotation_item(self, map_point: QgsPointXY):
        f = self.create_feature(point=self.initial_point, rotation=0)

        # find symbol for feature
        renderer = self.current_layer().renderer().clone()
        context = QgsRenderContext.fromMapSettings(self.canvas().mapSettings())
        context.expressionContext().appendScope(
            QgsExpressionContextUtils.layerScope(self.current_layer()))
        context.expressionContext().setFeature(f)

        renderer.startRender(context, self.current_layer().fields())
        symbol = renderer.originalSymbolForFeature(f, context)
        if symbol is None:
            # e.g. code which doesn't match existing category
            if len(renderer.symbols(context)):
                symbol = renderer.symbols(context)[0]
            else:
                symbol = QgsSymbol.defaultSymbol(
                    self.current_layer().geometryType())

        renderer.stopRender(context)

        # clear existing data defined rotation
        symbol.setDataDefinedAngle(QgsProperty())

        # render symbol to image
        symbol_image = GuiUtils.big_marker_preview_image(
            symbol, context.expressionContext())

        self.rotation_item = PointRotationItem(self.canvas())
        self.rotation_item.set_symbol(symbol_image)
        self.rotation_item.set_point_location(map_point)
        self.rotation_item.set_symbol_rotation(0)
        self.rotation_item.update()
Example #20
0
 def customRender(self, capa):
     if self.params.colorContorn is None:
         self.params.colorContorn = self.params.colorBase
     total = self.params.numCategories
     alpha = mv.MAP_ALPHA_INI
     maxAlpha = (255 - mv.MAP_ALPHA_FIN)
     step = round((maxAlpha - alpha) / (total - 1))
     color = QColor(self.params.colorBase)
     decimals = self.params.maxDecimals(self.params.rangsCategories)
     categories = []
     for i, r in enumerate(self.params.rangsCategories):
         color.setAlpha(alpha)
         alpha = min(alpha + step, maxAlpha)
         if self.params.simbol is None:
             symbol = QgsSymbol.defaultSymbol(capa.geometryType())
         else:
             symbol = self.params.simbol.clone()
         self.setStrokeSymbology(symbol, self.params.colorContorn)
         symbol.setColor(color)
         f0 = self.params.numRang(r[0])
         f1 = self.params.numRang(r[1])
         label = QvApp().locale.toString(f0, 'f', decimals) + ' - ' + \
             QvApp().locale.toString(f1, 'f', decimals)
         category = QgsRendererRange(f0, f1, symbol, label)
         categories.append(category)
     renderer = QgsGraduatedSymbolRenderer(self.params.campCalculat,
                                           categories)
     renderer.setMode(QgsGraduatedSymbolRenderer.Custom)
     # renderer.setClassAttribute(str(decimals))
     capa.setRenderer(renderer)
     capa.setMapTipTemplate(self.params.calcTip())
     capa.triggerRepaint()
     return renderer
Example #21
0
def simple_polygon_without_brush(layer, width='0.26', color=QColor('black')):
    """Simple style to apply a border line only to a polygon layer.

    :param layer: The layer to style.
    :type layer: QgsVectorLayer

    :param color: Color to use for the line. Default to black.
    :type color: QColor

    :param width: Width to use for the line. Default to '0.26'.
    :type width: str
    """
    registry = QgsApplication.symbolLayerRegistry()
    line_metadata = registry.symbolLayerMetadata("SimpleLine")
    symbol = QgsSymbol.defaultSymbol(layer.geometryType())

    # Line layer
    line_layer = line_metadata.createSymbolLayer(
        {
            'width': width,
            'color': color.name(),
            'offset': '0',
            'penstyle': 'solid',
            'use_custom_dash': '0',
            'joinstyle': 'bevel',
            'capstyle': 'square'
        })

    # Replace the default layer with our custom line
    symbol.deleteSymbolLayer(0)
    symbol.appendSymbolLayer(line_layer)

    renderer = QgsSingleSymbolRenderer(symbol)
    layer.setRenderer(renderer)
Example #22
0
    def _set_line_colors(self, shapes_layer):
        layer_routes = QgsProject.instance().mapLayersByName('routes')[0]

        # join
        lineField = 'shape_id_short'
        routesField = 'route_id'
        joinObject = QgsVectorLayerJoinInfo()
        joinObject.setJoinFieldName(routesField)
        joinObject.setTargetFieldName(lineField)
        joinObject.setJoinLayerId(layer_routes.id())
        joinObject.setUsingMemoryCache(True)
        joinObject.setJoinLayer(layer_routes)
        shapes_layer.addJoin(joinObject)

        # coloring
        target_field = 'routes_fid'
        features_shape = shapes_layer.getFeatures()
        myCategoryList = []
        colors = {}
        for f in features_shape:
            r_fid = f['routes_fid']
            if r_fid not in colors:
                colors[r_fid] = (f['routes_route_color'],
                                 f['routes_route_short_name'])

        for r_fid, r_item in colors.items():
            symbol = QgsSymbol.defaultSymbol(shapes_layer.geometryType())
            symbol.setColor(QColor('#' + r_item[0]))
            myCategory = QgsRendererCategory(r_fid, symbol, r_item[1])
            myCategoryList.append(myCategory)
            myRenderer = QgsCategorizedSymbolRenderer(target_field,
                                                      myCategoryList)
            shapes_layer.setRenderer(myRenderer)
        shapes_layer.triggerRepaint()
        self.gtfs.setProgress(95)
Example #23
0
    def createLayer(self):
        """create and add huntplugin layer to the layer tree"""
        if (self.alkisSelectAreaLayer is not None):
            parent = QgsProject.instance().layerTreeRoot().findLayer(
                self.alkisSelectAreaLayer).parent()
            layeropts = QgsVectorLayer.LayerOptions(False, False)

            self.init(
            )  # reinit main instances because alkis instance conninfo might have changed
            (db, conninfo) = self.core.openDB()
            if db is None:
                return

            self.huntSelectAreaLayer = QgsVectorLayer(
                u"%s estimatedmetadata=true checkPrimaryKeyUnicity=0 key='ogc_fid' type=MULTIPOLYGON srid=%d table=%s.po_polygons (polygon) sql=false"
                % (conninfo, self.alkisplugin.epsg,
                   self.alkisplugin.quotedschema()), u"Jagd-Flächenmarkierung",
                "postgres", layeropts)

            sym = QgsSymbol.defaultSymbol(QgsWkbTypes.PolygonGeometry)
            sym.setColor(Qt.blue)
            sym.setOpacity(0.3)

            self.huntSelectAreaLayer.setRenderer(QgsSingleSymbolRenderer(sym))
            QgsProject.instance().addMapLayer(self.huntSelectAreaLayer, False)
            parent.insertLayer(0, self.huntSelectAreaLayer)

            self.core.hlayer = None
            QgsProject.instance().writeEntry("hunt", "/areaMarkerLayer",
                                             self.huntSelectAreaLayer.id())
Example #24
0
    def stylePoly(self, layer):
        """
        Style isochrone polygon layer.

        :param layer: Polygon layer to be styled.
        :type layer: QgsMapLayer
        """

        if self.dimension == 'time':
            legend_suffix = ' mins'
        else:
            legend_suffix = ' m'

        field = layer.fields().lookupField(self.field_dimension_name)
        unique_values = sorted(layer.uniqueValues(field))

        colors = {
            0: QColor('#2b83ba'),
            1: QColor('#64abb0'),
            2: QColor('#9dd3a7'),
            3: QColor('#c7e9ad'),
            4: QColor('#edf8b9'),
            5: QColor('#ffedaa'),
            6: QColor('#fec980'),
            7: QColor('#f99e59'),
            8: QColor('#e85b3a'),
            9: QColor('#d7191c')
        }

        categories = []

        for cid, unique_value in enumerate(unique_values):
            # initialize the default symbol for this geometry type
            symbol = QgsSymbol.defaultSymbol(layer.geometryType())

            # configure a symbol layer
            symbol_layer = QgsSimpleFillSymbolLayer(
                color=colors[cid], strokeColor=QColor('#000000'))

            # replace default symbol layer with the configured one
            if symbol_layer is not None:
                symbol.changeSymbolLayer(0, symbol_layer)

            # create renderer object
            category = QgsRendererCategory(unique_value, symbol,
                                           str(unique_value) + legend_suffix)
            # entry for the list of category items
            categories.append(category)

        # create renderer object
        renderer = QgsCategorizedSymbolRenderer(self.field_dimension_name,
                                                categories)

        # assign the created renderer to the layer
        if renderer is not None:
            layer.setRenderer(renderer)
        layer.setOpacity(0.5)

        layer.triggerRepaint()
Example #25
0
def hazard_class_style(layer, classification, display_null=False):
    """Set colors to the layer according to the hazard.

    :param layer: The layer to style.
    :type layer: QgsVectorLayer

    :param display_null: If we should display the null hazard zone. Default to
        False.
    :type display_null: bool

    :param classification: The hazard classification to use.
    :type classification: dict safe.definitions.hazard_classifications
    """
    categories = []

    # Conditional styling
    attribute_table_styles = []

    for hazard_class, (color, label) in list(classification.items()):
        if hazard_class == not_exposed_class['key'] and not display_null:
            # We don't want to display the null value (not exposed).
            # We skip it.
            continue

        symbol = QgsSymbol.defaultSymbol(layer.geometryType())
        symbol.setColor(color)
        if is_line_layer(layer):
            symbol.setWidth(line_width_exposure)
        category = QgsRendererCategory(hazard_class, symbol, label)
        categories.append(category)

        style = QgsConditionalStyle()
        style.setName(hazard_class)
        style.setRule("hazard_class='%s'" % hazard_class)
        style.setBackgroundColor(transparent)
        symbol = QgsSymbol.defaultSymbol(QgsWkbTypes.PointGeometry)
        symbol.setColor(color)
        symbol.setSize(3)
        style.setSymbol(symbol)
        attribute_table_styles.append(style)

    layer.conditionalStyles().setFieldStyles('hazard_class',
                                             attribute_table_styles)
    renderer = QgsCategorizedSymbolRenderer(hazard_class_field['field_name'],
                                            categories)
    layer.setRenderer(renderer)
Example #26
0
def hazard_class_style(layer, classification, display_null=False):
    """Set colors to the layer according to the hazard.

    :param layer: The layer to style.
    :type layer: QgsVectorLayer

    :param display_null: If we should display the null hazard zone. Default to
        False.
    :type display_null: bool

    :param classification: The hazard classification to use.
    :type classification: dict safe.definitions.hazard_classifications
    """
    categories = []

    # Conditional styling
    attribute_table_styles = []

    for hazard_class, (color, label) in list(classification.items()):
        if hazard_class == not_exposed_class['key'] and not display_null:
            # We don't want to display the null value (not exposed).
            # We skip it.
            continue

        symbol = QgsSymbol.defaultSymbol(layer.geometryType())
        symbol.setColor(color)
        if is_line_layer(layer):
            symbol.setWidth(line_width_exposure)
        category = QgsRendererCategory(hazard_class, symbol, label)
        categories.append(category)

        style = QgsConditionalStyle()
        style.setName(hazard_class)
        style.setRule("hazard_class='%s'" % hazard_class)
        style.setBackgroundColor(transparent)
        symbol = QgsSymbol.defaultSymbol(QgsWkbTypes.PointGeometry)
        symbol.setColor(color)
        symbol.setSize(3)
        style.setSymbol(symbol)
        attribute_table_styles.append(style)

    layer.conditionalStyles().setFieldStyles(
        'hazard_class', attribute_table_styles)
    renderer = QgsCategorizedSymbolRenderer(
        hazard_class_field['field_name'], categories)
    layer.setRenderer(renderer)
Example #27
0
    def testDefaultSymbol(self):
        p = QgsProjectStyleSettings()
        self.assertFalse(p.defaultSymbol(Qgis.SymbolType.Marker))
        self.assertFalse(p.defaultSymbol(Qgis.SymbolType.Line))
        self.assertFalse(p.defaultSymbol(Qgis.SymbolType.Fill))

        marker = QgsSymbol.defaultSymbol(QgsWkbTypes.PointGeometry)
        p.setDefaultSymbol(Qgis.SymbolType.Marker, marker)
        self.assertTrue(p.defaultSymbol(Qgis.SymbolType.Marker))

        line = QgsSymbol.defaultSymbol(QgsWkbTypes.LineGeometry)
        p.setDefaultSymbol(Qgis.SymbolType.Line, line)
        self.assertTrue(p.defaultSymbol(Qgis.SymbolType.Line))

        fill = QgsSymbol.defaultSymbol(QgsWkbTypes.PolygonGeometry)
        p.setDefaultSymbol(Qgis.SymbolType.Fill, fill)
        self.assertTrue(p.defaultSymbol(Qgis.SymbolType.Fill))
Example #28
0
    def _apply_symbology_fixed_divisions(self, layer, field, tbl_name, schema,
                                         min_v, max_v, steps):
        """Finds the amount of levels that is necessary to describe the layer,
        a maximum of 20 different levels is set.

        Parameters
        ----------
        layer: QgsVectorLayer
        field: str
        tbl_name: str
        schema: str
        min_v: float
        max_v: float
        steps: int
        """
        if min_v is not None and max_v is not None:
            distinct_values = list(np.arange(min_v, max_v, steps))
        else:
            distinct = self.db.get_distinct(tbl_name, field, schema)
            if len(distinct) == 1:
                return
            distinct_values = []
            distinct_count = []
            for value, count in distinct:
                distinct_values.append(value)
                distinct_count.append(count)
            if len(distinct_values) > 20:
                distinct_values.sort()
                temp_list = []
                for val in range(0, len(distinct_values), int(np.floor(len(distinct_values)/20))):
                    temp_list.append(distinct_values[val])
                if temp_list[-1] != distinct_values[-1]:
                    temp_list.append(distinct_values[-1])
                distinct_values = temp_list
        colors = self._create_colors(len(distinct_values))
        # TODO: fix for str values!
        if len(distinct_values) > 19:
            range_list = []
            for i in range(len(distinct_values) - 1):
                red, green, blue = colors[i]
                range_list.append(self._make_symbology(layer, distinct_values[i],
                                                     distinct_values[i + 1],
                                                     str(distinct_values[i]) + ' - ' + str(distinct_values[i + 1]),
                                                     QColor(int(red*255),int(green*255), int(blue*255), 128) ) )
            renderer = QgsGraduatedSymbolRenderer(field, range_list)
            renderer.setMode(QgsGraduatedSymbolRenderer.Custom )
        else:
            categories = []
            for i in range(len(distinct_values)):
                symbol = QgsSymbol.defaultSymbol(layer.geometryType())
                red, green, blue = colors[i]
                symbol.setColor(QColor(int(red*255),int(green*255), int(blue*255), 128))
                symbol.symbolLayer(0).setStrokeColor(QColor(int(red*255),int(green*255), int(blue*255), 128))
                category = QgsRendererCategory(str(distinct_values[i]), symbol, str(distinct_values[i]))
                categories.append(category)
            renderer = QgsCategorizedSymbolRenderer(field, categories)
            #renderer.setMode(QgsCategorizedSymbolRenderer.Custom)
        layer.setRenderer(renderer)
Example #29
0
 def __init__(self, iface, layer_name, symbol, color, size, attributes, group=None, visible=True):
     "..."
     WGS84Layer.__init__(self, iface, layer_name, "Point", visible, group)
     props = self.layer.renderer().symbol().symbolLayer(0).properties()
     symbol = QgsSymbol.defaultSymbol(QgsWkbTypes.PointGeometry)
     symbol.setSize(1.5)
     self.layer.renderer().setSymbol(symbol)
     WGS84Layer.refresh_legend(self)
     self.set_attributes(attributes)
Example #30
0
 def create_simple_fill_symbol_layer(self, layer: QgsVectorLayer,
                                     fill_color: QColor):
     # initialize the default symbol for this geometry type
     symbol = QgsSymbol.defaultSymbol(layer.geometryType())
     # configure a symbol layer
     symbol_layer = QgsSimpleFillSymbolLayer(fill_color)
     # replace default symbol layer with the configured one
     if symbol_layer is not None:
         symbol.changeSymbolLayer(0, symbol_layer)
     return symbol
Example #31
0
def get_default_symbol( geom_type):
    symbol = QgsSymbol.defaultSymbol(geom_type)
    if symbol is None:
        if geom_type == Qgis.Point:
            symbol = QgsMarkerSymbol()
        elif geom_type == Qgis.Line:
            symbol = QgsLineSymbol()
        elif geom_type == Qgis.Polygon:
            symbol = QgsFillSymbol()
    return symbol
Example #32
0
    def setSectorsStyle(self, layer):
        # get unique values
        field = 'Class'
        fni = layer.fields().indexFromName(field)

        if fni == -1:  # Hydraulic sectors
            field = 'SubNet'
            fni = layer.fields().indexFromName(field)

        unique_values = layer.dataProvider().uniqueValues(fni)

        # define categories
        categories = []
        for unique_value in unique_values:
            # initialize the default symbol for this geometry type
            symbol = QgsSymbol.defaultSymbol(layer.geometryType())

            # configure a symbol layer
            symbol_layer = None
            if layer.geometryType() == 0:  # Point
                layer_style = dict()
                layer_style['color'] = '%d, %d, %d' % (randrange(
                    0, 256), randrange(0, 256), randrange(0, 256))
                layer_style['size'] = str(2)
                symbol_layer = QgsSimpleMarkerSymbolLayer.create(layer_style)
            else:
                symbol = QgsLineSymbol().createSimple({})
                symbol.deleteSymbolLayer(0)
                # Line
                lineSymbol = QgsSimpleLineSymbolLayer()
                lineSymbol.setWidthUnit(2)  # Pixels
                lineSymbol.setWidth(1.5)
                lineSymbol.setColor(
                    QColor(randrange(0, 256), randrange(0, 256),
                           randrange(0, 256)))
                symbol.appendSymbolLayer(lineSymbol)

            # replace default symbol layer with the configured one
            if symbol_layer is not None:
                symbol.changeSymbolLayer(0, symbol_layer)

            # create renderer object
            category = QgsRendererCategory(unique_value, symbol,
                                           str(unique_value))
            # entry for the list of category items
            categories.append(category)

        # create renderer object
        renderer = QgsCategorizedSymbolRenderer(field, categories)

        # assign the created renderer to the layer
        if renderer is not None:
            layer.setRenderer(renderer)
Example #33
0
def set_category_renderer(layer: QgsVectorLayer, column: str,
                          start_color: Tuple[int, int, int],
                          end_color: Tuple[int, int, int], unit: str = ''):
    '''
    apply a category renderer to a layer. The categories will be the unique
    values of the given column with interpolated colors between given start
    and end color

    Parameters
    ----------
    layer : QgsVectorLayer
        layer to apply the renderer to
    column : str
        name of the column containing the categories
    start_color : tuple
        rgb values of the first color in the color range
    end_color : tuple
        rgb values of the last color in the color range
    unit : str
        a unit to be added to the category label, defaults to no unit
    '''
    idx = layer.fields().indexOf(column)
    unique_values = list(layer.uniqueValues(idx))
    unique_values.sort()
    categories = []
    geometry_type = layer.geometryType()
    for i, value in enumerate(unique_values):
        # initialize the default symbol for this geometry type
        symbol = QgsSymbol.defaultSymbol(geometry_type)

        # configure a symbol layer
        layer_style = {}
        rgb = []
        for c in range(3):
            rgb.append(str(int(interpolate(start_color[c], end_color[c],
                                           i, len(unique_values)))))
        layer_style['color'] = ','.join(rgb)
        #layer_style['outline'] = '#000000'
        symbol_layer = QgsSimpleFillSymbolLayer.create(layer_style)

        # replace default symbol layer with the configured one
        if symbol_layer is not None:
            symbol.changeSymbolLayer(0, symbol_layer)

        # create renderer object
        category = QgsRendererCategory(value, symbol, f'{value} {unit}')
        # entry for the list of category items
        categories.append(category)

    # create renderer object
    renderer = QgsCategorizedSymbolRenderer(column, categories)
    layer.setRenderer(renderer)
    def run(self):
        """Run method that performs all the real work"""
        
        layers = self.iface.mapCanvas().layers()
        layer_list = []
        self.dlg.layerComboBox.clear()
        for layer in layers:
            layer_list.append(layer.name())
        self.dlg.layerComboBox.addItems(layer_list)
        # TODO: Make the active layer the selected item in combo box  aLayer = qgis.utils.iface.activeLayer()
        
        # TODO: Add signal to update toleranceSpinBox.suffix (Degrees) from layerComboBox.crs.mapUnits when layer is selected:
        #my_UnitType = { 0: 'Meters', 1: 'Feet', 2: 'Degrees', 7: 'NauticalMiles', 8: 'Kilometers', 9: 'Yards', 10: 'Miles', 3: 'UnknownUnit'}
        #suffix = my_UnitType[aLayer.crs().mapUnits()]
        
        # show the dialog
        self.dlg.show()
        # Run the dialog event loop
        result = self.dlg.exec_()
        # See if OK was pressed
        if result:
            if self.checkNetworkXModule() < 0:
                return -4
            import networkx as nx
            
            layerName = self.dlg.layerComboBox.currentText()
            try:
                aLayer = QgsProject.instance().mapLayersByName(layerName)[0]
            except:
                self.iface.messageBar().pushMessage("Error", "Failed to load layer!", level=Qgis.Critical)
                return -1

            try:

                previousEditingMode = True
                if not aLayer.isEditable():
                    aLayer.startEditing()
                    #self.iface.messageBar().pushMessage("Info", "Layer " + aLayer.name() + " needs to be in edit mode", level=Qgis.Info)
                    #self.iface.messageBar().pushMessage("Error", "Layer " + aLayer.name() + " needs to be in edit mode", level=Qgis.Critical)
                    #return -2
                    previousEditingMode = False
                     
                attrIdx = self.getAttributeIndex(aLayer)
                if attrIdx < 0:
                    return -3  

                progressMessageBar = self.iface.messageBar().createMessage("Creating network graph...")
                progress = QProgressBar()
                progress.setMaximum(aLayer.featureCount())
                progress.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
                progressMessageBar.layout().addWidget(progress)
                self.iface.messageBar().pushWidget(progressMessageBar, Qgis.Info)          
                
                G = nx.Graph()

                aLayer.beginEditCommand("Clear group attribute, create graph")
                # construct undirected graph
                tolerance = self.dlg.toleranceSpinBox.value()
                if tolerance == 0:
                    tolerance = 0.000001
                count = 0
                for feat in aLayer.getFeatures():
                    count += 1
                    progress.setValue(count)
                    done = aLayer.changeAttributeValue(feat.id(), attrIdx, -1)
                    geom = feat.geometry()
                    QgsGeometry.convertToSingleType(geom)       # QGIS 3.x seems to load single LineString as MultiLineString??
                    line = geom.asPolyline()
                    
                    for i in range(len(line)-1):
                        G.add_edges_from([((int(line[i][0]/tolerance), int(line[i][1]/tolerance)), (int(line[i+1][0]/tolerance), int(line[i+1][1]/tolerance)), 
                                          {'fid': feat.id()})])     # first scale by tolerance, then convert to int.  Before doing this, there were problems (in NetworkX v1) with floats not equating, thus creating disconnects that weren't there.
                    if count % 100 == 0:
                        QApplication.processEvents()      # keep the UI responsive, every 100 features
                        #TODO: check to see if Esc pressed

                aLayer.endEditCommand()
                
                self.iface.messageBar().pushMessage("Finding connected subgraphs, please wait...",  level=Qgis.Warning)     # WARNING - to highlight the next stage, where we cannot show progress
                QApplication.processEvents()
                connected_components = list(nx.connected_component_subgraphs(G))    # this takes a long time.  TODO: how to show progress?
                self.iface.messageBar().pushMessage("Updating group attribute...",  level=Qgis.Info)
                QApplication.processEvents()
                          
                # gather edges and components to which they belong
                fid_comp = {}
                for i, graph in enumerate(connected_components):
                   for edge in graph.edges(data=True):
                       fid_comp[edge[2].get('fid', None)] = i
                
                # write output to csv file
                #with open('C:/Tmp/Components.csv', 'wb') as f:
                #    w = csv.DictWriter(f, fieldnames=['fid', 'group'])
                #    w.writeheader()
                #    for (fid, group) in fid_comp.items():
                #        w.writerow({'fid': fid, 'group': group})
                
                aLayer.beginEditCommand("Update group attribute")
                for (fid, group) in fid_comp.items():
                    done = aLayer.changeAttributeValue(fid, attrIdx, group)
                aLayer.endEditCommand()
                
                groups = list(set(fid_comp.values()))            
                if self.dlg.stylingCheckBox.isChecked():
                    aLayer.beginEditCommand("Update layer styling")
                    categories = []
                    firstCat = True
                    for cat in groups:
                        symbol = QgsSymbol.defaultSymbol(aLayer.geometryType())
                        symbol.setColor(QColor(randint(0,255), randint(0,255), randint(0,255)))
                        if firstCat:
                            firstCat = False
                        else:
                            symbol.setWidth(symbol.width()*5)
                        category = QgsRendererCategory(cat, symbol, "%d" % cat)
                        categories.append(category)

                    field = self.dlg.attributeNameEditBox.text()
                    renderer = QgsCategorizedSymbolRenderer(field, categories)
                    aLayer.setRenderer(renderer)

#                    if self.iface.mapCanvas().isCachingEnabled():
#                        aLayer.setCacheImage(None)
#                    else:
#                        self.iface.mapCanvas().refresh()
                    aLayer.triggerRepaint()
                    aLayer.endEditCommand()            
                   
                self.iface.messageBar().clearWidgets()   
                self.iface.messageBar().pushMessage("Found main network and %d disconnected islands in layer %s" % (len(groups)-1, aLayer.name()),  level=Qgis.Success)

                aLayer.commitChanges()
#                if not previousEditingMode: 
    
            except Exception as e:
                self.iface.messageBar().pushMessage("Error", "Exception caught: %s.  Please report an issue to the author of the plugin." % repr(e), level=Qgis.Critical)