Painting layer: enable (very) basic write support

Drawing on a painting layer will now actually store the changes in a
server-side N5 file.

Author: tomka

CHANGELOG.md

@@ -48,6 +48,12 @@ Data sources:
 - Neuroglancer Precomputed URLs that start with `gs://` are rewritten on the fly
   to use Google Cloud storage get API requess, improving CORS support.
 
+Painting tool:
+
+- A new tool allows to create per-user N5 files by painting on the dataset. This
+  tool needs to be enabled for users that should have it available (admin
+  interface).
+
 Cropping tool:
 
 - Neuroglancer Precomputed datasets (sharded and unsharded) are now supported

django/applications/catmaid/control/cropping.py

@@ -9,6 +9,7 @@
 import os
 import os.path
 import math
+import msgpack
 import numpy as np
 from PIL import Image as PILImage, TiffImagePlugin
 import requests
@@ -969,37 +970,60 @@ def write_block(request:HttpRequest, project_id=None, writable_stack_id=None) ->
 
     dataset_size = writable_stack.metadata.get('dataset_size')
     if not dataset_size:
-        raise ValueError('Need dataset_size parameter in writable stack metadata')
+        raise ValueError('Need parameter "dataset_size" in writable stack metadata')
 
-    data = request.POST.get('data')
-    if not data:
-        raise ValueError('Need data')
-    data = np.array(json.loads(data)).transpose([2, 1, 0])
+    compressed_data = request.POST.get('data')
+    if not compressed_data:
+        raise ValueError('Need parameter "data"')
 
-    data_bounds_json = request.POST.get('data_bounds')
-    if not data_bounds_json:
+    scale_level = request.POST.get('scale_level')
+    if scale_level is None:
+        raise ValueError('Need parameter "scale_level"')
+
+    data_bounds = get_request_list(request.POST, "data_bounds", map_fn=int)
+    if not data_bounds:
         raise ValueError('Need data_bounds paramaeter')
-    data_bounds = json.loads(data_bounds_json)
     if not isinstance(data_bounds, list) or len(data_bounds) != 2:
         raise ValueError('The data_bounds parameter needs to be a list of two lists')
     if not isinstance(data_bounds[0], list) or len(data_bounds[0]) != len(dataset_size):
-        raise ValueError('The first data_bounds list  needs to be a list with the correct dimensionality')
+        raise ValueError('The first data_bounds list needs to be a list with the correct dimensionality')
     if not isinstance(data_bounds[1], list) or len(data_bounds[1]) != len(dataset_size):
-        raise ValueError('The first data_bounds list  needs to be a list with the correct dimensionality')
+        raise ValueError('The first data_bounds list needs to be a list with the correct dimensionality')
 
-    dataset = writable_stack.metadata.get('dataset', 'volumes/main')
+    dataset = writable_stack.metadata.get('dataset', '')
     dtype = writable_stack.metadata.get('dtype', 'float64')
     compression_name = writable_stack.metadata.get('compression', 'GZIP')
     compression = getattr(pyn5.CompressionType, compression_name)
     compression_opts = writable_stack.metadata.get('compression_opts', -1)
     block_size = writable_stack.metadata.get('block_size', [1, 1, 1])
 
-    # TODO: Try to create only if not yet present
-    pyn5.create_dataset(writable_stack.path, dataset, dataset_size,
-                        block_size, dtype.upper())
+    compression = request.POST.get('compression')
+    if not compression or compression == 'raw':
+        block_data = json.loads(f'[{compressed_data}]')
+    elif compression == 'msgpack':
+        byte_list = bytes(json.loads(f'[{compressed_data}]'))
+        block_data = msgpack.unpackb(byte_list)
+    else:
+        raise ValueError(f'Unsupported compression: {compression}')
 
-    n5 = pyn5.open(writable_stack.path, dataset, dtype.upper(), False)
-    pyn5.write(n5, (np.array(data_bounds[0]), np.array(data_bounds[1])), data, dtype)
+    # We expect data to be a list of lists of lists, where X is the outer list,
+    # Y the second level and Z the last level.
+    data = np.array(block_data).reshape(block_size)
+
+    # TODO: Try to create only if not yet present
+    full_path = os.path.join(settings.MEDIA_ROOT,
+                                settings.MEDIA_WRITABLE_STACK_SUBDIRECTORY,
+                                writable_stack.path)
+    try:
+        pyn5.create_dataset(full_path, dataset, dataset_size,
+                            block_size, dtype.upper())
+    except ValueError:
+        # Assume the dataset exists already
+        pass
+
+    dataset += f"s{scale_level}"
+    n5 = pyn5.open(full_path, dataset, dtype.lower(), False)
+    pyn5.write(n5, (np.array(data_bounds[0]), np.array(data_bounds[1]) + 1), data, dtype)
 
     writable_stack.metadata['last_update_time'] = datetime.datetime.now(tz=datetime.timezone.utc).isoformat()
     writable_stack.metadata['last_update_bounds'] = data_bounds

