fix: handle images with 0 range or multiple components

Author: PaulHax

src/components/vtk/VtkSliceViewWindowManipulator.vue

@@ -50,7 +50,8 @@ const wlConfig = useWindowingConfig(viewId, imageId);
 useWindowingConfigInitializer(viewId, imageId);
 
 const computeStep = (range: Vector2) => {
-  return Math.min(range[1] - range[0], 1) / 256;
+  const diff = range[1] - range[0] || 1;
+  return Math.min(diff, 1) / 256;
 };
 const wlStep = computed(() => computeStep(wlConfig.range.value));
 

src/core/streaming/dicomChunkImage.ts

@@ -276,6 +276,7 @@ export default class DicomChunkImage
     this.dataRangeFromChunks().forEach(([min, max], compIdx) => {
       scalars.setRange({ min, max }, compIdx);
     });
+    scalars.modified(); // so image-stats will trigger update of range
   }
 
   private dataRangeFromChunks() {
@@ -363,8 +364,8 @@ export default class DicomChunkImage
       const newMin = rangeAlreadyInitialized ? Math.min(min, curRange[0]) : min;
       const newMax = rangeAlreadyInitialized ? Math.max(max, curRange[1]) : max;
       scalars.setRange({ min: newMin, max: newMax }, comp);
-      scalars.modified(); // so image-stats will trigger update of range
     }
+    scalars.modified(); // so image-stats will trigger update of range
 
     chunk.setUserData(DATA_RANGE_KEY, chunkDataRange);
 

src/core/vtk/vtkFieldRef.ts

@@ -1,4 +1,13 @@
-import { MaybeRef, Ref, computed, customRef, triggerRef, unref } from 'vue';
+import {
+  MaybeRef,
+  Ref,
+  computed,
+  customRef,
+  triggerRef,
+  unref,
+  watch,
+  isRef,
+} from 'vue';
 import { vtkObject } from '@kitware/vtk.js/interfaces';
 import { capitalize } from '@kitware/vtk.js/macros';
 import { onPausableVTKEvent } from '@/src/composables/onPausableVTKEvent';
@@ -52,23 +61,48 @@ export function vtkFieldRef<T extends Maybe<vtkObject>, R>(
   factory: GetterSetterFactory<R>
 ): Ref<R>;
 
