volview 4.0.0

package/src/vtk/RulerWidget/behavior.ts

@@ -0,0 +1,185 @@
+import { vtkSubscription } from '@kitware/vtk.js/interfaces';
+import macro from '@kitware/vtk.js/macro';
+import { Vector3 } from '@kitware/vtk.js/types';
+import { InteractionState, RulerPointWidgetState } from './state';
+
+export function shouldIgnoreEvent(e: any) {
+  return e.altKey || e.controlKey || e.shiftKey;
+}
+
+export default function widgetBehavior(publicAPI: any, model: any) {
+  model.classHierarchy.push('vtkRulerWidgetProp');
+
+  const superClass = { ...publicAPI };
+
+  const subscriptions: vtkSubscription[] = [];
+  let dragging: RulerPointWidgetState | null = null;
+
+  // support setting per-view widget manipulators
+  macro.setGet(publicAPI, model, ['manipulator']);
+  // support forwarding events
+  macro.event(publicAPI, model, 'RightClickEvent');
+
+  publicAPI.setFirstPoint = (coord: Vector3) => {
+    const point = model.widgetState.getFirstPoint();
+    point.setOrigin(coord);
+  };
+
+  publicAPI.setSecondPoint = (coord: Vector3) => {
+    const point = model.widgetState.getSecondPoint();
+    point.setOrigin(coord);
+  };
+
+  /**
+   * Places or drags a point.
+   */
+  publicAPI.handleLeftButtonPress = (eventData: any) => {
+    if (!model.manipulator || shouldIgnoreEvent(eventData)) {
+      return macro.VOID;
+    }
+
+    const intState = model.widgetState.getInteractionState();
+
+    // in order to place points, we should be...
+    if (
+      // focused
+      model.hasFocus &&
+      // not be settled
+      intState !== InteractionState.Settled
+    ) {
+      const worldCoords = model.manipulator.handleEvent(
+        eventData,
+        model._apiSpecificRenderWindow
+      );
+      if (worldCoords.length) {
+        if (intState === InteractionState.PlacingFirst) {
+          publicAPI.setFirstPoint(worldCoords);
+          model.widgetState.setInteractionState(InteractionState.PlacingSecond);
+        } else if (intState === InteractionState.PlacingSecond) {
+          publicAPI.setSecondPoint(worldCoords);
+          model.widgetState.setInteractionState(InteractionState.Settled);
+        }
+        publicAPI.invokeInteractionEvent();
+        return macro.EVENT_ABORT;
+      }
+    }
+
+    // widget is considered settled, so see if we
+    // are trying to drag a point.
+    if (model.activeState?.getActive() && model.pickable) {
+      dragging = model.activeState;
+      model._apiSpecificRenderWindow.setCursor('grabbing');
+      model._interactor.requestAnimation(publicAPI);
+      publicAPI.invokeStartInteractionEvent();
+      return macro.EVENT_ABORT;
+    }
+
+    return macro.VOID;
+  };
+
+  /**
+   * Moves a point around.
+   */
+  publicAPI.handleMouseMove = (eventData: any) => {
+    const intState = model.widgetState.getInteractionState();
+
+    if (model.hasFocus && intState === InteractionState.Settled) {
+      publicAPI.loseFocus();
+      return macro.VOID;
+    }
+
+    if (
+      dragging || // moving an existing point
+      intState !== InteractionState.Settled // placing a point
+    ) {
+      const worldCoords = model.manipulator.handleEvent(
+        eventData,
+        model._apiSpecificRenderWindow
+      );
+
+      if (worldCoords.length) {
+        if (dragging) {
+          dragging.setOrigin(worldCoords);
+        } else if (intState === InteractionState.PlacingFirst) {
+          model.widgetState.getFirstPoint().setVisible(true);
+          publicAPI.setFirstPoint(worldCoords);
+        } else if (intState === InteractionState.PlacingSecond) {
+          model.widgetState.getSecondPoint().setVisible(true);
+          publicAPI.setSecondPoint(worldCoords);
+        }
+        publicAPI.invokeInteractionEvent();
+      }
+
+      return macro.EVENT_ABORT;
+    }
+
+    return macro.VOID;
+  };
+
+  /**
+   * Finishes dragging
+   */
+  publicAPI.handleLeftButtonRelease = (eventData: any) => {
+    if (dragging) {
+      const worldCoords = model.manipulator.handleEvent(
+        eventData,
+        model._apiSpecificRenderWindow
+      );
+      if (worldCoords.length) {
+        dragging.setOrigin(worldCoords);
+      }
+
+      dragging = null;
+      model._apiSpecificRenderWindow.setCursor('pointer');
+      model.widgetState.deactivate();
+      model._interactor.cancelAnimation(publicAPI);
+      publicAPI.invokeEndInteractionEvent();
+      // model._widgetManager.enablePicking();
+      // model._interactor.render();
+    }
+  };
+
+  publicAPI.handleRightButtonPress = (eventData: any) => {
+    if (
+      shouldIgnoreEvent(eventData) ||
+      model.widgetState.getInteractionState() !== InteractionState.Settled || // ignore when still placing
+      !model.activeState?.getActive() || // ignore when no selected state
+      model.hasFocus || // ignore when focused
+      dragging // ignore when dragging
+    ) {
+      return macro.VOID;
+    }
+    publicAPI.invokeRightClickEvent(eventData);
+    return macro.EVENT_ABORT;
+  };
+
+  publicAPI.grabFocus = () => {
+    if (
+      !model.hasFocus &&
+      // only allow focus if placing points
+      model.widgetState.getInteractionState() !== InteractionState.Settled
+    ) {
+      model.hasFocus = true;
+      // render the (invisible) point handles
+      model._interactor.requestAnimation(publicAPI);
+      publicAPI.invokeStartInteractionEvent();
+    }
+  };
+
+  publicAPI.loseFocus = () => {
+    if (model.hasFocus) {
+      model._interactor.cancelAnimation(publicAPI);
+      publicAPI.invokeEndInteractionEvent();
+    }
+    model.hasFocus = false;
+    // model._widgetManager.enablePicking();
+    // model._interactor.render();
+  };
+
+  publicAPI.delete = () => {
+    superClass.delete();
+    while (subscriptions.length) {
+      subscriptions.pop()!.unsubscribe();
+    }
+  };
+}

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

