Feature: example linear registration pipeline

python/neuroglancer/__init__.py

@@ -107,6 +107,7 @@
     LocalAnnotationLayer,  # noqa: F401
     ManagedLayer,  # noqa: F401
     Layers,  # noqa: F401
+    LinkedDisplayDimensions,  # noqa: F401
     LinkedPosition,  # noqa: F401
     LinkedZoomFactor,  # noqa: F401
     LinkedDepthRange,  # noqa: F401

python/neuroglancer/viewer_state.py

@@ -1513,6 +1513,14 @@ class Linked(LinkedType):
 
     return Linked
 
+if typing.TYPE_CHECKING or _BUILDING_DOCS:
+    _LinkedDisplayDimensionsBase = LinkedType[list[str]]
+else:
+    _LinkedDisplayDimensionsBase = make_linked_navigation_type(typed_list(str), lambda x: x)
+
+@export
+class LinkedDisplayDimensions(_LinkedDisplayDimensionsBase):
+    __slots__ = ()
 
 if typing.TYPE_CHECKING or _BUILDING_DOCS:
     _LinkedPositionBase = LinkedType[np.typing.NDArray[np.float32]]
@@ -1741,6 +1749,9 @@ class LayerGroupViewer(JsonObjectWrapper):
     layers = wrapped_property("layers", typed_list(str))
     layout = wrapped_property("layout", data_panel_layout_wrapper("xy"))
     position = wrapped_property("position", LinkedPosition)
+    display_dimensions = displayDimensions = wrapped_property(
+        "displayDimensions", LinkedDisplayDimensions
+    )
     velocity = wrapped_property(
         "velocity", typed_map(key_type=str, value_type=DimensionPlaybackVelocity)
     )
@@ -1963,6 +1974,10 @@ class ViewerState(JsonObjectWrapper):
     tool_palettes = toolPalettes = wrapped_property(
         "toolPalettes", typed_map(key_type=str, value_type=ToolPalette)
     )
+    clip_dimensions_weight = clipDimensionsWeight = wrapped_property(
+        "clipDimensionsWeight",
+        optional(typed_map(key_type=str, value_type=typed_map(key_type=str, value_type=float)))
+    )
     selection = wrapped_property("selection", DataSelectionState)
 
     @staticmethod

src/annotation/renderlayer.ts

@@ -401,6 +401,8 @@ interface AttachmentState {
   chunkTransform: ValueOrError<ChunkTransformParameters>;
   displayDimensionRenderInfo: DisplayDimensionRenderInfo;
   chunkRenderParameters: AnnotationChunkRenderParameters | undefined;
+  // Map from layer name to map of dimension name to clip weight
+  clipDimensionsWeight: Map<string, Map<string, number>>;
 }
 
 type TransformedAnnotationSource = FrontendTransformedSource<
