volview 4.0.0

package/src/shims-vue.d.ts

@@ -0,0 +1,5 @@
+declare module '*.vue' {
+  import Vue from 'vue';
+
+  export default Vue;
+}

package/src/store/__tests__/datasets.spec.ts

@@ -0,0 +1,75 @@
+import chai, { expect } from 'chai';
+import chaiSubset from 'chai-subset';
+
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+
+import { setActivePinia, createPinia } from 'pinia';
+import { useDatasetStore } from '@src/store/datasets';
+import { makeEmptyFile } from '@/tests/testUtils';
+import { FILE_READERS } from '@/src/io';
+import { CorePiniaProviderPlugin } from '@/src/core/provider';
+import ProxyWrapper from '@/src/core/proxies';
+import Sinon from 'sinon';
+
+chai.use(chaiSubset);
+
+describe('Dataset store', () => {
+  let proxies = Sinon.createStubInstance(ProxyWrapper);
+
+  beforeEach(() => {
+    proxies = Sinon.createStubInstance(ProxyWrapper);
+
+    const pinia = createPinia();
+    pinia.use(
+      CorePiniaProviderPlugin({
+        proxies,
+      })
+    );
+
+    setActivePinia(pinia);
+  });
+
+  it('loads images', async () => {
+    const datasetStore = useDatasetStore();
+    const files = [
+      makeEmptyFile('test1.nrrd'),
+      makeEmptyFile('test2.nrrd'),
+      makeEmptyFile('test3.nrrd'),
+    ];
+
+    // override nrrd reader
+    const testImageData = vtkImageData.newInstance();
+    FILE_READERS.set('nrrd', () => testImageData);
+
+    const loadResults = await datasetStore.loadFiles(files);
+    expect(loadResults).to.containSubset([
+      { type: 'file', filename: 'test1.nrrd', loaded: true, dataType: 'image' },
+      { type: 'file', filename: 'test2.nrrd', loaded: true, dataType: 'image' },
+      { type: 'file', filename: 'test3.nrrd', loaded: true, dataType: 'image' },
+    ]);
+  });
+
+  it('handles missing readers', async () => {
+    const datasetStore = useDatasetStore();
+    const files = [makeEmptyFile('test1.invalid')];
+
+    const loadResults = await datasetStore.loadFiles(files);
+    expect(loadResults).to.containSubset([
+      { type: 'file', filename: 'test1.invalid', loaded: false },
+    ]);
+  });
+
+  it('handles readers that return an error', async () => {
+    const datasetStore = useDatasetStore();
+    const files = [makeEmptyFile('test1.invalid')];
+
+    FILE_READERS.set('invalid', () => {
+      throw new Error('invalid!');
+    });
+
+    const loadResults = await datasetStore.loadFiles(files);
+    expect(loadResults).to.containSubset([
+      { type: 'file', filename: 'test1.invalid', loaded: false },
+    ]);
+  });
+});

package/src/store/__tests__/messages.spec.ts

@@ -0,0 +1,74 @@
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+
+import { setActivePinia, createPinia } from 'pinia';
+
+import { MessageType, useMessageStore } from '@src/store/messages';
+
+chai.use(chaiAsPromised);
+
+describe('Message store', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+  });
+
+  it('supports adding, accessing, and deleting messages', () => {
+    const messageStore = useMessageStore();
+
+    const innerError = new Error('inner error');
+    const ids = [
+      messageStore.addError('an error', innerError),
+      messageStore.addWarning('warning'),
+      messageStore.addInfo('info'),
+      messageStore.addInfo('loading', {
+        details: 'Loading files',
+        persist: true,
+      }),
+    ];
+
+    const expected = [
+      {
+        type: MessageType.Error,
+        title: 'an error',
+        options: {
+          details: String(innerError),
+          persist: false,
+        },
+      },
+      {
+        type: MessageType.Warning,
+        title: 'warning',
+        options: {
+          persist: false,
+        },
+      },
+      {
+        type: MessageType.Info,
+        title: 'info',
+        options: {
+          persist: false,
+        },
+      },
+      {
+        type: MessageType.Info,
+        title: 'loading',
+        options: {
+          details: 'Loading files',
+          persist: true,
+        },
+      },
+    ].map((ex, i) => ({ ...ex, id: String(i + 1) }));
+
+    expect(messageStore.messages).to.have.length(4);
+
+    ids.forEach((id, index) => {
+      expect(messageStore.byID[id]).to.deep.equal(expected[index]);
+    });
+
+    messageStore.clearOne(ids[1]);
+    expect(messageStore.byID).to.not.have.property(ids[1]);
+
+    messageStore.clearAll();
+    expect(messageStore.messages).to.be.empty;
+  });
+});

