volview 4.0.0

package/src/utils/vtk-helpers.ts

@@ -0,0 +1,215 @@
+import vtkPiecewiseFunctionProxy from '@kitware/vtk.js/Proxy/Core/PiecewiseFunctionProxy';
+import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
+import vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import vtkOpenGLRenderWindow from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow';
+import { Vector2, Vector3 } from '@kitware/vtk.js/types';
+import { intersectDisplayWithPlane } from '@kitware/vtk.js/Widgets/Manipulators/PlaneManipulator';
+import { OpacityFunction } from '../types/views';
+
+export function computeWorldToDisplay(
+  xyz: Vector3,
+  renderer: vtkRenderer
+): Vector2 | null {
+  const view = renderer.getRenderWindow()?.getViews()?.[0];
+  if (view) {
+    const [x, y, z] = xyz;
+    return view.worldToDisplay(x, y, z, renderer);
+  }
+  return null;
+}
+
+export function computeDisplayToWorld(
+  xy: Vector2,
+  renderer: vtkRenderer
+): Vector3 | null {
+  const view = renderer.getRenderWindow()?.getViews()?.[0];
+  if (view) {
+    const [x, y] = xy;
+    return view.displayToWorld(x, y, 0, renderer);
+  }
+  return null;
+}
+
+export function normalizeMouseEventPosition(
+  ev: MouseEvent,
+  view: vtkOpenGLRenderWindow
+) {
+  // TODO fix typing in vtk.js
+  const canvas = (view as any).getCanvas() as HTMLCanvasElement | null;
+  if (!canvas) return null;
+
+  const bounds = canvas.getBoundingClientRect();
+  const scaleX = canvas.width / bounds.width;
+  const scaleY = canvas.height / bounds.height;
+  return [
+    scaleX * (ev.clientX - bounds.left),
+    scaleY * (bounds.height - ev.clientY + bounds.top),
+  ] as Vector2;
+}
+
+export function intersectMouseEventWithPlane(
+  ev: MouseEvent,
+  renderer: vtkRenderer,
+  origin: Vector3,
+  normal: Vector3
+) {
+  const view = renderer
+    .getRenderWindow()
+    ?.getViews()[0] as vtkOpenGLRenderWindow;
+  if (!view) return null;
+
+  const position = normalizeMouseEventPosition(ev, view);
+  if (!position) return null;
+
+  return intersectDisplayWithPlane(
+    position[0],
+    position[1],
+    origin,
+    normal,
+    renderer,
+    view
+  );
+}
+
+/**
+ * Converts world coordinates to SVG-friendly coordinates.
+ *
+ * Assumes that the SVG layer is the same size as the renderer.
+ * TODO verify this is the case.
+ */
+export function worldToSVG(xyz: Vector3, renderer: vtkRenderer) {
+  const coords = computeWorldToDisplay(xyz, renderer);
+  const view = renderer.getRenderWindow()?.getViews()?.[0];
+  if (coords && view) {
+    const [, height] = view.getViewportSize(renderer);
+    // convert from canvas space to svg space
+    return [
+      coords[0] / devicePixelRatio,
+      (height - coords[1]) / devicePixelRatio,
+    ] as Vector2;
+  }
+  return null;
+}
+
+/**
+ * Gets the CSS coordinates for a vtk.js mouse event.
+ */
+export function getCSSCoordinatesFromEvent(eventData: any) {
+  const { pokedRenderer }: { pokedRenderer: vtkRenderer } = eventData;
+  const view = pokedRenderer?.getRenderWindow()?.getViews()?.[0] as
+    | vtkOpenGLRenderWindow
+    | undefined;
+  const bbox = view?.getContainer()?.getBoundingClientRect();
+
+  if (!('position' in eventData) || !bbox) {
+    return null;
+  }
+
+  return [
+    bbox.left + eventData.position.x / devicePixelRatio,
+    bbox.top + bbox.height - eventData.position.y / devicePixelRatio,
+  ] as Vector2;
+}
+
+/**
+ * Shifts the opacity points from a preset.
+ */
+export function getShiftedOpacityFromPreset(
+  presetName: string,
+  effectiveRange: [number, number],
+  shift: number
+) {
+  const preset = vtkColorMaps.getPresetByName(presetName);
+  if (preset.OpacityPoints) {
+    const OpacityPoints = preset.OpacityPoints as number[];
+    const points = [];
+    for (let i = 0; i < OpacityPoints.length; i += 2) {
+      points.push([OpacityPoints[i], OpacityPoints[i + 1]]);
+    }
+
+    const [xmin, xmax] = effectiveRange;
+    const width = xmax - xmin;
+    return points.map(([x, y]) => [(x - xmin) / width + shift, y]);
+  }
+  return null;
+}
+
+/**
+ * Retrieves an OpacityFunction from a preset.
+ */
+export function getOpacityFunctionFromPreset(
+  presetName: string
+): Partial<OpacityFunction> {
+  const preset = vtkColorMaps.getPresetByName(presetName);
+
+  if (preset.OpacityPoints) {
+    return {
+      mode: vtkPiecewiseFunctionProxy.Mode.Points,
+      preset: presetName,
+      shift: 0,
+    };
+  }
+  return {
+    mode: vtkPiecewiseFunctionProxy.Mode.Gaussians,
+    // deep-copy necessary
+    gaussians: JSON.parse(
+      JSON.stringify(vtkPiecewiseFunctionProxy.Defaults.Gaussians)
+    ),
+  };
+}
+
+/**
+ * Inflate an axis bounds defined as [min, max] by some delta.
+ *
+ * @param bounds Must be [number, number]. (Typed number[] for convenience.)
+ * @param delta
+ * @returns
+ */
+export function inflateAxisBounds(bounds: number[], delta: number) {
+  return [bounds[0] + delta, bounds[1] + delta];
+}
+
+/**
+ * Retrieves the color function range, if any.
+ *
+ * Will only return the color function range if the preset
+ * has AbsoluteRange specified as true. For medical presets,
+ * the range is defined by the transfer function point range,
+ * rather than the dataset data range.
+ * @param presetName
+ * @returns
+ */
+export function getColorFunctionRangeFromPreset(
+  presetName: string
+): [number, number] | null {
+  const preset = vtkColorMaps.getPresetByName(presetName);
+  if (!preset) return null;
+
+  const { AbsoluteRange, RGBPoints } = preset;
+  if (AbsoluteRange && RGBPoints) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (let i = 0; i < RGBPoints.length; i += 4) {
+      min = Math.min(min, RGBPoints[i]);
+      max = Math.max(max, RGBPoints[i]);
+    }
+    return [min, max];
+  }
+  return null;
+}
+
+/**
+ * Retrieves the effective opacity mapping range, if any.
+ *
+ * Presets may specify an effective range for the scalar opacity
+ * mapping range.
+ * @param presetName
+ * @returns
+ */
+export function getOpacityRangeFromPreset(presetName: string) {
+  const preset = vtkColorMaps.getPresetByName(presetName);
+  if (preset.EffectiveRange) {
+    return [...preset.EffectiveRange] as [number, number];
+  }
+  return null;
+}

