@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/RenderingEngine/GenericViewport/WSI/wsiProjectionPresentation.js

@@ -0,0 +1,47 @@
+const DEFAULT_SELECTOR = {
+    rotation: true,
+    zoom: true,
+};
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+export function getWSIProjectionPresentation(snapshot, selector) {
+    const target = {};
+    const wsiSelector = selector ?? DEFAULT_SELECTOR;
+    if (wsiSelector.zoom) {
+        target.zoom = snapshot.presentation.zoom;
+    }
+    if (wsiSelector.rotation) {
+        target.rotation = snapshot.presentation.rotation;
+    }
+    return target;
+}
+export function withWSIProjectionPresentation(snapshot, presentation, options = {}) {
+    const hasZoom = hasOwn(presentation, 'zoom');
+    const hasRotation = hasOwn(presentation, 'rotation');
+    const nextZoom = Math.max(presentation.zoom ??
+        snapshot.presentation.zoom ??
+        snapshot.viewState.zoom ??
+        1, 0.001);
+    let nextViewState = {
+        ...snapshot.viewState,
+        centerIndex: snapshot.viewState.centerIndex
+            ? [snapshot.viewState.centerIndex[0], snapshot.viewState.centerIndex[1]]
+            : undefined,
+    };
+    if (hasZoom) {
+        if (snapshot.resolvedView) {
+            nextViewState = {
+                ...snapshot.resolvedView.withZoom(nextZoom, options.anchorCanvas).state
+                    .viewState,
+            };
+        }
+        else {
+            nextViewState.zoom = nextZoom;
+        }
+    }
+    if (hasRotation) {
+        nextViewState.rotation = presentation.rotation ?? 0;
+    }
+    return nextViewState;
+}

package/dist/esm/RenderingEngine/GenericViewport/WSI/wsiProjectionSnapshot.d.ts

@@ -0,0 +1,2 @@
+import { type WSIProjectionRequest, type WSIProjectionSnapshot } from './WSIProjectionTypes';
+export declare function getWSIProjectionSnapshot(request: WSIProjectionRequest): WSIProjectionSnapshot | undefined;

package/dist/esm/RenderingEngine/GenericViewport/WSI/wsiProjectionSnapshot.js

@@ -0,0 +1,90 @@
+import { WSI_PROJECTION_ID, } from './WSIProjectionTypes';
+function clonePoint2(point) {
+    return [point[0], point[1]];
+}
+function normalizeWSIProjectionViewState(viewState) {
+    return {
+        ...viewState,
+        centerIndex: viewState.centerIndex
+            ? [viewState.centerIndex[0], viewState.centerIndex[1]]
+            : undefined,
+        resolution: typeof viewState.resolution === 'number'
+            ? Math.max(viewState.resolution, 0.000001)
+            : undefined,
+        rotation: viewState.rotation ?? 0,
+        zoom: Math.max(viewState.zoom ?? 1, 0.001),
+    };
+}
+function getCenterCanvasPoint(canvasWidth, canvasHeight) {
+    return [canvasWidth / 2, canvasHeight / 2];
+}
+function getScale(args) {
+    const { canvasHeight, rendererCamera, zoom } = args;
+    if (typeof rendererCamera?.parallelScale === 'number') {
+        return {
+            kind: 'physical',
+            mmPerCanvasPixel: rendererCamera.parallelScale / Math.max(canvasHeight, 1),
+        };
+    }
+    return { kind: 'fit', value: zoom };
+}
+export function getWSIProjectionSnapshot(request) {
+    const { viewport } = request;
+    const currentViewState = request.viewState ?? viewport.getViewState?.();
+    if (!currentViewState) {
+        return;
+    }
+    const viewState = normalizeWSIProjectionViewState(currentViewState);
+    const resolvedView = request.resolvedView ?? viewport.getResolvedView?.();
+    const canvasWidth = request.canvasWidth ??
+        resolvedView?.state?.canvasWidth ??
+        viewport.element?.clientWidth ??
+        1;
+    const canvasHeight = request.canvasHeight ??
+        resolvedView?.state?.canvasHeight ??
+        viewport.element?.clientHeight ??
+        1;
+    const canvasPoint = getCenterCanvasPoint(canvasWidth, canvasHeight);
+    const worldPoint = resolvedView?.canvasToWorld(canvasPoint);
+    const rendererCamera = resolvedView?.toICamera();
+    const view = resolvedView?.state?.view;
+    const zoom = Math.max(view?.getZoom?.() ?? viewState.zoom ?? 1, 0.001);
+    const rotation = view?.getRotation?.() ?? viewState.rotation ?? 0;
+    const frameOfReferenceUID = request.frameOfReferenceUID ??
+        resolvedView?.getFrameOfReferenceUID() ??
+        viewport.getFrameOfReferenceUID?.();
+    return {
+        kind: WSI_PROJECTION_ID,
+        adapterId: WSI_PROJECTION_ID,
+        canvasHeight,
+        canvasWidth,
+        dataId: request.dataId,
+        frameOfReferenceUID,
+        presentation: {
+            position: {
+                kind: 'anchor',
+                worldPoint,
+                canvasPoint: clonePoint2(canvasPoint),
+            },
+            rotation,
+            scale: getScale({ canvasHeight, rendererCamera, zoom }),
+            zoom,
+        },
+        rendererCamera,
+        resolvedView,
+        spaces: {
+            canvas: Boolean(resolvedView),
+            image: true,
+            renderer: Boolean(rendererCamera),
+            world: Boolean(resolvedView),
+        },
+        transforms: resolvedView
+            ? {
+                canvasToWorld: (point) => resolvedView.canvasToWorld(point),
+                worldToCanvas: (point) => resolvedView.worldToCanvas(point),
+            }
+            : undefined,
+        viewState,
+        viewportType: viewport.type,
+    };
+}

