@cornerstonejs/adapters 1.56.2 → 1.57.1

package/dist/adapters.es.js

@@ -5072,6 +5072,7 @@ var Events$2;
   Events["CAMERA_MODIFIED"] = "CORNERSTONE_CAMERA_MODIFIED";
   Events["CAMERA_RESET"] = "CORNERSTONE_CAMERA_RESET";
   Events["VOI_MODIFIED"] = "CORNERSTONE_VOI_MODIFIED";
+  Events["PRESET_MODIFIED"] = "CORNERSTONE_VIEWPORT_RENDERING_PRESET_MODIFIED";
   Events["DISPLAY_AREA_MODIFIED"] = "CORNERSTONE_DISPLAY_AREA_MODIFIED";
   Events["ELEMENT_DISABLED"] = "CORNERSTONE_ELEMENT_DISABLED";
   Events["ELEMENT_ENABLED"] = "CORNERSTONE_ELEMENT_ENABLED";
@@ -38139,24 +38140,26 @@ function applyPreset(actor, preset) {
     normPoints.push([value, opacity]);
   }
   applyPointsToPiecewiseFunction(normPoints, shiftRange, ofun);
-  actor.getProperty().setScalarOpacity(0, ofun);
+  const property = actor.getProperty();
+  property.setScalarOpacity(0, ofun);
   const [gradientMinValue, gradientMinOpacity, gradientMaxValue, gradientMaxOpacity] = preset.gradientOpacity.split(' ').splice(1).map(parseFloat);
-  actor.getProperty().setUseGradientOpacity(0, true);
-  actor.getProperty().setGradientOpacityMinimumValue(0, gradientMinValue);
-  actor.getProperty().setGradientOpacityMinimumOpacity(0, gradientMinOpacity);
-  actor.getProperty().setGradientOpacityMaximumValue(0, gradientMaxValue);
-  actor.getProperty().setGradientOpacityMaximumOpacity(0, gradientMaxOpacity);
+  property.setUseGradientOpacity(0, true);
+  property.setGradientOpacityMinimumValue(0, gradientMinValue);
+  property.setGradientOpacityMinimumOpacity(0, gradientMinOpacity);
+  property.setGradientOpacityMaximumValue(0, gradientMaxValue);
+  property.setGradientOpacityMaximumOpacity(0, gradientMaxOpacity);
   if (preset.interpolation === '1') {
-    actor.getProperty().setInterpolationTypeToFastLinear();
+    property.setInterpolationTypeToFastLinear();
   }
+  property.setShade(preset.shade === '1');
   const ambient = parseFloat(preset.ambient);
   const diffuse = parseFloat(preset.diffuse);
   const specular = parseFloat(preset.specular);
   const specularPower = parseFloat(preset.specularPower);
