@cornerstonejs/core 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/esm/loaders/ProgressiveRetrieveImages.js

@@ -0,0 +1,230 @@
+import singleRetrieveStages from './configuration/singleRetrieve';
+import sequentialRetrieveStages from './configuration/sequentialRetrieve';
+import interleavedRetrieveStages from './configuration/interleavedRetrieve';
+import { loadAndCacheImage } from './imageLoader';
+import { triggerEvent, ProgressiveIterator, decimate } from '../utilities';
+import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
+import { ImageQualityStatus, RequestType, Events } from '../enums';
+import cache from '../cache';
+import eventTarget from '../eventTarget';
+import { fillNearbyFrames } from './fillNearbyFrames';
+export { sequentialRetrieveStages, interleavedRetrieveStages, singleRetrieveStages, };
+export class ProgressiveRetrieveImages {
+    static { this.createProgressive = createProgressive; }
+    static { this.interleavedRetrieveStages = {
+        stages: interleavedRetrieveStages,
+    }; }
+    static { this.singleRetrieveStages = {
+        stages: singleRetrieveStages,
+    }; }
+    static { this.sequentialRetrieveStages = {
+        stages: sequentialRetrieveStages,
+    }; }
+    constructor(imageRetrieveConfiguration) {
+        this.stages = imageRetrieveConfiguration.stages || singleRetrieveStages;
+        this.retrieveOptions = imageRetrieveConfiguration.retrieveOptions || {};
+    }
+    loadImages(imageIds, listener) {
+        const instance = new ProgressiveRetrieveImagesInstance(this, imageIds, listener);
+        return instance.loadImages();
+    }
+}
+class ProgressiveRetrieveImagesInstance {
+    constructor(configuration, imageIds, listener) {
+        this.outstandingRequests = 0;
+        this.stageStatusMap = new Map();
+        this.imageQualityStatusMap = new Map();
+        this.displayedIterator = new ProgressiveIterator('displayed');
+        this.stages = configuration.stages;
+        this.retrieveOptions = configuration.retrieveOptions;
+        this.imageIds = imageIds;
+        this.listener = listener;
+    }
+    async loadImages() {
+        const interleaved = this.createStageRequests();
+        this.outstandingRequests = interleaved.length;
+        for (const request of interleaved) {
+            this.addRequest(request);
+        }
+        if (this.outstandingRequests === 0) {
+            return Promise.resolve(null);
+        }
+        return this.displayedIterator.getDonePromise();
+    }
+    sendRequest(request, options) {
+        const { imageId, next } = request;
+        const errorCallback = (reason, done) => {
+            this.listener.errorCallback(imageId, complete || !next, reason);
+            if (done) {
+                this.updateStageStatus(request.stage, reason);
+            }
+        };
+        const loadedPromise = (options.loader || loadAndCacheImage)(imageId, options);
+        const uncompressedIterator = ProgressiveIterator.as(loadedPromise);
+        let complete = false;
+        uncompressedIterator
+            .forEach(async (image, done) => {
+            const oldStatus = this.imageQualityStatusMap.get(imageId);
+            if (!image) {
+                console.warn('No image retrieved', imageId);
+                return;
+            }
+            const { imageQualityStatus } = image;
+            complete ||= imageQualityStatus === ImageQualityStatus.FULL_RESOLUTION;
+            if (oldStatus !== undefined && oldStatus > imageQualityStatus) {
+                this.updateStageStatus(request.stage, null, true);
+                return;
+            }
+            this.listener.successCallback(imageId, image);
+            this.imageQualityStatusMap.set(imageId, imageQualityStatus);
+            this.displayedIterator.add(image);
+            if (done) {
+                this.updateStageStatus(request.stage);
+            }
+            fillNearbyFrames(this.listener, this.imageQualityStatusMap, request, image, options);
+        }, errorCallback)
+            .finally(() => {
+            if (!complete && next) {
+                if (cache.getImageLoadObject(imageId)) {
+                    cache.removeImageLoadObject(imageId);
+                }
+                this.addRequest(next, options.streamingData);
+            }
+            else {
+                if (!complete) {
+                    this.listener.errorCallback(imageId, true, "Couldn't decode");
+                }
+                this.outstandingRequests--;
+                for (let skip = next; skip; skip = skip.next) {
+                    this.updateStageStatus(skip.stage, null, true);
+                }
+            }
+            if (this.outstandingRequests <= 0) {
+                this.displayedIterator.resolve();
+            }
+        });
+        const doneLoad = uncompressedIterator.getDonePromise();
+        return doneLoad.catch((e) => null);
+    }
+    addRequest(request, streamingData = {}) {
+        const { imageId, stage } = request;
+        const baseOptions = this.listener.getLoaderImageOptions(imageId);
+        if (!baseOptions) {
+            return;
+        }
+        const { retrieveType = 'default' } = stage;
+        const { retrieveOptions: keyedRetrieveOptions } = this;
+        const retrieveOptions = keyedRetrieveOptions[retrieveType] || keyedRetrieveOptions.default;
+        const options = {
+            ...baseOptions,
+            retrieveType,
+            retrieveOptions,
+            streamingData,
+        };
+        const priority = stage.priority ?? -5;
+        const requestType = stage.requestType || RequestType.Interaction;
+        const additionalDetails = { imageId };
+        imageLoadPoolManager.addRequest(this.sendRequest.bind(this, request, options), requestType, additionalDetails, priority);
+    }
+    updateStageStatus(stage, failure, skipped = false) {
+        const { id } = stage;
+        const stageStatus = this.stageStatusMap.get(id);
+        if (!stageStatus) {
+            return;
+        }
+        stageStatus.imageLoadPendingCount--;
+        if (failure) {
+            stageStatus.imageLoadFailedCount++;
+        }
+        else if (!skipped) {
+            stageStatus.totalImageCount++;
+        }
+        if (!skipped && !stageStatus.stageStartTime) {
+            stageStatus.stageStartTime = Date.now();
+        }
+        if (!stageStatus.imageLoadPendingCount) {
+            const { imageLoadFailedCount: numberOfFailures, totalImageCount: numberOfImages, stageStartTime = Date.now(), startTime, } = stageStatus;
+            const detail = {
+                stageId: id,
+                numberOfFailures,
+                numberOfImages,
+                stageDurationInMS: stageStartTime ? Date.now() - stageStartTime : null,
+                startDurationInMS: Date.now() - startTime,
+            };
+            triggerEvent(eventTarget, Events.IMAGE_RETRIEVAL_STAGE, detail);
+            this.stageStatusMap.delete(id);
+        }
+    }
+    createStageRequests() {
+        const interleaved = new Array();
+        const imageRequests = new Map();
+        const addStageInstance = (stage, position) => {
+            const index = position < 0
+                ? this.imageIds.length + position
+                : position < 1
+                    ? Math.floor((this.imageIds.length - 1) * position)
+                    : position;
+            const imageId = this.imageIds[index];
+            if (!imageId) {
+                throw new Error(`No value found to add to requests at ${position}`);
+            }
+            const request = {
+                imageId,
+                stage,
+                nearbyRequests: this.findNearbyRequests(index, stage),
+            };
+            this.addStageStatus(stage);
+            const existingRequest = imageRequests.get(imageId);
+            if (existingRequest) {
+                existingRequest.next = request;
+            }
+            else {
+                interleaved.push(request);
+            }
+            imageRequests.set(imageId, request);
+        };
+        for (const stage of this.stages) {
+            const indices = stage.positions ||
+                decimate(this.imageIds, stage.decimate || 1, stage.offset ?? 0);
+            indices.forEach((index) => {
+                addStageInstance(stage, index);
+            });
+        }
+        return interleaved;
+    }
+    findNearbyRequests(index, stage) {
+        const nearby = new Array();
+        if (!stage.nearbyFrames) {
+            return nearby;
+        }
+        for (const nearbyItem of stage.nearbyFrames) {
+            const nearbyIndex = index + nearbyItem.offset;
+            if (nearbyIndex < 0 || nearbyIndex >= this.imageIds.length) {
+                continue;
+            }
+            nearby.push({
+                itemId: this.imageIds[nearbyIndex],
+                imageQualityStatus: nearbyItem.imageQualityStatus,
+            });
+        }
+        return nearby;
+    }
+    addStageStatus(stage) {
+        const { id } = stage;
+        const stageStatus = this.stageStatusMap.get(id) || {
+            stageId: id,
+            startTime: Date.now(),
+            stageStartTime: null,
+            totalImageCount: 0,
+            imageLoadFailedCount: 0,
+            imageLoadPendingCount: 0,
+        };
+        stageStatus.imageLoadPendingCount++;
+        this.stageStatusMap.set(id, stageStatus);
+        return stageStatus;
+    }
+}
+export function createProgressive(configuration) {
+    return new ProgressiveRetrieveImages(configuration);
+}
+export default ProgressiveRetrieveImages;