@@ -0,0 +1,25 @@
+import { vtkSubscription } from '@kitware/vtk.js/interfaces';
+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 { RulerWidgetState } from './state';
+
+export interface vtkRulerViewWidget extends vtkAbstractWidget {
+  setManipulator(manipulator: vtkPlaneManipulator): boolean;
+  getManipulator(): vtkPlaneManipulator;
+  onRightClickEvent(cb: (eventData: any) => void): vtkSubscription;
+}
+
+export interface vtkRulerWidget extends vtkAbstractWidgetFactory {
+  getLength(): number;
+  getWidgetState(): RulerWidgetState;
+}
+
+export function newInstance(): vtkRulerWidget;
+
+export function shouldIgnoreEvent(ev: any): boolean;
+
+export declare const vtkRulerWidget: {
+  newInstance: typeof newInstance;
+};
+export default vtkRulerWidget;

package/src/vtk/RulerWidget/index.js

@@ -0,0 +1,79 @@
+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 vtkSphereHandleRepresentation from '@kitware/vtk.js/Widgets/Representations/SphereHandleRepresentation';
+import { distance2BetweenPoints } from '@kitware/vtk.js/Common/Core/Math';
+
+import widgetBehavior from './behavior';
+import stateGenerator from './state';
+
+export { shouldIgnoreEvent } from './behavior';
+
+// ----------------------------------------------------------------------------
+// Factory
+// ----------------------------------------------------------------------------
+
+function vtkRulerWidget(publicAPI, model) {
+  model.classHierarchy.push('vtkRulerWidget');
+
+  // --- Widget Requirement ---------------------------------------------------
+
+  // model.methodsToLink = [
+  //   'activeScaleFactor',
+  //   'activeColor',
+  //   'useActiveColor',
+  //   'glyphResolution',
+  //   'defaultScale',
+  //   'text',
+  //   'textStateIndex',
+  // ];
+
+  publicAPI.getRepresentationsForViewType = () => [
+    {
+      builder: vtkSphereHandleRepresentation,
+      labels: ['points'],
+      initialValues: {
+        scaleInPixels: true,
+      },
+    },
+  ];
+
+  publicAPI.getLength = () => {
+    const first = model.widgetState.getFirstPoint().getOrigin();
+    const second = model.widgetState.getSecondPoint().getOrigin();
+    if (!first || !second) {
+      return 0;
+    }
+    return Math.sqrt(distance2BetweenPoints(first, second));
+  };
+
+  // Default manipulator
+  model.manipulator = vtkPlanePointManipulator.newInstance();
+}
+
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  vtkAbstractWidgetFactory.extend(publicAPI, model, {
+    ...initialValues,
+    behavior: widgetBehavior,
+    widgetState: stateGenerator(),
+  });
+  macro.get(publicAPI, model, ['manipulator']);
+
+  vtkRulerWidget(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(extend, 'vtkRulerWidget');
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };

