volview 4.0.0 → 4.0.1

package/src/vtk/PaintBrushContextRepresentation/index.js

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

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

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

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

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

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