volview 4.0.0

package/src/vtk/LPSView2DProxy/index.js

@@ -0,0 +1,89 @@
+import macro from '@kitware/vtk.js/macro';
+import vtkView2DProxy from '@kitware/vtk.js/Proxy/Core/View2DProxy';
+
+import { commonViewCustomizations } from '@/src/vtk/LPSView3DProxy';
+
+function vtkLPSView2DProxy(publicAPI, model) {
+  model.classHierarchy.push('vtkLPSView2DProxy');
+  const superClass = { ...publicAPI };
+
+  commonViewCustomizations(publicAPI, model);
+
+  // override; we will set the manipulator ourselves
+  publicAPI.bindRepresentationToManipulator = () => {};
+
+  // override reset camera to /just/ reset the camera
+  publicAPI.resetCamera = (boundsToUse = null) => {
+    model.renderer.resetCamera(boundsToUse);
+  };
+
+  // override addRepresentation
+  publicAPI.addRepresentation = (rep) => {
+    superClass.addRepresentation(rep);
+    if (rep.setSlicingMode && model.slicingMode) {
+      rep.setSlicingMode(model.slicingMode);
+    }
+  };
+
+  // this basically ignores model.axis
+  publicAPI.setSlicingMode = (mode) => {
+    if (superClass.setSlicingMode(mode) && mode) {
+      let count = model.representations.length;
+      while (count--) {
+        const rep = model.representations[count];
+        if (rep.setSlicingMode) {
+          rep.setSlicingMode(mode);
+        }
+      }
+    }
+  };
+
+  publicAPI.resizeToFit = (lookAxis, viewUpAxis, dims) => {
+    const [w, h] = model.openglRenderWindow.getSize();
+    let bw;
+    let bh;
+    if (lookAxis === 0 && viewUpAxis === 1) {
+      [, bh, bw] = dims;
+    } else if (lookAxis === 0 && viewUpAxis === 2) {
+      [, bw, bh] = dims;
+    } else if (lookAxis === 1 && viewUpAxis === 0) {
+      [bh, , bw] = dims;
+    } else if (lookAxis === 1 && viewUpAxis === 2) {
+      [bw, , bh] = dims;
+    } else if (lookAxis === 2 && viewUpAxis === 0) {
+      [bh, bw] = dims;
+    } else if (lookAxis === 2 && viewUpAxis === 1) {
+      [bw, bh] = dims;
+    }
+
+    const viewAspect = w / h;
+    const boundsAspect = bw / bh;
+    let scale = 0;
+    if (viewAspect >= boundsAspect) {
+      scale = bh / 2;
+    } else {
+      scale = bw / 2 / viewAspect;
+    }
+
+    model.camera.setParallelScale(scale);
+  };
+}
+
+const DEFAULT_VALUES = {
+  slicingMode: null, // XYZIJK. Null means fallback to model.axis.
+};
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, initialValues, DEFAULT_VALUES);
+
+  // slicing mode overrides axis
+  macro.setGet(publicAPI, model, ['slicingMode']);
+
+  vtkView2DProxy.extend(publicAPI, model, initialValues);
+
+  vtkLPSView2DProxy(publicAPI, model);
+}
+
+export const newInstance = macro.newInstance(extend, 'vtkLPSView2DProxy');
+
+export default { newInstance, extend };

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

@@ -0,0 +1,16 @@
+import { vec3 } from 'gl-matrix';
+import vtkViewProxy from '@kitware/vtk.js/Proxy/Core/ViewProxy';
+
+export interface ViewProxyCustomizations {
+  removeAllRepresentations(): void;
+  updateCamera(directionOfProjection: vec3, viewUp: vec3, focalPoint: vec3);
+}
+export interface vtkLPSView3DProxy
+  extends vtkViewProxy,
+    ViewProxyCustomizations {}
+
+export function commonViewCustomizations(publicAPI: any, model: any): void;
+
+// TODO extend, newInstance...
+export declare const vtkLPSView3DProxy: {};
+export default vtkLPSView3DProxy;