django/applications/catmaid/control/stack.py

@@ -281,7 +281,20 @@ def post(self, request:HttpRequest, project_id) -> JsonResponse:
         # Create N5 skeleton manually, because the cloud-volume files don't seem
         # to be compatible.
         root_attributes = {
-            "n5": "2.1.3"
+            "n5": "2.1.3",
+            "pixelResolution": {
+                "unit": "um",
+                "dimensions": [
+                    metadata['resolution'][0],
+                    metadata['resolution'][1],
+                    metadata['resolution'][2],
+                ]
+            },
+            "downsamplingFactors": [[
+                scale_level.x,
+                scale_level.y,
+                scale_level.z,
+            ] for scale_level in stack.downsample_factors]
         }
         scale_attributes = []
         for n, scale_level in enumerate(stack.downsample_factors):

django/applications/catmaid/static/js/image-block.js

@@ -124,29 +124,6 @@
           {zoomLevel, x, y, z, block});
     }
 
-    writeBlock(projectId, writableStackId, zoomLevel, x, y, z, block, format='n5') {
-      if (format !== 'n5') {
-        return Promise.reject(new CATMAID.Error('Not implemented'));
-      }
-
-      // First, write to cache to update UI
-      this.setBlock(zoomLevel, x, y, z, block);
-
-      // Second, write to back-end asynchronously
-      // TODO: This should be done with the help of rate limitng to only send
-      // changes every 3 seconds or so.
-      /*
-      CATMAID.fetch(`${projectId}/writable-stacks/${writableStackId}/write-block`, 'POST', {
-          // TODO: zip/lzw block, esp. useful for new blocks
-          data: block.tolist(),
-          data_bounds: [[x, y, z], [x, y, z]],
-        })
-        .then(response => {
-          return Promise.reject('Not yet implemented');
-        });
-      */
-    }
-
     evictAll() {
       this._cache.evictAll();
     }

django/applications/catmaid/static/js/layers/painting-layer.js

@@ -14,6 +14,7 @@
     // The stack viewer is needed by the PixiLayer constructor
     this.stackViewer = stackViewer;
     this.dataLayer = dataLayer;
+    this.paintingTool = tool;
     //CATMAID.PixiLayer.call(this);
 
     this.view = document.createElement('canvas');
@@ -186,8 +187,9 @@
 
     // Draw a circle into the data layer's cache
     if (!(this.dataLayer instanceof CATMAID.PixiImageBlockLayer)) {
-      CATMAID.warn('Painting data layer has wrong layer type');
-      return;
+      const msg = 'Painting data layer has wrong layer type';
+      CATMAID.warn(msg);
+      return Promise.reject(CATMAID.ValueError(msg));
     }
 
     // Convert screen coordinates to voxel coordinates. Convert voxel
@@ -244,13 +246,16 @@
       Math.floor(voxelPosZ /  blockSize[2]),
     ];
 
+    // FIXME: This should be handled more nicely
+    if (blockCoord[0] < 0 || blockCoord[1] < 0) {
+      return Promise.resolve();
+    }
+
     // Assume block is in cache
