@cornerstonejs/adapters 3.7.0 → 3.7.1

package/dist/esm/adapters/Cornerstone3D/Segmentation/labelmapImagesFromBuffer.js

@@ -1,9 +1,11 @@
-import { imageLoader } from '@cornerstonejs/core';
+import { triggerEvent, eventTarget, imageLoader } from '@cornerstonejs/core';
+import { utilities as utilities$1 } from '@cornerstonejs/tools';
 import { utilities, data, normalizers } from 'dcmjs';
 import ndarray from 'ndarray';
 import checkOrientation from '../../helpers/checkOrientation.js';
 import { getValidOrientations, getSegmentMetadata, unpackPixelData, calculateCentroid, readFromUnpackedChunks, alignPixelDataWithSourceData, getSegmentIndex, findReferenceSourceImageId } from '../../Cornerstone/Segmentation_4X.js';
 import { compactMergeSegmentDataWithoutInformationLoss } from './compactMergeSegData.js';
+import Events from '../../enums/Events.js';
 
 const {
   DicomMessage,
@@ -156,6 +158,11 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
     overlappingSegments: hasOverlappingSegments
   };
 }
+const throttledTriggerLoadProgressEvent = utilities$1.throttle(percentComplete => {
+  triggerEvent(eventTarget, Events.SEGMENTATION_LOAD_PROGRESS, {
+    percentComplete
+  });
+}, 200);
 function insertPixelDataPlanar(_ref4) {
   let {
     segmentsOnFrame,
@@ -181,75 +188,86 @@ function insertPixelDataPlanar(_ref4) {
   const groupsLen = PerFrameFunctionalGroupsSequence.length;
   let overlapping = false;
   return new Promise(resolve => {
-    for (let i = 0; i < groupsLen; ++i) {
-      const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
-      const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-      const view = readFromUnpackedChunks(pixelDataChunks, i * sliceLength, sliceLength);
-      const pixelDataI2D = ndarray(view, [Rows, Columns]);
-      const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
-      if (!alignedPixelDataI) {
-        throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
-      }
-      const segmentIndex = getSegmentIndex(multiframe, i);
-      if (segmentIndex === undefined) {
-        throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
-      }
-      if (!segmentsPixelIndices.has(segmentIndex)) {
-        segmentsPixelIndices.set(segmentIndex, {});
-      }
-      const imageId = findReferenceSourceImageId(multiframe, i, referencedImageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
-      if (!imageId) {
-        console.warn("Image not present in stack, can't import frame : " + i + ".");
-        continue;
-      }
-      const sourceImageMetadata = imageIdMaps.metadata[imageId];
-      if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
-        throw new Error("Individual SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
-      }
-      const imageIdIndex = imageIdMaps.indices[imageId];
-      const labelmapImage = labelMapImages[imageIdIndex];
-      const labelmap2DView = labelmapImage.getPixelData();
-      const data = alignedPixelDataI.data;
-      const indexCache = [];
-      for (let j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
-        if (data[j]) {
-          for (let x = j; x < len; ++x) {
-            if (data[x]) {
-              if (!overlapping && labelmap2DView[x] !== 0) {
-                overlapping = true;
-                return resolve(insertOverlappingPixelDataPlanar({
-                  segmentsOnFrame,
-                  labelMapImages,
-                  pixelDataChunks,
-                  multiframe,
-                  referencedImageIds,
-                  validOrientations,
-                  metadataProvider,
-                  tolerance,
-                  segmentsPixelIndices,
-                  sopUIDImageIdIndexMap,
-                  imageIdMaps
-                }));
+    const percentImagesPerChunk = 0.1;
+    const imagesPerChunk = Math.ceil(groupsLen * percentImagesPerChunk);
+    const processChunk = firstIndex => {
+      for (let i = firstIndex; i < firstIndex + imagesPerChunk && i < groupsLen; i++) {
+        const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
+        const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+        const view = readFromUnpackedChunks(pixelDataChunks, i * sliceLength, sliceLength);
+        const pixelDataI2D = ndarray(view, [Rows, Columns]);
+        const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
+        if (!alignedPixelDataI) {
+          throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
+        }
+        const segmentIndex = getSegmentIndex(multiframe, i);
+        if (segmentIndex === undefined) {
+          throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
+        }
+        if (!segmentsPixelIndices.has(segmentIndex)) {
+          segmentsPixelIndices.set(segmentIndex, {});
+        }
+        const imageId = findReferenceSourceImageId(multiframe, i, referencedImageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+        if (!imageId) {
+          console.warn("Image not present in stack, can't import frame : " + i + ".");
+          return;
+        }
+        const sourceImageMetadata = imageIdMaps.metadata[imageId];
+        if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
+          throw new Error("Individual SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
+        }
+        const imageIdIndex = imageIdMaps.indices[imageId];
+        const labelmapImage = labelMapImages[imageIdIndex];
+        const labelmap2DView = labelmapImage.getPixelData();
+        const data = alignedPixelDataI.data;
+        const indexCache = [];
+        for (let k = 0, len = alignedPixelDataI.data.length; k < len; ++k) {
+          if (data[k]) {
+            for (let x = k; x < len; ++x) {
+              if (data[x]) {
+                if (!overlapping && labelmap2DView[x] !== 0) {
+                  overlapping = true;
+                  return resolve(insertOverlappingPixelDataPlanar({
+                    segmentsOnFrame,
+                    labelMapImages,
+                    pixelDataChunks,
+                    multiframe,
+                    referencedImageIds,
+                    validOrientations,
+                    metadataProvider,
+                    tolerance,
+                    segmentsPixelIndices,
+                    sopUIDImageIdIndexMap,
+                    imageIdMaps
+                  }));
+                }
+                labelmap2DView[x] = segmentIndex;
+                indexCache.push(x);
               }
-              labelmap2DView[x] = segmentIndex;
-              indexCache.push(x);
             }
+            if (!segmentsOnFrame[imageIdIndex]) {
+              segmentsOnFrame[imageIdIndex] = [];
+            }
+            segmentsOnFrame[imageIdIndex].push(segmentIndex);
+            break;
           }
-          if (!segmentsOnFrame[imageIdIndex]) {
-            segmentsOnFrame[imageIdIndex] = [];
-          }
-          segmentsOnFrame[imageIdIndex].push(segmentIndex);
-          break;
         }
+        const segmentIndexObject = segmentsPixelIndices.get(segmentIndex);
+        segmentIndexObject[imageIdIndex] = indexCache;
+        segmentsPixelIndices.set(segmentIndex, segmentIndexObject);
       }
-      const segmentIndexObject = segmentsPixelIndices.get(segmentIndex);
-      segmentIndexObject[imageIdIndex] = indexCache;
-      segmentsPixelIndices.set(segmentIndex, segmentIndexObject);
-    }
-    resolve({
-      hasOverlappingSegments: overlapping,
-      arrayOfLabelMapImages: [labelMapImages]
-    });
+      const percentComplete = Math.round(firstIndex / groupsLen * 100);
+      throttledTriggerLoadProgressEvent(percentComplete);
+      if (firstIndex < groupsLen) {
+        setTimeout(() => processChunk(firstIndex + imagesPerChunk), 0);
+      } else {
+        resolve({
+          hasOverlappingSegments: false,
+          arrayOfLabelMapImages: [labelMapImages]
+        });
+      }
+    };
+    processChunk(0);
   });
 }
 const getAlignedPixelData = _ref5 => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cornerstonejs/adapters",
-    "version": "3.7.0",
+    "version": "3.7.1",
     "description": "Adapters for Cornerstone3D to/from formats including DICOM SR and others",
     "module": "./dist/esm/index.js",
     "types": "./dist/esm/index.d.ts",
@@ -84,8 +84,8 @@
         "ndarray": "^1.0.19"
     },
     "peerDependencies": {
-        "@cornerstonejs/core": "^3.7.0",
-        "@cornerstonejs/tools": "^3.7.0"
+        "@cornerstonejs/core": "^3.7.1",
+        "@cornerstonejs/tools": "^3.7.1"
     },
-    "gitHead": "177fce2dd8c2278d3c8473f15df795e757d40b7e"
+    "gitHead": "a4fe414ad0c938b9f842127dea4b0d12e334ac25"
 }