package/src/vtk/LPSView3DProxy/index.js

@@ -0,0 +1,78 @@
+import { vec3 } from 'gl-matrix';
+import macro from '@kitware/vtk.js/macro';
+import vtkViewProxy from '@kitware/vtk.js/Proxy/Core/ViewProxy';
+
+export function commonViewCustomizations(publicAPI, model) {
+  const delayedRender = macro.debounce(model.renderWindow.render, 5);
+
+  // override resize to avoid flickering from rendering later
+  publicAPI.resize = () => {
+    if (model.container) {
+      const dims = model.container.getBoundingClientRect();
+      if (dims.width === dims.height && dims.width === 0) {
+        return;
+      }
+      const devicePixelRatio = window.devicePixelRatio || 1;
+      const width = Math.max(10, Math.floor(devicePixelRatio * dims.width));
+      const height = Math.max(10, Math.floor(devicePixelRatio * dims.height));
+      model.openglRenderWindow.setSize(width, height);
+      publicAPI.invokeResize({ width, height });
+      publicAPI.render(true);
+    }
+  };
+
+  // override render to not reset camera
+  publicAPI.render = (blocking = true) => {
+    model.orientationWidget.updateMarkerOrientation();
+    if (blocking) {
+      model.renderWindow.render();
+    } else {
+      delayedRender();
+    }
+  };
+
+  // add helper function
+  publicAPI.removeAllRepresentations = () => {
+    model.representations.forEach((rep) => model.renderer.removeViewProp(rep));
+    model.representations.length = 0;
+  };
+
+  publicAPI.updateCamera = (directionOfProjection, viewUp, focalPoint) => {
+    const position = vec3.clone(focalPoint);
+    vec3.sub(position, position, directionOfProjection);
+    model.camera.setFocalPoint(...focalPoint);
+    model.camera.setPosition(...position);
+    model.camera.setDirectionOfProjection(...directionOfProjection);
+    model.camera.setViewUp(...viewUp);
+  };
+
+  // disable the built-in corner annotations
+  const { setContainer } = publicAPI;
+  publicAPI.setContainer = (el) => {
+    setContainer(el);
+    model.cornerAnnotation.setContainer(null);
+  };
+
+  const { resetCamera } = publicAPI;
+  publicAPI.resetCamera = (...args) => {
+    resetCamera(args);
+    model.renderer.updateLightsGeometryToFollowCamera();
+  };
+}
+
+function vtkLPSView3DProxy(publicAPI, model) {
+  model.classHierarchy.push('vtkLPSView3DProxy');
+  commonViewCustomizations(publicAPI, model);
+}
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, initialValues);
+
+  vtkViewProxy.extend(publicAPI, model, initialValues);
+
+  vtkLPSView3DProxy(publicAPI, model);
+}
+
+export const newInstance = macro.newInstance(extend, 'vtkLPSView3DProxy');
+
+export default { newInstance, extend };

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

@@ -0,0 +1,16 @@
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { Vector4 } from '@kitware/vtk.js/types';
+
+export interface vtkLabelMap extends vtkImageData {
+  setLabelColor(label: number, color: Vector4): void;
+  removeLabel(label: number): void;
+  setColorMap(colorMap: Record<number, number[]>): boolean;
+  getColorMap(): Record<number, number[]>;
+}
+
+export function newInstance(initialValues?: any): vtkLabelMap;
+
+export declare const vtkLabelMap: {
+  newInstance: typeof newInstance;
+};
+export default vtkLabelMap;

package/src/vtk/LabelMap/index.js