package/dist/esm/RenderingEngine/GenericViewport/WSI/wsiTransformUtils.d.ts

@@ -0,0 +1,29 @@
+import { mat4 } from 'gl-matrix';
+import type { CPUIImageData, Point2, Point3, VOIRange } from '../../../types';
+import type { WSIImageDataMetadata, WSIMapViewLike } from '../../../utilities/WSIUtilities';
+export declare function computeWSITransforms(metadata?: WSIImageDataMetadata): {
+    indexToWorld: mat4;
+    worldToIndexMatrix: mat4;
+};
+export declare function worldToIndexWSIMetadata(metadata: WSIImageDataMetadata | undefined, point: Point3): Point3;
+export declare function indexToWorldWSIMetadata(metadata: WSIImageDataMetadata | undefined, point: Point3): Point3;
+export declare function buildWSIImageData(args: {
+    metadata?: WSIImageDataMetadata;
+    modality?: string;
+    frameOfReferenceUID?: string | null;
+}): CPUIImageData | null;
+export declare function buildWSIColorTransform(voiRange?: VOIRange, averageWhite?: [number, number, number]): string | undefined;
+export declare function canvasToIndexForWSI(args: {
+    canvasPos: Point2;
+    canvasWidth: number;
+    canvasHeight: number;
+    view: WSIMapViewLike;
+    devicePixelRatio?: number;
+}): Point3;
+export declare function indexToCanvasForWSI(args: {
+    indexPos: Point3;
+    canvasWidth: number;
+    canvasHeight: number;
+    view: WSIMapViewLike;
+    devicePixelRatio?: number;
+}): Point2;

package/dist/esm/RenderingEngine/GenericViewport/WSI/wsiTransformUtils.js

