volview 4.0.0 → 4.0.1

package/src/vtk/RulerWidget/behavior.ts

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

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

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

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

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

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

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

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

package/tests/testUtils.js

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

@@ -1,46 +0,0 @@
-{
-  "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"
-  ]
-}