Processing: Rasterize a vector layer

packages/base/src/commands.ts

@@ -26,7 +26,11 @@ import keybindings from './keybindings.json';
 import { JupyterGISTracker } from './types';
 import { JupyterGISDocumentWidget } from './widget';
 import { getGdal } from './gdal';
-import { getGeoJSONDataFromLayerSource, downloadFile } from './tools';
+import {
+  getGeoJSONDataFromLayerSource,
+  downloadFile,
+  uint8ArrayToBase64
+} from './tools';
 import { ProcessingFormDialog } from './dialogs/ProcessingFormDialog';
 
 interface ICreateEntry {
@@ -1405,6 +1409,140 @@ export function addCommands(
     }
   });
 
+  commands.addCommand(CommandIDs.rasterize, {
+    label: trans.__('Rasterize'),
+    isEnabled: () => {
+      const selectedLayer = getSingleSelectedLayer(tracker);
+      return selectedLayer
+        ? ['VectorLayer', 'ShapefileLayer'].includes(selectedLayer.type)
+        : false;
+    },
+    execute: async () => {
+      const selectedLayer = getSingleSelectedLayer(tracker);
+      if (!selectedLayer) {
+        return;
+      }
+
+      const model = tracker.currentWidget?.model as IJupyterGISModel;
+      const sources = model.sharedModel.sources ?? {};
+
+      const exportSchema = {
+        ...(formSchemaRegistry.getSchemas().get('Rasterize') as IDict)
+      };
+      console.log(exportSchema);
+
+      const formValues = await new Promise<IDict>(resolve => {
+        const dialog = new ProcessingFormDialog({
+          title: 'Rasterize Layer',
+          schema: exportSchema,
+          model,
+          formContext: 'create',
+          processingType: 'export',
+          sourceData: {
+            resolutionX: 1200,
+            resolutionY: 1200,
+            outputLayerName: selectedLayer.name + ' Rasterized'
+          },
+          syncData: (props: IDict) => {
+            resolve(props);
+            dialog.dispose();
+          }
+        });
+
+        dialog.launch();
+      });
+
+      if (!formValues || !selectedLayer.parameters) {
+        return;
+      }
+
+      const outputFileName = formValues.outputLayerName;
+      const resolutionX = formValues.resolutionX ?? 1200;
+      const resolutionY = formValues.resolutionY ?? 1200;
+      const sourceId = selectedLayer.parameters.source;
+      const source = sources[sourceId];
+
+      const geojsonString = await getGeoJSONDataFromLayerSource(source, model);
+      if (!geojsonString) {
+        return;
+      }
+
+      const Gdal = await getGdal();
+      const datasetList = await Gdal.open(
+        new File([geojsonString], 'data.geojson', {
+          type: 'application/geo+json'
+        })
+      );
+      const dataset = datasetList.datasets[0];
+
+      if (!dataset) {
+        console.error('Dataset could not be opened.');
+        return;
+      }
+
+      const options = [
+        '-of',
+        'GTiff',
+        '-ot',
+        'Float32',
+        '-a_nodata',
+        '-1.0',
+        '-burn',
+        '0.0',
+        '-ts',
+        resolutionX.toString(),
+        resolutionY.toString(),
+        '-l',
+        'data',
+        'data.geojson',
+        'output.tif'
+      ];
+
+      const outputFilePath = await Gdal.gdal_rasterize(dataset, options);
+      const exportedBytes = await Gdal.getFileBytes(outputFilePath);
+
+      const base64String = uint8ArrayToBase64(exportedBytes);
+
+      const jgisFilePath = tracker.currentWidget?.model.filePath;
+      const jgisDir = jgisFilePath
+        ? jgisFilePath.substring(0, jgisFilePath.lastIndexOf('/'))
+        : '';
+
+      // Ensure the path is valid and construct the save path
+      const savePath = jgisDir
+        ? `${jgisDir}/${outputFileName}.tif`
+        : `${outputFileName}.tif`;
+
+      await app.serviceManager.contents.save(savePath, {
+        type: 'file',
+        format: 'base64',
+        content: base64String
+      });
+
+      Gdal.close(dataset);
+
+      // Store in shared model
+      const newSourceId = UUID.uuid4();
+      const sourceModel: IJGISSource = {
+        type: 'GeoTiffSource',
+        name: outputFileName,
+        parameters: {
+          urls: [{ url: `${outputFileName}.tif`, min: 0, max: 1000 }]
+        }
+      };
+
+      const layerModel: IJGISLayer = {
+        type: 'WebGlLayer',
+        parameters: { source: newSourceId },
+        visible: true,
+        name: outputFileName
+      };
+
+      model.sharedModel.addSource(newSourceId, sourceModel);
+      model.addLayer(UUID.uuid4(), layerModel);
+    }
+  });
+
   loadKeybindings(commands, keybindings);
 }
 

packages/base/src/constants.ts

@@ -27,6 +27,7 @@ export namespace CommandIDs {
   // Processing commands
   export const buffer = 'jupytergis:buffer';
   export const dissolve = 'jupytergis:dissolve';
+  export const rasterize = 'jupytergis:rasterize';
 
   // Sources only commands
   export const newRasterSource = 'jupytergis:newRasterSource';

packages/base/src/dialogs/ProcessingFormDialog.tsx

@@ -86,8 +86,6 @@ export class ProcessingFormDialog extends Dialog<IDict> {
 
     // Modify schema to include layer options and layer name field
     if (options.schema) {
-      console.log(options.schema.properties?.inputLayer);
-
       if (options.schema.properties?.inputLayer) {
         options.schema.properties.inputLayer.enum = layerOptions.map(
           option => option.value

packages/base/src/tools.ts

@@ -922,3 +922,11 @@ export async function getGeoJSONDataFromLayerSource(
   console.error("Source is missing both 'path' and 'data' parameters.");
   return null;
 }
+
+export const uint8ArrayToBase64 = (uint8Array: Uint8Array): string => {
+  let binaryString = '';
+  for (let i = 0; i < uint8Array.length; i++) {
+    binaryString += String.fromCharCode(uint8Array[i]);
+  }
+  return btoa(binaryString);
+};

packages/schema/src/schema/export/exportGeotiff.json

@@ -1,16 +1,10 @@
 {
   "type": "object",
-  "description": "ExportGeoTIFFSchema",
+  "description": "Rasterize",
   "title": "IExportGeoTIFF",
-  "required": ["exportFileName", "resolutionX", "resolutionY"],
+  "required": ["resolutionX", "resolutionY"],
   "additionalProperties": false,
   "properties": {
-    "exportFileName": {
-      "type": "string",
-      "title": "GeoTiFF File Name",
-      "default": "exported_layer",
-      "description": "The name of the exported GeoTIFF file."
-    },
     "resolutionX": {
       "type": "number",
       "title": "Resolution (Width)",

python/jupytergis_lab/src/index.ts

@@ -201,6 +201,10 @@ const plugin: JupyterFrontEndPlugin<void> = {
       command: CommandIDs.dissolve
     });
 
+    processingSubmenu.addItem({
+      command: CommandIDs.rasterize
+    });
+
     app.contextMenu.addItem({
       type: 'submenu',
       selector: '.jp-gis-layerItem',