package/dist/esm/loaders/configuration/interleavedRetrieve.d.ts

@@ -0,0 +1,3 @@
+import type { RetrieveStage } from '../../types';
+declare const interleavedRetrieveConfiguration: RetrieveStage[];
+export default interleavedRetrieveConfiguration;

package/dist/esm/loaders/configuration/interleavedRetrieve.js

@@ -0,0 +1,76 @@
+import { RequestType, ImageQualityStatus } from '../../enums';
+const nearbyFrames = [
+    {
+        offset: -1,
+        imageQualityStatus: ImageQualityStatus.ADJACENT_REPLICATE,
+    },
+    {
+        offset: +1,
+        imageQualityStatus: ImageQualityStatus.ADJACENT_REPLICATE,
+    },
+    { offset: +2, imageQualityStatus: ImageQualityStatus.FAR_REPLICATE },
+];
+const interleavedRetrieveConfiguration = [
+    {
+        id: 'initialImages',
+        positions: [0.5, 0, -1],
+        retrieveType: 'default',
+        requestType: RequestType.Thumbnail,
+        priority: 5,
+        nearbyFrames,
+    },
+    {
+        id: 'quarterThumb',
+        decimate: 4,
+        offset: 3,
+        requestType: RequestType.Thumbnail,
+        retrieveType: 'multipleFast',
+        priority: 6,
+        nearbyFrames,
+    },
+    {
+        id: 'halfThumb',
+        decimate: 4,
+        offset: 1,
+        priority: 7,
+        requestType: RequestType.Thumbnail,
+        retrieveType: 'multipleFast',
+        nearbyFrames,
+    },
+    {
+        id: 'quarterFull',
+        decimate: 4,
+        offset: 2,
+        priority: 8,
+        requestType: RequestType.Thumbnail,
+        retrieveType: 'multipleFinal',
+    },
+    {
+        id: 'halfFull',
+        decimate: 4,
+        offset: 0,
+        priority: 9,
+        requestType: RequestType.Thumbnail,
+        retrieveType: 'multipleFinal',
+    },
+    {
+        id: 'threeQuarterFull',
+        decimate: 4,
+        offset: 1,
+        priority: 10,
+        requestType: RequestType.Thumbnail,
+        retrieveType: 'multipleFinal',
+    },
+    {
+        id: 'finalFull',
+        decimate: 4,
+        offset: 3,
+        priority: 11,
+        requestType: RequestType.Thumbnail,
+        retrieveType: 'multipleFinal',
+    },
+    {
+        id: 'errorRetrieve',
+    },
+];
+export default interleavedRetrieveConfiguration;

