Add GeoParquet support

examples/geoparquet.jgis

@@ -0,0 +1,63 @@
+{
+  "layerTree": [
+    "9556ca29-a5ec-41af-bf14-4b543c52aafe",
+    "d7a2ad84-0750-4e9b-82c0-542fcc6b3265"
+  ],
+  "layers": {
+    "9556ca29-a5ec-41af-bf14-4b543c52aafe": {
+      "name": "OpenStreetMap.Mapnik Layer",
+      "parameters": {
+        "source": "2a52082b-7992-40dc-92d6-75e309a1ed27"
+      },
+      "type": "RasterLayer",
+      "visible": true
+    },
+    "d7a2ad84-0750-4e9b-82c0-542fcc6b3265": {
+      "name": "Custom GeoParquet Layer",
+      "parameters": {
+        "opacity": 1.0,
+        "source": "c1da95b9-8a71-4fee-b4e3-6f0b5f53d2d4"
+      },
+      "type": "VectorLayer",
+      "visible": true
+    }
+  },
+  "metadata": {},
+  "options": {
+    "bearing": 0.0,
+    "extent": [
+      -20037508.342789244,
+      -15214174.147482341,
+      20037508.342789244,
+      15214174.147482341
+    ],
+    "latitude": 0.0,
+    "longitude": 0.0,
+    "projection": "EPSG:3857",
+    "zoom": 1.5058115539195944
+  },
+  "schemaVersion": "0.5.0",
+  "sources": {
+    "2a52082b-7992-40dc-92d6-75e309a1ed27": {
+      "name": "OpenStreetMap.Mapnik",
+      "parameters": {
+        "attribution": "(C) OpenStreetMap contributors",
+        "maxZoom": 19.0,
+        "minZoom": 0.0,
+        "provider": "OpenStreetMap",
+        "url": "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
+        "urlParameters": {}
+      },
+      "type": "RasterSource"
+    },
+    "c1da95b9-8a71-4fee-b4e3-6f0b5f53d2d4": {
+      "name": "Custom GeoParquet Source",
+      "parameters": {
+        "attribution": "",
+        "path": "https://raw.githubusercontent.com/opengeospatial/geoparquet/main/examples/example.parquet",
+        "projection": "EPSG:4326"
+      },
+      "type": "GeoParquetSource"
+    }
+  }
+}

packages/base/package.json

@@ -80,7 +80,9 @@
     "date-fns": "^4.1.0",
     "gdal3.js": "^2.8.1",
     "geojson-vt": "^4.0.2",
+    "geoparquet": "^0.3.0",
     "geotiff": "^2.1.3",
+    "hyparquet-compressors": "^1.1.1",
     "lucide-react": "^0.513.0",
     "ol": "^10.1.0",
     "ol-pmtiles": "^0.5.0",

packages/base/src/commands/BaseCommandIDs.ts

@@ -24,6 +24,7 @@ export const newHillshadeEntry = 'jupytergis:newHillshadeEntry';
 export const newImageEntry = 'jupytergis:newImageEntry';
 export const newVideoEntry = 'jupytergis:newVideoEntry';
 export const newGeoTiffEntry = 'jupytergis:newGeoTiffEntry';
+export const newGeoParquetEntry = 'jupytergis:newGeoParquetEntry';
 
 // Layer and group actions
 export const renameLayer = 'jupytergis:renameLayer';

packages/base/src/commands/index.ts

@@ -320,6 +320,27 @@ export function addCommands(
     ...icons.get(CommandIDs.newVectorTileEntry),
   });
 
