@cornerstonejs/core
Version:
Cornerstone3D Core
96 lines (95 loc) • 4.02 kB
JavaScript
import { normalizePlanarScale } from './planarCameraScale.js';
import { getPlanarProjectionFallbackViewStateWithPan } from './planarProjectionFallback.js';
import { getPlanarProjectionPan, getPlanarProjectionScale, getPlanarProjectionZoom, } from './planarProjectionSnapshot.js';
import { cloneDisplayArea, normalizePlanarViewState } from './planarViewState.js';
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);
}