-  actor.getProperty().setAmbient(ambient);
-  actor.getProperty().setDiffuse(diffuse);
-  actor.getProperty().setSpecular(specular);
-  actor.getProperty().setSpecularPower(specularPower);
+  property.setAmbient(ambient);
+  property.setDiffuse(diffuse);
+  property.setSpecular(specular);
+  property.setSpecularPower(specularPower);
 }
 function getShiftRange(colorTransferArray) {
   let min = Infinity;
@@ -40953,7 +40956,7 @@ class Viewport {
   getCurrentImageIdIndex() {
     throw new Error('Not implemented');
   }
-  getTargetId(specifier) {
+  getReferenceId(specifier) {
     return null;
   }
   setPan(pan, storeAsInitialCamera = false) {
@@ -41230,6 +41233,32 @@ class Viewport {
       heightWorld: maxY - minY
     };
   }
+  getViewReference(viewRefSpecifier = {}) {
+    const {
+      focalPoint: cameraFocalPoint,
+      viewPlaneNormal
+    } = this.getCamera();
+    const target = {
+      FrameOfReferenceUID: this.getFrameOfReferenceUID(),
+      cameraFocalPoint,
+      viewPlaneNormal,
+      sliceIndex: viewRefSpecifier.sliceIndex ?? this.getCurrentImageIdIndex()
+    };
+    return target;
+  }
+  isReferenceViewable(viewRef, options) {
+    if (viewRef.FrameOfReferenceUID && viewRef.FrameOfReferenceUID !== this.getFrameOfReferenceUID()) {
+      return false;
+    }
+    const {
+      viewPlaneNormal
+    } = viewRef;
+    const camera = this.getCamera();
+    if (!isEqual$2(viewPlaneNormal, camera.viewPlaneNormal) && !isEqual$2(vec3.negate(camera.viewPlaneNormal, camera.viewPlaneNormal), viewPlaneNormal)) {
+      return options?.asVolume === true;
+    }
+    return true;
+  }
   _shouldUseNativeDataType() {
     const {
       useNorm16Texture,
@@ -41710,6 +41739,32 @@ class BaseVolumeViewport extends Viewport$1 {
       this.resetToDefaultProperties(volumeId);
     }
   }
+  getViewReference(viewRefSpecifier = {}) {
+    const target = super.getViewReference(viewRefSpecifier);
+    if (viewRefSpecifier?.forFrameOfReference !== false) {
+      target.volumeId = this.getVolumeId(viewRefSpecifier);
+    }
+    return {
+      ...target,
+      sliceIndex: this.getCurrentImageIdIndex()
+    };
+  }
+  isReferenceViewable(viewRef, options) {
+    if (!super.isReferenceViewable(viewRef, options)) {
+      return false;
+    }
+    if (options?.withNavigation) {
+      return true;
+    }
+    const currentSliceIndex = this.getCurrentImageIdIndex();
+    const {
+      sliceIndex
+    } = viewRef;
+    if (Array.isArray(sliceIndex)) {
+      return sliceIndex[0] <= currentSliceIndex && currentSliceIndex <= sliceIndex[1];
+    }
+    return sliceIndex === undefined || sliceIndex === currentSliceIndex;
+  }
   setProperties({
     voiRange,
     VOILUTFunction,
@@ -41786,7 +41841,7 @@ class BaseVolumeViewport extends Viewport$1 {
     }
     this.render();
   }
-  setPreset(presetName, volumeId, suppressEvents) {
+  setPreset(presetNameOrObj, volumeId, suppressEvents) {
     const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
     if (!applicableVolumeActorInfo) {
       return;
@@ -41794,14 +41849,24 @@ class BaseVolumeViewport extends Viewport$1 {
     const {
       volumeActor
     } = applicableVolumeActorInfo;
-    const preset = VIEWPORT_PRESETS.find(preset => {
-      return preset.name === presetName;
-    });
+    let preset = presetNameOrObj;
+    if (typeof preset === 'string') {
+      preset = VIEWPORT_PRESETS.find(preset => {
+        return preset.name === presetNameOrObj;
+      });
+    }
     if (!preset) {
       return;
     }
     applyPreset(volumeActor, preset);
-    this.viewportProperties.preset = presetName;
+    if (!suppressEvents) {
+      triggerEvent(this.element, EVENTS.PRESET_MODIFIED, {
+        viewportId: this.id,
+        volumeId: applicableVolumeActorInfo.volumeId,
+        actor: volumeActor,
+        presetName: preset.name
+      });
+    }
   }
   async setVolumes(volumeInputArray, immediate = false, suppressEvents = false) {
     const firstImageVolume = cache$1.getVolume(volumeInputArray[0].volumeId);
@@ -42004,10 +42069,20 @@ class BaseVolumeViewport extends Viewport$1 {
     const voxelIndex = index[2] * dimensions[0] * dimensions[1] + index[1] * dimensions[0] + index[0];
     return volume.getScalarData()[voxelIndex];
   }
-  getTargetId(specifier = {}) {
+  getVolumeId(specifier) {
+    if (!specifier?.volumeId) {
+      const actorEntries = this.getActors();
+      if (!actorEntries) {
+        return;
+      }
+      return actorEntries.find(actorEntry => actorEntry.actor.getClassName() === 'vtkVolume')?.uid;
+    }
+    return specifier.volumeId;
+  }
+  getReferenceId(specifier = {}) {
     let {
       volumeId,
-      sliceIndex
+      sliceIndex: sliceIndex
     } = specifier;
     if (!volumeId) {
       const actorEntries = this.getActors();
@@ -46154,11 +46229,52 @@ class StackViewport extends Viewport$1 {
     }
     return voiLUTFunction;
   }
-  getTargetId(specifier = {}) {
+  isReferenceViewable(viewRef, options = {}) {
+    if (!super.isReferenceViewable(viewRef, options)) {
+      return false;
+    }
+    let {
+      imageURI
+    } = options;
+    const {
+      referencedImageId,
+      sliceIndex
+    } = viewRef;
+    if (viewRef.volumeId && !referencedImageId) {
+      return options.asVolume === true;
+    }
+    let testIndex = this.getCurrentImageIdIndex();
+    if (options.withNavigation && typeof sliceIndex === 'number') {
+      testIndex = sliceIndex;
+    }
+    const imageId = this.imageIds[testIndex];
+    if (!imageId) {
+      return false;
+    }
+    if (!imageURI) {
+      const colonIndex = imageId.indexOf(':');
+      imageURI = imageId.substring(colonIndex + 1);
+    }
+    return referencedImageId.endsWith(imageURI);
+  }
+  getViewReference(viewRefSpecifier = {}) {
+    const {
+      sliceIndex = this.currentImageIdIndex
+    } = viewRefSpecifier;
+    return {
+      ...super.getViewReference(viewRefSpecifier),
+      referencedImageId: `${this.imageIds[sliceIndex]}`,
+      sliceIndex: sliceIndex
+    };
+  }
+  getReferenceId(specifier = {}) {
     const {
-      sliceIndex: imageIdIndex = this.currentImageIdIndex
+      sliceIndex = this.currentImageIdIndex
     } = specifier;
-    return `imageId:${this.imageIds[imageIdIndex]}`;
+    if (Array.isArray(sliceIndex)) {
+      throw new Error('Use of slice ranges for stacks not supported');
+    }
+    return `imageId:${this.imageIds[sliceIndex]}`;
   }
   getCPUFallbackError(method) {
     return new Error(`method ${method} cannot be used during CPU Fallback mode`);
@@ -46598,6 +46714,14 @@ class VideoViewport extends Viewport$1 {
         time: this.videoElement.currentTime,
         duration: this.videoElement.duration
       });
+      triggerEvent(this.element, EVENTS.IMAGE_RENDERED, {
+        element: this.element,
+        viewportId: this.id,
+        viewport: this,
+        renderingEngineId: this.renderingEngineId,
+        time: this.videoElement.currentTime,
+        duration: this.videoElement.duration
+      });
       const frame = this.getFrameNumber();
       if (this.isPlaying) {
         if (frame < this.frameRange[0]) {
@@ -46997,16 +47121,67 @@ class VideoViewport extends Viewport$1 {
     const current = this.imageId.replace('/frames/1', this.isPlaying ? `/frames/${this.frameRange[0]}-${this.frameRange[1]}` : `/frames/${this.getFrameNumber()}`);
     return current;
   }
-  getTargetId(specifier = {}) {
+  getReferenceId(specifier = {}) {
     const {
-      sliceIndex
+      sliceIndex: sliceIndex
     } = specifier;
     if (sliceIndex === undefined) {
       return `videoId:${this.getCurrentImageId()}`;
     }
+    if (Array.isArray(sliceIndex)) {
+      return `videoId:${this.imageId.substring(0, this.imageId.length - 1)}${sliceIndex[0] + 1}-${sliceIndex[1] + 1}`;
+    }
     const baseTarget = this.imageId.replace('/frames/1', `/frames/${1 + sliceIndex}`);
     return `videoId:${baseTarget}`;
   }
+  isReferenceViewable(viewRef, options = {}) {
+    let {
+      imageURI
+    } = options;
+    const {
+      referencedImageId,
+      sliceIndex: sliceIndex
+    } = viewRef;
+    if (!super.isReferenceViewable(viewRef)) {
+      return false;
+    }
+    const imageId = this.getCurrentImageId();
+    if (!imageURI) {
+      const colonIndex = imageId.indexOf(':');
+      imageURI = imageId.substring(colonIndex + 1, imageId.length - 1);
+    }
+    if (options.withNavigation) {
+      return true;
+    }
+    const currentIndex = this.getCurrentImageIdIndex();
+    if (Array.isArray(sliceIndex)) {
+      return currentIndex >= sliceIndex[0] && currentIndex <= sliceIndex[1];
+    }
+    if (sliceIndex !== undefined) {
+      return currentIndex === sliceIndex;
+    }
+    if (!referencedImageId) {
+      return false;
+    }
+    const match = referencedImageId.match(VideoViewport.frameRangeExtractor);
+    if (!match || !match[2]) {
+      return true;
+    }
+    const range = match[2].split('-').map(it => Number(it));
+    const frame = currentIndex + 1;
+    return range[0] <= frame && frame <= (range[1] ?? range[0]);
+  }
+  getViewReference(viewRefSpecifier) {
+    let sliceIndex = viewRefSpecifier?.sliceIndex;
+    if (!sliceIndex) {
+      sliceIndex = this.isPlaying ? [this.frameRange[0] - 1, this.frameRange[1] - 1] : this.getCurrentImageIdIndex();
+    }
+    return {
+      ...super.getViewReference(viewRefSpecifier),
+      referencedImageId: this.getReferenceId(viewRefSpecifier),
+      sliceIndex: sliceIndex
+    };
+  }
   getFrameNumber() {
     return 1 + this.getCurrentImageIdIndex();
   }
@@ -49195,8 +49370,11 @@ function getInterpolationData(viewportData, filterParams = []) {
   } = viewportData;
   const interpolationDatas = new Map();
   const annotations = getAnnotations(annotation.metadata.toolName, viewport.element);
+  if (!annotations) {
+    return interpolationDatas;
+  }
   for (let i = 0; i < sliceData.numberOfSlices; i++) {
-    const imageAnnotations = annotations.filter(x => x.metadata.referencedSliceIndex === i);
+    const imageAnnotations = annotations.filter(x => x.metadata.sliceIndex === i);
     if (!imageAnnotations?.length) {
       continue;
     }
@@ -49273,6 +49451,10 @@ function findAnnotationsForInterpolation(toolData, viewportData) {
     value: viewportData.interpolationUID
   }]);
   const rangeToInterpolate = getRangeToInterpolate(interpolationData);
+  if (!rangeToInterpolate) {
+    console.warn('No annotations found to interpolate', interpolationData);
+    return;
+  }
   const sliceEdited = _getSlicePositionOfToolData(interpolationData, toolData.annotationUID);
   const interpolationList = [];
   for (let i = rangeToInterpolate[0] + 1; i < rangeToInterpolate[1]; i++) {
@@ -49571,7 +49753,10 @@ function startInterpolation(viewportData) {
   const {
     interpolationData,
     interpolationList
-  } = findAnnotationsForInterpolation(toolData, viewportData);
+  } = findAnnotationsForInterpolation(toolData, viewportData) || {};
+  if (!interpolationData || !interpolationList) {
+    return;
+  }
   const eventData = {
     toolName: toolData.metadata.toolName,
     toolType: toolData.metadata.toolName,
@@ -49628,11 +49813,11 @@ function _addInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex,
     viewport
   } = eventData;
   const interpolatedAnnotation = createPolylineToolData(points, handlePoints, referencedToolData);
-  const targetId = viewport.getTargetId({
+  const targetId = viewport.getReferenceId({
     sliceIndex
   });
   interpolatedAnnotation.metadata.referencedImageId = targetId;
-  interpolatedAnnotation.metadata.referencedSliceIndex = sliceIndex;
+  interpolatedAnnotation.metadata.sliceIndex = sliceIndex;
   addAnnotation(interpolatedAnnotation, viewport.element);
   referencedToolData.onInterpolationComplete?.(interpolatedAnnotation, referencedToolData);
 }
@@ -49644,7 +49829,7 @@ function _editInterpolatedContour(interpolated3DPoints, handlePoints, sliceIndex
   let toolDataIndex;
   for (let i = 0; i < annotations.length; i++) {
     const annotation = annotations[i];
-    if (annotation.interpolationUID === referencedToolData.interpolationUID && annotation.metadata.referencedSliceIndex === sliceIndex) {
+    if (annotation.interpolationUID === referencedToolData.interpolationUID && annotation.metadata.sliceIndex === sliceIndex) {
       toolDataIndex = i;
       break;
     }
@@ -49871,7 +50056,7 @@ function deleteRelatedAnnotations(viewportData) {
     key: 'interpolationUID',
     value: viewportData.interpolationUID
   }]);
-  const referencedSliceIndex = annotation.metadata.referencedSliceIndex;
+  const referencedSliceIndex = annotation.metadata.sliceIndex;
   let minInterpolation = -1;
   let maxInterpolation = viewportData.sliceData.numberOfSlices;
   for (const [sliceIndex, annotations] of interpolationAnnotations.entries()) {
@@ -49915,7 +50100,7 @@ function deleteRelatedAnnotations(viewportData) {
       viewport: viewportData.viewport,
       sliceData: {
         numberOfSlices: viewportData.sliceData.numberOfSlices,
-        imageIndex: nextAnnotation.metadata.referencedSliceIndex
+        imageIndex: nextAnnotation.metadata.sliceIndex
       },
       annotation: nextAnnotation,
       interpolationUID: nextAnnotation.interpolationUID
@@ -49961,7 +50146,7 @@ class InterpolationManager {
         if (segmentIndex && segmentIndex !== data.segmentation.segmentIndex) {
           continue;
         }
-        if (sliceIndex !== undefined && metadata && sliceIndex !== metadata.referencedSliceIndex) {
+        if (sliceIndex !== undefined && metadata && sliceIndex !== metadata.sliceIndex) {
           continue;
         }
         if (segmentationId && segmentationId !== data.segmentation.segmentationId) {