@cornerstonejs/core 5.0.0-beta.1 → 5.0.1

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

@@ -0,0 +1,37 @@
+import { MPR_CAMERA_VALUES } from '../../../constants';
+import { OrientationAxis } from '../../../enums';
+import getAcquisitionPlaneOrientation from '../../../utilities/getAcquisitionPlaneOrientation';
+import { isPlanarOrientationVectors } from './planarLegacyCompatibility';
+export function getAcquisitionCameraVectors(imageVolume) {
+    const { viewPlaneNormal, viewUp } = getAcquisitionPlaneOrientation(imageVolume);
+    return {
+        viewPlaneNormal,
+        viewUp: viewUp,
+    };
+}
+export function getPlanarViewStateVectors(args) {
+    const { imageVolume, orientation } = args;
+    if (!orientation) {
+        return;
+    }
+    if (orientation === OrientationAxis.ACQUISITION) {
+        return getAcquisitionCameraVectors(imageVolume);
+    }
+    if (isPlanarOrientationVectors(orientation)) {
+        return {
+            viewPlaneNormal: [...orientation.viewPlaneNormal],
+            viewUp: [
+                ...(orientation.viewUp ||
+                    getAcquisitionCameraVectors(imageVolume).viewUp),
+            ],
+        };
+    }
+    const cameraValues = MPR_CAMERA_VALUES[orientation];
+    if (!cameraValues) {
+        return;
+    }
+    return {
+        viewPlaneNormal: [...cameraValues.viewPlaneNormal],
+        viewUp: [...cameraValues.viewUp],
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { ViewportProjectionAdapter } from '../ViewportProjectionTypes';
+import type { PlanarViewState } from './PlanarViewportTypes';
+import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom } from './planarProjectionSnapshot';
+import { type PlanarProjectionSnapshot, type PlanarProjectionAdapterPresentation } from './PlanarProjectionTypes';
+export { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom, };
+export type { PlanarProjectionPresentation, PlanarProjectionRequest, PlanarProjectionSnapshot, } from './PlanarProjectionTypes';
+export declare const planarProjectionAdapter: ViewportProjectionAdapter<PlanarViewState, PlanarProjectionAdapterPresentation, PlanarProjectionSnapshot>;

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

@@ -0,0 +1,28 @@
+import { ViewportType } from '../../../enums';
+import { applyPlanarICameraToRenderer } from './planarRenderCamera';
+import { getPlanarProjectionPresentation, withPlanarProjectionPresentation, } from './planarProjectionPresentation';
+import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom, } from './planarProjectionSnapshot';
+import { PLANAR_PROJECTION_ID, } from './PlanarProjectionTypes';
+export { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionSnapshot, getPlanarProjectionZoom, };
+function isVtkRenderer(target) {
+    return Boolean(target &&
+        typeof target === 'object' &&
+        'getActiveCamera' in target &&
+        typeof target.getActiveCamera === 'function');
+}
+export const planarProjectionAdapter = {
+    id: PLANAR_PROJECTION_ID,
+    viewportTypes: [ViewportType.PLANAR_NEXT],
+    getSnapshot: (request) => getPlanarProjectionSnapshot(request),
+    getPresentation: (snapshot, selector) => getPlanarProjectionPresentation(snapshot, selector),
+    withPresentation: (snapshot, presentation, _options) => withPlanarProjectionPresentation(snapshot, presentation),
+    applyToRenderer: (snapshot, target) => {
+        if (!isVtkRenderer(target)) {
+            return;
+        }
+        applyPlanarICameraToRenderer({
+            activeSourceICamera: snapshot.rendererCamera,
+            renderer: target,
+        });
+    },
+};

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

@@ -0,0 +1,4 @@
+import type { Point2 } from '../../../types';
+import type { PlanarViewState } from './PlanarViewportTypes';
+export declare function getPlanarProjectionFallbackPan(viewState: PlanarViewState, canvasWidth: number, canvasHeight: number): Point2;
+export declare function getPlanarProjectionFallbackViewStateWithPan(viewState: PlanarViewState, nextPan: Point2, canvasWidth: number, canvasHeight: number): PlanarViewState;

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

