@cornerstonejs/adapters 1.53.0 → 1.54.1

package/dist/adapters.es.js

@@ -5097,6 +5097,7 @@ var Events$2;
   Events["GEOMETRY_CACHE_GEOMETRY_ADDED"] = "CORNERSTONE_GEOMETRY_CACHE_GEOMETRY_ADDED";
   Events["VOLUME_SCROLL_OUT_OF_BOUNDS"] = "CORNERSTONE_VOLUME_SCROLL_OUT_OF_BOUNDS";
   Events["CLIPPING_PLANES_UPDATED"] = "CORNERSTONE_CLIPPING_PLANES_UPDATED";
+  Events["WEB_WORKER_PROGRESS"] = "CORNERSTONE_WEB_WORKER_PROGRESS";
 })(Events$2 || (Events$2 = {}));
 var EVENTS = Events$2;
 
@@ -14331,7 +14332,7 @@ class RequestPoolManager {
       interaction: 6,
       thumbnail: 6,
       prefetch: 5,
-      compute: 15
+      compute: 1000
     };
   }
   setMaxSimultaneousRequests(type, maxNumRequests) {
@@ -27700,6 +27701,15 @@ class ImageVolume {
   getScalarDataArrays() {
     return this.isDynamicVolume() ? this.scalarData : [this.scalarData];
   }
+  modified() {
+    this.imageData.modified();
+    if (this.isDynamicVolume()) {
+      throw new Error('Not implemented');
+    } else {
+      this.scalarData = this.imageData.getPointData().getScalars().getData();
+    }
+    this.numFrames = this._getNumFrames();
+  }
   decache(completelyRemove = false) {
     if (completelyRemove) {
       this.removeFromCache();
@@ -27863,8 +27873,11 @@ class ImageVolume {
     const byteLength = this.sizeInBytes;
     if (!this.imageIds?.length) {
       const referencedVolumeId = this.referencedVolumeId;
-      const referencedVolume = cache$1.getVolume(referencedVolumeId);
-      const numSlices = referencedVolume?.imageIds?.length || this.dimensions[2];
+      let numSlices = this.dimensions[2];
+      if (referencedVolumeId) {
+        const referencedVolume = cache$1.getVolume(referencedVolumeId);
+        numSlices = referencedVolume?.imageIds?.length ?? numSlices;
+      }
       this.imageIds = Array.from({
         length: numSlices
       }, (_, i) => {
@@ -27930,6 +27943,12 @@ class ImageVolume {
         });
       });
     }
+    const otherVolumes = cache$1.filterVolumesByReferenceId(this.volumeId);
+    if (otherVolumes.length) {
+      otherVolumes.forEach(volume => {
+        volume.referencedImageIds = this.imageIds;
+      });
+    }
     this.removeFromCache();
     return this.imageIds;
   }
@@ -28073,6 +28092,16 @@ class Cache {
       cachedVolume.timeStamp = Date.now();
       return cachedVolume.volume;
     };
+    this.getVolumes = () => {
+      const cachedVolumes = Array.from(this._volumeCache.values());
+      return cachedVolumes.map(cachedVolume => cachedVolume.volume);
+    };
+    this.filterVolumesByReferenceId = volumeId => {
+      const cachedVolumes = this.getVolumes();
+      return cachedVolumes.filter(volume => {
+        return volume.referencedVolumeId === volumeId;
+      });
+    };
     this.removeImageLoadObject = imageId => {
       if (imageId === undefined) {
         throw new Error('removeImageLoadObject: imageId must not be undefined');
@@ -35630,6 +35659,20 @@ function _processImageCacheOffsetMap(volume, scalarData) {
   });
 }
 function _processVolumeImages(volume, scalarData) {
+  let compatibleScalarData = scalarData;
+  const sampleImageIdWithImage = volume.imageIds.find(imageId => {
+    const image = cache$1.getImage(imageId);
+    return image;
+  });
+  if (!sampleImageIdWithImage) {
+    return;
+  }
+  const sampleImage = cache$1.getImage(sampleImageIdWithImage);
+  const samplePixelData = sampleImage.imageFrame?.pixelData || sampleImage.getPixelData();
+  if (scalarData.constructor !== samplePixelData.constructor) {
+    compatibleScalarData = new samplePixelData.constructor(scalarData.length);
+    compatibleScalarData.set(scalarData);
+  }
   volume.imageIds.forEach(imageId => {
     const image = cache$1.getImage(imageId);
     if (!image) {
@@ -35637,7 +35680,7 @@ function _processVolumeImages(volume, scalarData) {
     }
     const index = volume.getImageIdIndex(imageId);
     const offset = index * image.getPixelData().byteLength;
-    _updateImageWithScalarDataView(image, scalarData, offset);
+    _updateImageWithScalarDataView(image, compatibleScalarData, offset);
     cache$1.decrementImageCacheSize(image.sizeInBytes);
   });
 }
@@ -39513,13 +39556,11 @@ async function getVOIFromMinMax(imageVolume, useNativeDataType) {
       scalingParameters: scalingParametersToUse
     }
   };
-  const image = await loadAndCacheImage(imageId, options);
-  let imageScalarData;
-  if (!image) {
-    imageScalarData = _getImageScalarDataFromImageVolume(imageVolume, byteOffset, bytePerPixel, voxelsPerImage);
-  } else {
-    imageScalarData = image.getPixelData();
+  let image = cache$1.getImage(imageId);
+  if (!image?.referencedImageId) {
+    image = await loadAndCacheImage(imageId, options);
   }
+  const imageScalarData = image ? image.getPixelData() : _getImageScalarDataFromImageVolume(imageVolume, byteOffset, bytePerPixel, voxelsPerImage);
   const {
     min,
     max
@@ -40511,7 +40552,6 @@ class Viewport {
     this.flipHorizontal = false;
     this.flipVertical = false;
     this.viewportStatus = ViewportStatus$1.NO_DATA;
-    this.newActorAdded = false;
     this._suppressCameraModifiedEvents = false;
     this.hasPixelSpacing = true;
     this.id = props.id;
@@ -40706,7 +40746,6 @@ class Viewport {
     const renderer = this.getRenderer();
     renderer.addActor(actor);
     this._actors.set(actorUID, Object.assign({}, actorEntry));
-    this.newActorAdded = true;
   }
   removeAllActors() {
     this.getRenderer().removeAllViewProps();
@@ -40853,6 +40892,7 @@ class Viewport {
     radius = w1 + w2 + w3;
     radius = radius === 0 ? 1.0 : radius;
     radius = Math.sqrt(radius) * 0.5;
+    radius = this.type === ViewportType$1.VOLUME_3D ? radius * 10 : radius;
     const distance = this.insetImageMultiplier * radius;
     const viewUpToSet = Math.abs(vtkMath.dot(viewUp, viewPlaneNormal)) > 0.999 ? [-viewUp[2], viewUp[0], viewUp[1]] : viewUp;
     const focalPointToSet = this._getFocalPointForResetCamera(focalPoint, previousCamera, {
@@ -41057,7 +41097,7 @@ class Viewport {
       if (viewUp) {
         viewUpHasChanged = !isEqual$2(currentViewUp, prevViewUp);
       }
-      if (cameraModifiedOutOfPlane || viewUpHasChanged || this.newActorAdded) {
+      if (cameraModifiedOutOfPlane || viewUpHasChanged) {
         const actorEntry = this.getDefaultActor();
         if (!actorEntry?.actor) {
           return;
@@ -41065,7 +41105,7 @@ class Viewport {
         if (!actorIsA(actorEntry, 'vtkActor')) {
           this.updateClippingPlanesForActors(updatedCamera);
         }
-        if (actorIsA(actorEntry, 'vtkImageSlice')) {
+        if (actorIsA(actorEntry, 'vtkImageSlice') || this.type === ViewportType$1.VOLUME_3D) {
           const renderer = this.getRenderer();
           renderer.resetCameraClippingRange();
         }
@@ -41116,10 +41156,6 @@ class Viewport {
         viewport: this
       });
     });
-    this.posProcessNewActors();
-  }
-  posProcessNewActors() {
-    this.newActorAdded = false;
   }
   setOrientationOfClippingPlanes(vtkPlanes, slabThickness, viewPlaneNormal, focalPoint) {
     if (vtkPlanes.length < 2) {
@@ -41136,6 +41172,20 @@ class Viewport {
     vtkMath.add(focalPoint, scaledDistance, newOrigin2);
     vtkPlanes[1].setOrigin(newOrigin2);
   }
+  getClippingPlanesForActor(actorEntry) {
+    if (!actorEntry) {
+      actorEntry = this.getDefaultActor();
+    }
+    if (!actorEntry.actor) {
+      throw new Error('Invalid actor entry: Actor is undefined');
+    }
+    const mapper = actorEntry.actor.getMapper();
+    let vtkPlanes = actorEntry?.clippingFilter ? actorEntry.clippingFilter.getClippingPlanes() : mapper.getClippingPlanes();
+    if (vtkPlanes.length === 0 && actorEntry?.clippingFilter) {
+      vtkPlanes = [vtkPlane$1.newInstance(), vtkPlane$1.newInstance()];
+    }
+    return vtkPlanes;
+  }
   _getWorldDistanceViewUpAndViewRight(bounds, viewUp, viewPlaneNormal) {
     const viewUpCorners = this._getCorners(bounds);
     const viewRightCorners = this._getCorners(bounds);
@@ -42094,7 +42144,7 @@ async function convertVolumeToStackViewport({
     });
     imageIdIndexToJump = minDistanceIndex;
   }
-  await stackViewport.setStack(stack, imageIdIndexToJump);
+  await stackViewport.setStack(stack, imageIdIndexToJump ?? 0);
   stackViewport.render();
   return stackViewport;
 }
@@ -42221,6 +42271,9 @@ class VoxelManager {
     bounds[2][1] = Math.max(point[2], bounds[2][1]);
   }
   static createVolumeVoxelManager(dimensions, scalarData) {
+    if (dimensions.length !== 3) {
+      throw new Error('Dimensions must be provided as [number, number, number] for [width, height, depth]');
+    }
     const voxels = new VoxelManager(dimensions, index => scalarData[index], (index, v) => {
       const isChanged = scalarData[index] !== v;
       scalarData[index] = v;
@@ -42302,6 +42355,17 @@ function convertToGrayscale(scalarData, width, height) {
   }
 }
 
+function getViewportImageIds(viewport) {
+  if (viewport instanceof VolumeViewport$1) {
+    const defaultActor = viewport.getDefaultActor();
+    const volumeId = defaultActor.uid;
+    const volume = cache$1.getVolume(volumeId);
+    return volume.imageIds;
+  } else if (viewport.getImageIds) {
+    return viewport.getImageIds();
+  }
+}
+
 function linePlaneIntersection(p0, p1, plane) {
   const [x0, y0, z0] = p0;
   const [x1, y1, z1] = p1;
@@ -42412,6 +42476,7 @@ var utilities = /*#__PURE__*/Object.freeze({
   getSpacingInNormalDirection: getSpacingInNormalDirection,
   getTargetVolumeAndSpacingInNormalDir: getTargetVolumeAndSpacingInNormalDir,
   getViewportImageCornersInWorld: getViewportImageCornersInWorld,
+  getViewportImageIds: getViewportImageIds,
   getViewportModality: getViewportModality,
   getViewportsWithImageURI: getViewportsWithImageURI,
   getViewportsWithVolumeId: getViewportsWithVolumeId,
@@ -42463,6 +42528,12 @@ class VolumeViewport extends BaseVolumeViewport$1 {
       } = getImageSliceDataForVolumeViewport(this);
       return numberOfSlices;
     };
+    this.getSliceIndex = () => {
+      const {
+        imageIndex
+      } = getImageSliceDataForVolumeViewport(this);
+      return imageIndex;
+    };
     this.getCurrentImageIdIndex = volumeId => {
       const {
         viewPlaneNormal,
@@ -42503,6 +42574,37 @@ class VolumeViewport extends BaseVolumeViewport$1 {
       } = this.getCamera();
       return getClosestImageId(volume, focalPoint, viewPlaneNormal);
     };
+    this.getSlicePlaneCoordinates = () => {
+      const actorEntry = this.getDefaultActor();
+      if (!actorEntry?.actor) {
+        console.warn('No image data found for calculating vtkPlanes.');
+        return [];
+      }
+      const volumeId = actorEntry.uid;
+      const imageVolume = cache$1.getVolume(volumeId);
+      const camera = this.getCamera();
+      const {
+        focalPoint,
+        position,
+        viewPlaneNormal
+      } = camera;
+      const spacingInNormalDirection = getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
+      const sliceRange = getSliceRange(actorEntry.actor, viewPlaneNormal, focalPoint);
+      const numSlicesBackward = Math.round((sliceRange.current - sliceRange.min) / spacingInNormalDirection);
+      const numSlicesForward = Math.round((sliceRange.max - sliceRange.current) / spacingInNormalDirection);
+      const currentSliceIndex = this.getSliceIndex();
+      const focalPoints = [];
+      for (let i = -numSlicesBackward; i <= numSlicesForward; i++) {
+        const {
+          newFocalPoint: point
+        } = snapFocalPointToSlice(focalPoint, position, sliceRange, viewPlaneNormal, spacingInNormalDirection, i);
+        focalPoints.push({
+          sliceIndex: currentSliceIndex + i,
+          point
+        });
+      }
+      return focalPoints;
+    };
     const {
       orientation
     } = this.options;
@@ -42536,25 +42638,33 @@ class VolumeViewport extends BaseVolumeViewport$1 {
   }
   setOrientation(orientation, immediate = true) {
     let viewPlaneNormal, viewUp;
-    if (MPR_CAMERA_VALUES$1[orientation]) {
-      ({
+    if (typeof orientation === 'string') {
+      if (MPR_CAMERA_VALUES$1[orientation]) {
+        ({
+          viewPlaneNormal,
+          viewUp
+        } = MPR_CAMERA_VALUES$1[orientation]);
+      } else if (orientation === 'acquisition') {
+        ({
+          viewPlaneNormal,
+          viewUp
+        } = this._getAcquisitionPlaneOrientation());
+      } else {
+        throw new Error(`Invalid orientation: ${orientation}. Use Enums.OrientationAxis instead.`);
+      }
+      this.setCamera({
         viewPlaneNormal,
         viewUp
-      } = MPR_CAMERA_VALUES$1[orientation]);
-    } else if (orientation === 'acquisition') {
+      });
+      this.viewportProperties.orientation = orientation;
+      this.resetCamera();
+    } else {
       ({
         viewPlaneNormal,
         viewUp
-      } = this._getAcquisitionPlaneOrientation());
-    } else {
-      throw new Error(`Invalid orientation: ${orientation}. Use Enums.OrientationAxis instead.`);
+      } = orientation);
+      this.applyViewOrientation(orientation);
     }
-    this.setCamera({
-      viewPlaneNormal,
-      viewUp
-    });
-    this.viewportProperties.orientation = orientation;
-    this.resetCamera();
     if (immediate) {
       this.render();
     }
@@ -42711,6 +42821,27 @@ class VolumeViewport extends BaseVolumeViewport$1 {
     this.resetCamera(resetPan, resetZoom, resetToCenter, resetCameraRotation);
     triggerEvent(this.element, EVENTS.VOI_MODIFIED, eventDetails);
   }
+  getSlicesClippingPlanes() {
+    const focalPoints = this.getSlicePlaneCoordinates();
+    const {
+      viewPlaneNormal
+    } = this.getCamera();
+    const slabThickness = RENDERING_DEFAULTS$1.MINIMUM_SLAB_THICKNESS;
+    return focalPoints.map(({
+      point,
+      sliceIndex
+    }) => {
+      const vtkPlanes = [vtkPlane$1.newInstance(), vtkPlane$1.newInstance()];
+      this.setOrientationOfClippingPlanes(vtkPlanes, slabThickness, viewPlaneNormal, point);
+      return {
+        sliceIndex,
+        planes: vtkPlanes.map(plane => ({
+          normal: plane.getNormal(),
+          origin: plane.getOrigin()
+        }))
+      };
+    });
+  }
 }
 var VolumeViewport$1 = VolumeViewport;
 
@@ -45853,13 +45984,6 @@ class VolumeViewport3D extends BaseVolumeViewport$1 {
     this.resetVolumeViewportClippingRange();
     return;
   }
-  posProcessNewActors() {
-    if (this.newActorAdded) {
-      const renderer = this.getRenderer();
-      renderer.resetCameraClippingRange();
-    }
-    super.posProcessNewActors();
-  }
   setSlabThickness(slabThickness, filterActorUIDs) {
     return null;
   }
@@ -46562,6 +46686,13 @@ class RenderingEngine {
     });
     this.setVtkjsDrivenViewports(vtkDrivenViewportInputEntries);
     this.setCustomViewports(customRenderingViewportInputEntries);
+    viewportInputEntries.forEach(vp => {
+      const canvas = getOrCreateCanvas(vp.element);
+      const {
+        background
+      } = vp.defaultOptions;
+      this.fillCanvasWithBackgroundColor(canvas, background);
+    });
   }
   resize(immediate = true, keepCamera = true) {
     this._throwIfDestroyed();
@@ -47539,6 +47670,9 @@ class FrameOfReferenceSpecificAnnotationManager {
         this.annotations = cloneDeep(state);
       }
     };
+    this.getAllAnnotations = () => {
+      return Object.values(this.annotations).map(frameOfReferenceSpecificAnnotations => Object.values(frameOfReferenceSpecificAnnotations)).flat(2);
+    };
     this.getNumberOfAllAnnotations = () => {
       let count = 0;
       const annotations = this.annotations;
@@ -47682,51 +47816,17 @@ var contourFinder = {
   findContoursFromReducedSet
 };
 
-function ptInArray(array, pt) {
-  let index = -1;
-  for (let i = 0; i < array.length; i++) {
-    if (isSamePoint(pt, array[i])) {
-      index = i;
-    }
-  }
-  return index;
-}
-function isSamePoint(ptA, ptB) {
-  if (ptA[0] == ptB[0] && ptA[1] == ptB[1] && ptA[2] == ptB[2]) {
-    return true;
-  } else {
-    return false;
-  }
-}
-function replacePointIndexReferences(linesArray, oldIndex, newIndex) {
-  for (let i = 0; i < linesArray.length; i++) {
-    const line = linesArray[i];
-    if (line.a == oldIndex) {
-      line.a = newIndex;
-    } else if (line.b == oldIndex) {
-      line.b = newIndex;
-    }
-  }
-}
-function removeDuplicatePoints(polyData, bypass = false) {
+function getDeduplicatedVTKPolyDataPoints(polyData, bypass = false) {
   const points = polyData.getPoints();
   const lines = polyData.getLines();
-  const pointsArray = [];
-  for (let i = 0; i < points.getNumberOfPoints(); i++) {
-    const pt = points.getPoint(i).slice();
-    pointsArray.push(pt);
-  }
-  const linesArray = [];
-  for (let i = 0; i < lines.getNumberOfCells(); i++) {
+  const pointsArray = new Array(points.getNumberOfPoints()).fill(0).map((_, i) => points.getPoint(i).slice());
+  const linesArray = new Array(lines.getNumberOfCells()).fill(0).map((_, i) => {
     const cell = lines.getCell(i * 3).slice();
-    const a = cell[0];
-    const b = cell[1];
-    const line = {
-      a,
-      b
+    return {
+      a: cell[0],
+      b: cell[1]
     };
-    linesArray.push(line);
-  }
+  });
   if (bypass) {
     return {
       points: pointsArray,
@@ -47734,31 +47834,38 @@ function removeDuplicatePoints(polyData, bypass = false) {
     };
   }
   const newPoints = [];
-  for (let i = 0; i < pointsArray.length; i++) {
-    const pt = pointsArray[i];
-    let index = ptInArray(newPoints, pt);
+  for (const [i, pt] of pointsArray.entries()) {
+    const index = newPoints.findIndex(point => point[0] === pt[0] && point[1] === pt[1] && point[2] === pt[2]);
     if (index >= 0) {
-      replacePointIndexReferences(linesArray, i, index);
+      linesArray.map(line => {
+        if (line.a === i) {
+          line.a = index;
+        }
+        if (line.b === i) {
+          line.b = index;
+        }
+        return line;
+      });
     } else {
-      index = newPoints.length;
+      const newIndex = newPoints.length;
       newPoints.push(pt);
-      replacePointIndexReferences(linesArray, i, index);
+      linesArray.map(line => {
+        if (line.a === i) {
+          line.a = newIndex;
+        }
+        if (line.b === i) {
+          line.b = newIndex;
+        }
+        return line;
+      });
     }
   }
-  const newLines = [];
-  linesArray.forEach(line => {
-    if (line.a != line.b) {
-      newLines.push(line);
-    }
-  });
+  const newLines = linesArray.filter(line => line.a !== line.b);
   return {
     points: newPoints,
     lines: newLines
   };
 }
-var mergePoints = {
-  removeDuplicatePoints
-};
 
 const getIsPointInsidePolygon = (point, vertices) => {
   const x = point[0];
@@ -48251,7 +48358,7 @@ function generateContourSetsFromLabelmap$2({
         mSquares.setContourValues(cValues);
         mSquares.setMergePoints(false);
         const msOutput = mSquares.getOutputData();
-        const reducedSet = removeDuplicatePoints(msOutput);
+        const reducedSet = getDeduplicatedVTKPolyDataPoints(msOutput);
         if (reducedSet.points?.length) {
           const contours = findContoursFromReducedSet(reducedSet.lines);
           sliceContours.push({
@@ -49428,8 +49535,8 @@ var index = /*#__PURE__*/Object.freeze({
   generateContourSetsFromLabelmap: generateContourSetsFromLabelmap$2,
   getContourHolesDataCanvas: getContourHolesDataCanvas,
   getContourHolesDataWorld: getContourHolesDataWorld,
+  getDeduplicatedVTKPolyDataPoints: getDeduplicatedVTKPolyDataPoints,
   interpolation: index$1,
-  mergePoints: mergePoints,
   updateContourPolyline: updateContourPolyline
 });