volview 4.0.0 → 4.0.1

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

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

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

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

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

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

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

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

@@ -1,11 +0,0 @@
-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();