@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarSliceBasis.js

@@ -0,0 +1,330 @@
+import { vec3 } from 'gl-matrix';
+import { InterpolationType, OrientationAxis } from '../../../enums';
+import { getImageDataMetadata } from '../../../utilities/getImageDataMetadata';
+import { getCubeSizeInView } from '../../../utilities/getPlaneCubeIntersectionDimensions';
+import getSpacingInNormalDirection from '../../../utilities/getSpacingInNormalDirection';
+import { getVolumeCenterIJK } from '../../Viewport';
+import { getCpuEquivalentParallelScale, getOrthogonalVolumeSliceGeometry, } from './planarAdapterCoordinateTransforms';
+import { getPlanarViewStateVectors } from './planarOrientationVectors';
+import { getSafeCanvasDimension, normalizePoint3 } from './planarMath';
+const MIN_CAMERA_DISTANCE = 1;
+const MIN_SLICE_SPACING = 1e-6;
+const ORTHONORMAL_EPSILON = 1e-6;
+function getFitParallelScaleFromWorldSize(args) {
+    const { canvasHeight, canvasWidth, heightWorld, widthWorld } = args;
+    const safeCanvasWidth = getSafeCanvasDimension(canvasWidth);
+    const safeCanvasHeight = getSafeCanvasDimension(canvasHeight);
+    const safeWidthWorld = Math.max(widthWorld, MIN_SLICE_SPACING);
+    const safeHeightWorld = Math.max(heightWorld, MIN_SLICE_SPACING);
+    const sliceAspectRatio = safeWidthWorld / safeHeightWorld;
+    const canvasAspectRatio = safeCanvasWidth / safeCanvasHeight;
+    const scaleFactor = sliceAspectRatio / canvasAspectRatio;
+    return scaleFactor < 1
+        ? safeHeightWorld / 2
+        : (safeHeightWorld * scaleFactor) / 2;
+}
+function createFallbackVolumeSliceFitMetrics() {
+    return {
+        fitParallelScale: MIN_CAMERA_DISTANCE,
+        sliceWidthWorld: MIN_CAMERA_DISTANCE * 2,
+        sliceHeightWorld: MIN_CAMERA_DISTANCE * 2,
+    };
+}
+function isOne(value) {
+    return Math.abs(Math.abs(value) - 1) < ORTHONORMAL_EPSILON;
+}
+function isUnitAxis(direction, offset) {
+    return (isOne(direction[offset]) ||
+        isOne(direction[offset + 1]) ||
+        isOne(direction[offset + 2]));
+}
+function isOrthonormalDirection(direction) {
+    return (isUnitAxis(direction, 0) &&
+        isUnitAxis(direction, 3) &&
+        isUnitAxis(direction, 6));
+}
+function buildPlanarImageSliceBasis(args) {
+    const { canvasHeight, canvasWidth, columnOffset, columnsForFit, image, rowOffset, rowsForFit, } = args;
+    const { direction, origin } = getImageDataMetadata(image);
+    const rowVector = direction.slice(0, 3);
+    const columnVector = direction.slice(3, 6);
+    const viewPlaneNormal = direction
+        .slice(6, 9)
+        .map((value) => -value);
+    const viewUp = columnVector.map((value) => -value);
+    const sliceCenterWorld = [...origin];
+    const sliceWidthWorld = Math.max(columnsForFit, 1) * (image.columnPixelSpacing || 1);
+    const sliceHeightWorld = Math.max(rowsForFit, 1) * (image.rowPixelSpacing || 1);
+    vec3.scaleAndAdd(sliceCenterWorld, sliceCenterWorld, rowVector, rowOffset);
+    vec3.scaleAndAdd(sliceCenterWorld, sliceCenterWorld, columnVector, columnOffset);
+    return {
+        sliceCenterWorld,
+        viewPlaneNormal: vec3.clone(viewPlaneNormal),
+        viewUp,
+        fitParallelScale: getCpuEquivalentParallelScale({
+            canvasHeight,
+            canvasWidth,
+            columnPixelSpacing: image.columnPixelSpacing || 1,
+            columns: columnsForFit,
+            rowPixelSpacing: image.rowPixelSpacing || 1,
+            rows: rowsForFit,
+        }),
+        sliceWidthWorld,
+        sliceHeightWorld,
+        cameraDistance: 1,
+    };
+}
+export function createPlanarImageSliceBasis(args) {
+    const { image } = args;
+    const { dimensions, spacing } = getImageDataMetadata(image);
+    return buildPlanarImageSliceBasis({
+        ...args,
+        rowOffset: ((dimensions[0] - 1) / 2) * spacing[0],
+        columnOffset: ((dimensions[1] - 1) / 2) * spacing[1],
+        rowsForFit: Math.max(image.rows, 1),
+        columnsForFit: Math.max(image.columns, 1),
+    });
+}
+export function createPlanarCpuImageSliceBasis(args) {
+    return createPlanarImageSliceBasis(args);
+}
+function buildImageVolumeCorners(imageVolume) {
+    const imageData = imageVolume.imageData;
+    if (!imageData) {
+        return [];
+    }
+    const direction = imageData.getDirection();
+    if (isOrthonormalDirection(direction)) {
+        const bounds = imageData.extentToBounds(imageData.getExtent());
+        return [
+            [bounds[0], bounds[2], bounds[4]],
+            [bounds[0], bounds[2], bounds[5]],
+            [bounds[0], bounds[3], bounds[4]],
+            [bounds[0], bounds[3], bounds[5]],
+            [bounds[1], bounds[2], bounds[4]],
+            [bounds[1], bounds[2], bounds[5]],
+            [bounds[1], bounds[3], bounds[4]],
+            [bounds[1], bounds[3], bounds[5]],
+        ];
+    }
+    const [dx, dy, dz] = imageData.getDimensions();
+    const cornersIdx = [
+        [0, 0, 0],
+        [dx - 1, 0, 0],
+        [0, dy - 1, 0],
+        [dx - 1, dy - 1, 0],
+        [0, 0, dz - 1],
+        [dx - 1, 0, dz - 1],
+        [0, dy - 1, dz - 1],
+        [dx - 1, dy - 1, dz - 1],
+    ];
+    return cornersIdx.map((it) => imageData.indexToWorld(it));
+}
+function getGeometricImageVolumeCenter(imageVolume, viewPlaneNormal) {
+    const imageData = imageVolume.imageData;
+    if (imageData) {
+        const dimensions = imageData.getDimensions();
+        const ijk = viewPlaneNormal
+            ? getVolumeCenterIJK(dimensions, imageData.getDirection(), viewPlaneNormal)
+            : dimensions.map((d) => (d - 1) / 2);
+        return imageData.indexToWorld(ijk);
+    }
+    const corners = buildImageVolumeCorners(imageVolume);
+    if (!corners.length) {
+        return [0, 0, 0];
+    }
+    const center = vec3.create();
+    for (const corner of corners) {
+        vec3.add(center, center, corner);
+    }
+    return vec3.scale(center, center, 1 / corners.length);
+}
+function getSliceMetrics(args) {
+    const { imageVolume, viewPlaneNormal } = args;
+    const corners = buildImageVolumeCorners(imageVolume);
+    const spacingInNormalDirection = Math.max(getSpacingInNormalDirection(imageVolume, viewPlaneNormal), MIN_SLICE_SPACING);
+    if (!corners.length) {
+        return {
+            min: 0,
+            max: 0,
+            spacingInNormalDirection,
+            maxImageIdIndex: 0,
+        };
+    }
+    const projectedValues = corners.map((corner) => vec3.dot(corner, viewPlaneNormal));
+    const min = Math.min(...projectedValues);
+    const max = Math.max(...projectedValues);
+    const maxImageIdIndex = Math.max(0, Math.round((max - min) / spacingInNormalDirection));
+    return {
+        min,
+        max,
+        spacingInNormalDirection,
+        maxImageIdIndex,
+    };
+}
+function resolveCenteredImageIdIndex(args) {
+    const { centerProjection, min, max, maxImageIdIndex } = args;
+    const range = max - min;
+    if (!(range > 0) || maxImageIdIndex === 0) {
+        return 0;
+    }
+    const fraction = (centerProjection - min) / range;
+    const floatingImageIdIndex = fraction * maxImageIdIndex;
+    return Math.round(floatingImageIdIndex);
+}
+function clampImageIdIndex(args) {
+    const { centerProjection, imageIdIndex, max, maxImageIdIndex, min } = args;
+    if (typeof imageIdIndex !== 'number') {
+        return resolveCenteredImageIdIndex({
+            centerProjection,
+            min,
+            max,
+            maxImageIdIndex,
+        });
+    }
+    return Math.min(Math.max(0, imageIdIndex), maxImageIdIndex);
+}
+export function resolvePlanarVolumeImageIdIndex(args) {
+    const { viewState, fallbackImageIdIndex } = args;
+    const slice = viewState?.slice;
+    if (slice?.kind === 'volumePoint') {
+        return;
+    }
+    if (slice?.kind === 'stackIndex') {
+        return slice.imageIdIndex;
+    }
+    if (viewState?.orientation === OrientationAxis.ACQUISITION) {
+        return fallbackImageIdIndex;
+    }
+}
+function getCpuVolumeSliceFitMetrics(args) {
+    const { imageVolume, viewPlaneNormal, viewUp, canvasWidth, canvasHeight } = args;
+    const geometry = getOrthogonalVolumeSliceGeometry({
+        dimensions: imageVolume.dimensions,
+        direction: imageVolume.direction,
+        spacing: imageVolume.spacing,
+        viewPlaneNormal,
+        viewUp,
+    });
+    if (geometry) {
+        const columns = Math.max(geometry.columns, 1);
+        const rows = Math.max(geometry.rows, 1);
+        const sliceWidthWorld = columns * geometry.columnPixelSpacing;
+        const sliceHeightWorld = rows * geometry.rowPixelSpacing;
+        return {
+            fitParallelScale: getCpuEquivalentParallelScale({
+                canvasHeight: getSafeCanvasDimension(canvasHeight),
+                canvasWidth: getSafeCanvasDimension(canvasWidth),
+                columnPixelSpacing: geometry.columnPixelSpacing,
+                columns,
+                rowPixelSpacing: geometry.rowPixelSpacing,
+                rows,
+            }),
+            sliceWidthWorld,
+            sliceHeightWorld,
+        };
+    }
+    const imageData = imageVolume.imageData;
+    if (imageData) {
+        const { widthWorld, heightWorld } = getCubeSizeInView(imageData, viewPlaneNormal, viewUp);
+        if (widthWorld > 0 && heightWorld > 0) {
+            return {
+                fitParallelScale: getFitParallelScaleFromWorldSize({
+                    canvasHeight,
+                    canvasWidth,
+                    widthWorld,
+                    heightWorld,
+                }),
+                sliceWidthWorld: widthWorld,
+                sliceHeightWorld: heightWorld,
+            };
+        }
+    }
+    return createFallbackVolumeSliceFitMetrics();
+}
+function buildPlanarVolumeSliceBasis(args) {
+    const { center, fitParallelScale, imageIdIndex, imageVolume, orientation, sliceHeightWorld, sliceWidthWorld, viewState, } = args;
+    const cameraValues = getPlanarViewStateVectors({
+        imageVolume,
+        orientation,
+    });
+    if (!cameraValues) {
+        return {
+            sliceBasis: {
+                sliceCenterWorld: [0, 0, 0],
+                viewPlaneNormal: [0, 0, 1],
+                viewUp: [0, -1, 0],
+                fitParallelScale: MIN_CAMERA_DISTANCE,
+                sliceWidthWorld: MIN_CAMERA_DISTANCE * 2,
+                sliceHeightWorld: MIN_CAMERA_DISTANCE * 2,
+                cameraDistance: MIN_CAMERA_DISTANCE,
+            },
+            currentImageIdIndex: 0,
+            maxImageIdIndex: 0,
+        };
+    }
+    const viewPlaneNormal = normalizePoint3(cameraValues.viewPlaneNormal);
+    const viewUp = normalizePoint3(cameraValues.viewUp);
+    const { max, maxImageIdIndex, min, spacingInNormalDirection } = getSliceMetrics({
+        imageVolume,
+        viewPlaneNormal,
+    });
+    const centerProjection = vec3.dot(center, viewPlaneNormal);
+    const volumePoint = viewState?.slice?.kind === 'volumePoint'
+        ? viewState.slice.sliceWorldPoint
+        : undefined;
+    const requestedSliceProjection = Math.min(max, Math.max(min, volumePoint
+        ? vec3.dot(volumePoint, viewPlaneNormal)
+        : centerProjection));
+    const currentImageIdIndex = clampImageIdIndex({
+        imageIdIndex,
+        centerProjection: requestedSliceProjection,
+        min,
+        max,
+        maxImageIdIndex,
+    });
+    const targetProjection = typeof imageIdIndex === 'number'
+        ? Math.min(max, min + currentImageIdIndex * spacingInNormalDirection)
+        : requestedSliceProjection;
+    const scalarOffset = targetProjection - centerProjection;
+    const sliceCenterWorld = vec3.scaleAndAdd(vec3.create(), center, viewPlaneNormal, scalarOffset);
+    const cameraDistance = Math.max(max - min, spacingInNormalDirection, 1);
+    return {
+        sliceBasis: {
+            sliceCenterWorld,
+            viewPlaneNormal,
+            viewUp,
+            fitParallelScale,
+            sliceWidthWorld,
+            sliceHeightWorld,
+            cameraDistance,
+        },
+        currentImageIdIndex,
+        maxImageIdIndex,
+    };
+}
+export function createPlanarVolumeSliceBasis(args) {
+    const { imageVolume, orientation } = args;
+    const cameraValues = getPlanarViewStateVectors({
+        imageVolume,
+        orientation,
+    });
+    const sliceFitMetrics = cameraValues
+        ? getCpuVolumeSliceFitMetrics({
+            ...args,
+            viewPlaneNormal: cameraValues.viewPlaneNormal,
+            viewUp: cameraValues.viewUp,
+        })
+        : createFallbackVolumeSliceFitMetrics();
+    return buildPlanarVolumeSliceBasis({
+        ...args,
+        center: getGeometricImageVolumeCenter(imageVolume, cameraValues?.viewPlaneNormal),
+        ...sliceFitMetrics,
+    });
+}
+export function createPlanarCpuVolumeSliceBasis(args) {
+    return createPlanarVolumeSliceBasis(args);
+}
+export function shouldUsePlanarCpuVolumeSliceBasis(interpolationType = InterpolationType.LINEAR) {
+    return interpolationType === InterpolationType.NEAREST;
+}

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarViewPresentation.d.ts