package/src/utils/workerHandler.js

@@ -0,0 +1,42 @@
+class WorkerHandler {
+  constructor() {
+    this.handler = null;
+    onmessage = this.preHandler.bind(this);
+  }
+
+  registerHandler(func) {
+    this.handler = func;
+  }
+
+  preHandler(ev) {
+    if (this.handler) {
+      const { id, message } = ev.data;
+
+      let transferables = [];
+      const setTransferables = (iter) => {
+        transferables = Array.from(iter);
+      };
+
+      try {
+        Promise.resolve(this.handler(message, setTransferables)).then(
+          (result) => {
+            const msg = {
+              id,
+              message: result,
+            };
+            postMessage(msg, transferables);
+          }
+        );
+      } catch (error) {
+        const msg = {
+          id,
+          error: error.message,
+        };
+        postMessage(msg);
+      }
+    }
+  }
+}
+
+// To be used inside the worker
+export default new WorkerHandler();

package/src/vtk/ColorMaps.ts

@@ -0,0 +1,72 @@
+import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
+import MedicalPresets from '@/src/vtk/MedicalColorPresets.json';
+
+function registerPresets(presets: typeof MedicalPresets) {
+  for (let i = 0; i < presets.length; i += 1) {
+    vtkColorMaps.addPreset(presets[i]);
+  }
+}
+
+registerPresets(MedicalPresets);
+
+/* prettier-ignore */
+const GroupedPresets = [
+  {
+    group: 'Other',
+    presets: [
+      'Cool to Warm',
+    ],
+  },
+  {
+    group: 'CT',
+    presets: [
+      'CT-AAA',
+      'CT-AAA2',
+      'CT-Bone',
+      'CT-Bones',
+      'CT-Cardiac',
+      'CT-Cardiac2',
+      'CT-Cardiac3',
+      'CT-Chest-Contrast-Enhanced',
+      'CT-Chest-Vessels',
+      'CT-Coronary-Arteries',
+      'CT-Coronary-Arteries-2',
+      'CT-Coronary-Arteries-3',
+      'CT-Cropped-Volume-Bone',
+      'CT-Fat',
+      'CT-Liver-Vasculature',
+      'CT-Lung',
+      'CT-MIP',
+      'CT-Muscle',
+      'CT-Pulmonary-Arteries',
+      'CT-Soft-Tissue',
+      'CT-Air',
+      'CT-X-ray',
+    ],
+  },
+  {
+    group: 'MR',
+    presets: [
+      'MR-Default',
+      'MR-Angio',
+      'MR-MIP',
+      'MR-T2-Brain',
+    ],
+  },
+  {
+    group: 'DTI',
+    presets: [
+      'DTI-FA-Brain',
+    ],
+  },
+  {
+    group: 'US',
+    presets: [
+      'US-Fetal',
+    ],
+  },
+];
+
+export const DEFAULT_PRESET = 'Cool to Warm';
+export const PresetNameList = GroupedPresets.flatMap((group) => group.presets);
+export default GroupedPresets;

