Support exporting vectorLayer to qgis

examples/world.jGIS

@@ -0,0 +1,51 @@
+{
+  "layerTree": [
+    "ef427395-3dad-411d-ae4b-d56190cb2e68"
+  ],
+  "layers": {
+    "ef427395-3dad-411d-ae4b-d56190cb2e68": {
+      "name": "Custom GeoJSON Layer",
+      "parameters": {
+        "color": {
+          "fill-color": "#4ea4d0",
+          "stroke-color": "#ff0000",
+          "stroke-line-cap": "round",
+          "stroke-line-join": "round",
+          "stroke-width": 1.25
+        },
+        "opacity": 1.0,
+        "source": "5c228c74-5167-4437-a38b-f9302be9b80f",
+        "symbologyState": {
+          "renderType": "Single Symbol"
+        },
+        "type": "line"
+      },
+      "type": "VectorLayer",
+      "visible": true
+    }
+  },
+  "metadata": {},
+  "options": {
+    "bearing": 0.0,
+    "extent": [
+      -5350224.080333857,
+      -8168086.573252421,
+      13275562.199623892,
+      12116960.46690232
+    ],
+    "latitude": 17.459989741135686,
+    "longitude": 35.59726182186651,
+    "pitch": 0.0,
+    "projection": "EPSG:3857",
+    "zoom": 2.7438377054069027
+  },
+  "sources": {
+    "5c228c74-5167-4437-a38b-f9302be9b80f": {
+      "name": "Custom GeoJSON Layer Source",
+      "parameters": {
+        "path": "https://raw.githubusercontent.com/nvkelso/natural-earth-vector/master/geojson/ne_110m_admin_0_countries.geojson"
+      },
+      "type": "GeoJSONSource"
+    }
+  }
+}

python/jupytergis_qgis/jupytergis_qgis/qgis_loader.py

@@ -30,6 +30,12 @@
     QgsSingleBandPseudoColorRenderer,
     QgsVectorLayer,
     QgsVectorTileLayer,
+    QgsWkbTypes,
+    QgsSingleSymbolRenderer,
+    QgsCategorizedSymbolRenderer,
+    QgsRendererCategory,
+    QgsGraduatedSymbolRenderer,
+    QgsRendererRange,
 )
 
 # Prevent any Qt application and event loop to spawn when
@@ -400,6 +406,12 @@ def build_uri(parameters: dict[str, str], source_type: str) -> str | None:
             layer_config["url"] = url
             layer_config["type"] = "xyz"
 
+        if source_type == "GeoJSONSource":
+            path = parameters.get("path", None)
+            if path is None:
+                return
+            return path
+
         if source_type == "RasterSource":
             layer_config["crs"] = "EPSG:3857"
 
@@ -477,6 +489,147 @@ def build_uri(parameters: dict[str, str], source_type: str) -> str | None:
 
             renderer.setStyles(parsed_styles)
 
