refactor(voxel-annotations): remove obsolete color controls and limite the value to the valid range for the data type.

Author: briossant

src/layer/vox/controls.ts

@@ -17,45 +17,14 @@
 import type { UserLayerConstructor } from "#src/layer/index.js";
 import { LayerActionContext } from "#src/layer/index.js";
 import type { UserLayerWithVoxelEditing } from "#src/layer/vox/index.js";
-import type { WatchableValueInterface } from "#src/trackable_value.js";
 import { observeWatchable } from "#src/trackable_value.js";
-import { unpackRGB } from "#src/util/color.js";
-import { RefCounted } from "#src/util/disposable.js";
-import { vec3 } from "#src/util/geom.js";
-import { NullarySignal } from "#src/util/signal.js";
 import type { LayerControlDefinition } from "#src/widget/layer_control.js";
 import { registerLayerControl } from "#src/widget/layer_control.js";
 import { buttonLayerControl } from "#src/widget/layer_control_button.js";
 import { checkboxLayerControl } from "#src/widget/layer_control_checkbox.js";
-import { colorLayerControl } from "#src/widget/layer_control_color.js";
 import { enumLayerControl } from "#src/widget/layer_control_enum.js";
 import { rangeLayerControl } from "#src/widget/layer_control_range.js";
 
-class BigIntAsTrackableRGB
-  extends RefCounted
-  implements WatchableValueInterface<vec3>
-{
-  changed = new NullarySignal();
-  private tempColor = vec3.create();
-
-  constructor(public source: WatchableValueInterface<bigint>) {
-    super();
-    this.registerDisposer(source.changed.add(this.changed.dispatch));
-  }
-
-  get value(): vec3 {
-    const bigintValue = this.source.value;
-    const [r, g, b] = unpackRGB(Number(bigintValue & 0xffffffn));
-    vec3.set(this.tempColor, r, g, b);
-    return this.tempColor;
-  }
-
-  set value(newValue: vec3) {
-    const rgb = newValue.map((c: number) => Math.round(c * 255));
-    this.source.value = BigInt((rgb[0] << 16) | (rgb[1] << 8) | rgb[2]);
-  }
-}
-
 export const VOXEL_LAYER_CONTROLS: LayerControlDefinition<UserLayerWithVoxelEditing>[] =
   [
     {
@@ -104,14 +73,6 @@ export const VOXEL_LAYER_CONTROLS: LayerControlDefinition<UserLayerWithVoxelEdit
           layer.handleVoxAction("redo", new LayerActionContext()),
       }),
     },
