volview 4.0.0 → 4.0.1

package/src/store/datasets-images.ts

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

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

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

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