@@ -0,0 +1,25 @@
+import { normalizePlanarScale } from './planarCameraScale';
+import { normalizePlanarViewState } from './planarViewState';
+export function getPlanarProjectionFallbackPan(viewState, canvasWidth, canvasHeight) {
+    const anchorCanvas = viewState.anchorCanvas ?? [0.5, 0.5];
+    const anchorWorld = viewState.anchorWorld ?? [0, 0, 0];
+    const [scaleX, scaleY] = normalizePlanarScale(viewState.scale);
+    return [
+        (0 - anchorWorld[0]) * scaleX + (anchorCanvas[0] - 0.5) * canvasWidth,
+        (0 - anchorWorld[1]) * scaleY + (anchorCanvas[1] - 0.5) * canvasHeight,
+    ];
+}
+export function getPlanarProjectionFallbackViewStateWithPan(viewState, nextPan, canvasWidth, canvasHeight) {
+    const currentPan = getPlanarProjectionFallbackPan(viewState, canvasWidth, canvasHeight);
+    const [ax, ay] = viewState.anchorCanvas ?? [0.5, 0.5];
+    const deltaX = nextPan[0] - currentPan[0];
+    const deltaY = nextPan[1] - currentPan[1];
+    return normalizePlanarViewState({
+        ...viewState,
+        anchorCanvas: [
+            ax + deltaX / Math.max(canvasWidth, 1),
+            ay + deltaY / Math.max(canvasHeight, 1),
+        ],
+        displayArea: undefined,
+    });
+}

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

@@ -0,0 +1,5 @@
+import type { ViewPresentationSelector } from '../../../types/IViewport';
+import type { PlanarProjectionSnapshot } from './PlanarProjectionTypes';
+import type { PlanarViewPresentation, PlanarViewState } from './PlanarViewportTypes';
+export declare function getPlanarProjectionPresentation(snapshot: PlanarProjectionSnapshot, selector: ViewPresentationSelector | undefined): PlanarViewPresentation;
+export declare function withPlanarProjectionPresentation(snapshot: PlanarProjectionSnapshot, presentation: Partial<PlanarViewPresentation>): PlanarViewState;

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

@@ -0,0 +1,95 @@
+import { normalizePlanarScale } from './planarCameraScale';
+import { getPlanarProjectionFallbackViewStateWithPan } from './planarProjectionFallback';
+import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionZoom, } from './planarProjectionSnapshot';
+import { cloneDisplayArea, normalizePlanarViewState } from './planarViewState';
+const DEFAULT_SELECTOR = {
+    rotation: true,
+    displayArea: true,
+    zoom: true,
+    scale: true,
+    pan: true,
+    flipHorizontal: true,
+    flipVertical: true,
+};
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function preserveDisplayAreaClear(viewState, shouldPreserveClear) {
+    return shouldPreserveClear
+        ? { ...viewState, displayArea: undefined }
+        : viewState;
+}
+export function getPlanarProjectionPresentation(snapshot, selector) {
+    const target = {};
+    const planarSelector = selector ??
+        DEFAULT_SELECTOR;
+    if (planarSelector.rotation) {
+        target.rotation = snapshot.presentation.rotation;
+    }
+    if (planarSelector.displayArea) {
+        target.displayArea = cloneDisplayArea(snapshot.displayArea);
+    }
+    if (planarSelector.zoom) {
+        target.zoom = getPlanarProjectionZoom(snapshot);
+    }
+    if (planarSelector.scale) {
+        target.scale = getPlanarProjectionScale(snapshot);
+    }
+    if (planarSelector.pan) {
+        const scale = getPlanarProjectionScale(snapshot);
+        const pan = getPlanarProjectionPan(snapshot);
+        target.pan = [pan[0] / scale[0], pan[1] / scale[1]];
+    }
+    if (planarSelector.flipHorizontal) {
+        target.flipHorizontal = snapshot.presentation.flipHorizontal ?? false;
+    }
+    if (planarSelector.flipVertical) {
+        target.flipVertical = snapshot.presentation.flipVertical ?? false;
+    }
+    return target;
+}
+export function withPlanarProjectionPresentation(snapshot, presentation) {
+    const { pan, rotation = snapshot.presentation.rotation, flipHorizontal = snapshot.viewState?.flipHorizontal ?? false, flipVertical = snapshot.viewState?.flipVertical ?? false, } = presentation;
+    const viewState = snapshot.viewState ?? {};
+    const hasZoom = hasOwn(presentation, 'zoom');
+    const hasScale = hasOwn(presentation, 'scale');
+    const hasDisplayArea = hasOwn(presentation, 'displayArea');
+    const nextScale = hasScale
+        ? normalizePlanarScale(presentation.scale)
+        : normalizePlanarScale(presentation.zoom ?? snapshot.presentation.scaleVector);
+    const nextCamera = {
+        flipHorizontal,
+        flipVertical,
+        rotation,
+    };
+    if (hasDisplayArea) {
+        const displayArea = cloneDisplayArea(presentation.displayArea);
+        nextCamera.anchorCanvas = [0.5, 0.5];
+        nextCamera.anchorWorld = undefined;
+        nextCamera.displayArea = displayArea;
+        nextCamera.scale = hasZoom || hasScale ? nextScale : [1, 1];
+        nextCamera.scaleMode = displayArea?.scaleMode ?? 'fit';
+    }
+    else if (hasZoom || hasScale || !viewState.displayArea) {
+        nextCamera.scale = nextScale;
+        nextCamera.scaleMode = 'fit';
+    }
+    if (pan) {
+        const targetPan = [pan[0] * nextScale[0], pan[1] * nextScale[1]];
+        const baseViewState = normalizePlanarViewState({
+            ...viewState,
+            ...nextCamera,
+        });
+        const resolvedView = snapshot.resolveViewState?.(baseViewState) ??
+            (baseViewState === snapshot.viewState
+                ? snapshot.resolvedView
+                : undefined);
+        const nextViewState = resolvedView?.withPan(targetPan).state.viewState ??
+            getPlanarProjectionFallbackViewStateWithPan(baseViewState, targetPan, snapshot.canvasWidth, snapshot.canvasHeight);
+        return preserveDisplayAreaClear(nextViewState, hasDisplayArea && presentation.displayArea === undefined);
+    }
+    return preserveDisplayAreaClear(normalizePlanarViewState({
+        ...viewState,
+        ...nextCamera,
+    }), hasDisplayArea && presentation.displayArea === undefined);
+}

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