-    {
-      label: "Paint Color",
-      toolJson: { type: "vox-paint-color" },
-      ...colorLayerControl(
-        (layer: UserLayerWithVoxelEditing) =>
-          new BigIntAsTrackableRGB(layer.paintValue),
-      ),
-    },
     {
       label: "Paint Value",
       toolJson: { type: "vox-paint-value" },
@@ -121,7 +82,7 @@ export const VOXEL_LAYER_CONTROLS: LayerControlDefinition<UserLayerWithVoxelEdit
         control.title = "Specify segment ID or intensity value to paint";
         control.addEventListener("change", () => {
           try {
-            layer.setVoxelPaintValue(BigInt(control.value));
+            layer.setVoxelPaintValue(control.value);
           } catch {
             control.value = layer.paintValue.value.toString();
           }

src/layer/vox/index.ts

@@ -30,6 +30,7 @@ import {
   getChunkTransformParameters,
 } from "#src/render_coordinate_transform.js";
 import type { SliceViewSourceOptions } from "#src/sliceview/base.js";
+import { DataType } from "#src/sliceview/base.js";
 import type { MultiscaleVolumeChunkSource } from "#src/sliceview/volume/frontend.js";
 import type { ImageRenderLayer } from "#src/sliceview/volume/image_renderlayer.js";
 import type { SegmentationRenderLayer } from "#src/sliceview/volume/segmentation_renderlayer.js";
@@ -62,6 +63,16 @@ const BRUSH_SHAPE_JSON_KEY = "brushShape";
 const FLOOD_FILL_MAX_VOXELS_JSON_KEY = "floodFillMaxVoxels";
 const PAINT_VALUE_JSON_KEY = "paintValue";
 
+const DATA_TYPE_BIT_INFO = {
+  [DataType.UINT8]: { bits: 8, signed: false },
+  [DataType.INT8]: { bits: 8, signed: true },
+  [DataType.UINT16]: { bits: 16, signed: false },
+  [DataType.INT16]: { bits: 16, signed: true },
+  [DataType.UINT32]: { bits: 32, signed: false },
+  [DataType.INT32]: { bits: 32, signed: true },
+  [DataType.UINT64]: { bits: 64, signed: false },
+};
+
 export class VoxelEditingContext
   extends RefCounted
   implements VoxelEditControllerHost
@@ -189,7 +200,7 @@ export declare abstract class UserLayerWithVoxelEditing extends UserLayer {
     transform: WatchableValueInterface<RenderLayerTransformOrError>,
   ): ImageRenderLayer | SegmentationRenderLayer;
   abstract getVoxelPaintValue(erase: boolean): bigint;
-  abstract setVoxelPaintValue(value: bigint): void;
+  abstract setVoxelPaintValue(value: any): bigint;
 
   initializeVoxelEditingForSubsource(
     loadedSubsource: LoadedDataSubsource,
@@ -276,10 +287,41 @@ export function UserLayerWithVoxelEditingMixin<
       if (erase) return 0n;
       return this.paintValue.value;
     }
-    setVoxelPaintValue(value: bigint) {
-      this.paintValue.value = value;
+
+    setVoxelPaintValue(x: any) {
+      const editContext = this.editingContexts.values().next().value;
+      const dataType = editContext.primarySource.dataType;
+      let value: bigint;
+
+      if (dataType === DataType.FLOAT32) {
+        const floatValue = parseFloat(String(x));
+        value = BigInt(Math.round(floatValue));
+      } else {
+        value = BigInt(x);
+      }
+
+      const info = DATA_TYPE_BIT_INFO[dataType as keyof typeof DATA_TYPE_BIT_INFO];
+      if (!info) {
+        this.paintValue.value = value;
+        return value;
+      }
+
+      const { bits, signed } = info;
+      const mask = (1n << BigInt(bits)) - 1n;
+      let truncated = value & mask;
+
+      if (signed) {
+        const signBit = 1n << BigInt(bits - 1);
+        if ((truncated & signBit) !== 0n) {
+          truncated -= (1n << BigInt(bits));
+        }
+      }
+
+      this.paintValue.value = truncated;
+      return truncated;
     }
 
+
     abstract _createVoxelRenderLayer(
       source: MultiscaleVolumeChunkSource,
       transform: WatchableValueInterface<RenderLayerTransformOrError>,
@@ -359,7 +401,7 @@ export function UserLayerWithVoxelEditingMixin<
           controller.redo();
           break;
         case "randomize-paint-value":
-          this.paintValue.value = randomUint64();
+          this.setVoxelPaintValue(randomUint64());
           break;
       }
     }

src/voxel_annotation/TODOs.md

@@ -17,56 +17,3 @@
 
 - design a dataset creation feature
 - adapt the brush size to the zoom level linearly
-
-## Merging vox layer into seg and img layers
-
-The proposed architecture integrates voxel editing directly into the existing Image and Segmentation layers by leveraging their inherent capabilities, rather than introducing a separate, simplified render layer. The core of the design is a new UserLayerWithVoxelEditingMixin which equips a host UserLayer with an editing controller and an associated in-memory VolumeChunkSource for optimistic previews. When a user paints, the edits are applied locally to this in-memory source. A second instance of the layer's primary, feature-rich RenderLayer class is then used to draw these edits as an overlay. This ensures the live preview is rendered with the exact same user-defined shaders and settings as the base data for perfect visual fidelity, while also elegantly handling the performance issue of editing compressed chunks by operating on an uncompressed in-memory source. This architecture reuses existing components, simplifies the overall codebase by eliminating the need for a separate VoxelAnnotationRenderLayer, and cleanly separates the concerns of displaying committed data versus previewing transient edits.
-
-```mermaid
-sequenceDiagram
-participant User
-participant Tool as VoxelBrushTool
-participant ControllerFE as VoxelEditController (FE)
-participant EditSourceFE as OverlayChunkSource (FE)
-participant BaseSourceFE as VolumeChunkSource (FE)
-participant ControllerBE as VoxelEditController (BE)
-participant BaseSourceBE as VolumeChunkSource (BE)
-
-    User->>Tool: Mouse Down/Drag
-    Tool->>ControllerFE: paintBrushWithShape(mouse, ...)
-    ControllerFE->>ControllerFE: Calculates affected voxels and chunks
-
-    ControllerFE->>EditSourceFE: applyLocalEdits(chunkKeys, ...)
-    activate EditSourceFE
-    EditSourceFE->>EditSourceFE: Modifies its own in-memory chunk data
-    note over EditSourceFE: This chunk's texture is re-uploaded to the GPU
-    deactivate EditSourceFE
-
-    ControllerFE->>ControllerBE: commitEdits(edits, ...) [RPC]
-
-    activate ControllerBE
-    ControllerBE->>ControllerBE: Debounces and batches edits
-    ControllerBE->>BaseSourceBE: applyEdits(chunkKeys, ...)
-    activate BaseSourceBE
-    BaseSourceBE-->>ControllerBE: Returns VoxelChange (for undo stack)
-    deactivate BaseSourceBE
-    ControllerBE->>ControllerFE: callChunkReload(chunkKeys) [RPC]
-    activate ControllerFE
-    ControllerFE->>BaseSourceFE: invalidateChunks(chunkKeys)
-    note over BaseSourceFE: BaseSourceFE re-fetches chunk with the now-permanent edit.
-    ControllerFE->>EditSourceFE: clearOptimisticChunk(chunkKeys)
-    deactivate ControllerFE
-
-    ControllerBE->>ControllerBE: Pushes change to Undo Stack & enqueues for downsampling
-    deactivate ControllerBE
-
-    loop Downsampling & Reload Cascade
-        ControllerBE->>ControllerBE: downsampleStep(chunkKeys)
-        ControllerBE->>ControllerFE: callChunkReload(chunkKeys) [RPC]
-        activate ControllerFE
-        ControllerFE->>BaseSourceFE: invalidateChunks(chunkKeys)
-        note over BaseSourceFE: BaseSourceFE re-fetches chunk with the now-permanent edit.
-        ControllerFE->>EditSourceFE: clearOptimisticChunk(chunkKeys)
-        deactivate ControllerFE
-    end
-```