volview 4.0.0

package/src/core/tools/paint/brush.ts

@@ -0,0 +1,20 @@
+import { Vector2 } from '@kitware/vtk.js/types';
+
+export interface IBrushStencil {
+  pixels: Uint8Array;
+  size: [number, number];
+}
+export interface IPaintBrush {
+  /**
+   * Sets the size of the stencil, pre-scaling.
+   */
+  setSize(size: number): void;
+  /**
+   * Sets the scale of the stencil.
+   */
+  setScale(scale: Vector2): void;
+  /**
+   * Returns the stencil with the applied scaling.
+   */
+  getStencil(): IBrushStencil;
+}

package/src/core/tools/paint/ellipse-brush.ts

@@ -0,0 +1,96 @@
+import { Vector2 } from '@kitware/vtk.js/types';
+import { IBrushStencil, IPaintBrush } from './brush';
+
+// Adapted from http://members.chello.at/easyfilter/bresenham.html
+function rasterizeEllipse(xdiam: number, ydiam: number) {
+  const buffer = new Uint8Array(xdiam * ydiam);
+
+  const putPixel = (x: number, y: number) => {
+    buffer[x + y * xdiam] = 1;
+  };
+
+  const blitLine = (x0: number, x1: number, y: number) => {
+    const start = y * xdiam + x0;
+    const end = start + (x1 - x0 + 1);
+    buffer.fill(1, start, end);
+  };
+
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = xdiam - 1;
+  let y1 = ydiam - 1;
+
+  let a = x1;
+  let b = y1;
+  // eslint-disable-next-line no-bitwise
+  const b1 = b & 1;
+  let dx = 4 * (1 - a) * b * b;
+  let dy = 4 * (b1 + 1) * a * a;
+  let err = dx + dy + b1 * a * a;
+  let e2 = 0;
+
+  y0 += Math.floor((b + 1) / 2);
+  y1 = y0 - b1;
+  a *= 8 * a;
+  b *= 8 * b;
+  do {
+    blitLine(x0, x1, y0);
+    blitLine(x0, x1, y1);
+    e2 = 2 * err;
+    if (e2 <= dy) {
+      y0++;
+      y1--;
+      dy += a;
+      err += dy;
+    }
+    if (e2 >= dx || 2 * err > dy) {
+      x0++;
+      x1--;
+      dx += b;
+      err += dx;
+    }
+  } while (x0 <= x1);
+  while (y0 - y1 < ydiam) {
+    putPixel(x0 - 1, y0);
+    putPixel(x1 + 1, y0++);
+    putPixel(x0 - 1, y1);
+    putPixel(x1 + 1, y1--);
+  }
+
+  return buffer;
+}
+
+export default class EllipsePaintBrush implements IPaintBrush {
+  private size: number = 1;
+  private scale: Vector2 = [1, 1];
+  private cachedStencil!: IBrushStencil;
+
+  constructor() {
+    this.recomputeStencil();
+  }
+
+  setSize(size: number) {
+    this.size = Math.max(0, size);
+    this.recomputeStencil();
+  }
+
+  setScale(scale: Vector2) {
+    this.scale = scale;
+    this.recomputeStencil();
+  }
+
+  private recomputeStencil() {
+    const scaledSize = [
+      Math.ceil(this.size * this.scale[0]),
+      Math.ceil(this.size * this.scale[1]),
+    ] as Vector2;
+    this.cachedStencil = {
+      size: scaledSize,
+      pixels: rasterizeEllipse(scaledSize[0], scaledSize[1]),
+    };
+  }
+
+  getStencil() {
+    return this.cachedStencil;
+  }
+}

package/src/core/tools/paint/index.ts