package/src/vtk/CrosshairsWidget/behavior.ts

@@ -0,0 +1,112 @@
+import macro from '@kitware/vtk.js/macro';
+import { Bounds } from '@kitware/vtk.js/types';
+import { vec3 } from 'gl-matrix';
+
+function clampPointToBounds(bounds: Bounds, point: vec3) {
+  return point.map((p, i) =>
+    Math.max(bounds[i * 2], Math.min(bounds[i * 2 + 1], p))
+  ) as vec3;
+}
+
+export default function widgetBehavior(publicAPI: any, model: any) {
+  model.classHierarchy.push('vtkCrosshairsWidgetProp');
+  let isDragging = false;
+
+  // support setting per-view widget manipulators
+  macro.setGet(publicAPI, model, ['manipulator']);
+
+  // --------------------------------------------------------------------------
+  // Interactor events
+  // --------------------------------------------------------------------------
+
+  function ignoreKey(e: any) {
+    return e.altKey || e.controlKey || e.shiftKey;
+  }
+
+  // --------------------------------------------------------------------------
+  // Left press: Select handle to drag
+  // --------------------------------------------------------------------------
+
+  publicAPI.handleLeftButtonPress = (e: any) => {
+    if (!model.pickable || ignoreKey(e)) {
+      return macro.VOID;
+    }
+
+    model.widgetState.setPlaced(true);
+    isDragging = true;
+    model._interactor.requestAnimation(publicAPI);
+    model._apiSpecificRenderWindow.setCursor('crosshairs');
+    publicAPI.invokeStartInteractionEvent();
+    publicAPI.handleMouseMove(e);
+    return macro.EVENT_ABORT;
+  };
+
+  // --------------------------------------------------------------------------
+  // Mouse move: Drag selected handle / Handle follow the mouse
+  // --------------------------------------------------------------------------
+
+  publicAPI.handleMouseMove = (callData: any) => {
+    // technically need to call requestAnimation during
+    // the initial phase of placing the crosshairs,
+    // but that's not needed since no VTK object
+    // is actually being rendered.
+
+    if (
+      (!model.widgetState.getPlaced() || isDragging) &&
+      model.pickable &&
+      model.manipulator &&
+      !ignoreKey(callData)
+    ) {
+      const worldCoordsOfPointer = model.manipulator.handleEvent(
+        callData,
+        model._apiSpecificRenderWindow
+      );
+
+      const handle = model.widgetState.getHandle();
+      const worldToIndex = model.widgetState.getWorldToIndex();
+      const indexToWorld = model.widgetState.getIndexToWorld();
+      if (worldToIndex.length && indexToWorld.length) {
+        const indexCoordsOfPointer = vec3.create();
+        const worldOrigin = vec3.create();
+        const bounds = handle.getBounds();
+
+        vec3.transformMat4(
+          indexCoordsOfPointer,
+          worldCoordsOfPointer,
+          worldToIndex
+        );
+        const indexOrigin = clampPointToBounds(bounds, indexCoordsOfPointer);
+        vec3.transformMat4(worldOrigin, indexOrigin, indexToWorld);
+
+        handle.setOrigin(worldOrigin);
+        publicAPI.invokeInteractionEvent();
+        return macro.EVENT_ABORT;
+      }
+    }
+
+    return macro.VOID;
+  };
+
+  // --------------------------------------------------------------------------
+  // Left release: Finish drag / Create new handle
+  // --------------------------------------------------------------------------
+
+  publicAPI.handleLeftButtonRelease = () => {
+    if (isDragging && model.pickable) {
+      model._interactor.cancelAnimation(publicAPI);
+      model._apiSpecificRenderWindow.setCursor('default');
+      publicAPI.invokeEndInteractionEvent();
+    }
+    isDragging = false;
+  };
+
+  // --------------------------------------------------------------------------
+  // Focus API - modeHandle follow mouse when widget has focus
+  // --------------------------------------------------------------------------
+
+  publicAPI.grabFocus = () => {};
+
+  // --------------------------------------------------------------------------
+
+  publicAPI.loseFocus = () => {};
+}