@@ -414,27 +416,52 @@ interface SpatiallyIndexedValidAttachmentState extends AttachmentState {
 
 function getAnnotationProjectionParameters(
   chunkDisplayTransform: ChunkDisplayTransformParameters,
+  layerName: string | undefined,
+  clipDimensionsWeight: Map<string, Map<string, number>>,
 ) {
   const { chunkTransform } = chunkDisplayTransform;
-  const { unpaddedRank } = chunkTransform.modelTransform;
+  const { unpaddedRank, layerDimensionNames } = chunkTransform.modelTransform;
   const modelClipBounds = new Float32Array(unpaddedRank * 2);
   const renderSubspaceTransform = new Float32Array(unpaddedRank * 3);
   renderSubspaceTransform.fill(0);
   modelClipBounds.fill(1, unpaddedRank);
   const { numChunkDisplayDims, chunkDisplayDimensionIndices } =
     chunkDisplayTransform;
+
+  // Set display dimensions to not clip (multiplier = 0)
   for (let i = 0; i < numChunkDisplayDims; ++i) {
     const chunkDim = chunkDisplayDimensionIndices[i];
     modelClipBounds[unpaddedRank + chunkDim] = 0;
     renderSubspaceTransform[chunkDim * 3 + i] = 1;
   }
+
+  // Apply custom clip dimension weights to non display dims
+  if (layerName !== undefined) {
+    const dimWeights = clipDimensionsWeight.get(layerName);
+    if (dimWeights !== undefined && dimWeights.size > 0) {
+      for (const [dimName, weight] of dimWeights) {
+        // TODO not sure if can directly use layer names
+        // TODO ensure not in chunk display dims
+        const dimIndex = layerDimensionNames.indexOf(dimName);
+        if (dimIndex !== -1 && dimIndex < unpaddedRank) {
+          // Set the multiplier to the specified weight for this dimension
+          // Weight of 0.0 = no clipping, 1.0 = full clipping
+          const newIndex = unpaddedRank + dimIndex;
+          modelClipBounds[newIndex] = weight;
+        }
+      }
+    }
+  }
+
   return { modelClipBounds, renderSubspaceTransform };
 }
 
 function getChunkRenderParameters(
   chunkTransform: ValueOrError<ChunkTransformParameters>,
   displayDimensionRenderInfo: DisplayDimensionRenderInfo,
   messages: MessageList,
+  layerName: string | undefined,
+  clipDimensionsWeight: Map<string, Map<string, number>>,
 ): AnnotationChunkRenderParameters | undefined {
   messages.clearMessages();
   const returnError = (message: string) => {
@@ -458,7 +485,11 @@ function getChunkRenderParameters(
     return returnError((e as Error).message);
   }
   const { modelClipBounds, renderSubspaceTransform } =
-    getAnnotationProjectionParameters(chunkDisplayTransform);
+    getAnnotationProjectionParameters(
+      chunkDisplayTransform,
+      layerName,
+      clipDimensionsWeight,
+    );
   return {
     chunkTransform,
     chunkDisplayTransform,
@@ -540,13 +571,43 @@ function AnnotationRenderLayer<
       const { chunkTransform } = this;
       const displayDimensionRenderInfo =
         attachment.view.displayDimensionRenderInfo.value;
+
+      // Get clip dimensions weight from the viewer
+      const clipDimensionsWeight = new Map<string, Map<string, number>>();
+      const viewer = (attachment.view as any).viewer;
+      const trackableClipDimensionsWeight = viewer?.clipDimensionsWeight;
+      if (trackableClipDimensionsWeight?.value) {
+        for (const [
+          layerName,
+          dimWeights,
+        ] of trackableClipDimensionsWeight.value) {
+          clipDimensionsWeight.set(layerName, new Map(dimWeights));
+        }
+      }
+
+      // Listen for changes to clipDimensionsWeight
+      if (trackableClipDimensionsWeight) {
+        attachment.registerDisposer(
+          trackableClipDimensionsWeight.changed.add(() => {
+            this.updateAttachmentState(attachment);
+            this.redrawNeeded.dispatch();
+          }),
+        );
+      }
+
+      // Get the layer name
+      const layerName = this.base.state?.dataSource?.layer?.managedLayer?.name;
+
       attachment.state = {
         chunkTransform,
         displayDimensionRenderInfo,
+        clipDimensionsWeight,
         chunkRenderParameters: getChunkRenderParameters(
           chunkTransform,
           displayDimensionRenderInfo,
           attachment.messages,
+          layerName,
+          clipDimensionsWeight,
         ),
       };
     }
@@ -559,20 +620,61 @@ function AnnotationRenderLayer<
       const { chunkTransform } = this;
       const displayDimensionRenderInfo =
         attachment.view.displayDimensionRenderInfo.value;
+
+      // Get clip dimensions weight from the viewer
+      const clipDimensionsWeight = new Map<string, Map<string, number>>();
+      const viewer = (attachment.view as any).viewer;
+      const trackableClipDimensionsWeight = viewer?.clipDimensionsWeight;
+      if (trackableClipDimensionsWeight?.value) {
+        for (const [
+          layerName,
+          dimWeights,
+        ] of trackableClipDimensionsWeight.value) {
+          clipDimensionsWeight.set(layerName, new Map(dimWeights));
+        }
+      }
+
+      // Check if clipDimensionsWeight has changed
+      let clipWeightsChanged =
+        state.clipDimensionsWeight.size !== clipDimensionsWeight.size;
+      if (!clipWeightsChanged) {
+        for (const [layerName, dimWeights] of clipDimensionsWeight) {
+          const oldDimWeights = state.clipDimensionsWeight.get(layerName);
+          if (!oldDimWeights || oldDimWeights.size !== dimWeights.size) {
+            clipWeightsChanged = true;
+            break;
+          }
+          for (const [dimName, weight] of dimWeights) {
+            if (oldDimWeights.get(dimName) !== weight) {
+              clipWeightsChanged = true;
+              break;
+            }
+          }
+          if (clipWeightsChanged) break;
+        }
+      }
+
+      // Get the layer name
+      const layerName = this.base.state?.dataSource?.layer?.managedLayer?.name;
+
       if (
         state !== undefined &&
         state.chunkTransform === chunkTransform &&
-        state.displayDimensionRenderInfo === displayDimensionRenderInfo
+        state.displayDimensionRenderInfo === displayDimensionRenderInfo &&
+        !clipWeightsChanged
       ) {
         return state.chunkRenderParameters;
       }
       state.chunkTransform = chunkTransform;
       state.displayDimensionRenderInfo = displayDimensionRenderInfo;
+      state.clipDimensionsWeight = clipDimensionsWeight;
       const chunkRenderParameters = (state.chunkRenderParameters =
         getChunkRenderParameters(
           chunkTransform,
           displayDimensionRenderInfo,
           attachment.messages,
+          layerName,
+          clipDimensionsWeight,
         ));
       return chunkRenderParameters;
     }
@@ -1009,12 +1111,23 @@ const SpatiallyIndexedAnnotationLayer = <
       >,
     ) {
       super.attach(attachment);
+
+      // Get clip dimensions weight from the viewer
+      const viewer = (attachment.view as any).viewer;
+      const trackableClipDimensionsWeight = viewer?.clipDimensionsWeight || {
+        value: new Map(),
+      };
+
+      // Get the layer name
+      const layerName = this.base.state?.dataSource?.layer?.managedLayer?.name;
+
       attachment.state!.sources = attachment.registerDisposer(
         registerNested(
           (
             context: RefCounted,
             transform: RenderLayerTransformOrError,
             displayDimensionRenderInfo: DisplayDimensionRenderInfo,
+            clipDimensionsWeightValue: Map<string, Map<string, number>>,
           ) => {
             const transformedSources = getVolumetricTransformedSources(
               displayDimensionRenderInfo,
@@ -1033,6 +1146,8 @@ const SpatiallyIndexedAnnotationLayer = <
                   tsource,
                   getAnnotationProjectionParameters(
                     tsource.chunkDisplayTransform,
+                    layerName,
+                    clipDimensionsWeightValue,
                   ),
                 );
               }
@@ -1052,6 +1167,7 @@ const SpatiallyIndexedAnnotationLayer = <
           },
           this.base.state.transform,
           attachment.view.displayDimensionRenderInfo,
+          trackableClipDimensionsWeight,
         ),
       );
     }