-    this.dataLayer._readBlock(this.stackViewer.s, ...blockCoord)
+    return this.dataLayer._readBlock(this.stackViewer.s, ...blockCoord)
       .then((block) => {
         if (!block) {
-          // No block found in cache and on server
-          CATMAID.msg('success', 'A new block is created, because no existing block is found');
-          // TODO: Init new block
+          // No block found in cache and on server, create new block
           const backgroundValue = 0;
           block = nj.zeros(blockSize, dataType);
           block.assign(backgroundValue, false);
@@ -272,17 +277,70 @@
         for (let x = -halfBrushSize; x <= halfBrushSize; x++) {
           for (let y = -halfBrushSize; y <= halfBrushSize; y++) {
             const sqDist = x * x + y * y;
-            if (sqDist <= sqBrushSize) {
+            if (sqDist <= sqBrushSize && (relVoxelPos[0] + x) >= 0 && (relVoxelPos[1] + y) >= 0) {
               block.set(relVoxelPos[0] + x, relVoxelPos[1] + y, relVoxelPos[2], this.value);
             }
           }
         }
 
-        // Write block back to server. This is done asynchronously in regular
-        // intervals (if changes happen).
-        return this.dataLayer.writeBlock(project.id, this.stackViewer.s, zoom, ...blockCoord, block);
-      })
-      .catch(CATMAID.handleError);
+        const projectId = project.id;
+
+        // Write block to data layer cache, to display it quickly.
+        // TODO: Pin unsaved changed blocks in cache, because cache is used
+        // below to get latest actual block data.
+        this.dataLayer.writeBlock(projectId, zoom, ...blockCoord, block);
+
+        const activeWritableStackId = this.paintingTool.getActiveWritableStack();
+
+        if (!activeWritableStackId) {
+          CATMAID.warn('No active writable stack selected');
+          return;
+        }
+
+        // Second, write to back-end asynchronously. De-duplicate request to write
+        // data back and queue the write request. For this, always use latest
+        // block data available. This is done instead of regular write
+        // operations (like every minute). # TODO: Test if this is reasonable.
+        const url = `${projectId}/writable-stacks/${activeWritableStackId}/write-block`;
+        return this.paintingTool.writeDeduper.dedup(
+          `${url}-${blockCoord.join('-')}`,
+          () => {
+            const getMostRecentBlock = this.dataLayer._readBlock(this.stackViewer.s, ...blockCoord);
+
+            return getMostRecentBlock.then(mostRecentBlock => {
+              return CATMAID.fetch({
+                  url: url,
+                  method: 'POST',
+                  data: {
+                    scale_level: 0,
+                    //compression: 'raw',
+                    //data: mostRecentBlock.tolist().join(','),
+                    compression: 'msgpack',
+                    // msgpack data is sent as string for now.
+                    // TODO: Send all parameters as single JSON.
+                    data: msgpack.encode(mostRecentBlock.tolist()).join(','),
+                    data_bounds: [
+                      [
+                        blockCoord[0] * blockSize[0],
+                        blockCoord[1] * blockSize[1],
+                        blockCoord[2] * blockSize[2],
+                      ],
+                      [
+                        (blockCoord[0] + 1) * blockSize[0] - 1,
+                        (blockCoord[1] + 1) * blockSize[1] - 1,
+                        (blockCoord[2] + 1) * blockSize[2] - 1,
+                      ]
+                    ],
+                  },
+                  api: this.api,
+                })
+                .then(response => {
+                  console.log(response);
+                });
+            });
+          })
+          .catch(CATMAID.handleError);
+      });
   };
 
   // Export layer into CATMAID namespace

django/applications/catmaid/static/js/layers/pixi-image-block-layer.js

@@ -385,9 +385,12 @@
         });
     }
 
-    writeBlock(projectId, writableStackId, zoomLevel, x, y, z, block, format='n5') {
+    writeBlock(projectId, zoomLevel, x, y, z, block) {
       let blockCoord = CATMAID.tools.permute([x, y, z], this.recipDimPerm);
-      return this._blockCache.writeBlock(projectId, writableStackId, zoomLevel, ...blockCoord, block, format);
+      // First, write to cache to update UI
+      // TODO: Introduce pinning so that this block isn't removed until it is
+      // written to server?
+      this._blockCache.setBlock(zoomLevel, ...blockCoord, block);
     }
 
     _sliceBlock(block, blockZ) {

django/applications/catmaid/static/js/tools/painting-tool.js

@@ -82,6 +82,8 @@
     let isDrawing = false;
     // All currently available writable stacks for the active stack viewer.
     let writableStacks = new Map();
+    // A central deduplicator is used for writing operations
+    this.writeDeduper = new CATMAID.CoalescingPromiseDeduplicator();
 
     const actions = [];
 
@@ -338,6 +340,13 @@
       return activeStackViewer;
     };
 
+    /**
+     * Return the presently active writable stack (if any).
+     */
+    this.getActiveWritableStack = function() {
+      return activeWritableStack;
+    };
+
     /**
       * Display both project and stack space center coordinates in the status
       * bar. In case no active stack is available, only project coordinates are