@@ -0,0 +1,141 @@
+import vtkLabelMap from '@/src/vtk/LabelMap';
+import vtkPaintWidget from '@/src/vtk/PaintWidget';
+import { Vector2 } from '@kitware/vtk.js/types';
+import { vec3 } from 'gl-matrix';
+import { IPaintBrush } from './brush';
+import EllipsePaintBrush from './ellipse-brush';
+
+export default class PaintTool {
+  readonly factory: vtkPaintWidget;
+  private brush: IPaintBrush;
+  private brushValue: number;
+
+  constructor() {
+    this.factory = vtkPaintWidget.newInstance();
+    this.brush = new EllipsePaintBrush();
+    this.brushValue = 1;
+  }
+
+  private updateWidgetStencil() {
+    // use unscaled stencil for paint outline
+    const stencil = this.brush.getStencil();
+    const widgetState = this.factory.getWidgetState();
+    widgetState.setStencil(stencil);
+  }
+
+  setBrushSize(size: number) {
+    this.brush.setSize(size);
+    this.updateWidgetStencil();
+  }
+
+  setBrushScale(scale: Vector2) {
+    this.brush.setScale(scale);
+    this.updateWidgetStencil();
+  }
+
+  setBrushValue(value: number) {
+    this.brushValue = value;
+  }
+
+  /**
+   * Adds paint to a labelmap.
+   *
+   * If endPoint is specified, then linearly interpolates the brush
+   * from the start to the end.
+   *
+   * Assumption: startPoint and endPoint are on the same slice axis.
+   *
+   * @param labelmap paint in this labelmap
+   * @param sliceAxis Which index-space axis to paint on (0, 1, or 2).
+   * @param startPoint start point
+   * @param endPoint ending point (optional)
+   */
+  paintLabelmap(
+    labelmap: vtkLabelMap,
+    sliceAxis: 0 | 1 | 2,
+    startPoint: vec3,
+    endPoint?: vec3
+  ) {
+    const stencil = this.brush.getStencil();
+
+    const start = [
+      // transforms + floating point errors can make zero values occasionally
+      // turn into really tiny negative values
+      ...startPoint.map((val) => Math.round(val)),
+    ];
+    // Assumption: startPoint and endPoint are on the same slice axis.
+    const ijkSlice = start[sliceAxis];
+    start.splice(sliceAxis, 1);
+
+    let end = [...start];
+    if (endPoint) {
+      end = [...endPoint.map((val) => Math.round(val))];
+      end.splice(sliceAxis, 1);
+    }
+
+    const labelmapPixels = labelmap.getPointData().getScalars().getData();
+    const labelmapDims = labelmap.getDimensions();
+    const jStride = labelmapDims[0];
+    const kStride = labelmapDims[0] * labelmapDims[1];
+
+    const isInBounds = (point: number[]) =>
+      point[0] >= 0 &&
+      point[1] >= 0 &&
+      point[2] >= 0 &&
+      point[0] < labelmapDims[0] &&
+      point[1] < labelmapDims[1] &&
+      point[2] < labelmapDims[2];
+
+    const { pixels, size } = stencil;
+    const centerX = Math.floor((size[0] - 1) / 2);
+    const centerY = Math.floor((size[1] - 1) / 2);
+
+    const point1 = [...start];
+    const point2 = [...end];
+    const rounded = [0, 0, 0];
+    const curPoint: number[] = [0, 0];
+    for (let y = 0; y < size[1]; y++) {
+      const ydelta = y - centerY;
+      const yoffset = y * size[0];
+      for (let x = 0; x < size[0]; x++) {
+        const xdelta = x - centerX;
+        const pixelOffset = yoffset + x;
+        if (pixels[pixelOffset]) {
+          point1[0] = start[0] + xdelta;
+          point1[1] = start[1] + ydelta;
+          point2[0] = end[0] + xdelta;
+          point2[1] = end[1] + ydelta;
+
+          // line between the two points
+          const dx = point2[0] - point1[0];
+          const dy = point2[1] - point1[1];
+          let steps = Math.abs(Math.abs(dx) > Math.abs(dy) ? dx : dy);
+          const incX = dx / steps;
+          const incY = dy / steps;
+          [curPoint[0], curPoint[1]] = point1;
+          while (steps-- >= 0) {
+            // add slice axis to make a proper 3D index
+            curPoint.splice(sliceAxis, 0, ijkSlice);
+            rounded[0] = Math.round(curPoint[0]);
+            rounded[1] = Math.round(curPoint[1]);
+            rounded[2] = Math.round(curPoint[2]);
+
+            if (isInBounds(rounded)) {
+              const offset =
+                rounded[0] + rounded[1] * jStride + rounded[2] * kStride;
+              labelmapPixels[offset] = this.brushValue;
+            }
+
+            // undo adding the slice axis value
+            curPoint.splice(sliceAxis, 1);
+
+            curPoint[0] += incX;
+            curPoint[1] += incY;
+          }
+        }
+      }
+    }
+
+    labelmap.modified();
+  }
+}