package/src/store/__tests__/rulers.spec.ts

@@ -0,0 +1,77 @@
+import chai, { expect } from 'chai';
+import chaiSubset from 'chai-subset';
+
+import { setActivePinia, createPinia } from 'pinia';
+import { CorePiniaProviderPlugin } from '@/src/core/provider';
+import RulerTool from '@/src/core/tools/ruler';
+import { useRulerStore } from '@/src/store/tools/rulers';
+import { InteractionState } from '@/src/vtk/RulerWidget/state';
+import { Vector3 } from '@kitware/vtk.js/types';
+import { LPSAxis } from '@/src/types/lps';
+
+chai.use(chaiSubset);
+
+describe('Ruler store', () => {
+  let rulerCore: RulerTool;
+  let rulerStore: ReturnType<typeof useRulerStore>;
+
+  beforeEach(() => {
+    rulerCore = new RulerTool();
+
+    const pinia = createPinia();
+    pinia.use(
+      CorePiniaProviderPlugin({
+        rulers: rulerCore,
+      })
+    );
+
+    setActivePinia(pinia);
+
+    rulerStore = useRulerStore();
+    rulerStore.initialize();
+  });
+
+  afterEach(() => {
+    rulerStore.uninitialize();
+  });
+
+  it('should support CRUD operations', () => {
+    const id = rulerStore.addNewRuler({});
+    expect(rulerStore.rulerIDs).to.include(id);
+
+    const patch = {
+      name: 'ruler #1',
+      firstPoint: [0, 0, 1] as Vector3,
+      secondPoint: [0, 0, 2] as Vector3,
+      viewAxis: 'Axial' as LPSAxis,
+      slice: 50,
+      imageID: '3',
+      interactionState: InteractionState.Settled,
+      color: '#ccc',
+    };
+    rulerStore.updateRuler(id, patch);
+    expect(rulerStore.rulers[id]).to.deep.equal(patch);
+
+    rulerStore.removeRuler(id);
+    expect(rulerStore.rulerIDs).to.not.include(id);
+  });
+
+  it('should sync state with the injected RulerTool', () => {
+    const id = rulerStore.addNewRuler({});
+    const factory = rulerCore.getFactory(id);
+    expect(factory).to.not.be.null;
+
+    const state = factory!.getWidgetState();
+    state.getFirstPoint().setOrigin([1, 2, 3]);
+    expect(rulerStore.rulers[id].firstPoint).to.deep.equal([1, 2, 3]);
+
+    rulerStore.updateRuler(id, {
+      secondPoint: [4, 5, 6],
+    });
+
+    expect(state.getSecondPoint().getOrigin()).to.deep.equal([4, 5, 6]);
+  });
+
+  // addRulerFromViewEvent requires an integration test due to
+  // its dependency on vtkOpenGLRenderWindow
+});

package/src/store/__tests__/view-configs.spec.ts

@@ -0,0 +1,37 @@
+import vtkPiecewiseFunctionProxy from '@kitware/vtk.js/Proxy/Core/PiecewiseFunctionProxy';
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+
+import { setActivePinia, createPinia } from 'pinia';
+import { useViewConfigStore } from '../view-configs';
+
+chai.use(chaiAsPromised);
+
+describe('View Config Store', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+  });
+
+  it('supports setting and getting volume coloring configs', () => {
+    const configStore = useViewConfigStore();
+
+    configStore.updateVolumeColorConfig('1', '2', {
+      colorBy: {
+        arrayName: 'Scalars',
+        location: 'pointData',
+      },
+      transferFunction: {
+        preset: 'Hot',
+        mappingRange: [0, 1],
+      },
+      opacityFunction: {
+        mode: vtkPiecewiseFunctionProxy.Mode.Gaussians,
+        gaussians: [],
+        mappingRange: [0, 1],
+      },
+    });
+
+    const config = configStore.getVolumeColorConfig('1', '2');
+    expect(config).to.not.be.undefined;
+  });
+});

package/src/store/datasets-dicom.ts

@@ -0,0 +1,398 @@
+import vtkITKHelper from '@kitware/vtk.js/Common/DataModel/ITKHelper';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { set, del } from '@vue/composition-api';
+import { defineStore } from 'pinia';
+import { pick, removeFromArray } from '../utils';
+import { useImageStore } from './datasets-images';
+import { useFileStore } from './datasets-files';
+import { StateFile, DataSetType, DataSet } from '../io/state-file/schema';
+import { serializeData } from '../io/state-file/utils';
+
+export const ANONYMOUS_PATIENT = 'Anonymous';
+export const ANONYMOUS_PATIENT_ID = 'ANONYMOUS';
+
+export function imageCacheMultiKey(offset: number, asThumbnail: boolean) {
+  return `${offset}!!${asThumbnail}`;
+}
+
+export interface VolumeKeys {
+  patientKey: string;
+  studyKey: string;
+  volumeKey: string;
+}
+
+export interface PatientInfo {
+  PatientID: string;
+  PatientName: string;
+  PatientBirthDate: string;
+  PatientSex: string;
+}
+
+export interface StudyInfo {
+  StudyID: string;
+  StudyInstanceUID: string;
+  StudyDate: string;
+  StudyTime: string;
+  AccessionNumber: string;
+  StudyDescription: string;
+}
+
+export interface VolumeInfo {
+  NumberOfSlices: number;
+  VolumeID: string;
+  Modality: string;
+  SeriesInstanceUID: string;
+  SeriesNumber: string;
+  SeriesDescription: string;
+}
+
+/**
+ * Generate a synthetic multi-key patient key from a Patient object.
+ *
+ * This key is used to try to uniquely identify a patient, since the PatientID
+ * is not guaranteed to be unique (especially in the anonymous case).
+ *
+ * Required keys in the Patient object:
+ * - PatientName
+ * - PatientID
+ * - PatientBirthDate
+ * - PatientSex
+ *
+ * @param {Patient} patient
+ */
+export function genSynPatientKey(patient: PatientInfo) {
+  const pid = patient.PatientID.trim();
+  const name = patient.PatientName.trim();
+  const bdate = patient.PatientBirthDate.trim();
+  const sex = patient.PatientSex.trim();
+  // we only care about making a unique key here. The
+  // data doesn't actually matter.
+  return [pid, name, bdate, sex].map((s) => s.replace('|', '_')).join('|');
+}
+
+interface State {
+  // volumeKey -> imageCacheMultiKey -> ITKImage
+  sliceData: Record<string, Record<string, object>>;
+
+  // volumeKey -> imageID
+  volumeToImageID: Record<string, string>;
+  // imageID -> volumeKey
+  imageIDToVolumeKey: Record<string, string>;
+
+  // volume invalidation information
+  needsRebuild: Record<string, boolean>;
+
+  // patientKey -> patient info
+  patientInfo: Record<string, PatientInfo>;
+  // patientKey -> array of studyKeys
+  patientStudies: Record<string, string[]>;
+
+  // studyKey -> study info
+  studyInfo: Record<string, StudyInfo>;
+  // studyKey -> array of volumeKeys
+  studyVolumes: Record<string, string[]>;
+
+  // volumeKey -> volume info
+  volumeInfo: Record<string, VolumeInfo>;
+
+  // parent pointers
+  // volumeKey -> studyKey
+  volumeStudy: Record<string, string>;
+  // studyKey -> patientKey
+  studyPatient: Record<string, string>;
+}
+
+export const useDICOMStore = defineStore('dicom', {
+  state: (): State => ({
+    sliceData: {},
+    volumeToImageID: {},
+    imageIDToVolumeKey: {},
+    patientInfo: {},
+    patientStudies: {},
+    studyInfo: {},
+    studyVolumes: {},
+    volumeInfo: {},
+    volumeStudy: {},
+    studyPatient: {},
+    needsRebuild: {},
+  }),
+  actions: {
+    async importFiles(files: File[]) {
+      const fileStore = useFileStore();
+
+      const dicomIO = this.$dicomIO;
+
+      if (!files.length) {
+        return [];
+      }
+
+      const nameToFileMap = new Map(files.map((f) => [f.name, f]));
+
+      const volumesToFilesMap = await dicomIO.categorizeFiles(files);
+      const updatedVolumeKeys: VolumeKeys[] = [];
+
+      await Promise.all(
+        Object.entries(volumesToFilesMap).map(
+          async ([volumeKey, fileNames]) => {
+            const volumeFiles: File[] = [];
+            fileNames.forEach((fileName) => {
+              const file = nameToFileMap.get(fileName);
+              if (file) {
+                volumeFiles.push(file);
+              }
+            });
+
+            // Add file entries to the file store
+            fileStore.add(volumeKey, volumeFiles);
+
+            // Now read the tags
+            const numberOfSlices = volumeFiles.length;
+
+            if (!(volumeKey in this.volumeInfo)) {
+              const info = await dicomIO.readTags(volumeFiles[0], [
+                { name: 'PatientName', tag: '0010|0010', strconv: true },
+                { name: 'PatientID', tag: '0010|0020', strconv: true },
+                { name: 'PatientBirthDate', tag: '0010|0030' },
+                { name: 'PatientSex', tag: '0010|0040' },
+                { name: 'StudyInstanceUID', tag: '0020|000d' },
+                { name: 'StudyDate', tag: '0008|0020' },
+                { name: 'StudyTime', tag: '0008|0030' },
+                { name: 'StudyID', tag: '0020|0010', strconv: true },
+                { name: 'AccessionNumber', tag: '0008|0050' },
+                { name: 'StudyDescription', tag: '0008|1030', strconv: true },
+                { name: 'Modality', tag: '0008|0060' },
+                { name: 'SeriesInstanceUID', tag: '0020|000e' },
+                { name: 'SeriesNumber', tag: '0020|0011' },
+                { name: 'SeriesDescription', tag: '0008|103e', strconv: true },
+              ]);
+
+              // TODO parse the raw string values
+              const patient = {
+                PatientID: info.PatientID || ANONYMOUS_PATIENT_ID,
+                PatientName: info.PatientName || ANONYMOUS_PATIENT,
+                PatientBirthDate: info.PatientBirthDate || '',
+                PatientSex: info.PatientSex || '',
+              };
+              const patientKey = genSynPatientKey(patient);
+
+              const studyKey = info.StudyInstanceUID;
+              const study = pick(
+                info,
+                'StudyID',
+                'StudyInstanceUID',
+                'StudyDate',
+                'StudyTime',
+                'AccessionNumber',
+                'StudyDescription'
+              );
+
+              const volumeInfo = {
+                ...pick(
+                  info,
+                  'Modality',
+                  'SeriesInstanceUID',
+                  'SeriesNumber',
+                  'SeriesDescription'
+                ),
+                NumberOfSlices: numberOfSlices,
+                VolumeID: volumeKey,
+              };
+
+              updatedVolumeKeys.push({
+                patientKey,
+                studyKey,
+                volumeKey,
+              });
+
+              this._updateDatabase(patient, study, volumeInfo);
+            }
+
+            // invalidate any existing volume
+            if (volumeKey in this.volumeToImageID) {
+              // buildVolume requestor uses this as a rebuild hint
+              set(this.needsRebuild, volumeKey, true);
+            }
+          }
+        )
+      );
+
+      return updatedVolumeKeys;
+    },
+
+    _updateDatabase(
+      patient: PatientInfo,
+      study: StudyInfo,
+      volume: VolumeInfo
+    ) {
+      const patientKey = patient.PatientID;
+      const studyKey = study.StudyInstanceUID;
+      const volumeKey = volume.VolumeID;
+
+      if (!(patientKey in this.patientInfo)) {
+        set(this.patientInfo, patientKey, patient);
+        set(this.patientStudies, patientKey, []);
+      }
+
+      if (!(studyKey in this.studyInfo)) {
+        set(this.studyInfo, studyKey, study);
+        set(this.studyVolumes, studyKey, []);
+        set(this.studyPatient, studyKey, patientKey);
+        this.patientStudies[patientKey].push(studyKey);
+      }
+
+      if (!(volumeKey in this.volumeInfo)) {
+        set(this.volumeInfo, volumeKey, volume);
+        set(this.volumeStudy, volumeKey, studyKey);
+        set(this.sliceData, volumeKey, {});
+        this.studyVolumes[studyKey].push(volumeKey);
+      }
+    },
+
+    deleteVolume(volumeKey: string) {
+      const imageStore = useImageStore();
+      if (volumeKey in this.volumeInfo) {
+        const studyKey = this.volumeStudy[volumeKey];
+        del(this.volumeInfo, volumeKey);
+        del(this.sliceData, volumeKey);
+        del(this.volumeStudy, volumeKey);
+
+        if (volumeKey in this.volumeToImageID) {
+          const imageID = this.volumeToImageID[volumeKey];
+          imageStore.deleteData(imageID);
+          del(this.volumeToImageID, volumeKey);
+          del(this.imageIDToVolumeKey, imageID);
+        }
+
+        removeFromArray(this.studyVolumes[studyKey], volumeKey);
+        if (this.studyVolumes[studyKey].length === 0) {
+          this.deleteStudy(studyKey);
+        }
+      }
+    },
+
+    deleteStudy(studyKey: string) {
+      if (studyKey in this.studyInfo) {
+        const patientKey = this.studyPatient[studyKey];
+        del(this.studyInfo, studyKey);
+        del(this.studyPatient, studyKey);
+
+        [...this.studyVolumes[studyKey]].forEach((volumeKey) =>
+          this.deleteVolume(volumeKey)
+        );
+        del(this.studyVolumes, studyKey);
+
+        removeFromArray(this.patientStudies[patientKey], studyKey);
+        if (this.patientStudies[patientKey].length === 0) {
+          this.deletePatient(patientKey);
+        }
+      }
+    },
+
+    deletePatient(patientKey: string) {
+      if (patientKey in this.patientInfo) {
+        del(this.patientInfo, patientKey);
+
+        [...this.patientStudies[patientKey]].forEach((studyKey) =>
+          this.deleteStudy(studyKey)
+        );
+        del(this.patientStudies, patientKey);
+      }
+    },
+
+    async serialize(stateFile: StateFile) {
+      const dataIDs = Object.keys(this.volumeInfo);
+      await serializeData(stateFile, dataIDs, DataSetType.DICOM);
+    },
+
+    async deserialize(dataSet: DataSet, files: File[]) {
+      return this.importFiles(files).then((volumeKeys) => {
+        if (volumeKeys.length !== 1) {
+          // Volumes are store individually so we should get one back.
+          throw new Error('Invalid state file.');
+        }
+
+        return volumeKeys[0].volumeKey;
+      });
+    },
+
+    // returns an ITK image object
+    async getVolumeSlice(
+      volumeKey: string,
+      sliceIndex: number,
+      asThumbnail = false
+    ) {
+      const dicomIO = this.$dicomIO;
+      const fileStore = useFileStore();
+
+      const cacheKey = imageCacheMultiKey(sliceIndex, asThumbnail);
+      if (
+        volumeKey in this.sliceData &&
+        cacheKey in this.sliceData[volumeKey]
+      ) {
+        return this.sliceData[volumeKey][cacheKey];
+      }
+
+      if (!(volumeKey in this.volumeInfo)) {
+        throw new Error(`Cannot find given volume key: ${volumeKey}`);
+      }
+      const volumeInfo = this.volumeInfo[volumeKey];
+      const numSlices = volumeInfo.NumberOfSlices;
+
+      if (sliceIndex < 1 || sliceIndex > numSlices) {
+        throw new Error(`Slice ${sliceIndex} is out of bounds`);
+      }
+
+      const volumeFiles = fileStore.getFiles(volumeKey);
+
+      if (!volumeFiles) {
+        throw new Error(`No files found for volume key: ${volumeKey}`);
+      }
+
+      const sliceFile = volumeFiles[sliceIndex - 1];
+
+      const itkImage = dicomIO.getVolumeSlice(sliceFile, asThumbnail);
+
+      set(this.sliceData[volumeKey], cacheKey, itkImage);
+      return itkImage;
+    },
+
+    async buildVolume(volumeKey: string, forceRebuild: boolean = false) {
+      const imageStore = useImageStore();
+      const fileStore = useFileStore();
+      const dicomIO = this.$dicomIO;
+
+      const rebuild = forceRebuild || this.needsRebuild[volumeKey];
+
+      if (!rebuild && volumeKey in this.volumeToImageID) {
+        return imageStore.dataIndex[this.volumeToImageID[volumeKey]];
+      }
+
+      if (!(volumeKey in this.volumeInfo)) {
+        throw new Error(`Cannot find given volume key: ${volumeKey}`);
+      }
+
+      const volumeFiles = fileStore.getFiles(volumeKey);
+      if (!volumeFiles) {
+        throw new Error(`No files found for volume key: ${volumeKey}`);
+      }
+
+      const itkImage = await dicomIO.buildVolume(volumeFiles);
+      const vtkImage: vtkImageData =
+        vtkITKHelper.convertItkToVtkImage(itkImage);
+
+      if (volumeKey in this.volumeToImageID) {
+        const imageID = this.volumeToImageID[volumeKey];
+        imageStore.updateData(imageID, vtkImage);
+      } else {
+        const name = this.volumeInfo[volumeKey].SeriesInstanceUID;
+        const imageID = imageStore.addVTKImageData(name, vtkImage);
+        set(this.volumeToImageID, volumeKey, imageID);
+        set(this.imageIDToVolumeKey, imageID, volumeKey);
+      }
+
+      del(this.needsRebuild, volumeKey);
+
+      return vtkImage;
+    },
+  },
+});

package/src/store/datasets-files.ts

@@ -0,0 +1,35 @@
+import { del, set } from '@vue/composition-api';
+import { defineStore } from 'pinia';
+
+interface State {
+  byDataID: Record<string, File[]>;
+}
+
+/**
+ * Store the File objects associated with a given dataset.
+ */
+export const useFileStore = defineStore('files', {
+  state: (): State => ({
+    byDataID: {},
+  }),
+  getters: {
+    getFiles: (state) => {
+      return (dataID: string) => {
+        if (dataID in state.byDataID) {
+          return state.byDataID[dataID];
+        }
+        return null;
+      };
+    },
+  },
+  actions: {
+    remove(dataID: string) {
+      if (dataID in this.byDataID) {
+        del(this.byDataID, dataID);
+      }
+    },
+    add(dataID: string, files: File[]) {
+      set(this.byDataID, dataID, files);
+    },
+  },
+});