src/data_panel_layout.ts

@@ -66,6 +66,7 @@ import { NullarySignal } from "#src/util/signal.js";
 import type { Trackable } from "#src/util/trackable.js";
 import { optionallyRestoreFromJsonMember } from "#src/util/trackable.js";
 import { WatchableMap } from "#src/util/watchable_map.js";
+import type { TrackableClipDimensionsWeight } from "#src/viewer.js";
 import type { VisibilityPrioritySpecification } from "#src/viewer_state.js";
 import { DisplayDimensionsWidget } from "#src/widget/display_dimensions_widget.js";
 import type { ScaleBarOptions } from "#src/widget/scale_bar.js";
@@ -101,6 +102,7 @@ export interface ViewerUIState
   crossSectionBackgroundColor: TrackableRGB;
   perspectiveViewBackgroundColor: TrackableRGB;
   hideCrossSectionBackground3D: TrackableBoolean;
+  clipDimensionsWeight: TrackableClipDimensionsWeight;
   pickRadius: TrackableValue<number>;
 }
 
@@ -180,6 +182,7 @@ export function getCommonViewerState(viewer: ViewerUIState) {
     wireFrame: viewer.wireFrame,
     enableAdaptiveDownsampling: viewer.enableAdaptiveDownsampling,
     visibleLayerRoles: viewer.visibleLayerRoles,
+    clipDimensionsWeight: viewer.clipDimensionsWeight,
     selectedLayer: viewer.selectedLayer,
     visibility: viewer.visibility,
     scaleBarOptions: viewer.scaleBarOptions,

src/layer_group_viewer.ts

@@ -78,6 +78,7 @@ import {
   CompoundTrackable,
   optionallyRestoreFromJsonMember,
 } from "#src/util/trackable.js";
+import type { TrackableClipDimensionsWeight } from "#src/viewer.js";
 import type { WatchableVisibilityPriority } from "#src/visibility_priority/frontend.js";
 import { EnumSelectWidget } from "#src/widget/enum_widget.js";
 import type { TrackableScaleBarOptions } from "#src/widget/scale_bar.js";
@@ -104,6 +105,7 @@ export interface LayerGroupViewerState {
   crossSectionBackgroundColor: TrackableRGB;
   perspectiveViewBackgroundColor: TrackableRGB;
   hideCrossSectionBackground3D: TrackableBoolean;
+  clipDimensionsWeight: TrackableClipDimensionsWeight;
   pickRadius: TrackableValue<number>;
 }
 
@@ -390,6 +392,9 @@ export class LayerGroupViewer extends RefCounted {
   get scaleBarOptions() {
     return this.viewerState.scaleBarOptions;
   }
+  get clipDimensionsWeight() {
+    return this.viewerState.clipDimensionsWeight;
+  }
   layerPanel: LayerBar | undefined;
   layout: DataPanelLayoutContainer;
   toolBinder: LocalToolBinder<this>;

src/layer_groups_layout.ts

@@ -421,6 +421,7 @@ function getCommonViewerState(viewer: Viewer) {
     crossSectionBackgroundColor: viewer.crossSectionBackgroundColor,
     perspectiveViewBackgroundColor: viewer.perspectiveViewBackgroundColor,
     hideCrossSectionBackground3D: viewer.hideCrossSectionBackground3D,
+    clipDimensionsWeight: viewer.clipDimensionsWeight,
     pickRadius: viewer.uiConfiguration.pickRadius,
   };
 }