-export function vtkFieldRef<T extends Maybe<vtkObject>>(
-  obj: MaybeRef<T>,
-  fieldNameOrFactory: string | GetterSetterFactory<any>
-): any {
-  let getter: () => any;
-  let setter: (v: any) => boolean | undefined;
+/**
+ * A customRef wrapper that triggers the ref based on a vtk object modification event,
+ * using the provided function as a getter. The ref will be read-only.
+ * @param obj The vtkObject or a Ref to it.
+ * @param getterFunc A function that retrieves the value from the vtkObject.
+ */
+export function vtkFieldRef<TValue extends Maybe<vtkObject>, R>(
+  obj: MaybeRef<TValue>,
+  getterFunc: () => R
+): Ref<R>;
+
+export function vtkFieldRef<TValue extends Maybe<vtkObject>>(
+  obj: MaybeRef<TValue>,
+  config: string | GetterSetterFactory<any> | (() => any)
+): Ref<any> {
+  let _sourceGet: () => any;
+  let _finalSetter: (v: any) => boolean | undefined;
   let lastValue: any;
   let lastValueIsArray = false;
 
-  if (typeof fieldNameOrFactory === 'string') {
-    const getterName = `get${capitalize(fieldNameOrFactory)}` as keyof T;
-    const setterName = `set${capitalize(fieldNameOrFactory)}` as keyof T;
+  const updateLastValueAndReturnClonedIfArray = (rawValue: any) => {
+    if (Array.isArray(rawValue)) {
+      lastValue = [...rawValue];
+      lastValueIsArray = true;
+    } else {
+      lastValue = rawValue;
+      lastValueIsArray = false;
+    }
+    return lastValue;
+  };
+
+  if (typeof config === 'string') {
+    const fieldName = config;
+    const getterName = `get${capitalize(fieldName)}` as keyof TValue;
+    const setterName = `set${capitalize(fieldName)}` as keyof TValue;
 
-    const _getter = computed(
+    const _objGetter = computed(
       () => unref(obj)?.[getterName] as (() => any) | undefined
     );
-    const _setter = computed(
+    _sourceGet = () => _objGetter.value?.();
+
+    const _objSetter = computed(
       () =>
         unref(obj)?.[setterName] as ((...args: any[]) => boolean) | undefined
     );
@@ -79,67 +113,54 @@ export function vtkFieldRef<T extends Maybe<vtkObject>>(
       return val ? setterName in val : false;
     });
 
-    getter = () => {
-      const value = _getter.value?.();
-      // create a new reference to trigger update
-      if (Array.isArray(value)) {
-        lastValue = [...value];
-        lastValueIsArray = true;
-        return lastValue;
-      }
-      lastValue = value;
-      lastValueIsArray = false;
-      return value;
-    };
-
-    setter = (v: any) => {
-      const set = _setter.value;
+    _finalSetter = (v: any) => {
+      const set = _objSetter.value;
       if (!notNull.value) return false;
       if (!hasSetter.value || !set)
-        throw new Error(`No setter for field '${fieldNameOrFactory}'`);
+        throw new Error(`No setter for field '${fieldName}'`);
 
-      // handle certain array setters not accepting an array as input
       if (Array.isArray(v) && set.length === v.length) {
         return (set as ArraySetter)(...v);
       }
       return set(v);
     };
-  } else {
-    const originalGetter = fieldNameOrFactory.get;
-    getter = () => {
-      const value = originalGetter();
-      // create a new reference to trigger update
-      if (Array.isArray(value)) {
-        lastValue = [...value];
-        lastValueIsArray = true;
-        return lastValue;
-      }
-      lastValue = value;
-      lastValueIsArray = false;
-      return value;
+  } else if (typeof config === 'function') {
+    _sourceGet = config;
+    _finalSetter = () => {
+      console.warn(
+        '[vtkFieldRef] Attempted to set a ref that was defined with a getter function only. This ref is read-only.'
+      );
+      return false;
     };
-    setter = fieldNameOrFactory.set;
+  } else {
+    _sourceGet = config.get;
+    _finalSetter = config.set;
   }
 
-  let pause: () => void;
-  let resume: () => void;
+  const refGetter = () => {
+    const rawValue = _sourceGet();
+    return updateLastValueAndReturnClonedIfArray(rawValue);
+  };
+
+  refGetter(); // Initialize lastValue
+
+  let currentPauseListener: () => void = () => {};
+  let currentResumeListener: () => void = () => {};
 
   const ref = customRef<any>((track, trigger) => {
     return {
       get: () => {
         track();
-        return getter();
+        return refGetter();
       },
       set: (v) => {
+        currentPauseListener();
         let changed = false;
-        pause();
-
         try {
-          const ret = setter(v);
-          // in the event a setter returns undefined, assume something changed.
+          const ret = _finalSetter(v);
           changed = ret === undefined ? true : ret;
         } finally {
-          resume();
+          currentResumeListener();
         }
 
         if (changed) {
@@ -150,36 +171,59 @@ export function vtkFieldRef<T extends Maybe<vtkObject>>(
   });
 
   const onModified = batchForNextTask(() => {
-    if (unref(obj)?.isDeleted()) return;
-
-    // Special handling for array values that might have been mutated
-    if (lastValueIsArray) {
-      const currentValue = getter();
-      if (Array.isArray(currentValue)) {
-        const previousValue = lastValue;
-        // Check if array contents changed
-        if (
-          previousValue.length !== currentValue.length ||
-          previousValue.some(
-            (val: any, idx: number) => val !== currentValue[idx]
-          )
-        ) {
-          // Values changed, trigger the ref
-          triggerRef(ref);
-          return;
-        }
+    const currentVtkObj = unref(obj);
+    if (currentVtkObj?.isDeleted()) return;
+
+    const currentSourceValue = _sourceGet();
+    let valueChanged = false;
+
+    if (lastValueIsArray && Array.isArray(currentSourceValue)) {
+      if (
+        lastValue.length !== currentSourceValue.length ||
+        lastValue.some(
+          (val: any, idx: number) => val !== currentSourceValue[idx]
+        )
+      ) {
+        valueChanged = true;
       }
+    } else if (lastValue !== currentSourceValue) {
+      valueChanged = true;
     }
 
-    // Always trigger for non-array values
-    triggerRef(ref);
+    if (valueChanged) {
+      triggerRef(ref);
+    }
   });
 
-  ({ pause, resume } = onPausableVTKEvent(
-    obj as vtkObject,
-    'onModified',
-    onModified
-  ));
+  const setupVtkListener = (targetVtkObject: Maybe<vtkObject>) => {
+    currentPauseListener(); // Clean up previous listener's effect
+
+    if (targetVtkObject && !targetVtkObject.isDeleted()) {
+      const { pause: newPause, resume: newResume } = onPausableVTKEvent(
+        targetVtkObject,
+        'onModified',
+        onModified
+      );
+      currentPauseListener = newPause;
+      currentResumeListener = newResume;
+    } else {
+      currentPauseListener = () => {};
+      currentResumeListener = () => {};
+    }
+  };
+
+  if (isRef(obj)) {
+    watch(
+      obj,
+      (newVtkObj) => {
+        setupVtkListener(newVtkObj);
+        triggerRef(ref); // Trigger dependents as the source object has changed
+      },
+      { immediate: true }
+    );
+  } else {
+    setupVtkListener(unref(obj));
+  }
 
   return ref;
 }

src/store/image-stats.ts

@@ -26,9 +26,7 @@ export type ImageStats = {
   autoRangeValues?: Record<string, [number, number]>;
 };
 
-async function computeAutoRangeValues(
-  imageData: vtkImageData
-): Promise<Record<string, [number, number]>> {
+async function computeAutoRangeValues(imageData: vtkImageData) {
   const scalars = imageData.getPointData()?.getScalars();
   if (!scalars) {
     return {};
@@ -115,7 +113,9 @@ export const useImageStatsStore = defineStore('image-stats', () => {
     const activeScalars = computed(() =>
       imageData.value?.getPointData()?.getScalars()
     );
-    const scalarRange = vtkFieldRef(activeScalars, 'range');
+    const scalarRange = vtkFieldRef(activeScalars, () =>
+      activeScalars.value?.getRange(0)
+    );
 
     watch(
       scalarRange,