Add support for Leaflet Styles (#3)

* Add .gitattributes

* Use newest qgis_plugin_tools

* Add support for multiple style types: SimpleStyle and PointStyle

* Multiply with symbol opacity and store widths as float

* Enable fill and stroke fields for PointStyle

* Use always canvas crs in bounding box chooser

Author: Joonalai

GemeindescanExporter/.gitattributes

@@ -0,0 +1,4 @@
+.gitattributes export-ignore
+.editorconfig export-ignore
+test export-ignore
+

GemeindescanExporter/core/datapackage.py

@@ -62,7 +62,7 @@ def create_snapshot(self, snapshot_name: str, snapshot_config: SnapshotConfig, s
         snapshot.resources = []
 
         for styled_layer in styled_layers:
-            resource = Resource(styled_layer.resource_name, mediatype='application/geo+json',
+            resource = Resource(styled_layer.resource_name, mediatype=styled_layer.style_type.media_type,
                                 data=styled_layer.get_geojson_data())
             snapshot.resources.append(resource)
 

GemeindescanExporter/core/processing/algorithms.py

@@ -41,6 +41,7 @@ class StyleToAttributesAlg(BaseProcessingAlgorithm):
     PRIMARY = 'PRIMARY'
     OUTPUT = 'OUTPUT'
     OUTPUT_LEGEND = 'OUTPUT_LEGEND'
+    OUTPUT_STYLE_TYPE = 'OUTPUT_STYLE_TYPE'
     EXTENT = 'EXTENT'
 
     def name(self) -> str:
@@ -103,5 +104,6 @@ def processAlgorithm(self, parameters: Dict[str, Any], context: QgsProcessingCon
 
         ret_val = {self.OUTPUT: dest_id,
                    self.OUTPUT_LEGEND: wrkr.get_legend(),
+                   self.OUTPUT_STYLE_TYPE: wrkr.style_type.name
                    }
         return ret_val

GemeindescanExporter/core/styles2attributes.py

@@ -17,32 +17,24 @@
 #  You should have received a copy of the GNU General Public License
 #  along with GemeindescanExporter.  If not, see <https://www.gnu.org/licenses/>.
 
-from typing import Optional, Dict
+from typing import Optional, Dict, List
 
 from PyQt5.QtCore import QVariant
 from qgis.core import (QgsVectorLayer, QgsFields, QgsField, QgsFeatureSink, QgsFillSymbol, QgsLineSymbol,
                        QgsFeature, QgsProcessingFeedback, QgsRectangle, QgsSpatialIndex, QgsFeatureRequest,
-                       QgsMarkerSymbol, QgsSymbol, QgsSymbolLayer)
+                       QgsMarkerSymbol, QgsSymbol, QgsSymbolLayer, QgsPropertyCollection, QgsProperty)
 
+from ..definitions.style import Style, PointStyle
 from ..definitions.symbols import SymbolLayerType, SymbolType
+from ..definitions.types import StyleType
 from ..model.snapshot import Legend
+from ..qgis_plugin_tools.tools.exceptions import QgsPluginNotImplementedException
 from ..qgis_plugin_tools.tools.i18n import tr
 
 
 class StylesToAttributes:
-    field_mapper = {"fill": "fillColor", "fill-opacity": "fillOpacity", "stroke": "strokeColor",
-                    "stroke-opacity": "strokeOpacity", "stroke-width": "strokeWidth", "type": "shape"}
-
-    DEFAULT_TEMPLATE = {
-        "fill": "#000000",
-        "fill-opacity": 1.0,
-        "stroke": "#ffffff",
-        "stroke-opacity": 1.0,
-        "stroke-width": 1.0
-    }
 
     def __init__(self, layer: QgsVectorLayer, layer_name: str, feedback: QgsProcessingFeedback,
-                 field_template: Optional = None,
                  primary_layer: bool = False):
         self.layer = layer
         self.layer_name = layer_name
@@ -51,6 +43,9 @@ def __init__(self, layer: QgsVectorLayer, layer_name: str, feedback: QgsProcessi
         self.renderer = self.layer.renderer()
         self.symbol_type: SymbolType = SymbolType[self.renderer.type()]
 
+        self.style_type: StyleType = StyleType.from_layer(layer)
+        self.field_template = self.style_type.get_style().to_dict()
+
         if self.symbol_type in [SymbolType.categorizedSymbol, SymbolType.graduatedSymbol]:
             self.mapped_col = self.renderer.classAttribute()
         else:
@@ -59,9 +54,6 @@ def __init__(self, layer: QgsVectorLayer, layer_name: str, feedback: QgsProcessi
         self.symbols = {}
         self.primary_layer = primary_layer
 
-        field_template = field_template if field_template is not None else StylesToAttributes.DEFAULT_TEMPLATE
-        self.field_template = field_template.copy()
-
         self.fields: QgsFields = self._generate_fields()
         self.legend = {}
 
@@ -75,61 +67,80 @@ def _rgb_extract(prop):
     def get_legend(self) -> Dict:
         return {label: legend.to_dict() for label, legend in self.legend.items()}
 
+    def get_symbols(self) -> Dict:
+        return {key: {**val, 'style': val['style'].to_dict()} for key, val in self.symbols.items()}
+
     def extract_styles_to_layer(self, sink: QgsFeatureSink, extent: Optional[QgsRectangle] = None):
         try:
             self._update_symbols()
-            self._update_legend()
             self._copy_fields(sink, extent)
+            self._update_legend()
         except Exception as e:
             self.feedback.reportError(tr('Error occurred: {}', e), True)
             self.feedback.cancel()
 
-    def _get_style(self, symbol: QgsSymbol):
+    def _get_style(self, symbol: QgsSymbol) -> Style:
         self.feedback.pushDebugInfo(str(type(symbol)))
 
-        style = self.field_template.copy()
+        symbol_opacity: float = symbol.opacity()
+
         symbol_layer: QgsSymbolLayer = symbol.symbolLayers()[0]
         if symbol_layer.subSymbol() is not None:
             return self._get_style(symbol_layer.subSymbol())
 
+        style: Style = self.style_type.get_style()
         sym_type = SymbolLayerType[symbol_layer.layerType()]
         sym = symbol_layer.properties()
+
+        # Add data defined properties for the style
+        if symbol_layer.hasDataDefinedProperties():
+            data_defined_props: QgsPropertyCollection = symbol_layer.dataDefinedProperties()
+            for key in data_defined_props.propertyKeys():
+                prop: QgsProperty = data_defined_props.property(key)
+                if prop.field() != '':
+                    style.add_data_defined_expression(prop.field(), prop.asExpression())
+
         if isinstance(symbol, QgsFillSymbol):
             if sym_type == SymbolLayerType.SimpleLine:
-                style["type"] = "line"
-                style["fill"] = "#000000"
-                style["fill-opacity"] = 0
-                style["stroke"] = self._rgb_extract(sym['outline_color'])[0]
-                style["stroke-opacity"] = self._rgb_extract(sym['outline_color'])[1]
-                style["stroke-width"] = sym['outline_width']
+                style.type = "line"
+                style.fill = "#000000"
+                style.fill_opacity = 0
+                style.stroke = self._rgb_extract(sym['outline_color'])[0]
+                style.stroke_opacity = symbol_opacity * self._rgb_extract(sym['outline_color'])[1]
+                style.stroke_width = float(sym['outline_width'])
             if sym_type in [SymbolLayerType.CentroidFill, SymbolLayerType.SimpleFill]:
                 if sym_type == SymbolLayerType.CentroidFill:
-                    style["type"] = "circle"
+                    style.type = "circle"
                 else:
-                    style["type"] = "rectangle"
-                style["fill"] = self._rgb_extract(sym['color'])[0]
-                style["fill-opacity"] = self._rgb_extract(sym['color'])[1]
-                style["stroke"] = self._rgb_extract(sym['outline_color'])[0]
-                style["stroke-opacity"] = self._rgb_extract(sym['outline_color'])[1]
-                style["stroke-width"] = sym['outline_width']
+                    style.type = "rectangle"
+                style.fill = self._rgb_extract(sym['color'])[0]
+                style.fill_opacity = symbol_opacity * self._rgb_extract(sym['color'])[1]
+                style.stroke = self._rgb_extract(sym['outline_color'])[0]
+                style.stroke_opacity = symbol_opacity * self._rgb_extract(sym['outline_color'])[1]
+                style.stroke_width = float(sym['outline_width'])
 
         elif isinstance(symbol, QgsLineSymbol):
             if sym_type == SymbolLayerType.SimpleLine:
                 self.feedback.pushDebugInfo(symbol_layer.properties())
-                style["type"] = "line"
-                style["fill"] = "transparent"
-                style["fill-opacity"] = 0
-                style["stroke"] = self._rgb_extract(sym['line_color'])[0]
-                style["stroke-opacity"] = self._rgb_extract(sym['line_color'])[1]
-                style["stroke-width"] = sym['line_width']
+                style.type = "line"
+                style.fill = "transparent"
+                style.fill_opacity = 0
+                style.stroke = self._rgb_extract(sym['line_color'])[0]
+                style.stroke_opacity = symbol_opacity * self._rgb_extract(sym['line_color'])[1]
+                style.stroke_width = float(sym['line_width'])
         elif isinstance(symbol, QgsMarkerSymbol):
             if sym_type == SymbolLayerType.SimpleMarker:
-                style["type"] = "circle"
-                style["fill"] = self._rgb_extract(sym['color'])[0]
-                style["fill-opacity"] = self._rgb_extract(sym['color'])[1]
-                style["stroke"] = self._rgb_extract(sym['outline_color'])[0]
-                style["stroke-opacity"] = self._rgb_extract(sym['outline_color'])[1]
-                style["stroke-width"] = sym['outline_width']
+                style: PointStyle
+                style.type = "circle"
+                style.fill = self._rgb_extract(sym['color'])[0]
+                style.fill_opacity = symbol_opacity * self._rgb_extract(sym['color'])[1]
+                style.has_fill = style.fill_opacity > 0.0
+                style.stroke = self._rgb_extract(sym['outline_color'])[0]
+                style.stroke_opacity = symbol_opacity * self._rgb_extract(sym['outline_color'])[1]
+                style.stroke_width = float(sym['outline_width'])
+                style.has_stroke = style.stroke_opacity > 0.0
+                style.radius = sym['size']
+
         else:
             raise ValueError(f"Unkown symbol type: {symbol_layer.layerType()}")
         return style
@@ -171,13 +182,12 @@ def _copy_fields(self, sink: QgsFeatureSink, extent: Optional[QgsRectangle] = No
                 sink.addFeature(f, QgsFeatureSink.FastInsert)
             else:
                 feat = QgsFeature()
-                style_attributes = self._get_style_for_feature(f)
-
-                attributes = f.attributes() + [style_attributes[key] for key in
-                                               sorted(style_attributes.keys())]
+                attributes = self._get_attributes_for_feature(f)
                 feat.setAttributes(attributes)
                 feat.setGeometry(f.geometry())
-                sink.addFeature(feat, QgsFeatureSink.FastInsert)
+                succeeded = sink.addFeature(feat, QgsFeatureSink.FastInsert)
+                if not succeeded:
+                    raise ValueError(tr('Could not add feature to target layer. Attributes: {}', attributes))
             self.feedback.setProgress(int(current * total))
 
     def _generate_fields(self) -> QgsFields:
@@ -186,15 +196,19 @@ def _generate_fields(self) -> QgsFields:
             if field_template_name not in self.layer.fields().names():
                 if isinstance(field_template_value, str):
                     field = QgsField(field_template_name, QVariant.String)
-                    fields.append(field)
                 elif isinstance(field_template_value, float):
                     field = QgsField(field_template_name, QVariant.Double)
-                    fields.append(field)
+                elif isinstance(field_template_value, bool):
+                    field = QgsField(field_template_name, QVariant.Bool)
+                else:
+                    raise QgsPluginNotImplementedException(
+                        tr('Field type not implemented: {}', type(field_template_value)))
+                fields.append(field)
 
         return fields
 
-    def _get_style_for_feature(self, feature: QgsFeature):
-        ret_val = {}
+    def _get_attributes_for_feature(self, feature: QgsFeature) -> List[any]:
+        attributes = {i: feature[field.name()] for i, field in enumerate(feature.fields().toList())}
         if self.symbol_type == SymbolType.graduatedSymbol:
             feature_value = feature[self.mapped_col]
             matched = None
@@ -205,7 +219,10 @@ def _get_style_for_feature(self, feature: QgsFeature):
                         break
                 if matched is not None:
                     for field_name in self.field_template.keys():
-                        ret_val[self.fields.names().index(field_name)] = self.symbols[matched]['style'][field_name]
+                        style: Style = self.symbols[matched]['style']
+                        style.evaluate_data_defined_expressions(feature)
+                        attributes[self.fields.names().index(field_name)] = style.to_dict()[
+                            field_name]
 
         elif self.symbol_type == SymbolType.categorizedSymbol:
             feature_value = feature[self.mapped_col]
@@ -216,22 +233,26 @@ def _get_style_for_feature(self, feature: QgsFeature):
                         matched = index
                 if matched is not None:
                     for field_name in self.field_template.keys():
-                        ret_val[self.fields.names().index(field_name)] = self.symbols[matched]['style'][field_name]
+                        style = self.symbols[matched]['style']
+                        style.evaluate_data_defined_expressions(feature)
+                        attributes[self.fields.names().index(field_name)] = style.to_dict()[
+                            field_name]
 
         elif self.symbol_type == SymbolType.singleSymbol:
             for field_name in self.field_template.keys():
-                ret_val[self.fields.names().index(field_name)] = self.symbols[0]['style'][field_name]
+                style = self.symbols[0]['style']
+                style.evaluate_data_defined_expressions(feature)
+                attributes[self.fields.names().index(field_name)] = style.to_dict()[field_name]
 
         # TODO: Add more
 
-        return ret_val
+        return [attributes[key] for key in sorted(attributes.keys())]
 
     def _update_legend(self):
         legend = {}
         i = 0
         for index, item in self.symbols.items():
-            legend_style = item["style"].copy()
-            legend_style = {self.field_mapper[key]: value for key, value in legend_style.items()}
+            legend_style = item["style"].legend_style
             legend_style['size'] = 1
             legend_style["primary"] = self.primary_layer and (i == 0 or i == (len(self.symbols.items()) - 1))
             legend_style["label"] = item["label"]

GemeindescanExporter/definitions/style.py

@@ -0,0 +1,93 @@
+#  Gispo Ltd., hereby disclaims all copyright interest in the program GemeindescanExporter
+#  Copyright (C) 2020 Gispo Ltd (https://www.gispo.fi/).
+#
+#
+#  This file is part of GemeindescanExporter.
+#
+#  GemeindescanExporter is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  GemeindescanExporter is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with GemeindescanExporter.  If not, see <https://www.gnu.org/licenses/>.
+from typing import Dict, Union
+
+from qgis._core import QgsFeature, QgsExpression, QgsExpressionContext
+
+
+class Style:
+    LEGEND_MAPPER = {'fill': 'fillColor', 'fill-opacity': 'fillOpacity', 'stroke': 'strokeColor',
+                     'stroke-opacity': 'strokeOpacity', 'stroke-width': 'strokeWidth', 'type': 'shape'}
+    FIELD_MAPPER = {
+        'fill': 'fill', 'fill-opacity': 'fill_opacity', 'stroke': 'stroke', 'stroke-opacity': 'stroke_opacity',
+        'stroke-width': 'stroke_width'
+    }
+
+    def __init__(self):
+        self.fill = '#000000'
+        self.fill_opacity = 1.0
+        self.stroke = '#ffffff'
+        self.stroke_opacity = 1.0
+        self.stroke_width = 1.0
+
+        # Not in template
+        self.type = ''
+
+        self.data_defined_expressions: Dict[str, QgsExpression] = {}
+
+    @property
+    def legend_style(self) -> Dict[str, any]:
+        values = self.to_dict(for_legend=True)
+        return {self.LEGEND_MAPPER[key]: value for key, value in values.items()
+                if key in self.LEGEND_MAPPER.keys()}
+
+    def add_data_defined_expression(self, field_name: str, expression: str):
+        self.data_defined_expressions[field_name] = QgsExpression(expression)
+
+    def evaluate_data_defined_expressions(self, feature: QgsFeature):
+        context = QgsExpressionContext()
+        context.setFeature(feature)
+        for fld_name, exp in self.data_defined_expressions.items():
+            evaluate = exp.evaluate(context)
+            self.__dict__[fld_name] = evaluate
+
+    def to_dict(self, for_legend: bool = False) -> Dict[str, any]:
+        values_dict = self.__dict__
+        values = {f_name: values_dict[c_name] for f_name, c_name in self.FIELD_MAPPER.items()}
+
+        if for_legend:
+            values['type'] = self.type
+        return values
+
+
+class SimpleStyle(Style):
+    pass
+
+
+class PointStyle(Style):
+    LEGEND_MAPPER = {'fillColor': 'fillColor', 'fillOpacity': 'fillOpacity', 'color': 'strokeColor',
+                     'opacity': 'strokeOpacity', 'weight': 'strokeWidth', 'type': 'shape'}
+    FIELD_MAPPER = {
+        'fill': 'has_fill',
+        'fillColor': 'fill',
+        'fillOpacity': 'fill_opacity',
+        'stroke': 'has_stroke',
+        'color': 'stroke',
+        'opacity': 'stroke_opacity',
+        'weight': 'stroke_width',
+        'radius': 'radius',
+        # 'title': 'title',
+    }
+
+    def __init__(self):
+        super().__init__()
+        self.radius: Union[int, float, str] = 2.0  # based on QGIS default mm radius
+        self.has_fill = True
+        self.has_stroke = True
+        self.title = ''