@cornerstonejs/adapters 3.0.0-beta.5 → 3.0.0

package/dist/esm/adapters/Cornerstone/Segmentation_3X.js

@@ -1,22 +1,28 @@
-import { toConsumableArray as _toConsumableArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
-import { utilities, normalizers, derivations, log } from 'dcmjs';
+import { utilities, log, normalizers, derivations } from 'dcmjs';
 import ndarray from 'ndarray';
 import getDatasetsFromImages from '../helpers/getDatasetsFromImages.js';
 
-var _utilities$orientatio = utilities.orientation,
-  rotateDirectionCosinesInPlane = _utilities$orientatio.rotateDirectionCosinesInPlane,
-  flipIOP = _utilities$orientatio.flipImageOrientationPatient,
-  flipMatrix2D = _utilities$orientatio.flipMatrix2D,
-  rotateMatrix902D = _utilities$orientatio.rotateMatrix902D;
-var datasetToBlob = utilities.datasetToBlob,
-  BitArray = utilities.BitArray,
-  DicomMessage = utilities.DicomMessage,
-  DicomMetaDictionary = utilities.DicomMetaDictionary;
-var Normalizer = normalizers.Normalizer;
-var SegmentationDerivation = derivations.Segmentation;
-var Segmentation = {
-  generateSegmentation: generateSegmentation,
-  generateToolState: generateToolState
+const {
+  rotateDirectionCosinesInPlane,
+  flipImageOrientationPatient: flipIOP,
+  flipMatrix2D,
+  rotateMatrix902D
+} = utilities.orientation;
+const {
+  datasetToBlob,
+  BitArray,
+  DicomMessage,
+  DicomMetaDictionary
+} = utilities;
+const {
+  Normalizer
+} = normalizers;
+const {
+  Segmentation: SegmentationDerivation
+} = derivations;
+const Segmentation = {
+  generateSegmentation,
+  generateToolState
 };
 
 /**
@@ -36,58 +42,61 @@ var Segmentation = {
  * @returns {type}           description
  */
 function generateSegmentation(images, brushData) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
     includeSliceSpacing: true
   };
-  var toolState = brushData.toolState,
-    segments = brushData.segments;
+  const {
+    toolState,
+    segments
+  } = brushData;
 
   // Calculate the dimensions of the data cube.
-  var image0 = images[0];
-  var dims = {
+  const image0 = images[0];
+  const dims = {
     x: image0.columns,
     y: image0.rows,
     z: images.length
   };
   dims.xy = dims.x * dims.y;
-  var numSegments = _getSegCount(seg, segments);
+  const numSegments = _getSegCount(seg, segments);
   if (!numSegments) {
     throw new Error("No segments to export!");
   }
-  var isMultiframe = image0.imageId.includes("?frame");
-  var seg = _createSegFromImages(images, isMultiframe, options);
-  var _getNumberOfFramesPer = _getNumberOfFramesPerSegment(toolState, images, segments),
-    referencedFramesPerSegment = _getNumberOfFramesPer.referencedFramesPerSegment,
-    segmentIndicies = _getNumberOfFramesPer.segmentIndicies;
-  var NumberOfFrames = 0;
-  for (var i = 0; i < referencedFramesPerSegment.length; i++) {
+  const isMultiframe = image0.imageId.includes("?frame");
+  const seg = _createSegFromImages(images, isMultiframe, options);
+  const {
+    referencedFramesPerSegment,
+    segmentIndicies
+  } = _getNumberOfFramesPerSegment(toolState, images, segments);
+  let NumberOfFrames = 0;
+  for (let i = 0; i < referencedFramesPerSegment.length; i++) {
     NumberOfFrames += referencedFramesPerSegment[i].length;
   }
   seg.setNumberOfFrames(NumberOfFrames);
-  for (var _i = 0; _i < segmentIndicies.length; _i++) {
-    var segmentIndex = segmentIndicies[_i];
-    var referencedFrameIndicies = referencedFramesPerSegment[_i];
+  for (let i = 0; i < segmentIndicies.length; i++) {
+    const segmentIndex = segmentIndicies[i];
+    const referencedFrameIndicies = referencedFramesPerSegment[i];
 
     // Frame numbers start from 1.
-    var referencedFrameNumbers = referencedFrameIndicies.map(function (element) {
+    const referencedFrameNumbers = referencedFrameIndicies.map(element => {
       return element + 1;
     });
-    var segment = segments[segmentIndex];
+    const segment = segments[segmentIndex];
     seg.addSegment(segment, _extractCornerstoneToolsPixelData(segmentIndex, referencedFrameIndicies, toolState, images, dims), referencedFrameNumbers);
   }
   seg.bitPackPixelData();
-  var segBlob = datasetToBlob(seg.dataset);
+  const segBlob = datasetToBlob(seg.dataset);
   return segBlob;
 }
 function _extractCornerstoneToolsPixelData(segmentIndex, referencedFrames, toolState, images, dims) {
-  var pixelData = new Uint8Array(dims.xy * referencedFrames.length);
-  var pixelDataIndex = 0;
-  for (var i = 0; i < referencedFrames.length; i++) {
-    var frame = referencedFrames[i];
-    var imageId = images[frame].imageId;
-    var imageIdSpecificToolState = toolState[imageId];
-    var brushPixelData = imageIdSpecificToolState.brush.data[segmentIndex].pixelData;
-    for (var p = 0; p < brushPixelData.length; p++) {
+  const pixelData = new Uint8Array(dims.xy * referencedFrames.length);
+  let pixelDataIndex = 0;
+  for (let i = 0; i < referencedFrames.length; i++) {
+    const frame = referencedFrames[i];
+    const imageId = images[frame].imageId;
+    const imageIdSpecificToolState = toolState[imageId];
+    const brushPixelData = imageIdSpecificToolState.brush.data[segmentIndex].pixelData;
+    for (let p = 0; p < brushPixelData.length; p++) {
       pixelData[pixelDataIndex] = brushPixelData[p];
       pixelDataIndex++;
     }
@@ -95,32 +104,32 @@ function _extractCornerstoneToolsPixelData(segmentIndex, referencedFrames, toolS
   return pixelData;
 }
 function _getNumberOfFramesPerSegment(toolState, images, segments) {
-  var segmentIndicies = [];
-  var referencedFramesPerSegment = [];
-  for (var i = 0; i < segments.length; i++) {
+  const segmentIndicies = [];
+  const referencedFramesPerSegment = [];
+  for (let i = 0; i < segments.length; i++) {
     if (segments[i]) {
       segmentIndicies.push(i);
       referencedFramesPerSegment.push([]);
     }
   }
-  for (var z = 0; z < images.length; z++) {
-    var imageId = images[z].imageId;
-    var imageIdSpecificToolState = toolState[imageId];
-    for (var _i2 = 0; _i2 < segmentIndicies.length; _i2++) {
-      var segIdx = segmentIndicies[_i2];
+  for (let z = 0; z < images.length; z++) {
+    const imageId = images[z].imageId;
+    const imageIdSpecificToolState = toolState[imageId];
+    for (let i = 0; i < segmentIndicies.length; i++) {
+      const segIdx = segmentIndicies[i];
       if (imageIdSpecificToolState && imageIdSpecificToolState.brush && imageIdSpecificToolState.brush.data && imageIdSpecificToolState.brush.data[segIdx] && imageIdSpecificToolState.brush.data[segIdx].pixelData) {
-        referencedFramesPerSegment[_i2].push(z);
+        referencedFramesPerSegment[i].push(z);
       }
     }
   }
   return {
-    referencedFramesPerSegment: referencedFramesPerSegment,
-    segmentIndicies: segmentIndicies
+    referencedFramesPerSegment,
+    segmentIndicies
   };
 }
 function _getSegCount(seg, segments) {
-  var numSegments = 0;
-  for (var i = 0; i < segments.length; i++) {
+  let numSegments = 0;
+  for (let i = 0; i < segments.length; i++) {
     if (segments[i]) {
       numSegments++;
     }
@@ -136,7 +145,7 @@ function _getSegCount(seg, segments) {
  * @returns {Object}              The Seg derived dataSet.
  */
 function _createSegFromImages(images, isMultiframe, options) {
-  var multiframe = getDatasetsFromImages(images, isMultiframe);
+  const multiframe = getDatasetsFromImages(images, isMultiframe);
   return new SegmentationDerivation([multiframe], options);
 }
 
@@ -151,52 +160,52 @@ function _createSegFromImages(images, isMultiframe, options) {
  *                    segment metadata can be derived.
  */
 function generateToolState(imageIds, arrayBuffer, metadataProvider) {
-  var dicomData = DicomMessage.readFile(arrayBuffer);
-  var dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+  const dicomData = DicomMessage.readFile(arrayBuffer);
+  const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
   dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
-  var multiframe = Normalizer.normalizeToDataset([dataset]);
-  var imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
+  const multiframe = Normalizer.normalizeToDataset([dataset]);
+  const imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
   if (!imagePlaneModule) {
     console.warn("Insufficient metadata, imagePlaneModule missing.");
   }
-  var ImageOrientationPatient = Array.isArray(imagePlaneModule.rowCosines) ? [].concat(_toConsumableArray(imagePlaneModule.rowCosines), _toConsumableArray(imagePlaneModule.columnCosines)) : [imagePlaneModule.rowCosines.x, imagePlaneModule.rowCosines.y, imagePlaneModule.rowCosines.z, imagePlaneModule.columnCosines.x, imagePlaneModule.columnCosines.y, imagePlaneModule.columnCosines.z];
+  const ImageOrientationPatient = Array.isArray(imagePlaneModule.rowCosines) ? [...imagePlaneModule.rowCosines, ...imagePlaneModule.columnCosines] : [imagePlaneModule.rowCosines.x, imagePlaneModule.rowCosines.y, imagePlaneModule.rowCosines.z, imagePlaneModule.columnCosines.x, imagePlaneModule.columnCosines.y, imagePlaneModule.columnCosines.z];
 
   // Get IOP from ref series, compute supported orientations:
-  var validOrientations = getValidOrientations(ImageOrientationPatient);
-  var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence;
-  var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
-  var sliceLength = multiframe.Columns * multiframe.Rows;
-  var segMetadata = getSegmentMetadata(multiframe);
-  var pixelData = unpackPixelData(multiframe);
-  var PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence;
-  var toolState = {};
-  var inPlane = true;
-  for (var i = 0; i < PerFrameFunctionalGroupsSequence.length; i++) {
-    var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
-    var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-    var pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, i * sliceLength, sliceLength), [multiframe.Rows, multiframe.Columns]);
-    var alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations);
+  const validOrientations = getValidOrientations(ImageOrientationPatient);
+  const SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence;
+  const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
+  const sliceLength = multiframe.Columns * multiframe.Rows;
+  const segMetadata = getSegmentMetadata(multiframe);
+  const pixelData = unpackPixelData(multiframe);
+  const PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence;
+  const toolState = {};
+  let inPlane = true;
+  for (let i = 0; i < PerFrameFunctionalGroupsSequence.length; i++) {
+    const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
+    const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+    const pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, i * sliceLength, sliceLength), [multiframe.Rows, multiframe.Columns]);
+    const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations);
     if (!alignedPixelDataI) {
       console.warn("This segmentation object is not in-plane with the source data. Bailing out of IO. It'd be better to render this with vtkjs. ");
       inPlane = false;
       break;
     }
-    var segmentIndex = PerFrameFunctionalGroups.SegmentIdentificationSequence.ReferencedSegmentNumber - 1;
-    var SourceImageSequence = void 0;
+    const segmentIndex = PerFrameFunctionalGroups.SegmentIdentificationSequence.ReferencedSegmentNumber - 1;
+    let SourceImageSequence;
     if (SharedFunctionalGroupsSequence.DerivationImageSequence && SharedFunctionalGroupsSequence.DerivationImageSequence.SourceImageSequence) {
       SourceImageSequence = SharedFunctionalGroupsSequence.DerivationImageSequence.SourceImageSequence[i];
     } else {
       SourceImageSequence = PerFrameFunctionalGroups.DerivationImageSequence.SourceImageSequence;
     }
-    var imageId = getImageIdOfSourceImage(SourceImageSequence, imageIds, metadataProvider);
+    const imageId = getImageIdOfSourceImage(SourceImageSequence, imageIds, metadataProvider);
     addImageIdSpecificBrushToolState(toolState, imageId, segmentIndex, alignedPixelDataI);
   }
   if (!inPlane) {
     return;
   }
   return {
-    toolState: toolState,
-    segMetadata: segMetadata
+    toolState,
+    segMetadata
   };
 }
 
@@ -207,15 +216,13 @@ function generateToolState(imageIds, arrayBuffer, metadataProvider) {
  * @return {Uint8Array}      The unpacked pixelData.
  */
 function unpackPixelData(multiframe) {
-  var segType = multiframe.SegmentationType;
+  const segType = multiframe.SegmentationType;
   if (segType === "BINARY") {
     return BitArray.unpack(multiframe.PixelData);
   }
-  var pixelData = new Uint8Array(multiframe.PixelData);
-  var max = multiframe.MaximumFractionalValue;
-  var onlyMaxAndZero = pixelData.find(function (element) {
-    return element !== 0 && element !== max;
-  }) === undefined;
+  const pixelData = new Uint8Array(multiframe.PixelData);
+  const max = multiframe.MaximumFractionalValue;
+  const onlyMaxAndZero = pixelData.find(element => element !== 0 && element !== max) === undefined;
   if (!onlyMaxAndZero) {
     log.warn("This is a fractional segmentation, which is not currently supported.");
     return;
@@ -245,10 +252,10 @@ function addImageIdSpecificBrushToolState(toolState, imageId, segmentIndex, pixe
     toolState[imageId].brush.data = [];
   }
   toolState[imageId].brush.data[segmentIndex] = {};
-  var brushDataI = toolState[imageId].brush.data[segmentIndex];
+  const brushDataI = toolState[imageId].brush.data[segmentIndex];
   brushDataI.pixelData = new Uint8Array(pixelData2D.data.length);
-  var cToolsPixelData = brushDataI.pixelData;
-  for (var p = 0; p < cToolsPixelData.length; p++) {
+  const cToolsPixelData = brushDataI.pixelData;
+  for (let p = 0; p < cToolsPixelData.length; p++) {
     if (pixelData2D.data[p]) {
       cToolsPixelData[p] = 1;
     } else {
@@ -267,8 +274,10 @@ function addImageIdSpecificBrushToolState(toolState, imageId, segmentIndex, pixe
  * @return {String}                     The corresponding imageId.
  */
 function getImageIdOfSourceImage(SourceImageSequence, imageIds, metadataProvider) {
-  var ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
-    ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
+  const {
+    ReferencedSOPInstanceUID,
+    ReferencedFrameNumber
+  } = SourceImageSequence;
   return ReferencedFrameNumber ? getImageIdOfReferencedFrame(ReferencedSOPInstanceUID, ReferencedFrameNumber, imageIds, metadataProvider) : getImageIdOfReferencedSingleFramedSOPInstance(ReferencedSOPInstanceUID, imageIds, metadataProvider);
 }
 
@@ -283,8 +292,8 @@ function getImageIdOfSourceImage(SourceImageSequence, imageIds, metadataProvider
  * @return {String}                  The imageId that corresponds to the sopInstanceUid.
  */
 function getImageIdOfReferencedSingleFramedSOPInstance(sopInstanceUid, imageIds, metadataProvider) {
-  return imageIds.find(function (imageId) {
-    var sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
+  return imageIds.find(imageId => {
+    const sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
     if (!sopCommonModule) {
       return;
     }
@@ -304,12 +313,12 @@ function getImageIdOfReferencedSingleFramedSOPInstance(sopInstanceUid, imageIds,
  * @return {String}                  The imageId that corresponds to the sopInstanceUid.
  */
 function getImageIdOfReferencedFrame(sopInstanceUid, frameNumber, imageIds, metadataProvider) {
-  var imageId = imageIds.find(function (imageId) {
-    var sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
+  const imageId = imageIds.find(imageId => {
+    const sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
     if (!sopCommonModule) {
       return;
     }
-    var imageIdFrameNumber = Number(imageId.split("frame=")[1]);
+    const imageIdFrameNumber = Number(imageId.split("frame=")[1]);
     return (
       //frameNumber is zero indexed for cornerstoneDICOMImageLoader image Ids.
       sopCommonModule.sopInstanceUID === sopInstanceUid && imageIdFrameNumber === frameNumber - 1
@@ -325,7 +334,7 @@ function getImageIdOfReferencedFrame(sopInstanceUid, frameNumber, imageIds, meta
  * @return  An array of valid orientations.
  */
 function getValidOrientations(iop) {
-  var orientations = [];
+  const orientations = [];
 
   // [0,  1,  2]: 0,   0hf,   0vf
   // [3,  4,  5]: 90,  90hf,  90vf
@@ -334,7 +343,7 @@ function getValidOrientations(iop) {
   orientations[0] = iop;
   orientations[1] = flipIOP.h(iop);
   orientations[2] = flipIOP.v(iop);
-  var iop90 = rotateDirectionCosinesInPlane(iop, Math.PI / 2);
+  const iop90 = rotateDirectionCosinesInPlane(iop, Math.PI / 2);
   orientations[3] = iop90;
   orientations[4] = flipIOP.h(iop90);
   orientations[5] = flipIOP.v(iop90);
@@ -378,7 +387,7 @@ function alignPixelDataWithSourceData(pixelData2D, iop, orientations) {
     return rotateMatrix902D(rotateMatrix902D(rotateMatrix902D(pixelData2D)));
   }
 }
-var dx = 1e-5;
+const dx = 1e-5;
 
 /**
  * compareIOP - Returns true if iop1 and iop2 are equal
@@ -392,10 +401,10 @@ function compareIOP(iop1, iop2) {
   return Math.abs(iop1[0] - iop2[0]) < dx && Math.abs(iop1[1] - iop2[1]) < dx && Math.abs(iop1[2] - iop2[2]) < dx && Math.abs(iop1[3] - iop2[3]) < dx && Math.abs(iop1[4] - iop2[4]) < dx && Math.abs(iop1[5] - iop2[5]) < dx;
 }
 function getSegmentMetadata(multiframe) {
-  var data = [];
-  var segmentSequence = multiframe.SegmentSequence;
+  const data = [];
+  const segmentSequence = multiframe.SegmentSequence;
   if (Array.isArray(segmentSequence)) {
-    for (var segIdx = 0; segIdx < segmentSequence.length; segIdx++) {
+    for (let segIdx = 0; segIdx < segmentSequence.length; segIdx++) {
       data.push(segmentSequence[segIdx]);
     }
   } else {
@@ -404,7 +413,7 @@ function getSegmentMetadata(multiframe) {
   }
   return {
     seriesInstanceUid: multiframe.ReferencedSeriesSequence.SeriesInstanceUID,
-    data: data
+    data
   };
 }