package/dist/esm/loaders/configuration/sequentialRetrieve.d.ts

@@ -0,0 +1,3 @@
+import type { RetrieveStage } from '../../types';
+declare const sequentialRetrieveStages: RetrieveStage[];
+export default sequentialRetrieveStages;

package/dist/esm/loaders/configuration/sequentialRetrieve.js

@@ -0,0 +1,11 @@
+const sequentialRetrieveStages = [
+    {
+        id: 'lossySequential',
+        retrieveType: 'singleFast',
+    },
+    {
+        id: 'finalSequential',
+        retrieveType: 'singleFinal',
+    },
+];
+export default sequentialRetrieveStages;

package/dist/esm/loaders/configuration/singleRetrieve.d.ts

@@ -0,0 +1,3 @@
+import type { RetrieveStage } from '../../types';
+declare const singleRetrieveStages: RetrieveStage[];
+export default singleRetrieveStages;

package/dist/esm/loaders/configuration/singleRetrieve.js

@@ -0,0 +1,10 @@
+const singleRetrieveStages = [
+    {
+        id: 'initialImages',
+        retrieveType: 'single',
+    },
+    {
+        id: 'errorRetrieve',
+    },
+];
+export default singleRetrieveStages;

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

@@ -0,0 +1,3 @@
+import type { ImageLoadListener } from '../types';
+import type { ImageQualityStatus } from '../enums';
+export declare function fillNearbyFrames(listener: ImageLoadListener, imageQualityStatusMap: Map<string, ImageQualityStatus>, request: any, image: any, options: any): void;