@@ -0,0 +1,49 @@
+import macro from '@kitware/vtk.js/macro';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+
+// ----------------------------------------------------------------------------
+// vtkLabelMap methods
+// ----------------------------------------------------------------------------
+
+function vtkLabelMap(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkLabelMap');
+
+  if (model.colorMap === null) {
+    // default colormap
+    model.colorMap = {
+      0: [0, 0, 0, 0],
+      1: [0, 0, 0, 255],
+    };
+  }
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  // default opacity map uses 0 as the transparent pixel
+  colorMap: null,
+};
+
+// ----------------------------------------------------------------------------
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  vtkImageData.extend(publicAPI, model, initialValues);
+
+  macro.setGet(publicAPI, model, ['colorMap']);
+
+  // Object specific methods
+  vtkLabelMap(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(extend, 'vtkLabelMap');
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };

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

@@ -0,0 +1,6 @@
+import vtkIJKSliceRepresentationProxy from '../IJKSliceRepresentationProxy';
+
+export interface vtkLabelMapSliceRepProxy
+  extends vtkIJKSliceRepresentationProxy {}
+
+export default vtkLabelMapSliceRepProxy;

package/src/vtk/LabelMapSliceRepProxy/index.js

@@ -0,0 +1,104 @@
+import macro from '@kitware/vtk.js/macro';
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
+import ImagePropertyConstants from '@kitware/vtk.js/Rendering/Core/ImageProperty/Constants';
+
+import vtkIJKSliceRepresentationProxy from '../IJKSliceRepresentationProxy';
+
+const { InterpolationType } = ImagePropertyConstants;
+
+// ----------------------------------------------------------------------------
+// vtkLabelMapSliceRepProxy methods
+// ----------------------------------------------------------------------------
+
+function vtkLabelMapSliceRepProxy(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkLabelMapSliceRepProxy');
+
+  let labelMapSub = null;
+
+  // needed for vtk.js >= 23.0.0
+  model.property.setUseLookupTableScalarRange(true);
+  model.property.setInterpolationType(InterpolationType.NEAREST);
+  model.mapper.setRelativeCoincidentTopologyPolygonOffsetParameters(-2, -2);
+
+  let cachedColorMap = null;
+
+  function updateTransferFunctions(labelmap) {
+    const colorMap = labelmap.getColorMap();
+    if (colorMap === cachedColorMap) {
+      return;
+    }
+    // Cache the colormap using ref equality. This will
+    // avoid updating the colormap unnecessarily.
+    cachedColorMap = colorMap;
+
+    const cfun = vtkColorTransferFunction.newInstance();
+    const ofun = vtkPiecewiseFunction.newInstance();
+
+    Object.keys(colorMap).forEach((label) => {
+      const l = Number(label);
+      cfun.addRGBPoint(l, ...colorMap[label].slice(0, 3).map((c) => c / 255));
+      ofun.addPoint(l, colorMap[label][3] / 255);
+    });
+
+    model.property.setRGBTransferFunction(cfun);
+    model.property.setScalarOpacity(ofun);
+  }
+
+  function setInputData(labelmap) {
+    if (labelMapSub) {
+      labelMapSub.unsubscribe();
+      labelMapSub = null;
+    }
+
+    if (labelmap) {
+      labelMapSub = labelmap.onModified(() =>
+        updateTransferFunctions(labelmap)
+      );
+      updateTransferFunctions(labelmap);
+    }
+  }
+
+  // override because we manage our own color/opacity functions
+  publicAPI.setColorBy = () => {};
+
+  publicAPI.delete = macro.chain(publicAPI.delete, () => {
+    if (labelMapSub) {
+      labelMapSub.unsubscribe();
+      labelMapSub = null;
+    }
+  });
+
+  // Keep things updated
+  model.sourceDependencies.push({ setInputData });
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Object methods
+  vtkIJKSliceRepresentationProxy.extend(publicAPI, model);
+
+  // Object specific methods
+  vtkLabelMapSliceRepProxy(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(
+  extend,
+  'vtkLabelMapSliceRepProxy'
+);
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };