@cornerstonejs/core 5.0.0-beta.1 → 5.0.1

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

@@ -0,0 +1,4 @@
+import type { ActorEntry, IImage, IStackInput } from '../../../types';
+import type { IViewport } from '../../../types/IViewport';
+export declare function createPlanarImageOverlayActorEntry(image: IImage, stackInput: IStackInput): ActorEntry;
+export declare function createPlanarCpuImageOverlayActorEntry(viewport: IViewport, image: IImage, stackInput: IStackInput): ActorEntry;

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

@@ -0,0 +1,42 @@
+import vtkImageMapper from '@kitware/vtk.js/Rendering/Core/ImageMapper';
+import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
+import CanvasActor from '../../CanvasActor';
+import { ActorRenderMode } from '../../../types';
+import uuidv4 from '../../../utilities/uuidv4';
+import { createVTKImageDataFromImage } from '../../helpers/planarImageRendering';
+export function createPlanarImageOverlayActorEntry(image, stackInput) {
+    const mapper = vtkImageMapper.newInstance();
+    const actor = vtkImageSlice.newInstance();
+    const imageData = createVTKImageDataFromImage(image);
+    mapper.setInputData(imageData);
+    actor.setMapper(mapper);
+    if (typeof stackInput.visibility === 'boolean') {
+        actor.setVisibility(stackInput.visibility);
+    }
+    return {
+        uid: uuidv4(),
+        actor,
+        actorMapper: {
+            actor,
+            mapper,
+            renderMode: ActorRenderMode.VTK_IMAGE,
+        },
+        referencedId: image.imageId,
+        ...stackInput,
+    };
+}
+export function createPlanarCpuImageOverlayActorEntry(viewport, image, stackInput) {
+    const actor = new CanvasActor(viewport, image);
+    actor.setVisibility(typeof stackInput.visibility === 'boolean' ? stackInput.visibility : true);
+    return {
+        uid: uuidv4(),
+        actor,
+        actorMapper: {
+            actor,
+            mapper: actor.getMapper(),
+            renderMode: ActorRenderMode.CPU_IMAGE,
+        },
+        referencedId: image.imageId,
+        ...stackInput,
+    };
+}

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

@@ -0,0 +1,44 @@
+export { canvasToWorldContextPool, worldToCanvasContextPool, } from '../../helpers/vtkCanvasCoordinateTransforms';
+import type { CPUFallbackEnabledElement, ICamera, IImage, Point2, Point3 } from '../../../types';
+import { type PlanarScaleInput } from './planarCameraScale';
+type PlanarResolvedView = Pick<Required<ICamera>, 'focalPoint' | 'parallelScale' | 'viewPlaneNormal' | 'viewUp'> & {
+    presentationScale?: PlanarScaleInput;
+};
+export declare function canvasToWorldPlanarViewState(args: {
+    camera: PlanarResolvedView;
+    canvasWidth: number;
+    canvasHeight: number;
+    canvasPos: Point2;
+}): Point3;
+export declare function worldToCanvasPlanarViewState(args: {
+    camera: PlanarResolvedView;
+    canvasWidth: number;
+    canvasHeight: number;
+    worldPos: Point3;
+}): Point2;
+export declare function getCanvasCssDimensions(canvas: HTMLCanvasElement): {
+    canvasWidth: number;
+    canvasHeight: number;
+};
+export declare function canvasToWorldCPUImage(enabledElement: CPUFallbackEnabledElement, image: IImage, canvasPos: Point2): Point3;
+export declare function worldToCanvasCPUImage(enabledElement: CPUFallbackEnabledElement, image: IImage, worldPos: Point3): Point2;
+export declare function getCpuEquivalentParallelScale(args: {
+    canvasHeight: number;
+    canvasWidth: number;
+    columnPixelSpacing: number;
+    columns: number;
+    rowPixelSpacing: number;
+    rows: number;
+}): number;
+export declare function getOrthogonalVolumeSliceGeometry(args: {
+    dimensions: Point3;
+    direction: number[] | ArrayLike<number>;
+    spacing: Point3;
+    viewPlaneNormal: Point3;
+    viewUp: Point3;
+}): {
+    columnPixelSpacing: number;
+    columns: number;
+    rowPixelSpacing: number;
+    rows: number;
+} | undefined;

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

@@ -0,0 +1,129 @@
+import { vec3 } from 'gl-matrix';
+import canvasToPixel from '../../helpers/cpuFallback/rendering/canvasToPixel';
+import pixelToCanvas from '../../helpers/cpuFallback/rendering/pixelToCanvas';
+export { canvasToWorldContextPool, worldToCanvasContextPool, } from '../../helpers/vtkCanvasCoordinateTransforms';
+import { getImageDataMetadata } from '../../../utilities/getImageDataMetadata';
+import { getPlanarScaleRatio, } from './planarCameraScale';
+function getPlanarViewStateBasis(camera) {
+    const viewUp = vec3.normalize(vec3.create(), camera.viewUp);
+    const viewPlaneNormal = vec3.normalize(vec3.create(), camera.viewPlaneNormal);
+    let right = vec3.cross(vec3.create(), viewUp, viewPlaneNormal);
+    if (!vec3.length(right)) {
+        right = vec3.fromValues(1, 0, 0);
+    }
+    return {
+        right: vec3.normalize(vec3.create(), right),
+        viewPlaneNormal,
+        viewUp,
+    };
+}
+export function canvasToWorldPlanarViewState(args) {
+    const { camera, canvasWidth, canvasHeight, canvasPos } = args;
+    const safeCanvasWidth = Math.max(canvasWidth, 1);
+    const safeCanvasHeight = Math.max(canvasHeight, 1);
+    const { right, viewUp } = getPlanarViewStateBasis(camera);
+    const worldHeight = Math.max(camera.parallelScale, 0.001) * 2;
+    const worldWidth = worldHeight *
+        (safeCanvasWidth / safeCanvasHeight) *
+        (1 / getPlanarScaleRatio(camera.presentationScale));
+    const xOffset = (canvasPos[0] / safeCanvasWidth - 0.5) * worldWidth;
+    const yOffset = (0.5 - canvasPos[1] / safeCanvasHeight) * worldHeight;
+    const worldPos = [...camera.focalPoint];
+    vec3.scaleAndAdd(worldPos, worldPos, right, xOffset);
+    vec3.scaleAndAdd(worldPos, worldPos, viewUp, yOffset);
+    return worldPos;
+}
+export function worldToCanvasPlanarViewState(args) {
+    const { camera, canvasWidth, canvasHeight, worldPos } = args;
+    const safeCanvasWidth = Math.max(canvasWidth, 1);
+    const safeCanvasHeight = Math.max(canvasHeight, 1);
+    const { right, viewUp } = getPlanarViewStateBasis(camera);
+    const worldHeight = Math.max(camera.parallelScale, 0.001) * 2;
+    const worldWidth = worldHeight *
+        (safeCanvasWidth / safeCanvasHeight) *
+        (1 / getPlanarScaleRatio(camera.presentationScale));
+    const delta = vec3.subtract(vec3.create(), worldPos, camera.focalPoint);
+    const xOffset = vec3.dot(delta, right);
+    const yOffset = vec3.dot(delta, viewUp);
+    return [
+        (xOffset / worldWidth + 0.5) * safeCanvasWidth,
+        (0.5 - yOffset / worldHeight) * safeCanvasHeight,
+    ];
+}
+export function getCanvasCssDimensions(canvas) {
+    const devicePixelRatio = typeof window === 'undefined' ? 1 : window.devicePixelRatio || 1;
+    return {
+        canvasWidth: canvas.width / devicePixelRatio,
+        canvasHeight: canvas.height / devicePixelRatio,
+    };
+}
+function getDisplayedAreaSource(enabledElement) {
+    const displayedArea = enabledElement.viewport.displayedArea;
+    return [(displayedArea?.tlhc.x ?? 1) - 1, (displayedArea?.tlhc.y ?? 1) - 1];
+}
+export function canvasToWorldCPUImage(enabledElement, image, canvasPos) {
+    const [px, py] = canvasToPixel(enabledElement, canvasPos);
+    const { origin, spacing, direction } = getImageDataMetadata(image);
+    const [sourceX, sourceY] = getDisplayedAreaSource(enabledElement);
+    const iVector = direction.slice(0, 3);
+    const jVector = direction.slice(3, 6);
+    const worldPos = [...origin];
+    const imageX = px + sourceX - 0.5;
+    const imageY = py + sourceY - 0.5;
+    vec3.scaleAndAdd(worldPos, origin, iVector, imageX * spacing[0]);
+    vec3.scaleAndAdd(worldPos, worldPos, jVector, imageY * spacing[1]);
+    return worldPos;
+}
+export function worldToCanvasCPUImage(enabledElement, image, worldPos) {
+    const { spacing, direction, origin } = getImageDataMetadata(image);
+    const iVector = direction.slice(0, 3);
+    const jVector = direction.slice(3, 6);
+    const [sourceX, sourceY] = getDisplayedAreaSource(enabledElement);
+    const diff = vec3.subtract(vec3.create(), worldPos, origin);
+    const indexPoint = [
+        vec3.dot(diff, iVector) / spacing[0] + 0.5 - sourceX,
+        vec3.dot(diff, jVector) / spacing[1] + 0.5 - sourceY,
+    ];
+    return pixelToCanvas(enabledElement, indexPoint);
+}
+export function getCpuEquivalentParallelScale(args) {
+    const { canvasHeight, canvasWidth, columnPixelSpacing, columns, rowPixelSpacing, rows, } = args;
+    const safeHeight = Math.max(canvasHeight, 1);
+    const safeWidth = Math.max(canvasWidth, 1);
+    const physicalHeight = Math.max(rows, 1) * (rowPixelSpacing || 1);
+    const physicalWidth = Math.max(columns, 1) * (columnPixelSpacing || 1);
+    const aspectRatio = safeWidth / safeHeight;
+    return Math.max(physicalHeight, physicalWidth / aspectRatio) * 0.5;
+}
+export function getOrthogonalVolumeSliceGeometry(args) {
+    const { dimensions, direction, spacing, viewPlaneNormal, viewUp } = args;
+    const directionArray = Array.from(direction);
+    const rowAxis = directionArray.slice(0, 3);
+    const colAxis = directionArray.slice(3, 6);
+    const scanAxis = directionArray.slice(6, 9);
+    const normalizedViewUp = vec3.normalize(vec3.create(), viewUp);
+    const normalizedViewPlaneNormal = vec3.normalize(vec3.create(), viewPlaneNormal);
+    const right = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), normalizedViewUp, normalizedViewPlaneNormal));
+    const basis = [rowAxis, colAxis, scanAxis];
+    const columnAxisIndex = getMajorAxisIndex(right, basis);
+    const rowAxisIndex = getMajorAxisIndex(vec3.negate(vec3.create(), normalizedViewUp), basis);
+    if (columnAxisIndex === undefined ||
+        rowAxisIndex === undefined ||
+        columnAxisIndex === rowAxisIndex) {
+        return;
+    }
+    return {
+        columns: dimensions[columnAxisIndex],
+        rows: dimensions[rowAxisIndex],
+        columnPixelSpacing: spacing[columnAxisIndex],
+        rowPixelSpacing: spacing[rowAxisIndex],
+    };
+}
+function getMajorAxisIndex(vector, basis) {
+    const scores = basis.map((axis) => Math.abs(vec3.dot(vector, axis)));
+    const maxScore = Math.max(...scores);
+    if (maxScore < 0.995) {
+        return;
+    }
+    return scores.indexOf(maxScore);
+}

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

@@ -0,0 +1,11 @@
+import type { IImageVolume, Point3 } from '../../../types';
+export type IndexMajorAxis = {
+    axis: 0 | 1 | 2;
+    sign: 1 | -1;
+};
+export declare const SOURCE_SLICE_INDEX_TOLERANCE = 0.0001;
+export declare const NEAREST_VOXEL_TIE_EPSILON = 0.000001;
+export declare function getIndexMajorAxis(volume: IImageVolume, worldVector: Point3, majorThreshold?: number): IndexMajorAxis | undefined;
+export declare function getSpatiallyClampedContinuousCoordinate(dimension: number, value: number): number | undefined;
+export declare function getNearestVoxelIndex(continuousIndex: number): number;
+export declare function getSpatiallyClampedContinuousIndex(dimensions: Point3, continuousIndex: Point3): Point3 | undefined;

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

@@ -0,0 +1,54 @@
+import { vec3 } from 'gl-matrix';
+export const SOURCE_SLICE_INDEX_TOLERANCE = 1e-4;
+export const NEAREST_VOXEL_TIE_EPSILON = 1e-6;
+function dot(a, b) {
+    return vec3.dot(a, b);
+}
+export function getIndexMajorAxis(volume, worldVector, majorThreshold = 0.995) {
+    const row = volume.direction.slice(0, 3);
+    const col = volume.direction.slice(3, 6);
+    const scan = volume.direction.slice(6, 9);
+    const components = [
+        dot(worldVector, row),
+        dot(worldVector, col),
+        dot(worldVector, scan),
+    ];
+    const absComponents = components.map((value) => Math.abs(value));
+    const maxValue = Math.max(...absComponents);
+    const axis = absComponents.indexOf(maxValue);
+    if (maxValue < majorThreshold) {
+        return;
+    }
+    const secondary = absComponents
+        .filter((_value, index) => index !== axis)
+        .some((value) => value > 1 - majorThreshold);
+    if (secondary) {
+        return;
+    }
+    return {
+        axis,
+        sign: components[axis] >= 0 ? 1 : -1,
+    };
+}
+export function getSpatiallyClampedContinuousCoordinate(dimension, value) {
+    const upperBound = dimension - 0.5;
+    if (value < -0.5 - SOURCE_SLICE_INDEX_TOLERANCE ||
+        value > upperBound + SOURCE_SLICE_INDEX_TOLERANCE) {
+        return;
+    }
+    return Math.min(dimension - 1, Math.max(0, value));
+}
+export function getNearestVoxelIndex(continuousIndex) {
+    return Math.floor(continuousIndex + 0.5 - NEAREST_VOXEL_TIE_EPSILON);
+}
+export function getSpatiallyClampedContinuousIndex(dimensions, continuousIndex) {
+    const clampedIndex = [0, 0, 0];
+    for (let axis = 0; axis < 3; axis++) {
+        const clampedCoordinate = getSpatiallyClampedContinuousCoordinate(dimensions[axis], continuousIndex[axis]);
+        if (clampedCoordinate === undefined) {
+            return;
+        }
+        clampedIndex[axis] = clampedCoordinate;
+    }
+    return clampedIndex;
+}

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

@@ -0,0 +1,10 @@
+import type { Point2 } from '../../../types';
+import type { CameraScaleMode } from '../ViewportCameraTypes';
+export type PlanarScaleInput = number | Point2;
+export type PlanarScale = Point2;
+export declare const MIN_PLANAR_SCALE = 0.001;
+export declare function normalizePlanarScale(scale?: PlanarScaleInput): PlanarScale;
+export declare function clonePlanarScale(scale?: PlanarScaleInput): PlanarScale;
+export declare function getPlanarScaleZoom(scale?: PlanarScaleInput): number;
+export declare function normalizePlanarScaleMode(scaleMode?: string): CameraScaleMode;
+export declare function getPlanarScaleRatio(scale?: PlanarScaleInput): number;

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

@@ -0,0 +1,35 @@
+export const MIN_PLANAR_SCALE = 0.001;
+const PLANAR_SCALE_MODES = new Set([
+    'fit',
+    'fitAspect',
+    'fitWidth',
+    'fitHeight',
+    'absolute',
+]);
+function normalizeScaleValue(value) {
+    return typeof value === 'number' && Number.isFinite(value)
+        ? Math.max(value, MIN_PLANAR_SCALE)
+        : 1;
+}
+export function normalizePlanarScale(scale) {
+    if (Array.isArray(scale)) {
+        return [normalizeScaleValue(scale[0]), normalizeScaleValue(scale[1])];
+    }
+    const scalarScale = normalizeScaleValue(scale);
+    return [scalarScale, scalarScale];
+}
+export function clonePlanarScale(scale) {
+    return normalizePlanarScale(scale);
+}
+export function getPlanarScaleZoom(scale) {
+    return normalizePlanarScale(scale)[1];
+}
+export function normalizePlanarScaleMode(scaleMode) {
+    return PLANAR_SCALE_MODES.has(scaleMode || '')
+        ? scaleMode
+        : 'fit';
+}
+export function getPlanarScaleRatio(scale) {
+    const [scaleX, scaleY] = normalizePlanarScale(scale);
+    return scaleX / scaleY;
+}

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

@@ -0,0 +1,3 @@
+import type { CPUFallbackEnabledElement, CPUIImageData, Point2, Point3 } from '../../../types';
+export declare function canvasToWorldPlanarCpuImage(enabledElement: CPUFallbackEnabledElement, imageData: CPUIImageData, canvasPos: Point2, worldPos?: Point3): Point3;
+export declare function worldToCanvasPlanarCpuImage(enabledElement: CPUFallbackEnabledElement, imageData: CPUIImageData, worldPos: Point3): Point2;

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

@@ -0,0 +1,35 @@
+import { vec3 } from 'gl-matrix';
+import canvasToPixel from '../../helpers/cpuFallback/rendering/canvasToPixel';
+import pixelToCanvas from '../../helpers/cpuFallback/rendering/pixelToCanvas';
+function getDisplayedAreaSource(enabledElement) {
+    const displayedArea = enabledElement.viewport.displayedArea;
+    return [(displayedArea?.tlhc.x ?? 1) - 1, (displayedArea?.tlhc.y ?? 1) - 1];
+}
+export function canvasToWorldPlanarCpuImage(enabledElement, imageData, canvasPos, worldPos = [0, 0, 0]) {
+    const image = enabledElement.image;
+    if (!image) {
+        return worldPos;
+    }
+    const [px, py] = canvasToPixel(enabledElement, canvasPos);
+    const { origin, spacing, direction } = imageData;
+    const [sourceX, sourceY] = getDisplayedAreaSource(enabledElement);
+    const iVector = direction.slice(0, 3);
+    const jVector = direction.slice(3, 6);
+    const imageX = px + sourceX - 0.5;
+    const imageY = py + sourceY - 0.5;
+    vec3.scaleAndAdd(worldPos, origin, iVector, imageX * spacing[0]);
+    vec3.scaleAndAdd(worldPos, worldPos, jVector, imageY * spacing[1]);
+    return worldPos;
+}
+export function worldToCanvasPlanarCpuImage(enabledElement, imageData, worldPos) {
+    const { origin, spacing, direction } = imageData;
+    const iVector = direction.slice(0, 3);
+    const jVector = direction.slice(3, 6);
+    const [sourceX, sourceY] = getDisplayedAreaSource(enabledElement);
+    const diff = vec3.subtract(vec3.create(), worldPos, origin);
+    const indexPoint = [
+        vec3.dot(diff, iVector) / spacing[0] + 0.5 - sourceX,
+        vec3.dot(diff, jVector) / spacing[1] + 0.5 - sourceY,
+    ];
+    return pixelToCanvas(enabledElement, indexPoint);
+}

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

@@ -0,0 +1,10 @@
+import type { CPUFallbackViewport, IImage, Point2 } from '../../../types';
+import { type PlanarScaleInput } from './planarCameraScale';
+export declare function resolvePlanarCpuImageDisplayedArea(image: IImage): CPUFallbackViewport['displayedArea'];
+export declare function resolvePlanarCpuViewportScale(args: {
+    canvas: HTMLCanvasElement;
+    parallelScale?: number;
+    rowPixelSpacing: number;
+    columnPixelSpacing: number;
+    presentationScale?: PlanarScaleInput;
+}): number | Point2;

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

@@ -0,0 +1,35 @@
+import { getPlanarScaleRatio, } from './planarCameraScale';
+const EPSILON = 1e-6;
+export function resolvePlanarCpuImageDisplayedArea(image) {
+    return {
+        tlhc: {
+            x: 1,
+            y: 1,
+        },
+        brhc: {
+            x: Math.max(image.columns, 1),
+            y: Math.max(image.rows, 1),
+        },
+        rowPixelSpacing: image.rowPixelSpacing ?? 1,
+        columnPixelSpacing: image.columnPixelSpacing ?? 1,
+        presentationSizeMode: 'NONE',
+    };
+}
+export function resolvePlanarCpuViewportScale(args) {
+    const { canvas, columnPixelSpacing, parallelScale, presentationScale, rowPixelSpacing, } = args;
+    const worldHeight = Math.max((parallelScale ?? 1) * 2, EPSILON);
+    const worldToCanvasScale = canvas.height / worldHeight;
+    const scaleRatio = getPlanarScaleRatio(presentationScale);
+    if (Math.abs(scaleRatio - 1) > EPSILON) {
+        const safeCanvasHeight = Math.max(canvas.height, 1);
+        const safeCanvasWidth = Math.max(canvas.width, 1);
+        const worldWidth = worldHeight * (safeCanvasWidth / safeCanvasHeight) * (1 / scaleRatio);
+        return [
+            Math.max((safeCanvasWidth * (columnPixelSpacing || 1)) /
+                Math.max(worldWidth, EPSILON), EPSILON),
+            Math.max((safeCanvasHeight * (rowPixelSpacing || 1)) / worldHeight, EPSILON),
+        ];
+    }
+    return Math.max(Math.min(rowPixelSpacing || 1, columnPixelSpacing || 1) *
+        worldToCanvasScale, EPSILON);
+}

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

@@ -0,0 +1,22 @@
+import type { IImage } from '../../../types';
+import type { PlanarViewState } from './PlanarViewportTypes';
+interface PlanarImageEventContext {
+    viewportId: string;
+    renderingEngineId: string;
+    viewport: {
+        element: HTMLDivElement;
+    };
+}
+interface PlanarNewImageArgs {
+    image?: IImage;
+    imageId?: string;
+    imageIdIndex?: number;
+}
+export declare function triggerPlanarNewImage(ctx: PlanarImageEventContext, args?: PlanarNewImageArgs): void;
+export declare function triggerPlanarVolumeNewImage(ctx: PlanarImageEventContext, params: {
+    camera: PlanarViewState | undefined;
+    acquisitionOrientation?: PlanarViewState['orientation'];
+    imageIds: string[];
+    imageIdIndex: number | undefined;
+}): void;
+export {};

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

@@ -0,0 +1,28 @@
+import { Events, OrientationAxis } from '../../../enums';
+import triggerEvent from '../../../utilities/triggerEvent';
+export function triggerPlanarNewImage(ctx, args = {}) {
+    triggerEvent(ctx.viewport.element, Events.STACK_NEW_IMAGE, {
+        image: args.image,
+        imageId: args.imageId ?? args.image?.imageId,
+        imageIdIndex: args.imageIdIndex,
+        viewportId: ctx.viewportId,
+        renderingEngineId: ctx.renderingEngineId,
+    });
+}
+export function triggerPlanarVolumeNewImage(ctx, params) {
+    const orientation = params.camera?.orientation;
+    const isAcquisitionAligned = !orientation ||
+        orientation === OrientationAxis.ACQUISITION ||
+        (params.acquisitionOrientation !== undefined &&
+            orientation === params.acquisitionOrientation);
+    if (isAcquisitionAligned &&
+        typeof params.imageIdIndex === 'number' &&
+        params.imageIds[params.imageIdIndex]) {
+        triggerPlanarNewImage(ctx, {
+            imageId: params.imageIds[params.imageIdIndex],
+            imageIdIndex: params.imageIdIndex,
+        });
+        return;
+    }
+    triggerPlanarNewImage(ctx);
+}

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

@@ -0,0 +1,13 @@
+import type BlendModes from '../../../enums/BlendModes';
+import type { ColormapPublic, OrientationVectors, StackViewportProperties, VolumeViewportProperties } from '../../../types';
+import type { PlanarDataPresentation, PlanarOrientation } from './PlanarViewportTypes';
+export type PlanarLegacyViewportProperties = Partial<Omit<StackViewportProperties & VolumeViewportProperties, 'orientation'> & Pick<PlanarDataPresentation, 'opacity' | 'visible'> & {
+    blendMode?: BlendModes;
+    orientation?: PlanarOrientation;
+}>;
+export declare function isPlanarOrientationVectors(orientation: PlanarOrientation | undefined): orientation is OrientationVectors;
+export declare function clonePlanarOrientation(orientation: PlanarOrientation | undefined): PlanarOrientation | undefined;
+export declare function clonePlanarColormap(colormap: ColormapPublic | undefined): ColormapPublic | undefined;
+export declare function clonePlanarLegacyProperties(properties?: PlanarLegacyViewportProperties): PlanarLegacyViewportProperties;
+export declare function mergePlanarLegacyProperties(currentProperties?: PlanarLegacyViewportProperties, nextProperties?: PlanarLegacyViewportProperties): PlanarLegacyViewportProperties;
+export declare function toPlanarDataPresentation(properties?: PlanarLegacyViewportProperties): PlanarDataPresentation;

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

@@ -0,0 +1,136 @@
+const ORIENTATION_VECTOR_EPSILON = 1e-6;
+const ORIENTATION_DOT_EPSILON = 1e-3;
+function cloneVOIRange(voiRange) {
+    if (!voiRange) {
+        return;
+    }
+    return {
+        lower: voiRange.lower,
+        upper: voiRange.upper,
+    };
+}
+function cloneColormapOpacity(opacity) {
+    if (Array.isArray(opacity)) {
+        return opacity.map(({ opacity, value }) => ({
+            opacity,
+            value,
+        }));
+    }
+    return opacity;
+}
+function mergePlanarColormap(currentColormap, nextColormap) {
+    if (!nextColormap) {
+        return clonePlanarColormap(currentColormap);
+    }
+    if (nextColormap.name !== undefined) {
+        return clonePlanarColormap(nextColormap);
+    }
+    const mergedColormap = clonePlanarColormap(currentColormap) || {};
+    const nextClone = clonePlanarColormap(nextColormap);
+    if (nextClone) {
+        Object.assign(mergedColormap, nextClone);
+    }
+    return mergedColormap;
+}
+export function isPlanarOrientationVectors(orientation) {
+    return Boolean(orientation &&
+        typeof orientation === 'object' &&
+        'viewPlaneNormal' in orientation);
+}
+function normalizeOrientationVector(vector, fieldName) {
+    const [x, y, z] = vector || [];
+    const length = Math.hypot(x, y, z);
+    if (!Number.isFinite(x) ||
+        !Number.isFinite(y) ||
+        !Number.isFinite(z) ||
+        length < ORIENTATION_VECTOR_EPSILON) {
+        throw new Error(`[PlanarViewport] Invalid orientation vector ${fieldName}. Expected a finite non-zero Point3.`);
+    }
+    return [x / length, y / length, z / length];
+}
+export function clonePlanarOrientation(orientation) {
+    if (!isPlanarOrientationVectors(orientation)) {
+        return orientation;
+    }
+    const clone = {
+        viewPlaneNormal: normalizeOrientationVector(orientation.viewPlaneNormal, 'viewPlaneNormal'),
+    };
+    if (orientation.viewUp) {
+        clone.viewUp = normalizeOrientationVector(orientation.viewUp, 'viewUp');
+        const dot = clone.viewPlaneNormal[0] * clone.viewUp[0] +
+            clone.viewPlaneNormal[1] * clone.viewUp[1] +
+            clone.viewPlaneNormal[2] * clone.viewUp[2];
+        if (Math.abs(dot) > ORIENTATION_DOT_EPSILON) {
+            throw new Error('[PlanarViewport] Invalid orientation vectors. viewPlaneNormal and viewUp must be orthogonal.');
+        }
+    }
+    return clone;
+}
+export function clonePlanarColormap(colormap) {
+    if (!colormap) {
+        return;
+    }
+    const clone = {};
+    if (colormap.name !== undefined) {
+        clone.name = colormap.name;
+    }
+    const opacity = cloneColormapOpacity(colormap.opacity);
+    if (opacity !== undefined) {
+        clone.opacity = opacity;
+    }
+    if (colormap.threshold !== undefined) {
+        clone.threshold = colormap.threshold;
+    }
+    return clone;
+}
+export function clonePlanarLegacyProperties(properties = {}) {
+    const clone = Object.assign({}, properties);
+    if (properties.voiRange) {
+        clone.voiRange = cloneVOIRange(properties.voiRange);
+    }
+    if (properties.colormap) {
+        clone.colormap = clonePlanarColormap(properties.colormap);
+    }
+    if (properties.orientation !== undefined) {
+        clone.orientation = clonePlanarOrientation(properties.orientation);
+    }
+    return clone;
+}
+export function mergePlanarLegacyProperties(currentProperties = {}, nextProperties = {}) {
+    const current = clonePlanarLegacyProperties(currentProperties);
+    const next = clonePlanarLegacyProperties(nextProperties);
+    const merged = Object.assign({}, current);
+    Object.assign(merged, next);
+    if (next.colormap) {
+        merged.colormap = mergePlanarColormap(current.colormap, next.colormap);
+    }
+    return merged;
+}
+export function toPlanarDataPresentation(properties = {}) {
+    const presentation = {};
+    if (properties.colormap) {
+        presentation.colormap = clonePlanarColormap(properties.colormap);
+    }
+    if (properties.voiRange) {
+        presentation.voiRange = cloneVOIRange(properties.voiRange);
+    }
+    if (properties.invert !== undefined) {
+        presentation.invert = properties.invert;
+    }
+    if (properties.blendMode !== undefined) {
+        presentation.blendMode = properties.blendMode;
+    }
+    if (properties.interpolationType !== undefined) {
+        presentation.interpolationType = properties.interpolationType;
+    }
+    if (properties.opacity !== undefined) {
+        presentation.opacity = properties.opacity;
+    }
+    if (properties.slabThickness !== undefined) {
+        presentation.slabThickness = properties.slabThickness;
+    }
+    if (properties.visible !== undefined) {
+        presentation.visible = properties.visible;
+    }
+    return presentation;
+}

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

@@ -0,0 +1,3 @@
+import type { Point3 } from '../../../types';
+export declare function getSafeCanvasDimension(value: number): number;
+export declare function normalizePoint3(point: Point3, fallback?: Point3): Point3;

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

@@ -0,0 +1,15 @@
+import { vec3 } from 'gl-matrix';
+export function getSafeCanvasDimension(value) {
+    return Math.max(value || 0, 1);
+}
+export function normalizePoint3(point, fallback) {
+    const normalized = vec3.normalize(vec3.create(), point);
+    if (fallback &&
+        (!Number.isFinite(normalized[0]) ||
+            !Number.isFinite(normalized[1]) ||
+            !Number.isFinite(normalized[2]) ||
+            vec3.length(normalized) === 0)) {
+        return vec3.clone(fallback);
+    }
+    return normalized;
+}

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

@@ -0,0 +1,12 @@
+import type { IImageVolume, Point3 } from '../../../types';
+import type { PlanarViewState } from './PlanarViewportTypes';
+type PlanarViewStateVectors = {
+    viewPlaneNormal: Point3;
+    viewUp: Point3;
+};
+export declare function getAcquisitionCameraVectors(imageVolume: IImageVolume): PlanarViewStateVectors;
+export declare function getPlanarViewStateVectors(args: {
+    imageVolume: IImageVolume;
+    orientation?: PlanarViewState['orientation'];
+}): PlanarViewStateVectors | undefined;
+export {};