package/src/vtk/RulerWidget/state.ts

@@ -0,0 +1,63 @@
+import { Vector3 } from '@kitware/vtk.js/types';
+import vtkStateBuilder from '@kitware/vtk.js/Widgets/Core/StateBuilder';
+import vtkWidgetState from '@kitware/vtk.js/Widgets/Core/WidgetState';
+
+export enum InteractionState {
+  Settled = 0,
+  PlacingFirst = 1,
+  PlacingSecond = 2,
+}
+
+export interface RulerPointWidgetState extends vtkWidgetState {
+  setOrigin(origin: Vector3 | null): boolean;
+  getOrigin(): Vector3 | null;
+  setScale1(scale: number): boolean;
+  getScale1(): number;
+  setVisible(visible: boolean): boolean;
+  getVisible(): boolean;
+  setColor(color: number): boolean;
+  getColor(): number;
+}
+
+export interface RulerWidgetState extends vtkWidgetState {
+  getFirstPoint(): RulerPointWidgetState;
+  getSecondPoint(): RulerPointWidgetState;
+  getInteractionState(): InteractionState;
+  setInteractionState(state: InteractionState): boolean;
+}
+
+export default function generateState() {
+  return vtkStateBuilder
+    .createBuilder()
+    .addStateFromMixin({
+      labels: ['points'],
+      name: 'firstPoint',
+      mixins: ['origin', 'scale1', 'visible', 'color'],
+      initialValues: {
+        // diameter
+        scale1: 20,
+        origin: null,
+        visible: false,
+      },
+    })
+    .addStateFromMixin({
+      labels: ['points'],
+      name: 'secondPoint',
+      mixins: ['origin', 'scale1', 'visible', 'color'],
+      initialValues: {
+        // diameter
+        scale1: 20,
+        origin: null,
+        visible: false,
+      },
+    })
+    .addField({
+      name: 'interactionState',
+      initialValue: InteractionState.PlacingFirst,
+    })
+    .addField({
+      name: 'ID',
+      initialValue: '',
+    })
+    .build() as RulerWidgetState;
+}

package/src/vtk/TreJsonConverter/index.js