@@ -0,0 +1,128 @@
+import { mat4, vec3 } from 'gl-matrix';
+import { Transform } from '../../helpers/cpuFallback/rendering/transform';
+export function computeWSITransforms(metadata) {
+    if (!metadata) {
+        return;
+    }
+    const indexToWorld = mat4.create();
+    const worldToIndexMatrix = mat4.create();
+    mat4.fromTranslation(indexToWorld, metadata.origin);
+    indexToWorld[0] = metadata.direction[0];
+    indexToWorld[1] = metadata.direction[1];
+    indexToWorld[2] = metadata.direction[2];
+    indexToWorld[4] = metadata.direction[3];
+    indexToWorld[5] = metadata.direction[4];
+    indexToWorld[6] = metadata.direction[5];
+    indexToWorld[8] = metadata.direction[6];
+    indexToWorld[9] = metadata.direction[7];
+    indexToWorld[10] = metadata.direction[8];
+    mat4.scale(indexToWorld, indexToWorld, metadata.spacing);
+    mat4.invert(worldToIndexMatrix, indexToWorld);
+    return {
+        indexToWorld,
+        worldToIndexMatrix,
+    };
+}
+export function worldToIndexWSIMetadata(metadata, point) {
+    const transforms = computeWSITransforms(metadata);
+    if (!transforms) {
+        return [0, 0, 0];
+    }
+    const imageCoord = vec3.create();
+    vec3.transformMat4(imageCoord, point, transforms.worldToIndexMatrix);
+    return [imageCoord[0], imageCoord[1], imageCoord[2]];
+}
+export function indexToWorldWSIMetadata(metadata, point) {
+    const transforms = computeWSITransforms(metadata);
+    if (!transforms) {
+        return [0, 0, 0];
+    }
+    const worldPos = vec3.create();
+    vec3.transformMat4(worldPos, point, transforms.indexToWorld);
+    return [worldPos[0], worldPos[1], worldPos[2]];
+}
+export function buildWSIImageData(args) {
+    const { metadata, modality = 'SM', frameOfReferenceUID } = args;
+    if (!metadata) {
+        return null;
+    }
+    const imageData = {
+        getDirection: () => metadata.direction,
+        getDimensions: () => metadata.dimensions,
+        getRange: () => [0, 255],
+        getScalarData: () => null,
+        getSpacing: () => metadata.spacing,
+        worldToIndex: (point) => {
+            return worldToIndexWSIMetadata(metadata, point);
+        },
+        indexToWorld: (point) => {
+            return indexToWorldWSIMetadata(metadata, point);
+        },
+    };
+    return {
+        dimensions: metadata.dimensions,
+        spacing: metadata.spacing,
+        numberOfComponents: 3,
+        origin: metadata.origin,
+        direction: metadata.direction,
+        metadata: {
+            Modality: modality,
+            FrameOfReferenceUID: frameOfReferenceUID || '',
+        },
+        hasPixelSpacing: metadata.hasPixelSpacing,
+        preScale: {
+            scaled: false,
+        },
+        scalarData: null,
+        imageData,
+    };
+}
+export function buildWSIColorTransform(voiRange, averageWhite) {
+    if (!voiRange && !averageWhite) {
+        return;
+    }
+    const white = averageWhite || [255, 255, 255];
+    const maxWhite = Math.max(...white);
+    const scaleWhite = white.map((value) => maxWhite / value);
+    const { lower = 0, upper = 255 } = voiRange || {};
+    const wlScale = (upper - lower + 1) / 255;
+    const wlDelta = lower / 255;
+    return `url('data:image/svg+xml,\
+      <svg xmlns="http://www.w3.org/2000/svg">\
+        <filter id="colour" color-interpolation-filters="linearRGB">\
+        <feColorMatrix type="matrix" \
+        values="\
+          ${scaleWhite[0] * wlScale} 0 0 0 ${wlDelta} \
+          0 ${scaleWhite[1] * wlScale} 0 0 ${wlDelta} \
+          0 0 ${scaleWhite[2] * wlScale} 0 ${wlDelta} \
+          0 0 0 1 0" />\
+        </filter>\
+      </svg>#colour')`;
+}
+export function canvasToIndexForWSI(args) {
+    const transform = getWSICanvasTransform(args);
+    transform.invert();
+    const indexPoint = transform.transformPoint(args.canvasPos.map((value) => value * (args.devicePixelRatio || window.devicePixelRatio || 1)));
+    return [indexPoint[0], indexPoint[1], 0];
+}
+export function indexToCanvasForWSI(args) {
+    const transform = getWSICanvasTransform(args);
+    return transform
+        .transformPoint([args.indexPos[0], args.indexPos[1]])
+        .map((value) => value / (args.devicePixelRatio || window.devicePixelRatio || 1));
+}
+function getWSICanvasTransform(args) {
+    const resolution = args.view.getResolution();
+    const rotation = args.view.getRotation();
+    const center = args.view.getCenter();
+    const halfCanvas = [
+        Math.max(args.canvasWidth, 1) / 2,
+        Math.max(args.canvasHeight, 1) / 2,
+    ];
+    const transform = new Transform();
+    transform.translate(halfCanvas[0], halfCanvas[1]);
+    transform.rotate(rotation);
+    transform.scale(1 / resolution, -1 / resolution);
+    transform.translate(-center[0], -center[1]);
+    return transform;
+}

