@cornerstonejs/core 3.7.17 → 3.8.0

package/dist/esm/cache/cache.d.ts

@@ -4,6 +4,7 @@ declare class Cache {
     private readonly _imageCache;
     private readonly _volumeCache;
     private readonly _imageIdsToVolumeIdCache;
+    private readonly _referencedImageIdToImageIdCache;
     private readonly _geometryCache;
     private _imageCacheSize;
     private _maxCacheSize;
@@ -42,6 +43,7 @@ declare class Cache {
     private _decacheGeometry;
     incrementGeometryCacheSize: (increment: number) => void;
     decrementGeometryCacheSize: (decrement: number) => void;
+    getImageByReferencedImageId: (referencedImageId: string) => IImage | undefined;
     getImage: (imageId: string, minQuality?: ImageQualityStatus) => IImage | undefined;
     setPartialImage(imageId: string, partialImage?: IImage): void;
     getImageQuality(imageId: string): ImageQualityStatus;

package/dist/esm/cache/cache.js

@@ -10,6 +10,7 @@ class Cache {
         this._imageCache = new Map();
         this._volumeCache = new Map();
         this._imageIdsToVolumeIdCache = new Map();
+        this._referencedImageIdToImageIdCache = new Map();
         this._geometryCache = new Map();
         this._imageCacheSize = 0;
         this._maxCacheSize = 3 * ONE_GB;
@@ -43,6 +44,9 @@ class Cache {
                 throw new Error('Cannot decache an image with a shared cache key. You need to manually decache the volume first.');
             }
             const { imageLoadObject } = cachedImage;
+            if (cachedImage.image?.referencedImageId) {
+                this._referencedImageIdToImageIdCache.delete(cachedImage.image.referencedImageId);
+            }
             if (imageLoadObject?.cancelFn) {
                 imageLoadObject.cancelFn();
             }
@@ -200,6 +204,13 @@ class Cache {
         this.decrementGeometryCacheSize = (decrement) => {
             this._geometryCacheSize -= decrement;
         };
+        this.getImageByReferencedImageId = (referencedImageId) => {
+            const imageId = this._referencedImageIdToImageIdCache.get(referencedImageId);
+            if (imageId) {
+                return this._imageCache.get(imageId)?.image;
+            }
+            return undefined;
+        };
         this.getImage = (imageId, minQuality = ImageQualityStatus.FAR_REPLICATE) => {
             if (imageId === undefined) {
                 throw new Error('getImage: imageId must not be undefined');
@@ -375,6 +386,9 @@ class Cache {
         const eventDetails = {
             image: cachedImage,
         };
+        if (image.referencedImageId) {
+            this._referencedImageIdToImageIdCache.set(image.referencedImageId, imageId);
+        }
         triggerEvent(eventTarget, Events.IMAGE_CACHE_IMAGE_ADDED, eventDetails);
         cachedImage.sharedCacheKey = image.sharedCacheKey;
     }

package/dist/esm/loaders/imageLoader.d.ts

@@ -17,6 +17,7 @@ interface LocalImageOptions {
     spacing?: Point2;
     origin?: Point3;
     direction?: Mat3;
+    referencedImageId?: string;
     skipCreateBuffer?: boolean;
     onCacheAdd?: (image: IImage) => void;
 }

package/dist/esm/loaders/imageLoader.js

@@ -136,6 +136,7 @@ export function createAndCacheDerivedImage(referencedImageId, options = {}) {
         origin: imagePlaneModule.imagePositionPatient,
         direction: imagePlaneModule.imageOrientationPatient,
         frameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
+        referencedImageId: referencedImageId,
     });
     localImage.referencedImageId = referencedImageId;
     if (!cache.getImageLoadObject(imageId)) {
@@ -163,7 +164,7 @@ export function createAndCacheDerivedImages(referencedImageIds, options = {}) {
     return images;
 }
 export function createAndCacheLocalImage(imageId, options) {
-    const { scalarData, origin, direction, targetBuffer, skipCreateBuffer, onCacheAdd, frameOfReferenceUID, voxelRepresentation, } = options;
+    const { scalarData, origin, direction, targetBuffer, skipCreateBuffer, onCacheAdd, frameOfReferenceUID, voxelRepresentation, referencedImageId, } = options;
     const dimensions = options.dimensions;
     const spacing = options.spacing;
     if (!dimensions || !spacing) {
@@ -247,13 +248,15 @@ export function createAndCacheLocalImage(imageId, options) {
             metadata: metadata[type] || {},
         });
     });
+    const id = imageId;
     const voxelManager = (voxelRepresentation === VoxelManagerEnum.RLE &&
-        VoxelManager.createRLEImageVoxelManager({ dimensions })) ||
+        VoxelManager.createRLEImageVoxelManager({ dimensions, id })) ||
         VoxelManager.createImageVoxelManager({
             height,
             width,
             numberOfComponents,
             scalarData: scalarDataToUse,
+            id,
         });
     let minPixelValue = scalarDataToUse[0];
     let maxPixelValue = scalarDataToUse[0];
@@ -289,6 +292,7 @@ export function createAndCacheLocalImage(imageId, options) {
         getPixelData: () => voxelManager.getScalarData(),
         voxelManager,
         sizeInBytes: scalarData.byteLength,
+        referencedImageId,
     };
     onCacheAdd?.(image);
     cache.putImageSync(image.imageId, image);

package/dist/esm/loaders/volumeLoader.js

@@ -200,6 +200,7 @@ export function createLocalVolume(volumeId, options = {}) {
         imageIds,
         dimensions,
         numberOfComponents: 1,
+        id: volumeId,
     });
     imageVolume.voxelManager = voxelManager;
     if (!preventCache) {

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

@@ -27,6 +27,7 @@ export default class VoxelManager<T> {
         sliceIndex: number;
         slicePlane: number;
     }) => PixelDataTypedArray;
+    get id(): string;
     constructor(dimensions: any, options: {
         _get: (index: number) => T;
         _set?: (index: number, v: T) => boolean;
@@ -85,46 +86,52 @@ export default class VoxelManager<T> {
     private setSliceDataValue;
     private toNumber;
     private static _createRGBScalarVolumeVoxelManager;
-    static createImageVolumeVoxelManager({ dimensions, imageIds, numberOfComponents, }: {
+    static createImageVolumeVoxelManager({ dimensions, imageIds, numberOfComponents, id, }: {
         dimensions: Point3;
         imageIds: string[];
         numberOfComponents: number;
+        id?: string;
     }): IVoxelManager<number> | IVoxelManager<RGB>;
-    static createScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents, }: {
+    static createScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents, id, }: {
         dimensions: Point3;
         scalarData: any;
         numberOfComponents?: number;
+        id?: string;
     }): IVoxelManager<number> | IVoxelManager<RGB>;
-    static createScalarDynamicVolumeVoxelManager({ imageIdGroups, dimensions, dimensionGroupNumber, timePoint, numberOfComponents, }: {
+    static createScalarDynamicVolumeVoxelManager({ imageIdGroups, dimensions, dimensionGroupNumber, timePoint, numberOfComponents, id, }: {
         imageIdGroups: string[][];
         dimensions: Point3;
         dimensionGroupNumber?: number;
         timePoint?: number;
         numberOfComponents?: number;
+        id?: string;
     }): IVoxelManager<number> | IVoxelManager<RGB>;
-    static createImageVoxelManager({ width, height, scalarData, numberOfComponents, }: {
+    static createImageVoxelManager({ width, height, scalarData, numberOfComponents, id, }: {
         width: number;
         height: number;
         scalarData: PixelDataTypedArray;
         numberOfComponents?: number;
+        id?: string;
     }): IVoxelManager<number> | IVoxelManager<RGB>;
     private static _createNumberVolumeVoxelManager;
-    static createMapVoxelManager<T>({ dimension, }: {
+    static createMapVoxelManager<T>({ dimension, id, }: {
         dimension: Point3;
+        id?: string;
     }): IVoxelManager<T>;
-    static createHistoryVoxelManager<T>({ sourceVoxelManager, }: {
-        sourceVoxelManager: VoxelManager<T>;
-    }): VoxelManager<T>;
-    static createRLEHistoryVoxelManager<T>(sourceVoxelManager: VoxelManager<T>): VoxelManager<T>;
-    static createLazyVoxelManager<T>({ dimensions, planeFactory, }: {
+    static createHistoryVoxelManager<T>(sourceVoxelManager: VoxelManager<T>, id?: string): VoxelManager<T>;
+    static createRLEHistoryVoxelManager<T>(sourceVoxelManager: VoxelManager<T>, id?: string): VoxelManager<T>;
+    static createLazyVoxelManager<T>({ dimensions, planeFactory, id, }: {
         dimensions: Point3;
         planeFactory: (width: number, height: number) => T;
+        id?: string;
     }): VoxelManager<T>;
-    static createRLEVolumeVoxelManager<T>({ dimensions, }: {
+    static createRLEVolumeVoxelManager<T>({ dimensions, id, }: {
         dimensions: Point3;
+        id?: string;
     }): VoxelManager<T>;
-    static createRLEImageVoxelManager<T>({ dimensions, }: {
+    static createRLEImageVoxelManager<T>({ dimensions, id, }: {
         dimensions: Point2;
+        id?: string;
     }): VoxelManager<T>;
     static addInstanceToImage(image: IImage): void;
     static: any;

package/dist/esm/utilities/VoxelManager.js

@@ -4,6 +4,9 @@ import isEqual from './isEqual';
 import { iterateOverPointsInShapeVoxelManager } from './pointInShapeCallback';
 const DEFAULT_RLE_SIZE = 5 * 1024;
 export default class VoxelManager {
+    get id() {
+        return this._id;
+    }
     constructor(dimensions, options) {
         this.modifiedSlices = new Set();
         this.boundsIJK = [
@@ -369,7 +372,7 @@ export default class VoxelManager {
         }
         return 0;
     }
-    static _createRGBScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents = 3, }) {
+    static _createRGBScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents = 3, id, }) {
         const voxels = new VoxelManager(dimensions, {
             _get: (index) => {
                 index *= numberOfComponents;
@@ -379,7 +382,7 @@ export default class VoxelManager {
                     scalarData[index++],
                 ];
             },
-            _id: '_createRGBScalarVolumeVoxelManager',
+            _id: id || '_createRGBScalarVolumeVoxelManager',
             _set: (index, v) => {
                 index *= 3;
                 const isChanged = !isEqual(scalarData[index], v);
@@ -396,7 +399,7 @@ export default class VoxelManager {
         };
         return voxels;
     }
-    static createImageVolumeVoxelManager({ dimensions, imageIds, numberOfComponents = 1, }) {
+    static createImageVolumeVoxelManager({ dimensions, imageIds, numberOfComponents = 1, id, }) {
         const pixelsPerSlice = dimensions[0] * dimensions[1];
         function getPixelInfo(index) {
             const sliceIndex = Math.floor(index / pixelsPerSlice);
@@ -449,7 +452,7 @@ export default class VoxelManager {
             _set: setVoxelValue,
             numberOfComponents,
             _getConstructor,
-            _id: 'createImageVolumeVoxelManager',
+            _id: id || 'createImageVolumeVoxelManager',
         });
         voxelManager.getMiddleSliceData = () => {
             const middleSliceIndex = Math.floor(dimensions[2] / 2);
@@ -563,7 +566,7 @@ export default class VoxelManager {
         };
         return voxelManager;
     }
-    static createScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents, }) {
+    static createScalarVolumeVoxelManager({ dimensions, scalarData, numberOfComponents, id, }) {
         if (dimensions.length !== 3) {
             throw new Error('Dimensions must be provided as [number, number, number] for [width, height, depth]');
         }
@@ -581,14 +584,16 @@ export default class VoxelManager {
                 dimensions,
                 scalarData,
                 numberOfComponents,
+                id,
             });
         }
         return VoxelManager._createNumberVolumeVoxelManager({
             dimensions,
             scalarData,
+            id,
         });
     }
-    static createScalarDynamicVolumeVoxelManager({ imageIdGroups, dimensions, dimensionGroupNumber = 1, timePoint = 0, numberOfComponents = 1, }) {
+    static createScalarDynamicVolumeVoxelManager({ imageIdGroups, dimensions, dimensionGroupNumber = 1, timePoint = 0, numberOfComponents = 1, id, }) {
         let activeDimensionGroup = 0;
         if (dimensionGroupNumber !== undefined) {
             activeDimensionGroup = dimensionGroupNumber - 1;
@@ -615,13 +620,14 @@ export default class VoxelManager {
                 dimensions,
                 imageIds,
                 numberOfComponents,
+                id,
             });
         });
         const voxelManager = new VoxelManager(dimensions, {
             _get: (index) => voxelGroups[activeDimensionGroup]._get(index),
             _set: (index, v) => voxelGroups[activeDimensionGroup]._set(index, v),
             numberOfComponents,
-            _id: 'createScalarDynamicVolumeVoxelManager',
+            _id: id || 'createScalarDynamicVolumeVoxelManager',
         });
         voxelManager.getScalarDataLength = () => {
             return voxelGroups[activeDimensionGroup].getScalarDataLength();
@@ -674,7 +680,7 @@ export default class VoxelManager {
         };
         return voxelManager;
     }
-    static createImageVoxelManager({ width, height, scalarData, numberOfComponents = 1, }) {
+    static createImageVoxelManager({ width, height, scalarData, numberOfComponents = 1, id, }) {
         const dimensions = [width, height, 1];
         if (!numberOfComponents) {
             numberOfComponents = scalarData.length / width / height;
@@ -689,14 +695,16 @@ export default class VoxelManager {
                 dimensions,
                 scalarData,
                 numberOfComponents,
+                id,
             });
         }
         return VoxelManager._createNumberVolumeVoxelManager({
             dimensions,
             scalarData,
+            id,
         });
     }
-    static _createNumberVolumeVoxelManager({ dimensions, scalarData, }) {
+    static _createNumberVolumeVoxelManager({ dimensions, scalarData, id, }) {
         const voxels = new VoxelManager(dimensions, {
             _get: (index) => scalarData[index],
             _set: (index, v) => {
@@ -705,7 +713,7 @@ export default class VoxelManager {
                 return isChanged;
             },
             _getConstructor: () => scalarData.constructor,
-            _id: '_createNumberVolumeVoxelManager',
+            _id: id || '_createNumberVolumeVoxelManager',
         });
         voxels.scalarData = scalarData;
         voxels.clear = () => {
@@ -720,17 +728,17 @@ export default class VoxelManager {
         };
         return voxels;
     }
-    static createMapVoxelManager({ dimension, }) {
+    static createMapVoxelManager({ dimension, id, }) {
         const map = new Map();
         const voxelManager = new VoxelManager(dimension, {
             _get: map.get.bind(map),
             _set: (index, v) => map.set(index, v) && true,
-            _id: 'createMapVoxelManager',
+            _id: id || 'createMapVoxelManager',
         });
         voxelManager.map = map;
         return voxelManager;
     }
-    static createHistoryVoxelManager({ sourceVoxelManager, }) {
+    static createHistoryVoxelManager(sourceVoxelManager, id) {
         const map = new Map();
         const { dimensions } = sourceVoxelManager;
         const voxelManager = new VoxelManager(dimensions, {
@@ -748,14 +756,14 @@ export default class VoxelManager {
                 }
                 this.sourceVoxelManager.setAtIndex(index, v);
             },
-            _id: 'createHistoryVoxelManager',
+            _id: id || 'createHistoryVoxelManager',
         });
         voxelManager.map = map;
         voxelManager.scalarData = sourceVoxelManager.scalarData;
         voxelManager.sourceVoxelManager = sourceVoxelManager;
         return voxelManager;
     }
-    static createRLEHistoryVoxelManager(sourceVoxelManager) {
+    static createRLEHistoryVoxelManager(sourceVoxelManager, id) {
         const { dimensions } = sourceVoxelManager;
         const map = new RLEVoxelMap(dimensions[0], dimensions[1], dimensions[2]);
         const voxelManager = new VoxelManager(dimensions, {
@@ -780,13 +788,13 @@ export default class VoxelManager {
                 map.updateScalarData(scalarData);
                 return scalarData;
             },
-            _id: 'createRLEHistoryVoxelManager',
+            _id: id || 'createRLEHistoryVoxelManager',
         });
         voxelManager.map = map;
         voxelManager.sourceVoxelManager = sourceVoxelManager;
         return voxelManager;
     }
-    static createLazyVoxelManager({ dimensions, planeFactory, }) {
+    static createLazyVoxelManager({ dimensions, planeFactory, id, }) {
         const map = new Map();
         const [width, height] = dimensions;
         const planeSize = width * height;
@@ -802,12 +810,12 @@ export default class VoxelManager {
                 layer[index % planeSize] = v;
                 return true;
             },
-            _id: 'createLazyVoxelManager',
+            _id: id || 'createLazyVoxelManager',
         });
         voxelManager.map = map;
         return voxelManager;
     }
-    static createRLEVolumeVoxelManager({ dimensions, }) {
+    static createRLEVolumeVoxelManager({ dimensions, id, }) {
         const [width, height, depth] = dimensions;
         const map = new RLEVoxelMap(width, height, depth);
         const voxelManager = new VoxelManager(dimensions, {
@@ -821,16 +829,17 @@ export default class VoxelManager {
                 map.updateScalarData(scalarData);
                 return scalarData;
             },
-            _id: 'createRLEVolumeVoxelManager',
+            _id: id || 'createRLEVolumeVoxelManager',
         });
         voxelManager.map = map;
         voxelManager.getPixelData = map.getPixelData.bind(map);
         return voxelManager;
     }
-    static createRLEImageVoxelManager({ dimensions, }) {
+    static createRLEImageVoxelManager({ dimensions, id, }) {
         const [width, height] = dimensions;
         return VoxelManager.createRLEVolumeVoxelManager({
             dimensions: [width, height, 1],
+            id,
         });
     }
     static addInstanceToImage(image) {

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

@@ -1,6 +1,8 @@
 export type Memo = {
     restoreMemo: (undo?: boolean) => void;
     commitMemo?: () => boolean;
+    id?: string;
+    operationType?: string;
 };
 export type Memoable = {
     createMemo: () => Memo;
@@ -16,6 +18,7 @@ export declare class HistoryMemo {
     get size(): number;
     set size(newSize: number);
     undo(items?: number): void;
+    undoIf(condition: (item: Memo) => boolean): boolean;
     redo(items?: number): void;
     push(item: Memo | Memoable): Memo;
 }

package/dist/esm/utilities/historyMemo/index.js

@@ -1,3 +1,8 @@
+import eventTarget from '../../eventTarget';
+const Events = {
+    HISTORY_UNDO: 'CORNERSTONE_TOOLS_HISTORY_UNDO',
+    HISTORY_REDO: 'CORNERSTONE_TOOLS_HISTORY_REDO',
+};
 export class HistoryMemo {
     constructor(label = 'Tools', size = 50) {
         this.position = -1;
@@ -21,17 +26,44 @@ export class HistoryMemo {
         while (items > 0 && this.undoAvailable > 0) {
             const item = this.ring[this.position];
             item.restoreMemo(true);
+            if (item.id) {
+                eventTarget.dispatchEvent(new CustomEvent(Events.HISTORY_UNDO, {
+                    detail: {
+                        isUndo: true,
+                        id: item.id,
+                        operationType: item.operationType || 'annotation',
+                        memo: item,
+                    },
+                }));
+            }
             items--;
             this.redoAvailable++;
             this.undoAvailable--;
             this.position = (this.position - 1 + this.size) % this.size;
         }
     }
+    undoIf(condition) {
+        if (this.undoAvailable > 0 && condition(this.ring[this.position])) {
+            this.undo();
+            return true;
+        }
+        return false;
+    }
     redo(items = 1) {
         while (items > 0 && this.redoAvailable > 0) {
             const newPosition = (this.position + 1) % this.size;
             const item = this.ring[newPosition];
             item.restoreMemo(false);
+            if (item.id) {
+                eventTarget.dispatchEvent(new CustomEvent(Events.HISTORY_REDO, {
+                    detail: {
+                        isUndo: false,
+                        id: item.id,
+                        operationType: item.operationType || 'annotation',
+                        memo: item,
+                    },
+                }));
+            }
             items--;
             this.position = newPosition;
             this.undoAvailable++;

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

@@ -8,12 +8,14 @@ export interface FullImageLoadOptions {
     viewPresentation: ViewPresentation;
     imageId: undefined;
 }
-export interface CanvasLoadPosition {
+export type CanvasLoadPosition = {
     origin: Point3;
     topRight: Point3;
     bottomLeft: Point3;
     thicknessMm: number;
-}
+    rightVector: Point3;
+    downVector: Point3;
+};
 export type LoadImageOptions = {
     canvas: HTMLCanvasElement;
     imageId?: string;

package/dist/esm/utilities/renderToCanvasGPU.js

@@ -1,3 +1,4 @@
+import { vec3 } from 'gl-matrix';
 import getOrCreateCanvas, { EPSILON, } from '../RenderingEngine/helpers/getOrCreateCanvas';
 import { ViewportType, Events } from '../enums';
 import { getRenderingEngine } from '../RenderingEngine/getRenderingEngine';
@@ -70,6 +71,8 @@ export default function renderToCanvasGPU(canvas, imageOrVolume, modality = unde
                 0,
                 temporaryCanvas.height / devicePixelRatio,
             ]);
+            const rightVector = vec3.sub([0, 0, 0], viewport.canvasToWorld([1 / devicePixelRatio, 0]), origin);
+            const downVector = vec3.sub([0, 0, 0], viewport.canvasToWorld([0, 1 / devicePixelRatio]), origin);
             const thicknessMm = 1;
             elementRendered = true;
             element.removeEventListener(Events.IMAGE_RENDERED, onImageRendered);
@@ -85,6 +88,8 @@ export default function renderToCanvasGPU(canvas, imageOrVolume, modality = unde
                 bottomLeft,
                 topRight,
                 thicknessMm,
+                rightVector,
+                downVector,
             });
         };
         element.addEventListener(Events.IMAGE_RENDERED, onImageRendered);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "3.7.17",
+  "version": "3.8.0",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -91,5 +91,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "9a5dc66176f5172fd3bb11ebcf37f9b8667ab3c4"
+  "gitHead": "bc351a2bae5a5b2f93691a384222b71b26d5c263"
 }