package/src/core/tools/ruler.ts

@@ -0,0 +1,149 @@
+import { Vector3 } from '@kitware/vtk.js/types';
+import { ImageMetadata } from '@/src/store/datasets-images';
+import {
+  InteractionState,
+  RulerWidgetState,
+} from '@/src/vtk/RulerWidget/state';
+import vtkRulerWidget from '@/src/vtk/RulerWidget';
+import mitt, { Emitter } from 'mitt';
+import { LPSAxis } from '@/src/types/lps';
+
+export interface SerializedRulerV1 {
+  version: '1.0';
+  /**
+   * Index space
+   */
+  firstPoint: Vector3;
+  /**
+   * Index space
+   */
+  secondPoint: Vector3;
+  viewAxis: LPSAxis;
+  /**
+   * Index space slice
+   */
+  slice: number;
+  imageID: string;
+  /**
+   * imageMetadata is saved as context for where
+   * the measurement is located in the world.
+   */
+  imageMetadata: Omit<ImageMetadata, 'name'>;
+  /**
+   * Ruler metadata
+   */
+  color: string;
+}
+
+export interface RulerStateUpdate {
+  firstPoint?: Vector3 | null;
+  secondPoint?: Vector3 | null;
+  interactionState?: InteractionState;
+}
+
+type RulerToolManagerEvents = {
+  widgetUpdate: {
+    id: string;
+    update: RulerStateUpdate;
+  };
+};
+
+export default class RulerTool {
+  private listeners: Map<string, Function>;
+
+  private factories: Map<string, vtkRulerWidget>;
+
+  private recurseGuard: boolean = false;
+
+  public events: Emitter<RulerToolManagerEvents>;
+
+  constructor() {
+    this.listeners = new Map();
+    this.factories = new Map();
+    this.events = mitt();
+  }
+
+  teardown() {
+    this.events.all.clear();
+    this.listeners.forEach((stop) => stop());
+    this.factories.forEach((factory) => factory.delete());
+    this.listeners.clear();
+    this.factories.clear();
+  }
+
+  getFactory(id: string) {
+    return this.factories.get(id) ?? null;
+  }
+
+  createRuler(id: string): vtkRulerWidget {
+    if (this.factories.has(id)) {
+      return this.factories.get(id)!;
+    }
+    const factory = vtkRulerWidget.newInstance();
+    this.listeners.set(
+      id,
+      this.createStoreUpdater(id, factory.getWidgetState())
+    );
+
+    this.factories.set(id, factory);
+    return factory;
+  }
+
+  removeRuler(id: string) {
+    const factory = this.factories.get(id);
+    if (factory) {
+      factory.delete();
+      this.factories.delete(id);
+    }
+    const cleanup = this.listeners.get(id);
+    if (cleanup) {
+      cleanup();
+      this.listeners.delete(id);
+    }
+  }
+
+  private createStoreUpdater(id: string, state: RulerWidgetState) {
+    const sub = state.onModified(() => {
+      if (this.recurseGuard) {
+        return;
+      }
+
+      const update: RulerStateUpdate = {
+        firstPoint: state.getFirstPoint().getOrigin(),
+        secondPoint: state.getSecondPoint().getOrigin(),
+        interactionState: state.getInteractionState(),
+      };
+
+      this.events.emit('widgetUpdate', { id, update });
+    });
+
+    return () => {
+      sub.unsubscribe();
+    };
+  }
+
+  updateRuler(id: string, update: RulerStateUpdate) {
+    const factory = this.factories.get(id);
+    if (factory) {
+      this.recurseGuard = true;
+
+      const state = factory.getWidgetState();
+      const first = state.getFirstPoint();
+      const second = state.getSecondPoint();
+
+      if (update.firstPoint) {
+        first.setOrigin(update.firstPoint);
+        first.setVisible(true);
+      }
+      if (update.secondPoint) {
+        second.setOrigin(update.secondPoint);
+        second.setVisible(true);
+      }
+      if (Number.isInteger(update.interactionState)) {
+        state.setInteractionState(update.interactionState!);
+      }
+
+      this.recurseGuard = false;
+    }
+  }
+}