package/dist/esm/loaders/fillNearbyFrames.js

@@ -0,0 +1,34 @@
+export function fillNearbyFrames(listener, imageQualityStatusMap, request, image, options) {
+    if (!request?.nearbyRequests?.length) {
+        return;
+    }
+    const { arrayBuffer, offset: srcOffset, type, length: frameLength, } = options.targetBuffer;
+    if (!arrayBuffer || srcOffset === undefined || !type) {
+        return;
+    }
+    const scalarData = new Float32Array(arrayBuffer);
+    const bytesPerPixel = scalarData.byteLength / scalarData.length;
+    const offset = options.targetBuffer.offset / bytesPerPixel;
+    const src = scalarData.slice(offset, offset + frameLength);
+    for (const nearbyItem of request.nearbyRequests) {
+        try {
+            const { itemId: targetId, imageQualityStatus } = nearbyItem;
+            const targetStatus = imageQualityStatusMap.get(targetId);
+            if (targetStatus !== undefined && targetStatus >= imageQualityStatus) {
+                continue;
+            }
+            const targetOptions = listener.getLoaderImageOptions(targetId);
+            const { offset: targetOffset } = targetOptions.targetBuffer;
+            scalarData.set(src, targetOffset / bytesPerPixel);
+            const nearbyImage = {
+                ...image,
+                imageQualityStatus,
+            };
+            listener.successCallback(targetId, nearbyImage);
+            imageQualityStatusMap.set(targetId, imageQualityStatus);
+        }
+        catch (e) {
+            console.log("Couldn't fill nearby item ", nearbyItem.itemId, e);
+        }
+    }
+}

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

@@ -1,9 +1,9 @@
 import '@kitware/vtk.js/Rendering/Profiles/Geometry';
 import { GeometryType } from '../enums';
-import { IGeometry, PublicContourSetData } from '../types';
-declare type GeometryOptions = {
+import type { IGeometry, PublicContourSetData, PublicSurfaceData } from '../types';
+interface GeometryOptions {
     type: GeometryType;
-    geometryData: PublicContourSetData;
-};
+    geometryData: PublicContourSetData | PublicSurfaceData;
+}
 declare function createAndCacheGeometry(geometryId: string, options: GeometryOptions): Promise<IGeometry>;
 export { createAndCacheGeometry };

package/dist/esm/loaders/geometryLoader.js

@@ -1,14 +1,18 @@
 import '@kitware/vtk.js/Rendering/Profiles/Geometry';
 import cache from '../cache';
-import { ContourSet } from '../cache/classes/ContourSet';
 import { GeometryType } from '../enums';