@@ -0,0 +1,16 @@
+import type { Point3 } from '../../../types';
+export declare function normalizePlanarRotation(rotation?: number): number;
+export declare function rotatePlanarViewUp(args: {
+    rotation?: number;
+    viewPlaneNormal: Point3;
+    viewUp: Point3;
+}): Point3;
+export declare function applyPlanarViewFlip(args: {
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+    viewPlaneNormal: Point3;
+    viewUp: Point3;
+}): {
+    viewPlaneNormal: Point3;
+    viewUp: Point3;
+};

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarViewPresentation.js

@@ -0,0 +1,25 @@
+import { mat4, vec3 } from 'gl-matrix';
+export function normalizePlanarRotation(rotation = 0) {
+    return ((rotation % 360) + 360) % 360;
+}
+export function rotatePlanarViewUp(args) {
+    const { rotation = 0, viewPlaneNormal, viewUp } = args;
+    const normalizedRotation = normalizePlanarRotation(rotation);
+    if (normalizedRotation === 0) {
+        return [...viewUp];
+    }
+    const rotationMatrix = mat4.fromRotation(mat4.create(), (normalizedRotation * Math.PI) / 180, viewPlaneNormal);
+    return vec3.transformMat4(vec3.create(), viewUp, rotationMatrix);
+}
+export function applyPlanarViewFlip(args) {
+    const { flipHorizontal, flipVertical, viewPlaneNormal, viewUp } = args;
+    const shouldFlipNormal = Boolean(flipHorizontal) !== Boolean(flipVertical);
+    return {
+        viewPlaneNormal: shouldFlipNormal
+            ? vec3.negate(vec3.create(), viewPlaneNormal)
+            : [...viewPlaneNormal],
+        viewUp: flipVertical
+            ? vec3.negate(vec3.create(), viewUp)
+            : [...viewUp],
+    };
+}

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarViewReference.d.ts