@@ -0,0 +1,150 @@
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkAppendPolyData from '@kitware/vtk.js/Filters/General/AppendPolyData';
+import vtkPoints from '@kitware/vtk.js/Common/Core/Points';
+import vtkTubeFilter from '@kitware/vtk.js/Filters/General/TubeFilter';
+import { VaryRadius } from '@kitware/vtk.js/Filters/General/TubeFilter/Constants';
+import { VtkDataTypes } from '@kitware/vtk.js/Common/Core/DataArray/Constants';
+
+function concatPointData(pointDataList, arrayName) {
+  const length = pointDataList.reduce(
+    (len, pd) => len + pd[arrayName].getData().length,
+    0
+  );
+
+  // use first array to initialize our copy
+  const first = pointDataList[0][arrayName];
+
+  const outData = new (first.getData().constructor)(length);
+  const da = vtkDataArray.newInstance({
+    name: arrayName,
+    numberOfComponents: first.getNumberOfComponents(),
+    values: outData,
+  });
+
+  for (let i = 0, offset = 0; i < pointDataList.length; i += 1) {
+    const array = pointDataList[i][arrayName];
+    const data = array.getData();
+    outData.set(data, offset);
+    offset += data.length;
+  }
+
+  return da;
+}
+
+function centerlineToTube(centerline) {
+  const pd = vtkPolyData.newInstance();
+  const pts = vtkPoints.newInstance({
+    dataType: VtkDataTypes.FLOAT,
+    numberOfComponents: 3,
+  });
+  pts.setNumberOfPoints(centerline.length);
+
+  const pointData = new Float32Array(3 * centerline.length);
+  const lines = new Uint32Array(centerline.length + 1);
+
+  lines[0] = centerline.length;
+  for (let i = 0; i < centerline.length; i += 1) {
+    const [x, y, z] = centerline[i].PositionInWorldSpace;
+    pointData[3 * i + 0] = x;
+    pointData[3 * i + 1] = y;
+    pointData[3 * i + 2] = z;
+    lines[i + 1] = i;
+  }
+
+  const radii = centerline.map((pt) => pt.RadiusInWorldSpace);
+  const radiusData = new Float32Array(radii);
+  const radius = vtkDataArray.newInstance({
+    name: 'Radius',
+    values: radiusData,
+  });
+
+  pts.setData(pointData);
+  pd.setPoints(pts);
+  pd.getLines().setData(lines);
+  pd.getPointData().addArray(radius);
+
+  const filter = vtkTubeFilter.newInstance({
+    capping: true,
+    radius: 1, // scaling factor
+    varyRadius: VaryRadius.VARY_RADIUS_BY_ABSOLUTE_SCALAR,
+    numberOfSides: 5,
+  });
+
+  filter.setInputArrayToProcess(0, 'Radius', 'PointData', 'Scalars');
+  filter.setInputData(pd);
+
+  return filter.getOutputData();
+}
+
+function convertCenterlinesToTubes(centerlines) {
+  const appendPolyData = vtkAppendPolyData.newInstance();
+  appendPolyData.setInputData(vtkPolyData.newInstance());
+
+  let numberOfCells = 0;
+
+  // convert each centerline to polydata,
+  // and prepare to concatenate them
+  const cellCounts = Array(centerlines.length);
+  const pointData = [];
+  for (let i = 0; i < centerlines.length; i += 1) {
+    const cline = centerlines[i];
+    const tubePd = centerlineToTube(cline);
+    const data = tubePd.getPointData();
+    pointData.push({
+      Radius: data.getArray('Radius'),
+      TubeNormals: data.getArray('TubeNormals'),
+    });
+    appendPolyData.addInputData(tubePd);
+
+    cellCounts[i] = tubePd.getNumberOfCells();
+    numberOfCells += cellCounts[i];
+  }
+
+  const polyData = appendPolyData.getOutputData();
+
+  // copy over point data
+  polyData.getPointData().setScalars(concatPointData(pointData, 'Radius'));
+  polyData.getPointData().setNormals(concatPointData(pointData, 'TubeNormals'));
+
+  // add colors
+  const colorData = new Uint8Array(4 * numberOfCells);
+  for (let i = 0, colorIdx = 0; i < centerlines.length; i += 1, colorIdx += 4) {
+    const cline = centerlines[i];
+    const cellCount = cellCounts[i]; // # of cells for ith tube
+    for (let j = 0; j < cellCount; j += 1) {
+      colorData[colorIdx + 0] = cline.Red * 255;
+      colorData[colorIdx + 1] = cline.Green * 255;
+      colorData[colorIdx + 2] = cline.Blue * 255;
+      colorData[colorIdx + 3] = 255; // ignore specified alpha for now
+    }
+  }
+
+  const colors = vtkDataArray.newInstance({
+    name: 'Colors',
+    values: colorData,
+    numberOfComponents: 4,
+  });
+  polyData.getCellData().addArray(colors);
+
+  return polyData;
+}
+
+function flattenTreHierarchy(treJson) {
+  const list = [];
+  if (treJson.Points) {
+    list.push(treJson.Points);
+  }
+
+  const children = treJson.Children ?? [];
+  for (let i = 0; i < children.length; i += 1) {
+    list.push(...flattenTreHierarchy(children[i]));
+  }
+
+  return list;
+}
+
+export default function convertJsonToTre(treJson) {
+  const centerlines = flattenTreHierarchy(treJson);
+  return convertCenterlinesToTubes(centerlines);
+}

package/src/vtk/proxy.js