+import { createContourSet } from './utils/contourSet/createContourSet';
+import { createSurface } from './utils/surface/createSurface';
 async function createAndCacheGeometry(geometryId, options) {
     let geometry = cache.getGeometry(geometryId);
     if (geometry) {
         return geometry;
     }
     if (options.type === GeometryType.CONTOUR) {
-        geometry = _createContourSet(geometryId, options.geometryData);
+        geometry = createContourSet(geometryId, options.geometryData);
+    }
+    else if (options.type === GeometryType.SURFACE) {
+        geometry = createSurface(geometryId, options.geometryData);
     }
     else {
         throw new Error('Unknown geometry type, Only CONTOUR is supported');
@@ -19,40 +23,4 @@ async function createAndCacheGeometry(geometryId, options) {
     await cache.putGeometryLoadObject(geometryId, geometryLoadObject);
     return geometry;
 }
-function _createContourSet(geometryId, contourSetData) {
-    if (!contourSetData || contourSetData.data.length === 0) {
-        throw new Error('Invalid contour set data, see publicContourSetData type for more info');
-    }
-    if (!contourSetData.id) {
-        throw new Error('Invalid contour set data, each contour set must have an id');
-    }
-    if (!contourSetData.data || !Array.isArray(contourSetData.data)) {
-        throw new Error('Invalid contour set data, each contour set must have an array of contours');
-    }
-    contourSetData.data.forEach((contourData) => {
-        if (!contourData.points || !Array.isArray(contourData.points)) {
-            throw new Error('Invalid contour set data, each contour must have an array of points');
-        }
-        contourData.points.forEach((point) => {
-            if (!point || !Array.isArray(point) || point.length !== 3) {
-                throw new Error('Invalid contour set data, each point must be an array of length 3');
-            }
-        });
-    });
-    const contourSet = new ContourSet({
-        id: contourSetData.id,
-        data: contourSetData.data,
-        color: contourSetData.color,
-        frameOfReferenceUID: contourSetData.frameOfReferenceUID,
-        segmentIndex: contourSetData.segmentIndex,
-    });
-    const geometry = {
-        id: geometryId,
-        type: GeometryType.CONTOUR,
-        data: contourSet,
-        sizeInBytes: contourSet.getSizeInBytes(),
-    };
-    return geometry;
-}
 export { createAndCacheGeometry };
-//# sourceMappingURL=geometryLoader.js.map

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

@@ -1,15 +1,38 @@
-import { IImage, ImageLoaderFn } from '../types';
+import type { IImage, ImageLoaderFn, Point2, Point3, Mat3, PixelDataTypedArrayString, PixelDataTypedArray } from '../types';
 export interface ImageLoaderOptions {
     priority: number;
     requestType: string;
     additionalDetails?: Record<string, unknown>;
+    ignoreCache?: boolean;
 }
+interface LocalImageOptions {
+    scalarData?: PixelDataTypedArray;
+    targetBufferType?: PixelDataTypedArrayString;
+    dimensions?: Point2;
+    spacing?: Point2;
+    origin?: Point3;
+    direction?: Mat3;
+    skipCreateBuffer?: boolean;
+    onCacheAdd?: (image: IImage) => void;
+}
+type DerivedImageOptions = LocalImageOptions & {
+    imageId?: string;
+};
 export declare function loadImage(imageId: string, options?: ImageLoaderOptions): Promise<IImage>;
 export declare function loadAndCacheImage(imageId: string, options?: ImageLoaderOptions): Promise<IImage>;
-export declare function loadAndCacheImages(imageIds: Array<string>, options?: ImageLoaderOptions): Promise<IImage>[];
+export declare function loadAndCacheImages(imageIds: string[], options?: ImageLoaderOptions): Promise<IImage>[];
+export declare function createAndCacheDerivedImage(referencedImageId: string, options?: DerivedImageOptions): IImage;
+export declare function createAndCacheDerivedImages(referencedImageIds: string[], options?: DerivedImageOptions & {
+    getDerivedImageId?: (referencedImageId: string) => string;
+    targetBufferType?: PixelDataTypedArrayString;
+}): IImage[];
+export declare function createAndCacheLocalImage(imageId: string, options: LocalImageOptions): IImage;
 export declare function cancelLoadImage(imageId: string): void;
-export declare function cancelLoadImages(imageIds: Array<string>): void;
+export declare function cancelLoadImages(imageIds: string[]): void;
 export declare function cancelLoadAll(): void;
 export declare function registerImageLoader(scheme: string, imageLoader: ImageLoaderFn): void;
 export declare function registerUnknownImageLoader(imageLoader: ImageLoaderFn): ImageLoaderFn;
 export declare function unregisterAllImageLoaders(): void;
+export declare function createAndCacheDerivedSegmentationImages(referencedImageIds: string[], options?: DerivedImageOptions): IImage[];
+export declare function createAndCacheDerivedSegmentationImage(referencedImageId: string, options?: DerivedImageOptions): IImage;
+export {};