@@ -0,0 +1,46 @@
+import type { ReferenceCompatibleOptions, ViewReference, ViewReferenceSpecifier } from '../../../types';
+import type { PlaneRestriction } from '../../../types/IViewport';
+import type { PlanarViewState, PlanarPayload, PlanarViewportRenderContext } from './PlanarViewportTypes';
+import type { PlanarRendering } from './planarRuntimeTypes';
+export declare function getPlanarReferencedImageId(args: {
+    viewState: PlanarViewState;
+    data?: PlanarPayload;
+    frameOfReferenceUID?: string;
+    rendering?: PlanarRendering;
+    renderContext: PlanarViewportRenderContext;
+    viewRefSpecifier?: ViewReferenceSpecifier;
+}): string | undefined;
+export declare function getPlanarViewReference(args: {
+    viewState: PlanarViewState;
+    dataId?: string;
+    frameOfReferenceUID: string;
+    data?: PlanarPayload;
+    rendering?: PlanarRendering;
+    renderContext: PlanarViewportRenderContext;
+    viewRefSpecifier?: ViewReferenceSpecifier;
+}): ViewReference;
+export declare function getPlanarViewReferenceId(args: {
+    viewState: PlanarViewState;
+    frameOfReferenceUID?: string;
+    data?: PlanarPayload;
+    rendering?: PlanarRendering;
+    renderContext: PlanarViewportRenderContext;
+    viewRefSpecifier?: ViewReferenceSpecifier;
+}): string | null;
+export declare function isPlanarPlaneViewable(args: {
+    viewState: PlanarViewState;
+    frameOfReferenceUID: string;
+    planeRestriction: PlaneRestriction;
+    rendering?: PlanarRendering;
+    renderContext: PlanarViewportRenderContext;
+    options?: ReferenceCompatibleOptions;
+}): boolean;
+export declare function isPlanarReferenceViewable(args: {
+    viewState: PlanarViewState;
+    frameOfReferenceUID: string;
+    imageIds: string[];
+    rendering?: PlanarRendering;
+    renderContext: PlanarViewportRenderContext;
+    options?: ReferenceCompatibleOptions;
+    viewRef: ViewReference;
+}): boolean;

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarViewReference.js

