larvitar 1.5.14 → 2.0.2

package/imaging/loaders/{multiframeLoader.js → multiframeLoader.ts}

@@ -1,5 +1,5 @@
 /** @module loaders/multiframeLoader
- *  @desc This file is a custom wado loader for multiframe images
+ *  @desc This file is a custom DICOM loader for multiframe images
  */
 
 // external libraries
@@ -13,13 +13,20 @@ import {
   getLarvitarManager
 } from "./commonLoader";
 import { parseDataSet } from "../imageParsing";
+import type {
+  Image,
+  ImageFrame,
+  LarvitarManager,
+  MetaData,
+  Series
+} from "../types";
 
 // global module variables
 let customImageLoaderCounter = 0;
 
 // Local cache used to store multiframe datasets to avoid reading and parsing
 // the whole file to show a single frame.
-let multiframeDatasetCache = null;
+let multiframeDatasetCache: { [key: string]: Series | null } | null = null;
 /*
  * This module provides the following functions to be exported:
  * loadMultiFrameImage(elementId)
@@ -35,25 +42,26 @@ let multiframeDatasetCache = null;
  * @param {String} imageId - ImageId tag
  * @returns {Function} Custom Image Creation Function
  */
-export const loadMultiFrameImage = function (imageId) {
+export const loadMultiFrameImage = function (imageId: string) {
   let parsedImageId = cornerstoneDICOMImageLoader.wadouri.parseImageId(imageId);
   let rootImageId = parsedImageId.scheme + ":" + parsedImageId.url;
   let imageTracker = getLarvitarImageTracker();
   let seriesId = imageTracker[rootImageId];
-  let manager = getLarvitarManager();
+  let manager = getLarvitarManager() as LarvitarManager;
   if (multiframeDatasetCache === null) {
     multiframeDatasetCache = {};
   }
+
   if (multiframeDatasetCache[rootImageId]) {
     multiframeDatasetCache[rootImageId] = multiframeDatasetCache[rootImageId];
   } else if (manager) {
-    multiframeDatasetCache[rootImageId] = manager[seriesId];
+    multiframeDatasetCache[rootImageId] = manager[seriesId] as Series;
   } else {
     throw new Error("No multiframe dataset found for seriesId: " + seriesId);
   }
 
   let metadata =
-    multiframeDatasetCache[rootImageId].instances[imageId].metadata;
+    multiframeDatasetCache[rootImageId]?.instances[imageId].metadata;
   return createCustomImage(rootImageId, imageId, parsedImageId.frame, metadata);
 };
 
@@ -64,65 +72,66 @@ export const loadMultiFrameImage = function (imageId) {
  * @param {String} seriesId - SeriesId tag
  * @param {Object} serie - parsed serie object
  */
-export const buildMultiFrameImage = function (seriesId, serie) {
+export const buildMultiFrameImage = function (seriesId: string, serie: Series) {
   let t0 = performance.now();
   let manager = getLarvitarManager();
   let imageTracker = getLarvitarImageTracker();
-  let numberOfFrames =
-    serie.instances[serie.imageIds[0]].metadata.numberOfFrames;
-  let frameTime = serie.instances[serie.imageIds[0]].metadata.frameTime;
-  let frameDelay = serie.instances[serie.imageIds[0]].metadata.frameDelay
-    ? serie.instances[serie.imageIds[0]].metadata.frameDelay
-    : 0;
-
-  each(serie.imageIds, function (instanceId) {
-    let dataSet = serie.instances[instanceId].dataSet;
-    let metadata = serie.instances[instanceId].metadata;
-    let imageId = getMultiFrameImageId("multiFrameLoader");
-    imageTracker[imageId] = seriesId;
-
-    // check if manager exists for this seriesId
-    if (!manager[seriesId]) {
-      manager[seriesId] = serie;
-      manager[seriesId].imageIds = [];
-      manager[seriesId].instances = {};
-    }
-
-    each(range(numberOfFrames), function (frameNumber) {
-      let frameImageId = imageId + "?frame=" + frameNumber;
-      // EXTRACT MULTIFRAME METADATA (x52009230) Per-frame Functional Groups Sequence
-      let frameMetadata = { ...metadata };
+  let numberOfFrames = serie.metadata!.numberOfFrames!;
+  let frameTime = serie.metadata!.frameTime;
+  let frameDelay = serie.metadata!.frameDelay ? serie.metadata!.frameDelay : 0;
+  let rWaveTimeVector = serie.metadata!.rWaveTimeVector;
+  let sopInstanceUID = serie.metadata!["x00080018"] as string;
+  let dataSet = serie.dataSet;
+  let imageId = getMultiFrameImageId("multiFrameLoader");
+  imageTracker[imageId] = seriesId;
+
+  // check if manager exists for this seriesId
+  if (!manager[seriesId]) {
+    manager[seriesId] = serie;
+    manager[seriesId].imageIds = [];
+    manager[seriesId].instances = {};
+  }
 
-      parseDataSet(dataSet, frameMetadata, {
-        tags: ["x52009230"],
-        frameId: frameNumber
-      });
+  each(range(numberOfFrames as number), function (frameNumber) {
+    let frameImageId = imageId + "?frame=" + frameNumber;
+    // EXTRACT MULTIFRAME METADATA (x52009230) Per-frame Functional Groups Sequence
+    let frameMetadata = { ...serie.metadata! };
 
-      // store file references
-      manager[seriesId].seriesUID = seriesId;
-      manager[seriesId].studyUID = metadata["x0020000d"];
-      manager[seriesId].modality = metadata["x00080060"];
-      manager[seriesId].color = cornerstoneDICOMImageLoader.isColorImage(
-        metadata["x00280004"]
-      );
-      manager[seriesId].isMultiframe = true;
-      manager[seriesId].currentImageIdIndex = 0;
-      manager[seriesId].numberOfFrames = numberOfFrames;
-      manager[seriesId].frameTime = frameTime;
-      manager[seriesId].frameDelay = frameDelay;
-      manager[seriesId].numberOfImages = undefined;
-      manager[seriesId].bytes = serie.bytes;
-      manager[seriesId].imageIds.push(frameImageId);
-      manager[seriesId].instances[frameImageId] = {
-        instanceId: instanceId,
-        frame: frameNumber,
-        metadata: frameMetadata
-      };
-      manager[seriesId].dataSet = dataSet;
-      manager[seriesId].seriesDescription =
-        serie.instances[serie.imageIds[0]].metadata.seriesDescription;
+    parseDataSet(dataSet!, frameMetadata, {
+      tags: ["x52009230"],
+      frameId: frameNumber
     });
+
+    // TODO-ts REMOVE "AS" WHEN METADATA VALUES ARE TYPED
+    // store file references
+    const managerSeriesId = manager[seriesId] as Series;
+    managerSeriesId.seriesUID = seriesId;
+    managerSeriesId.studyUID = serie.metadata!["x0020000d"] as string;
+    managerSeriesId.modality = serie.metadata!["x00080060"] as string;
+    managerSeriesId.color = cornerstoneDICOMImageLoader.isColorImage(
+      serie.metadata!["x00280004"]
+    );
+
+    managerSeriesId.isMultiframe = true;
+    managerSeriesId.currentImageIdIndex = 0;
+    managerSeriesId.numberOfFrames = numberOfFrames;
+    managerSeriesId.frameTime = frameTime;
+    managerSeriesId.frameDelay = frameDelay;
+    managerSeriesId.rWaveTimeVector = rWaveTimeVector;
+    managerSeriesId.numberOfImages = undefined;
+    managerSeriesId.bytes = serie.bytes;
+    managerSeriesId.imageIds.push(frameImageId);
+    managerSeriesId.instanceUIDs[sopInstanceUID] = imageId;
+    managerSeriesId.instances[frameImageId] = {
+      instanceId: sopInstanceUID,
+      frame: frameNumber,
+      metadata: frameMetadata
+    };
+    managerSeriesId.dataSet = dataSet || null;
+    managerSeriesId.seriesDescription = serie.metadata!
+      .seriesDescription as string;
   });
+
   let t1 = performance.now();
   console.log(`Call to buildMultiFrameImage took ${t1 - t0} milliseconds.`);
 };
@@ -134,7 +143,7 @@ export const buildMultiFrameImage = function (seriesId, serie) {
  * @param {String} customLoaderName The custom loader name
  * @return {String} the custom image id
  */
-export const getMultiFrameImageId = function (customLoaderName) {
+export const getMultiFrameImageId = function (customLoaderName: string) {
   let imageId = customLoaderName + "://" + customImageLoaderCounter;
   customImageLoaderCounter++;
   return imageId;
@@ -146,20 +155,26 @@ export const getMultiFrameImageId = function (customLoaderName) {
  * @function clearMultiFrameCache
  * @param {String} seriesId - SeriesId tag
  */
-export const clearMultiFrameCache = function (seriesId) {
+export const clearMultiFrameCache = function (seriesId: string) {
   each(multiframeDatasetCache, function (image, imageId) {
+    if (!image) {
+      return;
+    }
     if (seriesId == image.seriesUID || !seriesId) {
       if (image.dataSet) {
+        // @ts-ignore: modify external type ?
         image.dataSet.byteArray = null;
       }
       image.dataSet = null;
       image.elements = null;
       each(image.instances, function (instance) {
+        // @ts-ignore: is needed to clear the cache ?
         instance.metadata = null;
       });
+      // @ts-ignore: is needed to clear the cache ?
       image.instances = null;
-      multiframeDatasetCache[imageId] = null;
-      delete multiframeDatasetCache[imageId];
+      multiframeDatasetCache![imageId] = null;
+      delete multiframeDatasetCache![imageId];
     }
   });
   if (!seriesId) {
@@ -179,8 +194,13 @@ export const clearMultiFrameCache = function (seriesId) {
  * @param {Object} dataSet dataset object
  * @returns {Object} custom image object
  */
-let createCustomImage = function (id, imageId, frameIndex, metadata) {
-  let options = {};
+let createCustomImage = function (
+  id: string,
+  imageId: string,
+  frameIndex: number,
+  metadata?: MetaData
+) {
+  let options: { [key: string]: any } = {}; //TODO-ts change any to proper type when available
   // always preScale the pixel array unless it is asked not to
   options.preScale = {
     enabled:
@@ -189,10 +209,20 @@ let createCustomImage = function (id, imageId, frameIndex, metadata) {
         : false
   };
 
-  let dataSet = multiframeDatasetCache[id].dataSet;
+  if (multiframeDatasetCache === null || !multiframeDatasetCache[id]) {
+    throw new Error("No multiframe dataset found for id: " + id);
+  }
+
+  let dataSet = (multiframeDatasetCache as { [key: string]: Series })[id]
+    .dataSet;
+
+  if (!dataSet) {
+    throw new Error("No dataset found for id: " + id);
+  }
+
   let pixelDataElement = dataSet.elements.x7fe00010;
   // Extract pixelData of the required frame
-  let pixelData;
+  let pixelData: number[];
   try {
     if (pixelDataElement.encapsulatedPixelData) {
       pixelData = cornerstoneDICOMImageLoader.wadouri.getEncapsulatedImageFrame(
@@ -206,14 +236,17 @@ let createCustomImage = function (id, imageId, frameIndex, metadata) {
       );
     }
   } catch (error) {
-    console.error(error);
+    throw new Error("No pixel data for id: " + id);
+  }
+
+  if (!metadata) {
+    throw new Error("No metadata for id: " + id);
   }
 
   let imageFrame = getImageFrame(metadata, dataSet);
   let transferSyntax = dataSet.string("x00020010");
 
   let canvas = window.document.createElement("canvas");
-
   // Get the scaling parameters from the metadata
   if (options.preScale.enabled) {
     const scalingParameters = cornerstoneDICOMImageLoader.getScalingParameters(
@@ -237,8 +270,8 @@ let createCustomImage = function (id, imageId, frameIndex, metadata) {
     options
   );
 
-  let promise = new Promise((resolve, reject) => {
-    decodePromise.then(function handleDecodeResponse(imageFrame) {
+  let promise: Promise<Image> = new Promise((resolve, reject) => {
+    decodePromise.then(function handleDecodeResponse(imageFrame: ImageFrame) {
       // This function uses the pixelData received as argument without manipulating
       // them: if the image is compressed, the decompress function should be called
       // before creating the custom image object (like the multiframe case).
@@ -260,35 +293,43 @@ let createCustomImage = function (id, imageId, frameIndex, metadata) {
         );
       }
 
-      let image = {
+      let image: Partial<Image> = {
         imageId: imageId,
         color: cornerstoneDICOMImageLoader.isColorImage(
           imageFrame.photometricInterpretation
         ),
-        columnPixelSpacing: pixelSpacing[1] ? pixelSpacing[1] : pixelSpacing, // check for specific spacing value
+        columnPixelSpacing: (pixelSpacing as number[])[1]
+          ? (pixelSpacing as number[])[1]
+          : (pixelSpacing as number), // check for specific spacing value
         columns: imageFrame.columns,
-        data: dataSet,
+        data: dataSet ? dataSet : undefined,
         height: imageFrame.rows,
         floatPixelData: undefined,
-        intercept: rescaleIntercept ? rescaleIntercept : 0,
+        intercept: (rescaleIntercept as number)
+          ? (rescaleIntercept as number)
+          : 0,
         invert: imageFrame.photometricInterpretation === "MONOCHROME1",
         minPixelValue: imageFrame.smallestPixelValue,
         maxPixelValue: imageFrame.largestPixelValue,
         render: undefined, // set below
-        rowPixelSpacing: pixelSpacing[0] ? pixelSpacing[0] : pixelSpacing, // check for specific spacing value
+        rowPixelSpacing: (pixelSpacing as number[])[0]
+          ? (pixelSpacing as number[])[0]
+          : (pixelSpacing as number), // check for specific spacing value
         rows: imageFrame.rows,
         sizeInBytes: getSizeInBytes(),
-        slope: rescaleSlope ? rescaleSlope : 1,
+        slope: (rescaleSlope as number) ? (rescaleSlope as number) : 1,
         width: imageFrame.columns,
-        windowCenter: windowCenter,
-        windowWidth: windowWidth,
+        windowCenter: windowCenter as number,
+        windowWidth: windowWidth as number,
         decodeTimeInMS: undefined, // TODO
-        loadTimeInMS: undefined, // TODO
-        render: undefined
+        loadTimeInMS: undefined // TODO
       };
       // add function to return pixel data
       image.getPixelData = function () {
-        return imageFrame.pixelData;
+        if (imageFrame.pixelData === undefined) {
+          throw new Error("No pixel data for image " + imageId);
+        }
+        return Array.from(imageFrame.pixelData);
       };
 
       // convert color space if not isJPEGBaseline8BitColor
@@ -305,6 +346,10 @@ let createCustomImage = function (id, imageId, frameIndex, metadata) {
 
         let context = canvas.getContext("2d");
 
+        if (!context) {
+          throw new Error("Unable to get canvas context");
+        }
+
         let imageData = context.createImageData(
           imageFrame.columns,
           imageFrame.rows
@@ -319,10 +364,13 @@ let createCustomImage = function (id, imageId, frameIndex, metadata) {
       // Setup the renderer
       if (image.color) {
         image.getCanvas = function () {
-          canvas.height = image.rows;
-          canvas.width = image.columns;
+          canvas.height = image.rows || 0;
+          canvas.width = image.columns || 0;
           let context = canvas.getContext("2d");
-          context.putImageData(imageFrame.imageData, 0, 0);
+          if (!context) {
+            throw new Error("Unable to get canvas context");
+          }
+          context.putImageData(imageFrame.imageData!, 0, 0);
           return canvas;
         };
       }
@@ -342,7 +390,12 @@ let createCustomImage = function (id, imageId, frameIndex, metadata) {
         if (image.color) {
           image.windowWidth = 255;
           image.windowCenter = 128;
-        } else {
+        } else if (
+          image.maxPixelValue &&
+          image.minPixelValue &&
+          image.slope &&
+          image.intercept
+        ) {
           let maxVoi = image.maxPixelValue * image.slope + image.intercept;
           let minVoi = image.minPixelValue * image.slope + image.intercept;
           image.windowWidth = maxVoi - minVoi;
@@ -350,7 +403,7 @@ let createCustomImage = function (id, imageId, frameIndex, metadata) {
         }
       }
 
-      resolve(image);
+      resolve(image as Image);
     }, reject);
   });
 
@@ -367,14 +420,16 @@ let createCustomImage = function (id, imageId, frameIndex, metadata) {
  * @function setPixelDataType
  * @param {Object} imageFrame The Id of the image
  */
-const setPixelDataType = function (imageFrame) {
+const setPixelDataType = function (imageFrame: ImageFrame) {
   if (imageFrame.bitsAllocated === 16) {
     if (imageFrame.pixelRepresentation === 0) {
-      imageFrame.pixelData = new Uint16Array(imageFrame.pixelData);
+      imageFrame.pixelData = new Uint16Array(
+        imageFrame.pixelData as Uint16Array
+      );
     } else {
-      imageFrame.pixelData = new Int16Array(imageFrame.pixelData);
+      imageFrame.pixelData = new Int16Array(imageFrame.pixelData as Int16Array);
     }
   } else {
-    imageFrame.pixelData = new Uint8Array(imageFrame.pixelData);
+    imageFrame.pixelData = new Uint8Array(imageFrame.pixelData as Uint8Array);
   }
 };