package/src/global.d.ts

@@ -0,0 +1,24 @@
+import 'pinia';
+import type { Framework } from 'vuetify/types';
+import IDGenerator from './core/id';
+import ProxyWrapper from './core/proxies';
+import PaintTool from './core/tools/paint';
+import RulerTool from './core/tools/ruler';
+import { DICOMIO } from './io/dicom';
+
+declare module 'pinia' {
+  export interface PiniaCustomProperties {
+    // from CorePiniaProviderPlugin
+    $rulers: RulerTool;
+    $paint: PaintTool;
+    $proxies: ProxyWrapper;
+    $id: IDGenerator;
+    $dicomIO: DICOMIO;
+  }
+}
+
+declare module 'vue/types/vue' {
+  interface Vue {
+    $vuetify: Framework;
+  }
+}

package/src/io/__tests__/io.spec.ts

@@ -0,0 +1,26 @@
+import { expect } from 'chai';
+import { retypeFile } from '@src/io';
+
+function makeEmptyFile(name: string) {
+  return new File([], name);
+}
+
+function makeDicomFile(name: string) {
+  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);
+}
+
+describe('I/O', () => {
+  it('should detect dicom files', async () => {
+    expect((await retypeFile(makeDicomFile('file.DCM'))).type).to.equal('dcm');
+    expect((await retypeFile(makeDicomFile('somedicom'))).type).to.equal('dcm');
+  });
+
+  it('should retype files based on extension', async () => {
+    expect((await retypeFile(makeEmptyFile('test.VTI'))).type).to.equal('vti');
+  });
+});

package/src/io/dicom.ts