@@ -0,0 +1,243 @@
+import { vec3 } from 'gl-matrix';
+import { ActorRenderMode } from '../../../types';
+import getClosestImageId from '../../../utilities/getClosestImageId';
+import imageIdToURI from '../../../utilities/imageIdToURI';
+import isEqual from '../../../utilities/isEqual';
+import getVolumeViewReferenceId from '../../../utilities/getVolumeViewReferenceId';
+import { updatePlaneRestriction } from '../../../utilities/updatePlaneRestriction';
+import { getDimensionGroupReferenceContext } from '../genericViewportReferenceCompatibility';
+import { resolvePlanarViewportView } from './PlanarResolvedView';
+export function getPlanarReferencedImageId(args) {
+    const { rendering, viewRefSpecifier } = args;
+    if (!rendering) {
+        return;
+    }
+    const imageIds = getImageIds(args.data);
+    if (!imageIds.length) {
+        return;
+    }
+    if (rendering.renderMode === ActorRenderMode.CPU_IMAGE ||
+        rendering.renderMode === ActorRenderMode.VTK_IMAGE) {
+        const imageIdIndex = typeof viewRefSpecifier?.sliceIndex === 'number'
+            ? Math.min(Math.max(0, viewRefSpecifier.sliceIndex), imageIds.length - 1)
+            : args.viewState?.slice?.kind === 'stackIndex'
+                ? Math.min(Math.max(0, args.viewState.slice.imageIdIndex), imageIds.length - 1)
+                : getCurrentSliceIndex(rendering);
+        return imageIds[imageIdIndex];
+    }
+    const resolvedView = getPlanarResolvedViewForReference({
+        viewState: args.viewState,
+        data: args.data,
+        frameOfReferenceUID: args.frameOfReferenceUID,
+        renderContext: args.renderContext,
+        rendering,
+        sliceIndex: viewRefSpecifier?.sliceIndex,
+    })?.toICamera();
+    if (!resolvedView?.focalPoint || !resolvedView.viewPlaneNormal) {
+        return imageIds[Math.min(getCurrentSliceIndex(rendering), imageIds.length - 1)];
+    }
+    return getClosestImageId(rendering.imageVolume, resolvedView.focalPoint, resolvedView.viewPlaneNormal);
+}
+export function getPlanarViewReference(args) {
+    const { frameOfReferenceUID, rendering, viewRefSpecifier } = args;
+    const { dimensionGroupNumber } = getDimensionGroupReferenceContext(args.data?.imageVolume);
+    const sliceIndex = viewRefSpecifier?.sliceIndex ??
+        (rendering ? getCurrentSliceIndex(rendering) : undefined);
+    const rangeEndSliceIndex = viewRefSpecifier?.rangeEndSliceIndex;
+    const targetCamera = getPlanarResolvedViewForReference({
+        ...args,
+        sliceIndex,
+    })?.toICamera();
+    const cameraFocalPoint = toPoint3(targetCamera?.focalPoint);
+    const viewPlaneNormal = toPoint3(targetCamera?.viewPlaneNormal);
+    const viewUp = toPoint3(targetCamera?.viewUp);
+    const inPlaneVector2 = viewUp && viewPlaneNormal
+        ? toPoint3(vec3.cross(vec3.create(), viewUp, viewPlaneNormal))
+        : undefined;
+    const viewReference = {
+        FrameOfReferenceUID: frameOfReferenceUID,
+        dataId: args.dataId,
+        dimensionGroupNumber,
+        cameraFocalPoint,
+        viewPlaneNormal,
+        viewUp,
+        sliceIndex,
+        planeRestriction: viewPlaneNormal && viewUp && cameraFocalPoint
+            ? {
+                FrameOfReferenceUID: frameOfReferenceUID,
+                point: toPoint3(viewRefSpecifier?.points?.[0]) || cameraFocalPoint,
+                inPlaneVector1: viewUp,
+                inPlaneVector2,
+            }
+            : undefined,
+    };
+    const referencedImageId = getPlanarReferencedImageId(args);
+    const rangeEndReferencedImageId = typeof sliceIndex === 'number' &&
+        typeof rangeEndSliceIndex === 'number' &&
+        rangeEndSliceIndex > sliceIndex
+        ? getPlanarReferencedImageId({
+            ...args,
+            viewRefSpecifier: {
+                ...viewRefSpecifier,
+                sliceIndex: rangeEndSliceIndex,
+            },
+        })
+        : undefined;
+    if (rendering &&
+        (rendering.renderMode === ActorRenderMode.CPU_VOLUME ||
+            rendering.renderMode === ActorRenderMode.VTK_VOLUME_SLICE) &&
+        viewRefSpecifier?.forFrameOfReference !== false) {
+        viewReference.volumeId = args.data?.volumeId;
+    }
+    if (referencedImageId) {
+        viewReference.referencedImageId = referencedImageId;
+        viewReference.referencedImageURI = imageIdToURI(referencedImageId);
+    }
+    if (rangeEndReferencedImageId &&
+        typeof rangeEndSliceIndex === 'number' &&
+        typeof sliceIndex === 'number' &&
+        rangeEndSliceIndex > sliceIndex) {
+        viewReference.multiSliceReference = {
+            FrameOfReferenceUID: frameOfReferenceUID,
+            referencedImageId: rangeEndReferencedImageId,
+            referencedImageURI: imageIdToURI(rangeEndReferencedImageId),
+            sliceIndex: rangeEndSliceIndex,
+        };
+    }
+    if (viewRefSpecifier?.points && viewReference.planeRestriction) {
+        updatePlaneRestriction(viewRefSpecifier.points, viewReference);
+    }
+    return viewReference;
+}
+export function getPlanarViewReferenceId(args) {
+    const { rendering, viewRefSpecifier } = args;
+    if (!rendering) {
+        return null;
+    }
+    if (rendering.renderMode === ActorRenderMode.CPU_VOLUME ||
+        rendering.renderMode === ActorRenderMode.VTK_VOLUME_SLICE) {
+        const resolvedView = getPlanarResolvedViewForReference({
+            ...args,
+            sliceIndex: viewRefSpecifier?.sliceIndex,
+        })?.toICamera();
+        const sliceIndex = viewRefSpecifier?.sliceIndex ?? getCurrentSliceIndex(rendering);
+        const volumeId = args.data?.volumeId;
+        if (!volumeId || !resolvedView?.viewPlaneNormal) {
+            return null;
+        }
+        return getVolumeViewReferenceId({
+            sliceIndex,
+            viewPlaneNormal: resolvedView.viewPlaneNormal,
+            volumeId,
+        });
+    }
+    const referencedImageId = getPlanarReferencedImageId(args);
+    return referencedImageId ? `imageId:${referencedImageId}` : null;
+}
+export function isPlanarPlaneViewable(args) {
+    const { frameOfReferenceUID, options, planeRestriction } = args;
+    if (planeRestriction.FrameOfReferenceUID !== frameOfReferenceUID) {
+        return false;
+    }
+    const resolvedView = getPlanarResolvedViewForReference(args)?.toICamera();
+    const { focalPoint, viewPlaneNormal } = resolvedView || {};
+    if (!focalPoint || !viewPlaneNormal) {
+        return false;
+    }
+    if (options?.withOrientation) {
+        return true;
+    }
+    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 { point } = planeRestriction;
+    const pointVector = vec3.sub(vec3.create(), point, focalPoint);
+    return isEqual(0, vec3.dot(pointVector, viewPlaneNormal));
+}
+export function isPlanarReferenceViewable(args) {
+    const { frameOfReferenceUID, imageIds, options = {}, viewRef } = args;
+    if (!viewRef) {
+        return false;
+    }
+    if (viewRef.planeRestriction) {
+        return isPlanarPlaneViewable({
+            viewState: args.viewState,
+            frameOfReferenceUID,
+            options,
+            planeRestriction: viewRef.planeRestriction,
+            renderContext: args.renderContext,
+            rendering: args.rendering,
+        });
+    }
+    if (viewRef.FrameOfReferenceUID &&
+        viewRef.FrameOfReferenceUID !== frameOfReferenceUID) {
+        return false;
+    }
+    const resolvedView = getPlanarResolvedViewForReference(args)?.toICamera();
+    if (!resolvedView?.viewPlaneNormal) {
+        return false;
+    }
+    if (viewRef.viewPlaneNormal &&
+        !isEqual(viewRef.viewPlaneNormal, resolvedView.viewPlaneNormal) &&
+        !isEqual(vec3.negate(vec3.create(), resolvedView.viewPlaneNormal), viewRef.viewPlaneNormal)) {
+        return Boolean(options.withOrientation);
+    }
+    if (viewRef.referencedImageId || viewRef.referencedImageURI) {
+        const referencedImageURI = viewRef.referencedImageURI ||
+            imageIdToURI(viewRef.referencedImageId);
+        const currentSliceIndex = args.rendering
+            ? getCurrentSliceIndex(args.rendering)
+            : 0;
+        const currentReferencedImageId = imageIds[currentSliceIndex];
+        if (currentReferencedImageId &&
+            imageIdToURI(currentReferencedImageId) === referencedImageURI) {
+            return true;
+        }
+        const foundSliceIndex = imageIds.findIndex((imageId) => imageIdToURI(imageId) === referencedImageURI);
+        if (foundSliceIndex === -1) {
+            return false;
+        }
+        if (options.withNavigation) {
+            return true;
+        }
+        const rangeEndSliceIndex = viewRef.multiSliceReference &&
+            imageIds.findIndex((imageId) => imageIdToURI(imageId) ===
+                imageIdToURI(viewRef.multiSliceReference.referencedImageId));
+        if (rangeEndSliceIndex !== undefined && rangeEndSliceIndex >= 0) {
+            return (foundSliceIndex <= currentSliceIndex &&
+                currentSliceIndex <= rangeEndSliceIndex);
+        }
+        return currentSliceIndex === foundSliceIndex;
+    }
+    const currentSliceIndex = args.rendering
+        ? getCurrentSliceIndex(args.rendering)
+        : 0;
+    const { sliceIndex } = viewRef;
+    if (Array.isArray(sliceIndex)) {
+        return (sliceIndex[0] <= currentSliceIndex && currentSliceIndex <= sliceIndex[1]);
+    }
+    return sliceIndex === undefined || sliceIndex === currentSliceIndex;
+}
+function getCurrentSliceIndex(rendering) {
+    return rendering.currentImageIdIndex;
+}
+function getImageIds(payload) {
+    return payload?.imageVolume?.imageIds || payload?.imageIds || [];
+}
+function toPoint3(point) {
+    if (!point) {
+        return;
+    }
+    return [point[0], point[1], point[2]];
+}
+function getPlanarResolvedViewForReference(args) {
+    return resolvePlanarViewportView(args);
+}

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarViewState.d.ts

@@ -0,0 +1,5 @@
+import type DisplayArea from '../../../types/displayArea';
+import type { PlanarDisplayArea, PlanarViewState } from './PlanarViewportTypes';
+export declare function cloneDisplayArea<T extends DisplayArea | PlanarDisplayArea>(displayArea?: T): T | undefined;
+export declare function createDefaultPlanarViewState(): PlanarViewState;
+export declare function normalizePlanarViewState(viewState: PlanarViewState): PlanarViewState;