+  commands.addCommand(CommandIDs.newGeoParquetEntry, {
+    label: trans.__('New GeoParquet Layer'),
+    isEnabled: () => {
+      return tracker.currentWidget
+        ? tracker.currentWidget.model.sharedModel.editable
+        : false;
+    },
+    execute: Private.createEntry({
+      tracker,
+      formSchemaRegistry,
+      title: 'Create GeoParquet Layer',
+      createLayer: true,
+      createSource: true,
+      sourceData: { name: 'Custom GeoParquet Source' },
+      layerData: { name: 'Custom GeoParquet Layer' },
+      sourceType: 'GeoParquetSource',
+      layerType: 'VectorLayer',
+    }),
+    ...icons.get(CommandIDs.newGeoParquetEntry),
+  });
+
   commands.addCommand(CommandIDs.newGeoJSONEntry, {
     label: trans.__('New GeoJSON layer'),
     isEnabled: () => {

packages/base/src/constants.ts

@@ -52,6 +52,7 @@ const iconObject = {
   [CommandIDs.newVideoEntry]: { iconClass: 'fa fa-video' },
   [CommandIDs.newShapefileEntry]: { iconClass: 'fa fa-file' },
   [CommandIDs.newGeoTiffEntry]: { iconClass: 'fa fa-image' },
+  [CommandIDs.newGeoParquetEntry]: { iconClass: 'fa fa-file' },
   [CommandIDs.symbology]: { iconClass: 'fa fa-brush' },
   [CommandIDs.identify]: { icon: infoIcon },
   [CommandIDs.temporalController]: { icon: clockIcon },

packages/base/src/formbuilder/formselectors.ts

@@ -60,6 +60,10 @@ export function getSourceTypeForm(
     case 'VectorTileSource':
       SourceForm = TileSourcePropertiesForm;
       break;
+    case 'GeoParquetSource':
+      SourceForm = PathBasedSourcePropertiesForm;
+      break;
+
     // ADD MORE FORM TYPES HERE
   }
   return SourceForm;

packages/base/src/mainview/mainView.tsx

@@ -26,6 +26,7 @@ import {
   IVectorLayer,
   IVectorTileLayer,
   IVectorTileSource,
+  IGeoParquetSource,
   IWebGlLayer,
   JgisCoordinates,
   JupyterGISModel,
@@ -769,6 +770,28 @@ export class MainView extends React.Component<IProps, IStates> {
 
         break;
       }
+
+      case 'GeoParquetSource': {
+        const parameters = source.parameters as IGeoParquetSource;
+
+        const geojson = await loadFile({
+          filepath: parameters.path,
+          type: 'GeoParquetSource',
+          model: this._model,
+        });
+
+        const geojsonData = Array.isArray(geojson) ? geojson[0] : geojson;
+
+        const format = new GeoJSON();
+
+        newSource = new VectorSource({
+          features: format.readFeatures(geojsonData, {
+            dataProjection: parameters.projection,
+            featureProjection: this._Map.getView().getProjection(),
+          }),
+        });
+        break;
+      }
     }
 
     newSource.set('id', id);

packages/base/src/menus.ts

@@ -26,6 +26,11 @@ export const vectorSubMenu = (commands: CommandRegistry) => {
     command: CommandIDs.newShapefileEntry,
   });
 
+  subMenu.addItem({
+    type: 'command',
+    command: CommandIDs.newGeoParquetEntry,
+  });
+
   return subMenu;
 };
 

packages/base/src/tools.ts

@@ -12,6 +12,7 @@ import { PathExt, URLExt } from '@jupyterlab/coreutils';
 import { Contents, ServerConnection } from '@jupyterlab/services';
 import { VectorTile } from '@mapbox/vector-tile';
 import * as d3Color from 'd3-color';
+import { compressors } from 'hyparquet-compressors';
 import Protobuf from 'pbf';
 import shp from 'shpjs';
 
@@ -567,6 +568,26 @@ export const loadFile = async (fileInfo: {
         throw new Error(`Failed to fetch ${filepath}`);
       }
 
+      case 'GeoParquetSource': {
+        const cached = await getFromIndexedDB(filepath);
+        if (cached) {
+          return cached.file;
+        }
+
+        const { asyncBufferFromUrl, toGeoJson } = await import('geoparquet');
+
+        const file = await asyncBufferFromUrl({ url: filepath });
+        const geojson = await toGeoJson({ file });
+
+        if (geojson) {
+          await saveToIndexedDB(filepath, geojson);
+          return geojson;
+        }
+
+        showErrorMessage('Network error', `Failed to fetch ${filepath}`);
+        throw new Error(`Failed to fetch ${filepath}`);
+      }
+
       default: {
         throw new Error(`Unsupported URL handling for source type: ${type}`);
       }
@@ -633,6 +654,18 @@ export const loadFile = async (fileInfo: {
         }
       }
 
+      case 'GeoParquetSource': {
+        if (typeof file.content === 'string') {
+          const { toGeoJson } = await import('geoparquet');
+
+          const arrayBuffer = await stringToArrayBuffer(file.content as string);
+
+          return await toGeoJson({ file: arrayBuffer, compressors });
+        } else {
+          throw new Error('Invalid file format for GeoParquet content.');
+        }
+      }
+
       default: {
         throw new Error(`Unsupported source type: ${type}`);
       }

packages/base/src/types/geoparquet.d.ts

@@ -0,0 +1,12 @@
+declare module 'geoparquet' {
+  export function asyncBufferFromUrl(options: {
+    url: string;
+    byteLength?: number;
+    requestInit?: RequestInit;
+  }): Promise<AsyncBuffer>;
+
+  export function toGeoJson(options: {
+    file: AsyncBuffer;
+    compressors?: any;
+  }): Promise<GeoJSON>;
+};

packages/base/tsconfig.json

@@ -15,6 +15,7 @@
     "src/**/*",
     "src/schema/*.json",
     "src/_interface/*.json",
-    "src/*.json"
+    "src/*.json",
+    "src/types/*"
   ]
 }

packages/schema/src/schema/project/jgis.json

@@ -54,7 +54,8 @@
         "VideoSource",
         "ImageSource",
         "ShapefileSource",
-        "GeoTiffSource"
+        "GeoTiffSource",
+        "GeoParquetSource"
       ]
     },
     "jGISLayer": {

packages/schema/src/schema/project/sources/geoParquetSource.json

@@ -0,0 +1,24 @@
+{
+  "type": "object",
+  "description": "GeoParquetSource",
+  "title": "IGeoParquetSource",
+  "required": ["path"],
+  "additionalProperties": false,
+  "properties": {
+    "path": {
+      "type": "string",
+      "description": "The path to the GeoParquet source"
+    },
+    "attribution": {
+      "type": "string",
+      "readOnly": true,
+      "description": "The attribution for the GeoParquet source.",
+      "default": ""
+    },
+    "projection": {
+      "type": "string",
+      "description": "The projection information for the GeoParquet data (optional).",
+      "default": "EPSG:4326"
+    }
+  }
+}

packages/schema/src/types.ts

@@ -9,6 +9,7 @@ export * from './_interface/project/sources/rasterSource';
 export * from './_interface/project/sources/shapefileSource';
 export * from './_interface/project/sources/vectorTileSource';
 export * from './_interface/project/sources/videoSource';
+export * from './_interface/project/sources/geoParquetSource';
 
 // Layers
 export * from './_interface/project/layers/heatmapLayer';

python/jupytergis_core/jupytergis_core/schema/__init__.py

@@ -15,6 +15,7 @@
 from .interfaces.project.sources.imageSource import IImageSource  # noqa
 from .interfaces.project.sources.geoTiffSource import IGeoTiffSource  # noqa
 from .interfaces.project.sources.rasterDemSource import IRasterDemSource  # noqa
+from .interfaces.project.sources.geoParquetSource import IGeoParquetSource  # noqa
 
 from .interfaces.processing.buffer import IBuffer  # noqa
 

python/jupytergis_lab/jupytergis_lab/notebook/gis_document.py

@@ -14,6 +14,7 @@
 
 from jupytergis_core.schema import (
     IGeoJSONSource,
+    IGeoParquetSource,
     IGeoTiffSource,
     IHeatmapLayer,
     IHillshadeLayer,
@@ -544,6 +545,59 @@ def add_heatmap_layer(
 
         return self._add_layer(OBJECT_FACTORY.create_layer(layer, self))
 
+    def add_geoparquet_layer(
+        self,
+        path: str,
+        name: str = "GeoParquetLayer",
+        type: "circle" | "fill" | "line" = "line",
+        opacity: float = 1,
+        logical_op: str | None = None,
+        feature: str | None = None,
+        operator: str | None = None,
+        value: Union[str, int, float] | None = None,
+        color_expr=None,
+    ):
+        """
+        Add a GeoParquet Layer to the document
+        :param path: The path to the GeoParquet file to embed into the jGIS file.
+        :param name: The name that will be used for the object in the document.
+        :param type: The type of the vector layer to create.
+        :param opacity: The opacity, between 0 and 1.
+        :param logical_op: The logical combination to apply to filters. Must be "any" or "all"
+        :param feature: The feature to be filtered on
+        :param operator: The operator used to compare the feature and value
+        :param value: The value to be filtered on
+        :param color_expr: The style expression used to style the layer
+        """
+
+        source = {
+            "type": SourceType.GeoParquetSource,
+            "name": f"{name} Source",
+            "parameters": {"path": path},
+        }
+
+        source_id = self._add_source(OBJECT_FACTORY.create_source(source, self))
+
+        layer = {
+            "type": LayerType.VectorLayer,
+            "name": name,
+            "visible": True,
+            "parameters": {
+                "source": source_id,
+                "type": type,
+                "opacity": opacity,
+                "color": color_expr,
+            },
+            "filters": {
+                "appliedFilters": [
+                    {"feature": feature, "operator": operator, "value": value}
+                ],
+                "logicalOp": logical_op,
+            },
+        }
+
+        return self._add_layer(OBJECT_FACTORY.create_layer(layer, self))
+
     def remove_layer(self, layer_id: str):
         """
         Remove a layer from the GIS document.
@@ -830,6 +884,7 @@ class Config:
         IVideoSource,
         IGeoTiffSource,
         IRasterDemSource,
+        IGeoParquetSource,
     ]
     _parent = Optional[GISDocument]
 
@@ -917,3 +972,4 @@ def create_source(
 OBJECT_FACTORY.register_factory(SourceType.VideoSource, IVideoSource)
 OBJECT_FACTORY.register_factory(SourceType.GeoTiffSource, IGeoTiffSource)
 OBJECT_FACTORY.register_factory(SourceType.RasterDemSource, IRasterDemSource)
+OBJECT_FACTORY.register_factory(SourceType.GeoParquetSource, IGeoParquetSource)