package/dist/esm/RenderingEngine/GenericViewport/genericViewportDataSetAccess.d.ts

@@ -0,0 +1,35 @@
+import type { IImage } from '../../types';
+import type { WSIClientLike } from '../../utilities/WSIUtilities';
+import type { ViewportDataReference } from './ViewportArchitectureTypes';
+export interface GenericViewportImageDataSet {
+    imageIds: string[];
+    [key: string]: unknown;
+}
+export interface GenericViewportPlanarDataSet extends GenericViewportImageDataSet {
+    kind?: 'planar';
+    initialImageIdIndex?: number;
+    volumeId?: string;
+    image?: IImage;
+    reference?: ViewportDataReference;
+}
+export interface GenericViewportSourceAliasDataSet {
+    kind: 'video' | 'ecg';
+    sourceDataId: string;
+}
+export interface GenericViewportWSIDataSet {
+    kind: 'wsi';
+    imageIds: string[];
+    options: {
+        miniNavigationOverlay?: boolean;
+        webClient: WSIClientLike;
+    };
+}
+export type GenericViewportRegisteredData = string | string[] | GenericViewportPlanarDataSet | GenericViewportSourceAliasDataSet | GenericViewportWSIDataSet;
+export declare function getGenericViewportRegisteredData(dataId: string): GenericViewportRegisteredData | undefined;
+export declare function getGenericViewportImageDataSet(dataId: string): GenericViewportImageDataSet | undefined;
+export declare function getGenericViewportPlanarDataSet(dataId: string): GenericViewportPlanarDataSet | undefined;
+export declare function getGenericViewportWSIDataSet(dataId: string): GenericViewportWSIDataSet | undefined;
+export declare function getGenericViewportSourceDataId(dataId: string): string;
+export declare function isGenericViewportImageDataSet(value: unknown): value is GenericViewportImageDataSet;
+export declare function isGenericViewportWSIDataSet(value: unknown): value is GenericViewportWSIDataSet;
+export declare function isGenericViewportSourceAliasDataSet(value: unknown): value is GenericViewportSourceAliasDataSet;

package/dist/esm/RenderingEngine/GenericViewport/genericViewportDataSetAccess.js

