@cornerstonejs/core 4.12.4 → 4.12.6

package/dist/esm/RenderingEngine/StackViewport.js

@@ -632,8 +632,11 @@ class StackViewport extends Viewport {
     calibrateIfNecessary(imageId, imagePlaneModule) {
         const calibration = metaData.get('calibratedPixelSpacing', imageId);
         const isUpdated = this.calibration !== calibration;
-        const { scale } = calibration || {};
-        this.hasPixelSpacing = scale > 0 || imagePlaneModule.rowPixelSpacing > 0;
+        const scale = calibration?.scale;
+        this.hasPixelSpacing =
+            scale > 0 ||
+                (!imagePlaneModule.usingDefaultValues &&
+                    imagePlaneModule.rowPixelSpacing > 0);
         imagePlaneModule.calibration = calibration;
         if (!isUpdated) {
             return imagePlaneModule;

package/dist/esm/RenderingEngine/WSIViewport.d.ts

@@ -13,8 +13,10 @@ declare class WSIViewport extends Viewport {
     protected metadataDicomweb: any;
     private microscopyElement;
     protected map: any;
+    private imageURISet;
     private internalCamera;
     private viewer;
+    private annotationRemovedListener;
     private voiRange;
     private feFilter;
     private averageWhite;

package/dist/esm/RenderingEngine/WSIViewport.js

@@ -9,14 +9,18 @@ import { EPSILON } from '../constants';
 import triggerEvent from '../utilities/triggerEvent';
 import { peerImport } from '../init';
 import microscopyViewportCss from '../constants/microscopyViewportCss';
+import eventTarget from '../eventTarget';
+import imageIdToURI from '../utilities/imageIdToURI';
 let WSIUtilFunctions = null;
 const EVENT_POSTRENDER = 'postrender';
+const ANNOTATION_REMOVED = 'CORNERSTONE_TOOLS_ANNOTATION_REMOVED';
 class WSIViewport extends Viewport {
     constructor(props) {
         super({
             ...props,
             canvas: props.canvas || getOrCreateCanvas(props.element),
         });
+        this.imageURISet = new Set();
         this.internalCamera = {
             rotation: 0,
             centerIndex: [0, 0],
@@ -26,6 +30,26 @@ class WSIViewport extends Viewport {
             resolution: 1,
             zoom: 1,
         };
+        this.annotationRemovedListener = (evt) => {
+            const { detail } = evt;
+            const metadata = detail?.annotation?.metadata;
+            if (!metadata) {
+                this.postrender();
+                return;
+            }
+            const referencedImageURI = metadata.referencedImageURI ??
+                (metadata.referencedImageId
+                    ? imageIdToURI(metadata.referencedImageId)
+                    : null);
+            if (referencedImageURI && !this.hasImageURI(referencedImageURI)) {
+                return;
+            }
+            const annotationFOR = metadata.FrameOfReferenceUID ?? null;
+            if (annotationFOR && annotationFOR !== this.frameOfReferenceUID) {
+                return;
+            }
+            this.postrender();
+        };
         this.voiRange = {
             lower: 0,
             upper: 255,
@@ -127,9 +151,11 @@ class WSIViewport extends Viewport {
     }
     addEventListeners() {
         this.canvas.addEventListener(EVENTS.ELEMENT_DISABLED, this.elementDisabledHandler);
+        eventTarget.addEventListener(ANNOTATION_REMOVED, this.annotationRemovedListener);
     }
     removeEventListeners() {
         this.canvas.removeEventListener(EVENTS.ELEMENT_DISABLED, this.elementDisabledHandler);
+        eventTarget.removeEventListener(ANNOTATION_REMOVED, this.annotationRemovedListener);
     }
     elementDisabledHandler() {
         this.removeEventListeners();
@@ -138,6 +164,7 @@ class WSIViewport extends Viewport {
         const cs3dElement = this.element.firstElementChild;
         cs3dElement.removeChild(this.microscopyElement);
         this.microscopyElement = null;
+        this.imageURISet.clear();
     }
     getImageDataMetadata(imageIndex = 0) {
         const maxImage = this.metadataDicomweb.reduce((maxImage, image) => {
@@ -269,7 +296,10 @@ class WSIViewport extends Viewport {
         return imageDataReturn;
     }
     hasImageURI(imageURI) {
-        return true;
+        if (!imageURI) {
+            return false;
+        }
+        return this.imageURISet.has(imageURI);
     }
     setCamera(camera) {
         const previousCamera = this.getCamera();
@@ -358,7 +388,7 @@ class WSIViewport extends Viewport {
         const webClient = options?.webClient ||
             metaData.get(MetadataModules.WADO_WEB_CLIENT, imageIds[0]);
         if (!webClient) {
-            throw new Error(`To use setDataIds on WSI data, you must provide metaData.webClient for ${imageIds[0]}`);
+            throw new Error(`To use setDataIds on WSI data, you must provide metaData.webClient for ${imageIds[0]}.`);
         }
         return this.setWSI(imageIds, webClient);
     }
@@ -366,6 +396,7 @@ class WSIViewport extends Viewport {
         this.microscopyElement.style.background = 'black';
         this.microscopyElement.innerText = 'Loading';
         this.imageIds = imageIds;
+        this.imageURISet = new Set(imageIds.map((imageId) => imageIdToURI(imageId)));
         const DicomMicroscopyViewer = await WSIViewport.getDicomMicroscopyViewer();
         WSIUtilFunctions ||= DicomMicroscopyViewer.utils;
         this.frameOfReferenceUID = null;

package/dist/esm/utilities/getPixelSpacingInformation.d.ts

@@ -1,16 +1,13 @@
 import { CalibrationTypes } from '../enums';
-export default function getPixelSpacingInformation(instance: any): {
+export declare function getERMF(instance: any): any;
+export declare function calculateRadiographicPixelSpacing(instance: any): {
     PixelSpacing: any;
     type: CalibrationTypes;
     isProjection: boolean;
-    PixelSpacingCalibrationType?: undefined;
-    PixelSpacingCalibrationDescription?: undefined;
-} | {
+};
+export declare function getPixelSpacingInformation(instance: any): {
     PixelSpacing: any;
     type: CalibrationTypes;
     isProjection: boolean;
-    PixelSpacingCalibrationType: any;
-    PixelSpacingCalibrationDescription: any;
-} | {
-    PixelSpacing: number[];
 };
+export default getPixelSpacingInformation;

package/dist/esm/utilities/getPixelSpacingInformation.js

@@ -14,50 +14,62 @@ const projectionRadiographSOPClassUIDs = new Set([
     '1.2.840.10008.5.1.4.1.1.12.2.1',
     '1.2.840.10008.5.1.4.1.1.12.3',
 ]);
-const alreadySeenWarn = new Set();
-function calculateRadiographicPixelSpacing(instance) {
-    const { PixelSpacing, ImagerPixelSpacing, EstimatedRadiographicMagnificationFactor, PixelSpacingCalibrationType, PixelSpacingCalibrationDescription, } = instance;
-    const isProjection = true;
-    if (!ImagerPixelSpacing) {
-        return {
-            PixelSpacing,
-            type: CalibrationTypes.UNKNOWN,
-            isProjection,
-        };
+export function getERMF(instance) {
+    const { PixelSpacing, ImagerPixelSpacing, EstimatedRadiographicMagnificationFactor: ermf, DistanceSourceToDetector: sid, DistanceSourceToPatient: sod, } = instance;
+    if (ermf) {
+        return ermf;
     }
-    if (!PixelSpacing) {
-        if (!EstimatedRadiographicMagnificationFactor) {
-            if (!alreadySeenWarn.has(instance.SeriesInstanceUID)) {
-                console.warn('EstimatedRadiographicMagnificationFactor was not present on series', instance.SeriesInstanceUID, ' Unable to correct ImagerPixelSpacing.');
-                alreadySeenWarn.add(instance.SeriesInstanceUID);
-            }
-            return {
-                PixelSpacing: ImagerPixelSpacing,
-                type: CalibrationTypes.PROJECTION,
-                isProjection,
-            };
+    if (sod < sid) {
+        return sid / sod;
+    }
+    if (ImagerPixelSpacing?.[0] > PixelSpacing?.[0]) {
+        return true;
+    }
+}
+export function calculateRadiographicPixelSpacing(instance) {
+    const { PixelSpacing, ImagerPixelSpacing, PixelSpacingCalibrationType } = instance;
+    const isProjection = true;
+    if (PixelSpacing && PixelSpacingCalibrationType === 'GEOMETRY') {
+        if (isEqual(PixelSpacing, ImagerPixelSpacing)) {
+            console.warn('Calibration type is geometry, but pixel spacing and imager pixel spacing identical', PixelSpacing, ImagerPixelSpacing);
         }
-        const correctedPixelSpacing = ImagerPixelSpacing.map((pixelSpacing) => pixelSpacing / EstimatedRadiographicMagnificationFactor);
         return {
-            PixelSpacing: correctedPixelSpacing,
+            PixelSpacing,
             type: CalibrationTypes.ERMF,
             isProjection,
         };
     }
-    if (isEqual(PixelSpacing, ImagerPixelSpacing)) {
+    if (PixelSpacing && PixelSpacingCalibrationType === 'FIDUCIAL') {
         return {
             PixelSpacing,
-            type: CalibrationTypes.PROJECTION,
+            type: CalibrationTypes.CALIBRATED,
             isProjection,
         };
     }
-    if (PixelSpacingCalibrationType || PixelSpacingCalibrationDescription) {
+    if (ImagerPixelSpacing) {
+        const ermf = getERMF(instance);
+        if (ermf > 1) {
+            const correctedPixelSpacing = ImagerPixelSpacing.map((pixelSpacing) => pixelSpacing / ermf);
+            return {
+                PixelSpacing: correctedPixelSpacing,
+                type: CalibrationTypes.ERMF,
+                isProjection,
+            };
+        }
+        if (ermf === true) {
+            return {
+                PixelSpacing,
+                type: CalibrationTypes.ERMF,
+                isProjection,
+            };
+        }
+        if (ermf) {
+            console.error('Illegal ERMF value:', ermf);
+        }
         return {
-            PixelSpacing,
-            type: CalibrationTypes.CALIBRATED,
+            PixelSpacing: PixelSpacing || ImagerPixelSpacing,
+            type: CalibrationTypes.PROJECTION,
             isProjection,
-            PixelSpacingCalibrationType,
-            PixelSpacingCalibrationDescription,
         };
     }
     return {
@@ -66,29 +78,8 @@ function calculateRadiographicPixelSpacing(instance) {
         isProjection,
     };
 }
-function calculateUSPixelSpacing(instance) {
-    const { SequenceOfUltrasoundRegions } = instance;
-    const isArrayOfSequences = Array.isArray(SequenceOfUltrasoundRegions);
-    if (isArrayOfSequences && SequenceOfUltrasoundRegions.length > 1) {
-        console.warn('Sequence of Ultrasound Regions > one entry. This is not yet implemented, all measurements will be shown in pixels.');
-        return;
-    }
-    const { PhysicalDeltaX, PhysicalDeltaY } = isArrayOfSequences
-        ? SequenceOfUltrasoundRegions[0]
-        : SequenceOfUltrasoundRegions;
-    const USPixelSpacing = [
-        Math.abs(PhysicalDeltaX) * 10,
-        Math.abs(PhysicalDeltaY) * 10,
-    ];
-    return {
-        PixelSpacing: USPixelSpacing,
-    };
-}
-export default function getPixelSpacingInformation(instance) {
-    const { PixelSpacing, SOPClassUID, SequenceOfUltrasoundRegions } = instance;
-    if (SequenceOfUltrasoundRegions) {
-        return calculateUSPixelSpacing(instance);
-    }
+export function getPixelSpacingInformation(instance) {
+    const { PixelSpacing, SOPClassUID } = instance;
     const isProjection = projectionRadiographSOPClassUIDs.has(SOPClassUID);
     if (isProjection) {
         return calculateRadiographicPixelSpacing(instance);
@@ -99,3 +90,4 @@ export default function getPixelSpacingInformation(instance) {
         isProjection: false,
     };
 }
+export default getPixelSpacingInformation;

package/dist/esm/utilities/index.d.ts

@@ -92,9 +92,9 @@ import getVolumeDirectionVectors from './getVolumeDirectionVectors';
 import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 export * as logger from './logger';
 import { calculateNeighborhoodStats } from './calculateNeighborhoodStats';
-import getPixelSpacingInformation from './getPixelSpacingInformation';
+export * from './getPixelSpacingInformation';
 import { asArray } from './asArray';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
 export * from './isEqual';
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, getPixelSpacingInformation, asArray, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, };

package/dist/esm/utilities/index.js

@@ -93,9 +93,9 @@ import getVolumeDirectionVectors from './getVolumeDirectionVectors';
 import calculateSpacingBetweenImageIds from './calculateSpacingBetweenImageIds';
 export * as logger from './logger';
 import { calculateNeighborhoodStats } from './calculateNeighborhoodStats';
-import getPixelSpacingInformation from './getPixelSpacingInformation';
+export * from './getPixelSpacingInformation';
 import { asArray } from './asArray';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
 export * from './isEqual';
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, getPixelSpacingInformation, asArray, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, };

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.12.4";
+export declare const version = "4.12.6";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.12.4';
+export const version = '4.12.6';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "4.12.4",
+  "version": "4.12.6",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -97,5 +97,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "709d5a61b1acccf6a2dd8f9193907f98b5ed6c4c"
+  "gitHead": "67da5ec35cb711e4310f0f1971bd8ed090377338"
 }