@@ -0,0 +1,66 @@
+import vtkLookupTableProxy from '@kitware/vtk.js/Proxy/Core/LookupTableProxy';
+import vtkPiecewiseFunctionProxy from '@kitware/vtk.js/Proxy/Core/PiecewiseFunctionProxy';
+
+import vtkSourceProxy from '@kitware/vtk.js/Proxy/Core/SourceProxy';
+
+import vtkVolumeRepresentationProxy from '@kitware/vtk.js/Proxy/Representations/VolumeRepresentationProxy';
+import vtkGeometryRepresentationProxy from '@kitware/vtk.js/Proxy/Representations/GeometryRepresentationProxy';
+
+import vtkLPSView3DProxy from '@/src/vtk/LPSView3DProxy';
+import vtkLPSView2DProxy from '@/src/vtk/LPSView2DProxy';
+import vtkIJKSliceRepresentationProxy from '@/src/vtk/IJKSliceRepresentationProxy';
+import vtkLabelMapSliceRepProxy from '@/src/vtk/LabelMapSliceRepProxy';
+
+function createProxyDefinition(
+  classFactory,
+  ui = [],
+  links = [],
+  definitionOptions = {},
+  props = {}
+) {
+  return {
+    class: classFactory,
+    options: { links, ui, ...definitionOptions },
+    props,
+  };
+}
+
+function createDefaultView(classFactory, options = [], props = {}) {
+  return createProxyDefinition(classFactory, [], [], options, props);
+}
+
+// ----------------------------------------------------------------------------
+
+export default {
+  definitions: {
+    Proxy: {
+      LookupTable: createProxyDefinition(vtkLookupTableProxy, [], [], {
+        presetName: 'Default (Cool to Warm)',
+      }),
+      PiecewiseFunction: createProxyDefinition(vtkPiecewiseFunctionProxy),
+    },
+    Sources: {
+      TrivialProducer: createProxyDefinition(vtkSourceProxy),
+    },
+    Representations: {
+      ImageSlice: createProxyDefinition(vtkIJKSliceRepresentationProxy),
+      LabelMapSlice: createProxyDefinition(vtkLabelMapSliceRepProxy),
+      Volume: createProxyDefinition(vtkVolumeRepresentationProxy),
+      Geometry: createProxyDefinition(vtkGeometryRepresentationProxy),
+    },
+    Views: {
+      View3D: createDefaultView(vtkLPSView3DProxy),
+      View2D: createDefaultView(vtkLPSView2DProxy),
+    },
+  },
+  representations: {
+    View3D: {
+      vtkImageData: { name: 'Volume' },
+      vtkPolyData: { name: 'Geometry' },
+    },
+    View2D: {
+      vtkImageData: { name: 'ImageSlice' },
+      vtkLabelMap: { name: 'LabelMapSlice' },
+    },
+  },
+};

package/src/vtk/proxyUtils.js

@@ -0,0 +1,16 @@
+export function createOrGetView(proxyManager, viewType, name) {
+  const views = proxyManager.getViews();
+  const view = views.find((v) => v.getName() === name);
+  if (view) {
+    return view;
+  }
+
+  return proxyManager.createProxy('Views', viewType, { name });
+}
+
+export function createFourUpViews(proxyManager) {
+  createOrGetView(proxyManager, 'ViewX', 'X:1');
+  createOrGetView(proxyManager, 'ViewY', 'Y:1');
+  createOrGetView(proxyManager, 'ViewZ', 'Z:1');
+  createOrGetView(proxyManager, 'View3D', '3D:1');
+}

package/src/vtk/webvr-empty.js

@@ -0,0 +1 @@
+export default function () {}

package/tests/testUtils.js

@@ -0,0 +1,12 @@
+export function makeEmptyFile(name) {
+  return new File([], name);
+}
+
+export function makeDicomFile(name) {
+  const buffer = new Uint8Array(132);
+  buffer[128] = 'D'.charCodeAt(0);
+  buffer[129] = 'I'.charCodeAt(0);
+  buffer[130] = 'C'.charCodeAt(0);
+  buffer[131] = 'M'.charCodeAt(0);
+  return new File([buffer.buffer], name);
+}

package/tsconfig.json

@@ -0,0 +1,46 @@
+{
+  "compilerOptions": {
+    "target": "es2019",
+    "module": "esnext",
+    "strict": true,
+    "jsx": "preserve",
+    "importHelpers": true,
+    "moduleResolution": "node",
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "resolveJsonModule": true,
+    "types": [
+      "webpack-env",
+      "mocha",
+      "chai"
+    ],
+    "paths": {
+      "@/*": [
+        "./*"
+      ],
+      "@src/*": [
+        "src/*"
+      ]
+    },
+    "lib": [
+      "esnext",
+      "dom",
+      "dom.iterable",
+      "scripthost"
+    ]
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "src/**/*.vue",
+    "tests/**/*.ts",
+    "tests/**/*.tsx"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}