@@ -0,0 +1,87 @@
+import genericViewportDataSetMetadataProvider from '../../utilities/genericViewportDataSetMetadataProvider';
+export function getGenericViewportRegisteredData(dataId) {
+    return genericViewportDataSetMetadataProvider.get(genericViewportDataSetMetadataProvider.VIEWPORT_V2_DATA_SET, dataId);
+}
+export function getGenericViewportImageDataSet(dataId) {
+    const registered = getGenericViewportRegisteredData(dataId);
+    if (isStringArray(registered)) {
+        return {
+            imageIds: registered,
+        };
+    }
+    if (!isGenericViewportImageDataSet(registered)) {
+        return;
+    }
+    return registered;
+}
+export function getGenericViewportPlanarDataSet(dataId) {
+    const registered = getGenericViewportRegisteredData(dataId);
+    if (isStringArray(registered)) {
+        return {
+            imageIds: registered,
+        };
+    }
+    if (!isGenericViewportImageDataSet(registered)) {
+        return;
+    }
+    if ('kind' in registered && registered.kind && registered.kind !== 'planar') {
+        return;
+    }
+    return registered;
+}
+export function getGenericViewportWSIDataSet(dataId) {
+    const registered = getGenericViewportRegisteredData(dataId);
+    if (isGenericViewportWSIDataSet(registered)) {
+        return registered;
+    }
+    if (isRecord(registered) &&
+        isStringArray(registered.imageIds) &&
+        isRecord(registered.options) &&
+        isWSIClientLike(registered.options.webClient)) {
+        return {
+            imageIds: registered.imageIds,
+            kind: 'wsi',
+            options: {
+                miniNavigationOverlay: registered.options.miniNavigationOverlay,
+                webClient: registered.options.webClient,
+            },
+        };
+    }
+}
+export function getGenericViewportSourceDataId(dataId) {
+    const registered = getGenericViewportRegisteredData(dataId);
+    if (typeof registered === 'string') {
+        return registered;
+    }
+    if (isStringArray(registered) && registered[0]) {
+        return registered[0];
+    }
+    if (isGenericViewportSourceAliasDataSet(registered)) {
+        return registered.sourceDataId;
+    }
+    return dataId;
+}
+export function isGenericViewportImageDataSet(value) {
+    return isRecord(value) && isStringArray(value.imageIds);
+}
+export function isGenericViewportWSIDataSet(value) {
+    return (isRecord(value) &&
+        value.kind === 'wsi' &&
+        isStringArray(value.imageIds) &&
+        isRecord(value.options) &&
+        isWSIClientLike(value.options.webClient));
+}
+export function isGenericViewportSourceAliasDataSet(value) {
+    return (isRecord(value) &&
+        (value.kind === 'video' || value.kind === 'ecg') &&
+        typeof value.sourceDataId === 'string');
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((item) => typeof item === 'string'));
+}
+function isWSIClientLike(value) {
+    return isRecord(value) && typeof value.getDICOMwebMetadata === 'function';
+}

package/dist/esm/RenderingEngine/GenericViewport/genericViewportReferenceCompatibility.d.ts

@@ -0,0 +1,18 @@
+import type { Point3, ReferenceCompatibleOptions, ViewReference } from '../../types';
+export type GenericViewportReferenceContext = {
+    allowAnyImageReference?: boolean;
+    cameraFocalPoint?: Point3;
+    currentImageIdIndex?: number;
+    dataId?: string;
+    dataIds?: string[];
+    dimensionGroupNumber?: number;
+    frameOfReferenceUID?: string;
+    imageIds?: string[];
+    imageURIs?: string[];
+    numDimensionGroups?: number;
+    viewPlaneNormal?: Point3;
+    volumeId?: string;
+    volumeIds?: string[];
+};
+export declare function isGenericViewportReferenceViewable(viewRef: ViewReference, contexts: GenericViewportReferenceContext[], options?: ReferenceCompatibleOptions): boolean;
+export declare function getDimensionGroupReferenceContext(value: unknown): Pick<GenericViewportReferenceContext, 'dimensionGroupNumber' | 'numDimensionGroups'>;

package/dist/esm/RenderingEngine/GenericViewport/genericViewportReferenceCompatibility.js