+    if layer_type == "VectorLayer" and source_type == "GeoJSONSource":
+        source_parameters = source.get("parameters", {})
+        uri = build_uri(source_parameters, "GeoJSONSource")
+        if not uri:
+            logs["warnings"].append(
+                f"Layer {layer_id} not exported: invalid GeoJSON source."
+            )
+            return
+
+        map_layer = QgsVectorLayer(uri, layer_name, "ogr")
+        if not map_layer.isValid():
+            logs["warnings"].append(
+                f"Layer {layer_id} not exported: failed to load GeoJSON source."
+            )
+            return
+
+        geometry_type = map_layer.geometryType()
+        layer_params = layer.get("parameters", {})
+        print(f"Geometry Type: {geometry_type}", layer_params)
+
+        if geometry_type == QgsWkbTypes.PointGeometry:
+            symbol = QgsMarkerSymbol()
+            color_params = layer_params.get("color", {})
+            opacity = layer_params.get("opacity", 1.0)
+            symbology_state = layer_params.get("symbologyState", {})
+            render_type = symbology_state.get("renderType", "Single Symbol")
+
+            # Set stroke color and width
+            stroke_color = QColor(color_params.get("circle-stroke-color", "#3399CC"))
+            stroke_width = color_params.get("circle-stroke-width", 1.25)
+            symbol.symbolLayer(0).setStrokeColor(stroke_color)
+            symbol.symbolLayer(0).setStrokeWidth(stroke_width)
+            symbol.setOpacity(opacity)
+
+            # Single Symbol Renderer
+            if render_type == "Single Symbol":
+                fill_color = QColor(color_params.get("circle-fill-color"))
+                symbol.setColor(fill_color)
+                renderer = QgsSingleSymbolRenderer(symbol)
+
+            # Categorized Renderer
+            elif render_type == "Categorized":
+                fill_color_rules = color_params.get("circle-fill-color", [])
+                if isinstance(fill_color_rules, list) and fill_color_rules[0] == "case":
+                    # Create a base symbol
+                    base_symbol = QgsMarkerSymbol()
+                    base_symbol.symbolLayer(0).setStrokeColor(
+                        QColor(color_params.get("circle-stroke-color"))
+                    )
+                    base_symbol.symbolLayer(0).setStrokeWidth(
+                        color_params.get("circle-stroke-width", 1)
+                    )
+                    base_symbol.setOpacity(opacity)
+
+                    renderer = QgsCategorizedSymbolRenderer(
+                        symbology_state.get("value")
+                    )
+
+                    for i in range(1, len(fill_color_rules) - 1, 2):
+                        condition = fill_color_rules[i]
+                        color = fill_color_rules[i + 1]
+
+                        if isinstance(color, list) and len(color) == 4:
+                            r, g, b, a = color
+                            color = [r, g, b, 1.0]
+
+                        category_symbol = base_symbol.clone()
+                        category_symbol.setColor(
+                            QColor(
+                                int(color[0]),
+                                int(color[1]),
+                                int(color[2]),
+                                int(color[3] * 255),
+                            )
+                        )
+
+                        category_symbol.setOpacity(1.0)
+
+                        category = QgsRendererCategory(
+                            condition[2], category_symbol, str(condition[2])
+                        )
+                        renderer.addCategory(category)
+
+            # Graduated Renderer
+            elif render_type == "Graduated":
+                fill_color_rules = color_params.get("circle-fill-color", [])
+                if (
+                    isinstance(fill_color_rules, list)
+                    and fill_color_rules[0] == "interpolate"
+                ):
+                    ranges = []
+                    for i in range(3, len(fill_color_rules) - 2, 2):
+                        lower_value = fill_color_rules[i]
+                        upper_value = fill_color_rules[i + 2]
+                        color = fill_color_rules[i + 1]
+
+                        if isinstance(color, list) and len(color) == 4:
+                            r, g, b, a = color
+                            qcolor = QColor(int(r), int(g), int(b), int(a * 255))
+                        range_symbol = symbol.clone()
+                        range_symbol.setColor(qcolor)
+                        g_range = QgsRendererRange(
+                            lower_value,
+                            upper_value,
+                            range_symbol,
+                            f"{lower_value} - {upper_value}",
+                        )
+                        ranges.append(g_range)
+                    renderer = QgsGraduatedSymbolRenderer(
+                        symbology_state.get("value"), ranges
+                    )
+
+        elif geometry_type == QgsWkbTypes.LineGeometry:
+            symbol = QgsLineSymbol()
+            color_params = layer_params.get("color", {})
+            color = QColor(color_params.get("stroke-color"))
+            opacity = int(layer_params.get("opacity"))
+            print(f"Line Color: {color.name()}, Opacity: {opacity}")
+            symbol.setColor(color)
+            symbol.setOpacity(opacity)
+            renderer = QgsSingleSymbolRenderer(symbol)
+
+        elif geometry_type == QgsWkbTypes.PolygonGeometry:
+            symbol = QgsFillSymbol()
+            color_params = layer_params.get("color", {})
+            opacity = layer_params.get("opacity", 1.0)
+            symbol.setOpacity(opacity)
+
+            fill_color = QColor(color_params.get("fill-color"))
+            symbol.setColor(fill_color)
+
+            stroke_color = QColor(color_params.get("stroke-color"))
+            stroke_width = color_params.get("stroke-width", 1)
+
+            symbol_layer = symbol.symbolLayer(0)
+            symbol_layer.setStrokeColor(stroke_color)
+            symbol_layer.setStrokeWidth(stroke_width)
+            renderer = QgsSingleSymbolRenderer(symbol)
+
+        map_layer.setRenderer(renderer)
+
     if layer_type == "WebGlLayer" and source_type == "GeoTiffSource":
         source_parameters = source.get("parameters", {})
         # TODO: Support sources with multiple URLs

python/jupytergis_qgis/jupytergis_qgis/tests/test_qgis.py

@@ -125,8 +125,8 @@ def test_qgis_saver():
     if os.path.exists(filename):
         os.remove(filename)
 
-    layer_ids = [str(uuid4()), str(uuid4()), str(uuid4()), str(uuid4())]
-    source_ids = [str(uuid4()), str(uuid4()), str(uuid4()), str(uuid4())]
+    layer_ids = [str(uuid4()), str(uuid4()), str(uuid4()), str(uuid4()), str(uuid4())]
+    source_ids = [str(uuid4()), str(uuid4()), str(uuid4()), str(uuid4()), str(uuid4())]
     jgis = {
         "options": {
             "bearing": 0.0,
@@ -185,6 +185,24 @@ def test_qgis_saver():
                 "type": "RasterLayer",
                 "visible": False,
             },
+            layer_ids[4]: {
+                "name": "Custom GeoJSON Layer",
+                "parameters": {
+                    "color": {
+                        "fill-color": "#4ea4d0",
+                        "stroke-color": "#ff0000",
+                        "stroke-line-cap": "round",
+                        "stroke-line-join": "round",
+                        "stroke-width": 1.25,
+                    },
+                    "opacity": 1.0,
+                    "source": source_ids[4],
+                    "symbologyState": {"renderType": "Single Symbol"},
+                    "type": "fill",
+                },
+                "type": "VectorLayer",
+                "visible": True,
+            },
         },
         "layerTree": [
             layer_ids[0],
@@ -196,6 +214,7 @@ def test_qgis_saver():
                 ],
                 "name": "group0",
             },
+            layer_ids[4],
         ],
         "sources": {
             source_ids[0]: {
@@ -234,6 +253,13 @@ def test_qgis_saver():
                     "minZoom": 0,
                 },
             },
+            source_ids[4]: {
+                "name": "Custom GeoJSON Layer Source",
+                "parameters": {
+                    "path": "https://raw.githubusercontent.com/nvkelso/natural-earth-vector/master/geojson/ne_110m_admin_0_countries.geojson"
+                },
+                "type": "GeoJSONSource",
+            },
         },
         "metadata": {},
     }