@@ -0,0 +1,187 @@
+import {
+  runPipeline,
+  TextStream,
+  InterfaceTypes,
+  readDICOMTags,
+  readImageDICOMFileSeries,
+} from 'itk-wasm';
+
+export interface TagSpec {
+  name: string;
+  tag: string;
+}
+
+// volume ID => file names
+export type VolumesToFilesMap = Record<string, string[]>;
+
+export class DICOMIO {
+  private webWorker: any;
+  private initializeCheck: Promise<void> | null;
+
+  constructor() {
+    this.webWorker = null;
+    this.initializeCheck = null;
+  }
+
+  private async runTask(
+    module: string,
+    args: any[],
+    inputs: any[],
+    outputs: any[]
+  ) {
+    return runPipeline(this.webWorker, module, args, outputs, inputs);
+  }
+
+  /**
+   * Helper that initializes the webworker.
+   *
+   * @async
+   * @throws Error initialization failed
+   */
+  private async initialize() {
+    if (!this.initializeCheck) {
+      this.initializeCheck = new Promise<void>((resolve, reject) => {
+        this.runTask('dicom', [], [], [])
+          .then((result) => {
+            if (result.webWorker) {
+              this.webWorker = result.webWorker;
+              resolve();
+            } else {
+              reject(new Error('Could not initialize webworker'));
+            }
+          })
+          .catch(reject);
+      });
+    }
+
+    return this.initializeCheck;
+  }
+
+  /**
+   * Categorize files
+   * @async
+   * @param {File[]} files
+   * @returns volumeID => file names mapping
+   */
+  async categorizeFiles(files: File[]): Promise<VolumesToFilesMap> {
+    await this.initialize();
+
+    const inputs = await Promise.all(
+      files.map(async (file) => {
+        const buffer = await file.arrayBuffer();
+        return {
+          type: InterfaceTypes.BinaryFile,
+          data: {
+            path: file.name,
+            data: new Uint8Array(buffer),
+          },
+        };
+      })
+    );
+
+    const args = [
+      '--action',
+      'categorize',
+      '--memory-io',
+      '0',
+      '--files',
+      ...inputs.map((fd) => fd.data.path),
+    ];
+
+    const outputs = [{ type: InterfaceTypes.TextStream }];
+
+    const result = await this.runTask(
+      // module
+      'dicom',
+      args,
+      inputs,
+      outputs
+    );
+
+    return JSON.parse((result.outputs[0].data as TextStream).data);
+  }
+
+  /**
+   * Reads a list of tags out from a given file.
+   *
+   * @param {File} file
+   * @param {[]Tag} tags
+   */
+  async readTags<T extends TagSpec[]>(
+    file: File,
+    tags: T
+  ): Promise<Record<T[number]['name'], string>> {
+    const tagsArgs = tags.map((t) => t.tag);
+
+    const result = await readDICOMTags(this.webWorker, file, tagsArgs);
+    const tagValues = result.tags;
+
+    return tags.reduce((info, t) => {
+      const { tag, name } = t;
+      if (tagValues.has(tag)) {
+        return { ...info, [name]: tagValues.get(tag) };
+      }
+      return info;
+    }, {} as Record<T[number]['name'], string>);
+  }
+
+  /**
+   * Retrieves a slice of a volume.
+   * @async
+   * @param {File} file containing the slice
+   * @param {Boolean} asThumbnail cast image to unsigned char. Defaults to false.
+   * @returns ItkImage
+   */
+  async getVolumeSlice(file: File, asThumbnail: boolean = false) {
+    await this.initialize();
+
+    const buffer = await file.arrayBuffer();
+
+    const inputs = [
+      {
+        type: InterfaceTypes.BinaryFile,
+        data: {
+          path: file.name,
+          data: new Uint8Array(buffer),
+        },
+      },
+    ];
+
+    const args = [
+      '--action',
+      'getSliceImage',
+      '--thumbnail',
+      asThumbnail.toString(),
+      '--file',
+      file.name,
+      '--memory-io',
+      '0',
+    ];
+
+    const outputs = [{ type: InterfaceTypes.Image }];
+
+    const result = await this.runTask(
+      // module
+      'dicom',
+      args,
+      inputs,
+      outputs
+    );
+
+    return result.outputs[0].data;
+  }
+
+  /**
+   * Builds a volume for a set of files.
+   * @async
+   * @param {File[]} files the set of files to build volume from
+   * @returns ItkImage
+   */
+  async buildVolume(files: File[]) {
+    await this.initialize();
+
+    const result = await readImageDICOMFileSeries(files);
+
+    return result.image;
+  }
+}

package/src/io/index.ts

@@ -0,0 +1,11 @@
+import { vtkObject } from '@kitware/vtk.js/interfaces';
+
+export * from './io';
+
+export type ReaderType = (file: File) => vtkObject | Promise<vtkObject>;
+export type FileReaderMap = Map<string, ReaderType>;
+
+/**
+ * A map of the currently registered file readers.
+ */
+export const FILE_READERS: FileReaderMap = new Map();