package/src/vtk/CrosshairsWidget/index.d.ts

@@ -0,0 +1,22 @@
+import vtkAbstractWidget from '@kitware/vtk.js/Widgets/Core/AbstractWidget';
+import vtkAbstractWidgetFactory from '@kitware/vtk.js/Widgets/Core/AbstractWidgetFactory';
+import vtkPlaneManipulator from '@kitware/vtk.js/Widgets/Manipulators/PlaneManipulator';
+import { mat4, vec3 } from 'gl-matrix';
+import { CrosshairsWidgetState } from './state';
+
+export interface vtkCrosshairsViewWidget extends vtkAbstractWidget {
+  setManipulator(manipulator: vtkPlaneManipulator): boolean;
+  getManipulator(): vtkPlaneManipulator;
+}
+
+export interface vtkCrosshairsWidget extends vtkAbstractWidgetFactory {
+  getWidgetState(): CrosshairsWidgetState;
+  getManipulator(): vtkPlaneManipulator;
+}
+
+export function newInstance(): vtkCrosshairsWidget;
+
+export declare const vtkCrosshairsWidget: {
+  newInstance: typeof newInstance;
+};
+export default vtkCrosshairsWidget;

package/src/vtk/CrosshairsWidget/index.js

@@ -0,0 +1,73 @@
+import macro from '@kitware/vtk.js/macro';
+import vtkAbstractWidgetFactory from '@kitware/vtk.js/Widgets/Core/AbstractWidgetFactory';
+import vtkPlanePointManipulator from '@kitware/vtk.js/Widgets/Manipulators/PlaneManipulator';
+
+import { ViewTypes } from '@kitware/vtk.js/Widgets/Core/WidgetManager/Constants';
+
+import stateGenerator from './state';
+import widgetBehavior from './behavior';
+
+// ----------------------------------------------------------------------------
+// Factory
+// ----------------------------------------------------------------------------
+
+function vtkCrosshairsWidget(publicAPI, model) {
+  model.classHierarchy.push('vtkCrosshairsWidget');
+
+  // --- Widget Requirement ---------------------------------------------------
+
+  model.behavior = widgetBehavior;
+  model.widgetState = stateGenerator();
+
+  publicAPI.getRepresentationsForViewType = (viewType) => {
+    switch (viewType) {
+      case ViewTypes.DEFAULT:
+      case ViewTypes.GEOMETRY:
+      case ViewTypes.SLICE:
+      case ViewTypes.VOLUME:
+      default:
+        return [];
+    }
+  };
+
+  // --------------------------------------------------------------------------
+  // initialization
+  // --------------------------------------------------------------------------
+
+  model.widgetState.onBoundsChange((bounds) => {
+    const center = [
+      (bounds[0] + bounds[1]) * 0.5,
+      (bounds[2] + bounds[3]) * 0.5,
+      (bounds[4] + bounds[5]) * 0.5,
+    ];
+    model.widgetState.getHandle().setOrigin(center);
+  });
+
+  // Default manipulator
+  model.manipulator = vtkPlanePointManipulator.newInstance();
+}
+
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  // manipulator: null,
+};
+
+// ----------------------------------------------------------------------------
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['manipulator']);
+
+  vtkCrosshairsWidget(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(extend, 'vtkCrosshairsWidget');
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };

package/src/vtk/CrosshairsWidget/state.ts

