volview 4.0.0

package/src/store/datasets-images.ts

@@ -0,0 +1,118 @@
+import { del, set } from '@vue/composition-api';
+import { defineStore } from 'pinia';
+import { vec3, mat3, mat4 } from 'gl-matrix';
+import { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { Bounds } from '@kitware/vtk.js/types';
+
+import { defaultLPSDirections, getLPSDirections } from '../utils/lps';
+import { removeFromArray } from '../utils';
+import { StateFile, DataSetType, DataSet } from '../io/state-file/schema';
+import { serializeData } from '../io/state-file/utils';
+import { FILE_READERS } from '../io';
+import { useFileStore } from './datasets-files';
+import { LPSDirections } from '../types/lps';
+
+export interface ImageMetadata {
+  name: string;
+  orientation: mat3;
+  lpsOrientation: LPSDirections;
+  spacing: vec3;
+  origin: vec3;
+  dimensions: vec3;
+  worldBounds: Bounds;
+  worldToIndex: mat4;
+  indexToWorld: mat4;
+}
+
+export const defaultImageMetadata = () => ({
+  name: '(none)',
+  orientation: mat3.create(),
+  lpsOrientation: defaultLPSDirections(),
+  spacing: vec3.fromValues(1, 1, 1),
+  origin: vec3.create(),
+  dimensions: vec3.fromValues(1, 1, 1),
+  worldBounds: [0, 1, 0, 1, 0, 1] as Bounds,
+  worldToIndex: mat4.create(),
+  indexToWorld: mat4.create(),
+});
+
+interface State {
+  idList: string[]; // list of IDs
+  dataIndex: Record<string, vtkImageData>; // ID -> VTK object
+  metadata: Record<string, ImageMetadata>; // ID -> metadata
+}
+
+export const useImageStore = defineStore('images', {
+  state: (): State => ({
+    idList: [],
+    dataIndex: Object.create(null),
+    metadata: Object.create(null),
+  }),
+  actions: {
+    addVTKImageData(name: string, imageData: vtkImageData) {
+      const id = this.$id.nextID();
+
+      this.idList.push(id);
+      set(this.dataIndex, id, imageData);
+
+      this.$proxies.addData(id, imageData);
+
+      set(this.metadata, id, { ...defaultImageMetadata(), name });
+      this.updateData(id, imageData);
+      return id;
+    },
+
+    updateData(id: string, imageData: vtkImageData) {
+      if (id in this.metadata) {
+        const metadata: ImageMetadata = {
+          name: this.metadata[id].name,
+          dimensions: imageData.getDimensions() as vec3,
+          spacing: imageData.getSpacing() as vec3,
+          origin: imageData.getOrigin() as vec3,
+          orientation: imageData.getDirection(),
+          lpsOrientation: getLPSDirections(imageData.getDirection()),
+          worldBounds: imageData.getBounds(),
+          worldToIndex: imageData.getWorldToIndex(),
+          indexToWorld: imageData.getIndexToWorld(),
+        };
+
+        set(this.metadata, id, metadata);
+      }
+    },
+
+    deleteData(id: string) {
+      if (id in this.dataIndex) {
+        del(this.dataIndex, id);
+        del(this.metadata, id);
+        removeFromArray(this.idList, id);
+      }
+    },
+
+    async serialize(stateFile: StateFile) {
+      const fileStore = useFileStore();
+      // We want to filter out volume data (which is generated so don't have
+      // associated files).
+      const dataIDs = this.idList.filter((id) => {
+        return id in fileStore.byDataID;
+      });
+
+      await serializeData(stateFile, dataIDs, DataSetType.IMAGE);
+    },
+
+    async deserialize(dataSet: DataSet, file: File) {
+      const reader = FILE_READERS.get(file.type);
+      if (reader) {
+        const dataObj = await reader(
+          new File([file], file.name, { type: file.type })
+        );
+        if (dataObj.isA('vtkImageData')) {
+          const id = this.addVTKImageData(file.name, dataObj as vtkImageData);
+
+          return id;
+        }
+      }
+
+      throw new Error(`No reader for ${file.name}`);
+    },
+  },
+});

package/src/store/datasets-labelmaps.ts

@@ -0,0 +1,136 @@
+import { set } from '@vue/composition-api';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { defineStore } from 'pinia';
+import { useImageStore } from '@/src/store/datasets-images';
+import vtkLabelMap from '../vtk/LabelMap';
+import { LABELMAP_PALETTE } from '../config';
+import { StateFile, Manifest } from '../io/state-file/schema';
+import { vtiReader, vtiWriter } from '../io/vtk/async';
+import { FileEntry } from '../io/types';
+
+const LabelmapArrayType = Uint8Array;
+export type LabelmapArrayType = Uint8Array;
+
+interface State {
+  idList: string[];
+  labelmaps: Record<string, vtkLabelMap>;
+  parentImage: Record<string, string>;
+}
+
+function createLabelmapFromImage(imageData: vtkImageData) {
+  const points = new LabelmapArrayType(imageData.getNumberOfPoints());
+  const labelmap = vtkLabelMap.newInstance(
+    imageData.get('spacing', 'origin', 'direction')
+  );
+  labelmap.getPointData().setScalars(
+    vtkDataArray.newInstance({
+      numberOfComponents: 1,
+      values: points,
+    })
+  );
+  labelmap.setDimensions(imageData.getDimensions());
+  labelmap.computeTransforms();
+  labelmap.setColorMap(LABELMAP_PALETTE);
+
+  return labelmap;
+}
+
+function toLabelMap(imageData: vtkImageData) {
+  const labelmap = vtkLabelMap.newInstance(
+    imageData.get(
+      'spacing',
+      'origin',
+      'direction',
+      'indexToWorld',
+      'worldToIndex',
+      'dataDescription',
+      'pointData'
+    )
+  );
+  labelmap.setDimensions(imageData.getDimensions());
+  labelmap.computeTransforms();
+  labelmap.setColorMap(LABELMAP_PALETTE);
+
+  return labelmap;
+}
+
+export const useLabelmapStore = defineStore('labelmap', {
+  state: (): State => ({
+    idList: [],
+    labelmaps: Object.create(null),
+    parentImage: Object.create(null),
+  }),
+  actions: {
+    newLabelmapFromImage(imageID: string) {
+      const imageStore = useImageStore();
+      const imageData = imageStore.dataIndex[imageID];
+      if (!imageData) {
+        return null;
+      }
+
+      const id = this.$id.nextID();
+      const labelmap = createLabelmapFromImage(imageData);
+
+      this.idList.push(id);
+      set(this.parentImage, id, imageID);
+      set(this.labelmaps, id, labelmap);
+
+      this.$proxies.addData(id, labelmap);
+
+      return id;
+    },
+    async serialize(state: StateFile) {
+      const { labelMaps } = state.manifest;
+      const { zip } = state;
+
+      await Promise.all(
+        Object.entries(this.labelmaps).map(async ([id, labelMap]) => {
+          const labelPath = `labels/${id}.vti`;
+          const parent = this.parentImage[id];
+          labelMaps.push({
+            id,
+            parent,
+            path: labelPath,
+          });
+
+          const serializedData = await vtiWriter(labelMap);
+          zip.file(labelPath, serializedData);
+        })
+      );
+    },
+    async deserialize(
+      manifest: Manifest,
+      stateFiles: FileEntry[],
+      dataIDMap: Record<string, string>
+    ) {
+      const { labelMaps } = manifest;
+
+      const labelmapIDMap: Record<string, string> = {};
+
+      labelMaps.forEach(async (labelMap) => {
+        const [file] = stateFiles
+          .filter(
+            (entry) => `${entry.path}${entry.file.name}` === labelMap.path
+          )
+          .map((entry) => entry.file);
+
+        // map parent id to new id
+        labelMap.parent = dataIDMap[labelMap.parent];
+
+        const { parent } = labelMap;
+        const id = this.$id.nextID();
+        labelmapIDMap[labelMap.id] = id;
+
+        const imageData = await vtiReader(file);
+        const labelMapObj = toLabelMap(imageData as vtkImageData);
+        this.idList.push(id);
+        set(this.parentImage, id, parent);
+        set(this.labelmaps, id, labelMapObj);
+        this.$proxies.addData(id, labelMapObj);
+      });
+
+      return labelmapIDMap;
+    },
+  },
+});

package/src/store/datasets-models.ts

@@ -0,0 +1,25 @@
+import { defineStore } from 'pinia';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import { set } from '@vue/composition-api';
+
+interface State {
+  idList: string[]; // list of IDs
+  dataIndex: Record<string, vtkPolyData>; // ID -> VTK object
+  metadata: Record<string, {}>; // ID -> metadata
+}
+export const useModelStore = defineStore('models', {
+  state: (): State => ({
+    idList: [],
+    dataIndex: {},
+    metadata: {},
+  }),
+  actions: {
+    addVTKPolyData(name: string, polyData: vtkPolyData) {
+      const id = this.$id.nextID();
+      this.idList.push(id);
+      set(this.dataIndex, id, polyData);
+      this.$proxies.addData(id, polyData);
+      return id;
+    },
+  },
+});

package/src/store/datasets.ts

@@ -0,0 +1,341 @@
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { vtkObject } from '@kitware/vtk.js/interfaces';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import { defineStore } from 'pinia';
+import { computed, ref } from '@vue/composition-api';
+import { useDICOMStore } from './datasets-dicom';
+import { useImageStore } from './datasets-images';
+import { useModelStore } from './datasets-models';
+import { extractArchivesRecursively, retypeFile, FILE_READERS } from '../io';
+import { useFileStore } from './datasets-files';
+import { DataSet, StateFile, DataSetType } from '../io/state-file/schema';
+import { useMessageStore } from './messages';
+import { readRemoteManifestFile } from '../io/manifest';
+
+export const DataType = {
+  Image: 'Image',
+  Model: 'Model',
+};
+
+const makeFileSuccessStatus = (
+  file: File,
+  type: 'model' | 'image',
+  dataID: string
+) =>
+  ({
+    type: 'file',
+    loaded: true,
+    filename: file.name,
+    dataID,
+    dataType: type,
+  } as const);
+
+export type FileLoadSuccess = ReturnType<typeof makeFileSuccessStatus>;
+
+export const makeFileFailureStatus = (file: File | string, reason: string) =>
+  ({
+    type: 'file',
+    loaded: false,
+    filename: typeof file === 'string' ? file : file.name,
+    error: new Error(reason),
+  } as const);
+
+export type FileLoadFailure = ReturnType<typeof makeFileFailureStatus>;
+
+const makeDICOMSuccessStatus = (volumeKey: string) =>
+  ({
+    type: 'dicom',
+    loaded: true,
+    dataID: volumeKey,
+    dataType: 'dicom',
+  } as const);
+
+export type DICOMLoadSuccess = ReturnType<typeof makeDICOMSuccessStatus>;
+
+const makeDICOMFailureStatus = (error: Error) =>
+  ({
+    type: 'dicom',
+    loaded: false,
+    error,
+  } as const);
+
+export type DICOMLoadFailure = ReturnType<typeof makeDICOMFailureStatus>;
+
+export type FileLoadResult = FileLoadSuccess | FileLoadFailure;
+export type DICOMLoadResult = DICOMLoadSuccess | DICOMLoadFailure;
+export type LoadResult = FileLoadResult | DICOMLoadResult;
+
+export const makeDICOMSelection = (volumeKey: string) =>
+  ({
+    type: 'dicom',
+    volumeKey,
+  } as const);
+
+export type DICOMSelection = ReturnType<typeof makeDICOMSelection>;
+
+export const makeImageSelection = (imageID: string) =>
+  ({
+    type: 'image',
+    dataID: imageID,
+  } as const);
+
+export type ImageSelection = ReturnType<typeof makeImageSelection>;
+
+export type DataSelection = DICOMSelection | ImageSelection;
+
+export function selectionEquals(s1: DataSelection, s2: DataSelection) {
+  if (s1.type === 'dicom' && s2.type === 'dicom') {
+    return s1.volumeKey === s2.volumeKey;
+  }
+  if (s1.type === 'image' && s2.type === 'image') {
+    return s1.dataID === s2.dataID;
+  }
+  return false;
+}
+
+export function convertSuccessResultToDataSelection(
+  result: FileLoadSuccess | DICOMLoadSuccess
+) {
+  if (result.type === 'dicom') {
+    return makeDICOMSelection(result.dataID);
+  }
+  if (result.type === 'file') {
+    if (result.dataType === 'image') {
+      return makeImageSelection(result.dataID);
+    }
+  }
+  return null;
+}
+
+export const useDatasetStore = defineStore('dataset', () => {
+  type _This = ReturnType<typeof useDatasetStore>;
+
+  const imageStore = useImageStore();
+  const modelStore = useModelStore();
+  const dicomStore = useDICOMStore();
+  const fileStore = useFileStore();
+
+  // --- state --- //
+
+  const primarySelection = ref<DataSelection | null>(null);
+
+  // --- getters --- //
+
+  const primaryDataset = computed<vtkImageData | null>(() => {
+    const sel = primarySelection.value;
+    const { dataIndex } = imageStore;
+    const { volumeToImageID } = dicomStore;
+
+    if (sel?.type === 'dicom') {
+      const id = volumeToImageID[sel.volumeKey];
+      return dataIndex[id] || null;
+    }
+    if (sel?.type === 'image') {
+      return dataIndex[sel.dataID] || null;
+    }
+    return null;
+  });
+
+  const allDataIDs = computed(() => {
+    return [...imageStore.idList, ...modelStore.idList];
+  });
+
+  function getDataProxyByID<T extends vtkObject>(this: _This, id: string) {
+    return this.$proxies.getData<T>(id);
+  }
+
+  // --- actions --- //
+
+  async function setPrimarySelection(sel: DataSelection | null) {
+    primarySelection.value = sel;
+
+    if (sel === null) {
+      return;
+    }
+
+    // if selection is dicom, call buildVolume
+    if (sel.type === 'dicom') {
+      try {
+        // trigger dicom dataset building
+        await dicomStore.buildVolume(sel.volumeKey);
+      } catch (err) {
+        if (err instanceof Error) {
+          const messageStore = useMessageStore();
+          messageStore.addError('Failed to build volume(s)', {
+            details: `${err}. More details can be found in the developer's console.`,
+          });
+        }
+      }
+    }
+  }
+
+  async function loadFiles(files: File[]): Promise<LoadResult[]> {
+    let allFiles = await Promise.all(files.map((f) => retypeFile(f)));
+
+    // process any json manifests
+    const manifestFiles = allFiles.filter((file) => file.type === 'json');
+    allFiles = allFiles.filter((file) => file.type !== 'json');
+
+    const manifestStatuses: FileLoadResult[] = [];
+    if (manifestFiles.length) {
+      await Promise.all(
+        manifestFiles.map(async (file) => {
+          try {
+            allFiles.push(...(await readRemoteManifestFile(file)));
+          } catch (err) {
+            manifestStatuses.push(
+              makeFileFailureStatus(
+                file,
+                'Failed to parse or download manifest'
+              )
+            );
+          }
+        })
+      );
+    }
+
+    // process archives
+    const fileEntries = await extractArchivesRecursively(allFiles);
+    allFiles = fileEntries.map((entry) => entry.file);
+
+    const dicoms = allFiles.filter(({ type }) => type === 'dcm');
+    const otherFiles = allFiles.filter(({ type }) => type !== 'dcm');
+
+    const dicomStatus = dicomStore
+      .importFiles(dicoms)
+      .then((volumeKeys) =>
+        volumeKeys.map((volKey) => makeDICOMSuccessStatus(volKey.volumeKey))
+      )
+      .catch((err) => [makeDICOMFailureStatus(err)]);
+
+    const otherStatuses = Promise.all([
+      ...otherFiles.map(async (file) => {
+        const reader = FILE_READERS.get(file.type);
+        if (reader) {
+          try {
+            const dataObj = await reader(file);
+            if (dataObj.isA('vtkImageData')) {
+              const id = imageStore.addVTKImageData(
+                file.name,
+                dataObj as vtkImageData
+              );
+              fileStore.add(id, [file]);
+
+              return makeFileSuccessStatus(file, 'image', id);
+            }
+            if (dataObj.isA('vtkPolyData')) {
+              const id = modelStore.addVTKPolyData(
+                file.name,
+                dataObj as vtkPolyData
+              );
+              fileStore.add(id, [file]);
+
+              return makeFileSuccessStatus(file, 'model', id);
+            }
+            return makeFileFailureStatus(
+              file,
+              `${file.name} did not result in a valid dataset`
+            );
+          } catch (e) {
+            return makeFileFailureStatus(
+              file,
+              `Reading ${file.name} gave an error: ${e}`
+            );
+          }
+        }
+        // indicate an error has occurred
+        return makeFileFailureStatus(file, `No reader for ${file.name}`);
+      }),
+    ]);
+
+    const statuses = [...(await dicomStatus), ...(await otherStatuses)];
+    return statuses;
+  }
+
+  async function serialize(stateFile: StateFile) {
+    await dicomStore.serialize(stateFile);
+    await imageStore.serialize(stateFile);
+
+    if (primarySelection.value !== null) {
+      let id = null;
+      if (primarySelection.value.type === 'dicom') {
+        id = primarySelection.value.volumeKey;
+      } else {
+        id = primarySelection.value.dataID;
+      }
+
+      const { manifest } = stateFile;
+      manifest.primarySelection = id;
+    }
+  }
+
+  async function deserialize(dataSet: DataSet, files: File[]) {
+    // dicom
+    if (dataSet.type === DataSetType.DICOM) {
+      return dicomStore
+        .deserialize(dataSet, files)
+        .then((volumeKey) => makeDICOMSuccessStatus(volumeKey))
+        .catch((err) => makeDICOMFailureStatus(err));
+    }
+
+    // image
+    if (files.length !== 1) {
+      throw new Error('Invalid state file.');
+    }
+    const file = files[0];
+
+    return imageStore
+      .deserialize(dataSet, file)
+      .then((dataID) => makeFileSuccessStatus(file, 'image', dataID))
+      .catch((err) =>
+        makeFileFailureStatus(
+          file.name,
+          `Reading ${file.name} gave an error: ${err}`
+        )
+      );
+  }
+
+  // --- watch for deletion --- //
+
+  imageStore.$onAction(({ name, args, after }) => {
+    if (name !== 'deleteData') {
+      return;
+    }
+    after(() => {
+      const [id] = args;
+      const sel = primarySelection.value;
+      if (sel?.type === 'image' && sel.dataID === id) {
+        primarySelection.value = null;
+      }
+      // remove file store entry
+      fileStore.remove(id);
+    });
+  });
+
+  dicomStore.$onAction(({ name, args, after }) => {
+    if (name !== 'deleteVolume') {
+      return;
+    }
+    after(() => {
+      const [volumeKey] = args;
+      const sel = primarySelection.value;
+      if (sel?.type === 'dicom' && volumeKey === sel.volumeKey) {
+        primarySelection.value = null;
+      }
+
+      // remove file store entry
+      fileStore.remove(volumeKey);
+    });
+  });
+
+  return {
+    primarySelection,
+    primaryDataset,
+    allDataIDs,
+    getDataProxyByID,
+    setPrimarySelection,
+    loadFiles,
+    serialize,
+    deserialize,
+  };
+});