volview 4.0.0

package/src/vtk/PaintBrushContextRepresentation/index.js

@@ -0,0 +1,191 @@
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkActor2D from '@kitware/vtk.js/Rendering/Core/Actor2D';
+import vtkContextRepresentation from '@kitware/vtk.js/Widgets/Representations/ContextRepresentation';
+import vtkWidgetRepresentation from '@kitware/vtk.js/Widgets/Representations/WidgetRepresentation';
+import macro from '@kitware/vtk.js/macros';
+import vtkMapper2D from '@kitware/vtk.js/Rendering/Core/Mapper2D';
+import vtkCoordinate from '@kitware/vtk.js/Rendering/Core/Coordinate';
+import { Coordinate } from '@kitware/vtk.js/Rendering/Core/Coordinate/Constants';
+import { Representation } from '@kitware/vtk.js/Rendering/Core/Property/Constants';
+import { DisplayLocation } from '@kitware/vtk.js/Rendering/Core/Property2D/Constants';
+import { vec3 } from 'gl-matrix';
+
+function generateContour({ stencil, location, slicingIndex, indexToWorld }) {
+  const [xdim, ydim] = stencil.size;
+  const xoffset = Math.floor((xdim - 1) / 2);
+  const yoffset = Math.floor((ydim - 1) / 2);
+
+  // grid of corner points (top-left to bottom-right)
+  const gridxdim = xdim + 1;
+  const gridydim = ydim + 1;
+
+  const vertices = []; // arr of 3-tuples
+  const lines = []; // arr of 2-tuples of vertex indices
+
+  // maps grid x/y to vertex index
+  const vertexMap = {};
+  const getOrCreateVertexIndex = (x, y) => {
+    const key = `${x},${y}`;
+    if (key in vertexMap) {
+      return vertexMap[key];
+    }
+
+    const indexCoords = [...location].map((val) => Math.round(val));
+    if (slicingIndex === 0) {
+      indexCoords[1] += x - xoffset - 0.5;
+      indexCoords[2] += y - yoffset - 0.5;
+    } else if (slicingIndex === 1) {
+      indexCoords[0] += x - xoffset - 0.5;
+      indexCoords[2] += y - yoffset - 0.5;
+    } else if (slicingIndex === 2) {
+      indexCoords[0] += x - xoffset - 0.5;
+      indexCoords[1] += y - yoffset - 0.5;
+    }
+
+    // get the grid point x/y's actual vertex in world space
+    // since grid x/y represents the top-left of the actual pixel
+    // at x/y, the true continuous index value of the vertex
+    // is x-0.5/y-0.5.
+
+    const worldCoords = [];
+    vec3.transformMat4(worldCoords, indexCoords, indexToWorld);
+    vertices.push(worldCoords);
+
+    const index = vertices.length - 1;
+    vertexMap[key] = index;
+    return index;
+  };
+
+  const getStampPixelAt = (x, y) => {
+    if (x < 0 || x >= xdim) return 0;
+    if (y < 0 || y >= ydim) return 0;
+    return stencil.pixels[y * xdim + x] || 0;
+  };
+
+  for (let gy = 0; gy < gridydim; gy++) {
+    for (let gx = 0; gx < gridxdim; gx++) {
+      // evaluate point to see if it needs inclusion
+      // by looking at all 4 pixels that share this point
+      // as a corner.
+      // if all empty or all filled, the current point is
+      // not used in the contour.
+      const count =
+        getStampPixelAt(gx, gy) +
+        getStampPixelAt(gx - 1, gy) +
+        getStampPixelAt(gx, gy - 1) +
+        getStampPixelAt(gx - 1, gy - 1);
+
+      if (count > 0 && count < 4) {
+        const v0 = getOrCreateVertexIndex(gx, gy);
+
+        // now do line check. We look at the east and south lines.
+        // east first
+        if (getStampPixelAt(gx, gy) !== getStampPixelAt(gx, gy - 1)) {
+          const v1 = getOrCreateVertexIndex(gx + 1, gy);
+          lines.push([v0, v1]);
+        }
+        // south next
+        if (getStampPixelAt(gx, gy) !== getStampPixelAt(gx - 1, gy)) {
+          const v1 = getOrCreateVertexIndex(gx, gy + 1);
+          lines.push([v0, v1]);
+        }
+      }
+    }
+  }
+
+  return {
+    points: new Float32Array(vertices.flat()),
+    lines: new Uint16Array(lines.map(([v0, v1]) => [2, v0, v1]).flat()),
+  };
+}
+
+function vtkPaintBrushContextRepresentation(publicAPI, model) {
+  model.classHierarchy.push('vtkPaintBrushContextRepresentation');
+
+  model.internalPolyData = vtkPolyData.newInstance({ mtime: 0 });
+  model.internalArrays = {
+    points: model.internalPolyData.getPoints(),
+    lines: model.internalPolyData.getLines(),
+  };
+
+  model.pipelines = {
+    brush: {
+      source: publicAPI,
+      mapper: vtkMapper2D.newInstance({
+        transformCoordinate: vtkCoordinate.newInstance({
+          coordinateSystem: Coordinate.WORLD,
+        }),
+      }),
+      actor: vtkActor2D.newInstance({ pickable: false, parentProp: publicAPI }),
+    },
+  };
+
+  const actorProperty = model.pipelines.brush.actor.getProperty();
+  actorProperty.setLineWidth(2);
+  actorProperty.setColor([1, 0, 0]);
+  actorProperty.setDisplayLocation(DisplayLocation.FOREGROUND);
+  actorProperty.setRepresentation(Representation.SURFACE);
+
+  vtkWidgetRepresentation.connectPipeline(model.pipelines.brush);
+
+  publicAPI.addActor(model.pipelines.brush.actor);
+
+  publicAPI.requestData = (inData, outData) => {
+    const widgetState = inData[0];
+
+    const stencil = widgetState.getStencil();
+    const brush = widgetState.getBrush();
+    const { indexToWorld, worldToIndex } = model;
+
+    if (stencil && brush.getOrigin()) {
+      const location = [];
+      vec3.transformMat4(location, brush.getOrigin(), worldToIndex);
+
+      const contour = generateContour({
+        stencil,
+        location,
+        slicingIndex: model.slicingIndex,
+        indexToWorld,
+      });
+
+      const { points, lines } = model.internalArrays;
+      points.setData(contour.points);
+      lines.setData(contour.lines);
+
+      model.internalPolyData.modified();
+    }
+    outData[0] = model.internalPolyData;
+  };
+}
+
+const DEFAULT_VALUES = {
+  defaultScale: 1,
+  drawBorder: false,
+  drawFace: true,
+  worldToIndex: null,
+  indexToWorld: null,
+  slicingIndex: 0,
+};
+
+// ----------------------------------------------------------------------------
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  vtkContextRepresentation.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, [
+    'slicingIndex',
+    'indexToWorld',
+    'worldToIndex',
+  ]);
+  macro.get(publicAPI, model, ['mapper', 'actor']);
+  vtkPaintBrushContextRepresentation(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(
+  extend,
+  'vtkPaintBrushContextRepresentation'
+);
+
+export default { newInstance, extend };

package/src/vtk/PaintWidget/behavior.ts

@@ -0,0 +1,101 @@
+import macro from '@kitware/vtk.js/macro';
+
+export function shouldIgnoreEvent(e: any) {
+  return e.altKey || e.controlKey || e.shiftKey;
+}
+
+export default function widgetBehavior(publicAPI: any, model: any) {
+  model.classHierarchy.push('vtkPaintWidgetProp');
+
+  // support setting per-view widget manipulators
+  macro.setGet(publicAPI, model, ['manipulator']);
+
+  let isPainting = false;
+
+  /**
+   * Starts painting
+   */
+  publicAPI.handleLeftButtonPress = (eventData: any) => {
+    if (!model.manipulator || shouldIgnoreEvent(eventData)) {
+      return macro.VOID;
+    }
+
+    const worldCoords = model.manipulator.handleEvent(
+      eventData,
+      model._apiSpecificRenderWindow
+    );
+
+    if (!worldCoords) {
+      return macro.VOID;
+    }
+
+    const brush = model.widgetState.getBrush();
+    brush.setOrigin(...worldCoords);
+
+    isPainting = true;
+    publicAPI.invokeStartInteractionEvent();
+    return macro.EVENT_ABORT;
+  };
+
+  /**
+   * Paints
+   */
+  publicAPI.handleMouseMove = (eventData: any) => {
+    if (shouldIgnoreEvent(eventData)) {
+      return macro.VOID;
+    }
+
+    const worldCoords = model.manipulator.handleEvent(
+      eventData,
+      model._apiSpecificRenderWindow
+    );
+
+    if (!worldCoords) {
+      return macro.VOID;
+    }
+
+    const brush = model.widgetState.getBrush();
+    brush.setOrigin(...worldCoords);
+
+    if (isPainting) {
+      publicAPI.invokeInteractionEvent();
+    }
+    return macro.EVENT_ABORT;
+  };
+
+  /**
+   * Finishes paint
+   */
+  publicAPI.handleLeftButtonRelease = (eventData: any) => {
+    if (!isPainting || shouldIgnoreEvent(eventData)) {
+      return macro.VOID;
+    }
+
+    isPainting = false;
+    publicAPI.invokeEndInteractionEvent();
+    return macro.EVENT_ABORT;
+  };
+
+  publicAPI.handleMouseWheel = () => {
+    if (isPainting) {
+      return macro.EVENT_ABORT;
+    }
+    return macro.VOID;
+  };
+
+  publicAPI.grabFocus = () => {
+    if (!model.hasFocus) {
+      model.hasFocus = true;
+      model._interactor.requestAnimation(publicAPI);
+    }
+  };
+
+  publicAPI.loseFocus = () => {
+    if (model.hasFocus) {
+      model._interactor.cancelAnimation(publicAPI);
+    }
+    model.hasFocus = false;
+    // model._widgetManager.enablePicking();
+    // model._interactor.render();
+  };
+}

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

@@ -0,0 +1,28 @@
+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 { PaintWidgetState } from './state';
+
+export interface vtkPaintViewWidget extends vtkAbstractWidget {
+  setManipulator(manipulator: vtkPlaneManipulator): boolean;
+  getManipulator(): vtkPlaneManipulator;
+  setSlicingIndex(index: number): boolean;
+  setIndexToWorld(transform: mat4): boolean;
+  getIndexToWorld(): mat4;
+  setWorldToIndex(transform: mat4): boolean;
+  getWorldToIndex(): mat4;
+}
+
+export interface vtkPaintWidget extends vtkAbstractWidgetFactory {
+  getWidgetState(): PaintWidgetState;
+}
+
+export function newInstance(): vtkPaintWidget;
+
+export function shouldIgnoreEvent(ev: any): boolean;
+
+export declare const vtkPaintWidget: {
+  newInstance: typeof newInstance;
+};
+export default vtkPaintWidget;

package/src/vtk/PaintWidget/index.js

@@ -0,0 +1,56 @@
+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 vtkPaintBrushContextRepresentation from '@/src/vtk/PaintBrushContextRepresentation';
+
+import widgetBehavior from './behavior';
+import stateGenerator from './state';
+
+export { shouldIgnoreEvent } from './behavior';
+
+// ----------------------------------------------------------------------------
+// Factory
+// ----------------------------------------------------------------------------
+
+function vtkPaintWidget(publicAPI, model) {
+  model.classHierarchy.push('vtkPaintWidget');
+
+  model.methodsToLink = ['slicingIndex', 'indexToWorld', 'worldToIndex'];
+
+  publicAPI.getRepresentationsForViewType = () => [
+    {
+      builder: vtkPaintBrushContextRepresentation,
+      labels: ['brush'],
+    },
+  ];
+
+  // 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']);
+
+  vtkPaintWidget(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(extend, 'vtkPaintWidget');
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };

package/src/vtk/PaintWidget/state.ts

@@ -0,0 +1,41 @@
+import { IBrushStencil } from '@/src/core/tools/paint/brush';
+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 interface PaintPointWidgetState 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 PaintWidgetState extends vtkWidgetState {
+  getBrush(): PaintPointWidgetState;
+  getStencil(): IBrushStencil;
+  setStencil(stencil: IBrushStencil): boolean;
+}
+
+export default function generateState() {
+  return vtkStateBuilder
+    .createBuilder()
+    .addStateFromMixin({
+      labels: ['brush'],
+      name: 'brush',
+      mixins: ['origin', 'scale1', 'visible', 'color'],
+      initialValues: {
+        scale1: 1,
+        origin: null,
+        visible: true,
+      },
+    })
+    .addField({
+      name: 'stencil',
+      initialValue: null,
+    })
+    .build() as PaintWidgetState;
+}

package/src/vtk/PiecewiseWidget/index.js

@@ -0,0 +1,203 @@
+import macro from '@kitware/vtk.js/macro';
+import vtkPiecewiseGaussianWidget from '@kitware/vtk.js/Interaction/Widgets/PiecewiseGaussianWidget';
+
+export const Mode = {
+  Gaussians: 1,
+  Points: 2,
+};
+
+export const ADJUST_POSITION_CURSOR = '-webkit-grab';
+
+/**
+ * Samples a piecewise linear function at regular intervals in [0,1].
+ * The first and last values are set to zero, since the output
+ * is used for vtkPiecewiseGaussianWidget.drawChart().
+ *
+ * Assumes normalized x/y coordinate points.
+ */
+
+export function samplePiecewiseLinear(points, shift = 0, samples = 256) {
+  const filledPoints = [...points];
+  // set endpoints to drop to 0
+  filledPoints.push([points[0][0], 0]);
+  filledPoints.push([points[points.length - 1][0], 0]);
+
+  const sampledPoints = [];
+  let pi = 0;
+  let p1 = filledPoints[0]; // left
+  let p2 = filledPoints[1]; // right
+  let slope = (p2[1] - p1[1]) / (p2[0] - p1[0]);
+  for (let i = 0; i < samples; i += 1) {
+    const sx = i / (samples - 1) - shift; // sample x
+    if (i < samples - 1) {
+      while (sx > p2[0] && pi < filledPoints.length - 2) {
+        pi += 1;
+        // extraneous work if this loop goes over more than once,
+        // which only happens if sx > 0 on first iteration (aka shift < 0)
+        p1 = filledPoints[pi];
+        p2 = filledPoints[pi + 1];
+        if (Math.abs(p2[0] - p1[0]) < 1e-8) {
+          slope = Infinity * Math.sign(p2[1] - p1[1]);
+        } else {
+          slope = (p2[1] - p1[1]) / (p2[0] - p1[0]);
+        }
+      }
+      if (slope === Infinity) {
+        sampledPoints.push(1);
+      } else if (slope === -Infinity) {
+        sampledPoints.push(0);
+      } else {
+        sampledPoints.push(slope * (sx - p1[0]) + p1[1]);
+      }
+    }
+  }
+  return sampledPoints;
+}
+
+// ----------------------------------------------------------------------------
+// vtkPiecewiseWidget methods
+// ----------------------------------------------------------------------------
+
+function vtkPiecewiseWidget(publicAPI, model) {
+  model.classHierarchy.push('vtkPiecewiseWidget');
+
+  const superClass = { ...publicAPI };
+
+  model.pwMode = Mode.Gaussians;
+  model.opacityPoints = [];
+  model.opacityPointShift = 0;
+
+  publicAPI.setGaussiansMode = () => {
+    model.pwMode = Mode.Gaussians;
+  };
+
+  publicAPI.setPointsMode = () => {
+    // clear gaussians so we don't keep this ref around
+    model.gaussians = [];
+    model.pwMode = Mode.Points;
+  };
+
+  publicAPI.isModeGaussians = () => model.pwMode === Mode.Gaussians;
+  publicAPI.isModePoints = () => model.pwMode === Mode.Points;
+  publicAPI.getMode = () => model.pwMode;
+
+  publicAPI.shiftPosition = (coords, meta) => {
+    model.opacityPointShift =
+      meta.originalOpacityPointShift + coords[0] - meta.originalXY[0];
+    return true;
+  };
+
+  publicAPI.onHover = (x, y) => {
+    if (publicAPI.isModeGaussians()) {
+      return superClass.onHover(x, y);
+    }
+    model.canvas.style.cursor = ADJUST_POSITION_CURSOR;
+    return true;
+  };
+
+  publicAPI.onClick = (x, y) => {
+    if (publicAPI.isModeGaussians()) {
+      return superClass.onClick(x, y);
+    }
+    return undefined;
+  };
+
+  publicAPI.onDown = (x, y) => {
+    if (publicAPI.isModeGaussians()) {
+      return superClass.onDown(x, y);
+    }
+
+    if (!model.mouseIsDown) {
+      publicAPI.invokeAnimation(true);
+    }
+
+    const mouseCoords = vtkPiecewiseGaussianWidget.normalizeCoordinates(
+      x,
+      y,
+      model.graphArea
+    );
+
+    model.mouseIsDown = true;
+    model.activeGaussian = -1;
+    model.dragAction = {
+      originalXY: mouseCoords,
+      originalOpacityPointShift: model.opacityPointShift,
+    };
+
+    return true;
+  };
+
+  publicAPI.onDrag = (x, y) => {
+    if (publicAPI.isModeGaussians()) {
+      return superClass.onDrag(x, y);
+    }
+
+    const normCoords = vtkPiecewiseGaussianWidget.normalizeCoordinates(
+      x,
+      y,
+      model.graphArea
+    );
+    if (publicAPI.shiftPosition(normCoords, model.dragAction)) {
+      model.opacities = samplePiecewiseLinear(
+        model.opacityPoints,
+        model.opacityPointShift
+      );
+      publicAPI.invokeOpacityChange(publicAPI, true);
+    }
+
+    publicAPI.modified();
+    return true;
+  };
+
+  publicAPI.setOpacityPoints = (points, shift = 0) => {
+    if (publicAPI.isModePoints()) {
+      // deep copy
+      model.opacityPoints = points.map((p) => [p[0], p[1]]);
+      model.opacityPointShift = shift;
+
+      model.opacities = samplePiecewiseLinear(
+        model.opacityPoints,
+        model.opacityPointShift
+      );
+      publicAPI.modified();
+    }
+  };
+
+  publicAPI.getEffectiveOpacityPoints = () =>
+    model.opacityPoints.map((p) => [p[0] + model.opacityPointShift, p[1]]);
+
+  publicAPI.render = () => {
+    if (publicAPI.isModePoints()) {
+      model.activeGaussian = -1;
+      model.selectedGaussian = -1;
+    }
+    superClass.render();
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  vtkPiecewiseGaussianWidget.extend(publicAPI, model, initialValues);
+
+  macro.setGet(publicAPI, model, ['opacityPoints', 'opacityPointShift']);
+
+  // Object specific methods
+  vtkPiecewiseWidget(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(extend, 'vtkPiecewiseWidget');
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };