volview 4.0.0 → 4.0.1

package/src/shims-vue.d.ts

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

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

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

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

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

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

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

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