@@ -0,0 +1,51 @@
+import { Bounds, Vector3 } from '@kitware/vtk.js/types';
+import vtkStateBuilder from '@kitware/vtk.js/Widgets/Core/StateBuilder';
+import vtkWidgetState from '@kitware/vtk.js/Widgets/Core/WidgetState';
+import { mat4 } from 'gl-matrix';
+
+export interface CrosshairsHandleWidgetState extends vtkWidgetState {
+  setOrigin(origin: Vector3 | null): boolean;
+  getOrigin(): Vector3 | null;
+  setScale1(scale: number): boolean;
+  getScale1(): number;
+  setVisible(visible: boolean): boolean;
+  getVisible(): boolean;
+  setBounds(bounds: Bounds): boolean;
+  getBounds(): Bounds;
+}
+
+export interface CrosshairsWidgetState extends vtkWidgetState {
+  setPlaced(placed: boolean): boolean;
+  getPlaced(): boolean;
+  setIndexToWorld(indexToWorld: mat4): boolean;
+  getIndexToWorld(): mat4;
+  setWorldToIndex(worldToIndex: mat4): boolean;
+  getWorldToIndex(): mat4;
+  getHandle(): CrosshairsHandleWidgetState;
+}
+
+export default function generateState() {
+  return vtkStateBuilder
+    .createBuilder()
+    .addField({
+      name: 'placed',
+      initialValue: false,
+    })
+    .addField({
+      name: 'indexToWorld',
+      initialValue: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    })
+    .addField({
+      name: 'worldToIndex',
+      initialValue: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    })
+    .addStateFromMixin({
+      labels: ['handle'],
+      mixins: ['origin', 'bounds'],
+      name: 'handle',
+      initialValues: {
+        origin: null,
+      },
+    })
+    .build();
+}

package/src/vtk/IJKSliceRepresentationProxy/index.d.ts

@@ -0,0 +1,9 @@
+import vtkSliceRepresentationProxy from '@kitware/vtk.js/Proxy/Core/SliceRepresentationProxy';
+
+export interface vtkIJKSliceRepresentationProxy
+  extends vtkSliceRepresentationProxy {
+  setOpacity(opacity: number): boolean;
+  getOpacity(): number;
+}
+
+export default vtkIJKSliceRepresentationProxy;

package/src/vtk/IJKSliceRepresentationProxy/index.js

@@ -0,0 +1,59 @@
+import macro from '@kitware/vtk.js/macro';
+
+import vtkSliceRepresentationProxy from '@kitware/vtk.js/Proxy/Representations/SliceRepresentationProxy';
+
+const SLICE_MODE_MAP = {
+  X: 'I',
+  Y: 'J',
+  Z: 'K',
+  I: 'I',
+  J: 'J',
+  K: 'K',
+};
+
+function vtkIJKSliceRepresentationProxy(publicAPI, model) {
+  model.classHierarchy.push('vtkIJKSliceRepresentationProxy');
+
+  const superClass = { ...publicAPI };
+
+  // don't set colors on slices
+  publicAPI.setColorBy = () => {};
+
+  // pretend XYZ slicing is actually just IJK.
+  publicAPI.setSlicingMode = (modeString) => {
+    return superClass.setSlicingMode(SLICE_MODE_MAP[modeString]);
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Object methods
+  vtkSliceRepresentationProxy.extend(publicAPI, model);
+
+  macro.proxyPropertyMapping(publicAPI, model, {
+    opacity: { modelKey: 'property', property: 'opacity' },
+  });
+
+  // Object specific methods
+  vtkIJKSliceRepresentationProxy(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(
+  extend,
+  'vtkIJKSliceRepresentationProxy'
+);
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };

package/src/vtk/LPSView2DProxy/index.d.ts

@@ -0,0 +1,18 @@
+import { vec3 } from 'gl-matrix';
+import { vtkView2DProxy } from '@kitware/vtk.js/Proxy/Core/View2DProxy';
+import { ViewProxyCustomizations } from '@src/vtk/LPSView3DProxy';
+
+export interface vtkLPSView2DProxy
+  extends vtkView2DProxy,
+    ViewProxyCustomizations {
+  resizeToFit(lookAxis: Vector3, viewUpAxis: Vector3, worldDims: Vector3);
+  resetCamera(boundsToUse?: number[]);
+  /**
+   * @param mode One of IJKXYZ
+   */
+  setSlicingMode(mode: string);
+}
+
+// TODO extend, newInstance...
+export declare const vtkLPSView2DProxy: {};
+export default vtkLPSView2DProxy;