@@ -0,0 +1,6 @@
+import type { Point2 } from '../../../types';
+import { type PlanarProjectionRequest, type PlanarProjectionSnapshot } from './PlanarProjectionTypes';
+export declare function getPlanarProjectionSnapshot(request: PlanarProjectionRequest): PlanarProjectionSnapshot | undefined;
+export declare function getPlanarProjectionZoom(snapshot: PlanarProjectionSnapshot): number;
+export declare function getPlanarProjectionScale(snapshot: PlanarProjectionSnapshot): Point2;
+export declare function getPlanarProjectionPan(snapshot: PlanarProjectionSnapshot): Point2;

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

@@ -0,0 +1,126 @@
+import { clonePlanarScale, getPlanarScaleZoom } from './planarCameraScale';
+import { getPlanarProjectionFallbackPan } from './planarProjectionFallback';
+import { PLANAR_PROJECTION_ID, } from './PlanarProjectionTypes';
+import { normalizePlanarRotation } from './planarViewPresentation';
+import { cloneDisplayArea, normalizePlanarViewState } from './planarViewState';
+function clonePoint2(point) {
+    return [point[0], point[1]];
+}
+function clonePoint3(point) {
+    return [point[0], point[1], point[2]];
+}
+function getProjectionScale(args) {
+    const { displayArea, scaleMode, zoom } = args;
+    if (displayArea) {
+        return {
+            kind: 'displayArea',
+            value: zoom,
+            area: displayArea,
+        };
+    }
+    if (scaleMode === 'fitWidth') {
+        return { kind: 'fitWidth', value: zoom };
+    }
+    if (scaleMode === 'fitHeight') {
+        return { kind: 'fitHeight', value: zoom };
+    }
+    return { kind: 'fit', value: zoom };
+}
+function getProjectionPosition(viewState, rendererCamera) {
+    if (viewState.anchorWorld) {
+        return {
+            kind: 'anchor',
+            worldPoint: clonePoint3(viewState.anchorWorld),
+            canvasPoint: clonePoint2(viewState.anchorCanvas ?? [0.5, 0.5]),
+        };
+    }
+    if (rendererCamera?.focalPoint) {
+        return {
+            kind: 'focalPoint',
+            worldPoint: clonePoint3(rendererCamera.focalPoint),
+        };
+    }
+    return {
+        kind: 'anchor',
+        canvasPoint: clonePoint2(viewState.anchorCanvas ?? [0.5, 0.5]),
+    };
+}
+export function getPlanarProjectionSnapshot(request) {
+    const { viewport } = request;
+    const viewState = normalizePlanarViewState(request.viewState ?? viewport.getViewState?.() ?? {});
+    const resolvedView = request.resolvedView ??
+        (request.viewState && request.resolveViewState
+            ? request.resolveViewState(viewState)
+            : viewport.getResolvedView?.({
+                frameOfReferenceUID: request.frameOfReferenceUID,
+                sliceIndex: request.sliceIndex,
+            }));
+    const canvasWidth = request.canvasWidth ??
+        resolvedView?.state.canvasWidth ??
+        viewport.element?.clientWidth ??
+        1;
+    const canvasHeight = request.canvasHeight ??
+        resolvedView?.state.canvasHeight ??
+        viewport.element?.clientHeight ??
+        1;
+    const displayArea = request.displayArea ?? viewport.getDisplayArea?.() ?? viewState.displayArea;
+    const scaleVector = resolvedView?.scale ?? clonePlanarScale(viewState.scale);
+    const zoom = resolvedView?.zoom ?? getPlanarScaleZoom(viewState.scale);
+    const rawPan = resolvedView?.pan ??
+        getPlanarProjectionFallbackPan(viewState, canvasWidth, canvasHeight);
+    const rendererCamera = resolvedView?.toICamera();
+    const frameOfReferenceUID = request.frameOfReferenceUID ??
+        resolvedView?.getFrameOfReferenceUID() ??
+        viewport.getFrameOfReferenceUID?.();
+    return {
+        kind: PLANAR_PROJECTION_ID,
+        adapterId: PLANAR_PROJECTION_ID,
+        canvasHeight,
+        canvasWidth,
+        dataId: request.dataId,
+        displayArea: cloneDisplayArea(displayArea),
+        frameOfReferenceUID,
+        presentation: {
+            displayArea: cloneDisplayArea(displayArea),
+            flipHorizontal: viewState.flipHorizontal === true,
+            flipVertical: viewState.flipVertical === true,
+            pan: clonePoint2(rawPan),
+            position: getProjectionPosition(viewState, rendererCamera),
+            rawPan: clonePoint2(rawPan),
+            rotation: resolvedView?.rotation ?? normalizePlanarRotation(viewState.rotation),
+            scale: getProjectionScale({
+                displayArea,
+                scaleMode: viewState.scaleMode,
+                zoom,
+            }),
+            scaleVector: clonePoint2(scaleVector),
+            zoom,
+        },
+        rendererCamera,
+        resolveViewState: request.resolveViewState,
+        resolvedView,
+        spaces: {
+            canvas: true,
+            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,
+    };
+}
+export function getPlanarProjectionZoom(snapshot) {
+    return snapshot.presentation.zoom ?? 1;
+}
+export function getPlanarProjectionScale(snapshot) {
+    return clonePoint2(snapshot.presentation.scaleVector);
+}
+export function getPlanarProjectionPan(snapshot) {
+    return clonePoint2(snapshot.presentation.rawPan);
+}

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

@@ -0,0 +1,46 @@
+import { mat4 } from 'gl-matrix';
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import type vtkVolumeMapper from '@kitware/vtk.js/Rendering/Core/VolumeMapper';
+import type { ICamera, Point2, Point3 } from '../../../types';
+import type { PlanarViewState, PlanarResolvedICamera } from './PlanarViewportTypes';
+import type { PlanarSliceBasis } from './planarSliceBasis';
+export interface DerivedPlanarPresentation {
+    pan: Point2;
+    zoom: number;
+    scale: Point2;
+    rotation: number;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+}
+export declare function projectAnchorWorldToCurrentPlane(anchorWorld: Point3, planePoint: Point3, planeNormal: Point3): Point3;
+export declare function derivePlanarPresentation(args: {
+    sliceBasis: PlanarSliceBasis;
+    camera?: PlanarViewState;
+    canvasWidth: number;
+    canvasHeight: number;
+}): DerivedPlanarPresentation;
+export declare function resolvePlanarICamera(args: {
+    sliceBasis: PlanarSliceBasis;
+    camera?: PlanarViewState;
+    canvasWidth: number;
+    canvasHeight: number;
+}): PlanarResolvedICamera;
+export declare function applyPlanarICameraToRenderer(args: {
+    renderer: vtkRenderer;
+    activeSourceICamera?: PlanarResolvedICamera;
+}): PlanarResolvedICamera | undefined;
+type PlanarScalableActor = {
+    setUserMatrix?: (matrix: mat4) => void;
+};
+export declare function createPlanarPresentationScaleMatrix(activeSourceICamera?: Pick<PlanarResolvedICamera, 'focalPoint' | 'presentationScale' | 'viewPlaneNormal' | 'viewUp'>): mat4;
+export declare function applyPlanarICameraToActor(args: {
+    actor?: PlanarScalableActor;
+    activeSourceICamera?: PlanarResolvedICamera;
+}): void;
+export declare function setPlanarVolumeCameraClippingRange(renderer: vtkRenderer): void;
+export declare function updatePlanarVolumeClippingPlanes(args: {
+    camera: Pick<ICamera, 'focalPoint' | 'viewPlaneNormal'>;
+    mapper: vtkVolumeMapper;
+    slabThickness?: number;
+}): void;
+export {};