@@ -0,0 +1,238 @@
+import { vec3 } from 'gl-matrix';
+import imageIdToURI from '../../utilities/imageIdToURI';
+import isEqual from '../../utilities/isEqual';
+export function isGenericViewportReferenceViewable(viewRef, contexts, options = {}) {
+    if (!viewRef) {
+        return false;
+    }
+    return contexts.some((context) => isReferenceViewableInContext(viewRef, context, options));
+}
+export function getDimensionGroupReferenceContext(value) {
+    const candidate = value;
+    const dimensionGroupNumber = toPositiveInteger(candidate?.dimensionGroupNumber);
+    const numDimensionGroups = toPositiveInteger(candidate?.numDimensionGroups);
+    return {
+        dimensionGroupNumber,
+        numDimensionGroups,
+    };
+}
+function isReferenceViewableInContext(viewRef, context, options) {
+    if (!isFrameOfReferenceCompatible(viewRef, context)) {
+        return false;
+    }
+    if (!isDataIdCompatible(viewRef, context)) {
+        return false;
+    }
+    if (!isVolumeIdCompatible(viewRef, context)) {
+        return false;
+    }
+    if (!isPlaneCompatible(viewRef, context, options)) {
+        return false;
+    }
+    if (!isReferencedImageCompatible(viewRef, context, options)) {
+        return false;
+    }
+    if (!isDimensionGroupCompatible(viewRef, context, options)) {
+        return false;
+    }
+    return isSliceIndexCompatible(viewRef, context, options);
+}
+function isFrameOfReferenceCompatible(viewRef, context) {
+    return (!viewRef.FrameOfReferenceUID ||
+        viewRef.FrameOfReferenceUID === context.frameOfReferenceUID);
+}
+function isDataIdCompatible(viewRef, context) {
+    if (!viewRef.dataId) {
+        return true;
+    }
+    return getContextDataIds(context).includes(viewRef.dataId);
+}
+function isVolumeIdCompatible(viewRef, context) {
+    if (!viewRef.volumeId) {
+        return true;
+    }
+    return getContextVolumeIds(context).includes(viewRef.volumeId);
+}
+function isPlaneCompatible(viewRef, context, options) {
+    if (viewRef.planeRestriction) {
+        return isPlaneRestrictionViewable(viewRef.planeRestriction, context, options);
+    }
+    if (!viewRef.viewPlaneNormal) {
+        return true;
+    }
+    const { viewPlaneNormal } = context;
+    if (!viewPlaneNormal) {
+        return false;
+    }
+    return (isEqual(viewRef.viewPlaneNormal, viewPlaneNormal) ||
+        isEqual(vec3.negate(vec3.create(), viewPlaneNormal), viewRef.viewPlaneNormal) ||
+        Boolean(options.withOrientation));
+}
+function isPlaneRestrictionViewable(planeRestriction, context, options) {
+    if (planeRestriction.FrameOfReferenceUID !== context.frameOfReferenceUID) {
+        return false;
+    }
+    if (options.withOrientation) {
+        return true;
+    }
+    const { cameraFocalPoint, viewPlaneNormal } = context;
+    if (!cameraFocalPoint || !viewPlaneNormal) {
+        return false;
+    }
+    if (planeRestriction.inPlaneVector1 &&
+        !isEqual(0, vec3.dot(viewPlaneNormal, planeRestriction.inPlaneVector1))) {
+        return false;
+    }
+    if (planeRestriction.inPlaneVector2 &&
+        !isEqual(0, vec3.dot(viewPlaneNormal, planeRestriction.inPlaneVector2))) {
+        return false;
+    }
+    if (options.withNavigation) {
+        return true;
+    }
+    const pointVector = vec3.sub(vec3.create(), planeRestriction.point, cameraFocalPoint);
+    return isEqual(0, vec3.dot(pointVector, viewPlaneNormal));
+}
+function isReferencedImageCompatible(viewRef, context, options) {
+    if (viewRef.planeRestriction &&
+        viewRef.volumeId &&
+        getContextVolumeIds(context).includes(viewRef.volumeId)) {
+        return true;
+    }
+    const referencedImageURIs = getReferencedImageURIs(viewRef);
+    if (!referencedImageURIs.length) {
+        return true;
+    }
+    const imageURIEntries = getContextImageURIEntries(context);
+    if (!imageURIEntries.length) {
+        return false;
+    }
+    const currentImageIdIndex = context.currentImageIdIndex ?? 0;
+    const currentImageURIEntry = imageURIEntries[currentImageIdIndex];
+    if (imageURIEntryMatches(currentImageURIEntry, referencedImageURIs)) {
+        return true;
+    }
+    const foundSliceIndex = imageURIEntries.findIndex((imageURIEntry) => imageURIEntryMatches(imageURIEntry, referencedImageURIs));
+    if (foundSliceIndex === -1) {
+        return false;
+    }
+    if (context.allowAnyImageReference) {
+        return true;
+    }
+    if (options.withNavigation) {
+        return true;
+    }
+    const rangeEndSliceIndex = getReferencedImageRangeEndIndex(imageURIEntries, viewRef);
+    if (rangeEndSliceIndex !== undefined) {
+        const start = Math.min(foundSliceIndex, rangeEndSliceIndex);
+        const end = Math.max(foundSliceIndex, rangeEndSliceIndex);
+        return start <= currentImageIdIndex && currentImageIdIndex <= end;
+    }
+    return currentImageIdIndex === foundSliceIndex;
+}
+function isDimensionGroupCompatible(viewRef, context, options) {
+    const hasDimensionGroupRestriction = typeof viewRef.dimensionGroupNumber !== 'undefined';
+    const dimensionGroupNumber = toPositiveInteger(viewRef.dimensionGroupNumber);
+    if (!hasDimensionGroupRestriction) {
+        return true;
+    }
+    if (!dimensionGroupNumber) {
+        return false;
+    }
+    if (context.dimensionGroupNumber === dimensionGroupNumber) {
+        return true;
+    }
+    if (!options.withNavigation) {
+        return false;
+    }
+    return (typeof context.numDimensionGroups === 'number' &&
+        dimensionGroupNumber <= context.numDimensionGroups);
+}
+function isSliceIndexCompatible(viewRef, context, options) {
+    const sliceIndex = viewRef.sliceIndex;
+    if (sliceIndex === undefined) {
+        return true;
+    }
+    const { currentImageIdIndex } = context;
+    if (Array.isArray(sliceIndex)) {
+        if (typeof currentImageIdIndex === 'number') {
+            return (sliceIndex[0] <= currentImageIdIndex &&
+                currentImageIdIndex <= sliceIndex[1]);
+        }
+        return false;
+    }
+    if (!Number.isFinite(sliceIndex)) {
+        return false;
+    }
+    if (currentImageIdIndex === sliceIndex) {
+        return true;
+    }
+    if (!options.withNavigation) {
+        return false;
+    }
+    return isIndexInImageRange(sliceIndex, context.imageIds);
+}
+function getReferencedImageURIs(viewRef) {
+    return uniqueStrings([
+        viewRef.referencedImageURI,
+        ...(viewRef.referencedImageId
+            ? getImageIdCompatibleURIs(viewRef.referencedImageId)
+            : []),
+    ]);
+}
+function getReferencedImageRangeEndIndex(imageURIEntries, viewRef) {
+    const rangeEndImageURI = viewRef.multiSliceReference &&
+        getReferencedImageURIs(viewRef.multiSliceReference);
+    if (!rangeEndImageURI?.length) {
+        return;
+    }
+    const rangeEndSliceIndex = imageURIEntries.findIndex((imageURIEntry) => imageURIEntryMatches(imageURIEntry, rangeEndImageURI));
+    return rangeEndSliceIndex === -1 ? undefined : rangeEndSliceIndex;
+}
+function getContextImageURIEntries(context) {
+    const imageURIEntries = (context.imageIds || []).map((imageId) => getImageIdCompatibleURIs(imageId));
+    const knownImageURIs = new Set();
+    for (const imageURIEntry of imageURIEntries) {
+        for (const imageURI of imageURIEntry) {
+            knownImageURIs.add(imageURI);
+        }
+    }
+    for (const imageURI of context.imageURIs || []) {
+        if (!knownImageURIs.has(imageURI)) {
+            imageURIEntries.push([imageURI]);
+            knownImageURIs.add(imageURI);
+        }
+    }
+    return imageURIEntries;
+}
+function getImageIdCompatibleURIs(imageId) {
+    return uniqueStrings([imageIdToURI(imageId), getLegacyImageIdURI(imageId)]);
+}
+function getLegacyImageIdURI(imageId) {
+    const colonIndex = imageId.indexOf(':');
+    return colonIndex === -1 ? imageId : imageId.substring(colonIndex + 1);
+}
+function imageURIEntryMatches(imageURIEntry, referencedImageURIs) {
+    return Boolean(imageURIEntry?.some((imageURI) => referencedImageURIs.includes(imageURI)));
+}
+function getContextDataIds(context) {
+    return uniqueStrings([context.dataId, ...(context.dataIds || [])]);
+}
+function getContextVolumeIds(context) {
+    return uniqueStrings([context.volumeId, ...(context.volumeIds || [])]);
+}
+function isIndexInImageRange(index, imageIds) {
+    if (!imageIds?.length) {
+        return true;
+    }
+    return index >= 0 && index < imageIds.length;
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((value) => typeof value === 'string')));
+}
+function toPositiveInteger(value) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1) {
+        return;
+    }
+    return value;
+}