volview 4.0.0 → 4.0.1

package/src/utils/vtk-helpers.ts

@@ -1,215 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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;