@cornerstonejs/core
Version:
Cornerstone3D Core
127 lines (126 loc) • 4.78 kB
JavaScript
import { clonePlanarScale, getPlanarScaleZoom } from './planarCameraScale.js';
import { getPlanarProjectionFallbackPan } from './planarProjectionFallback.js';
import { PLANAR_PROJECTION_ID, } from './PlanarProjectionTypes.js';
import { normalizePlanarRotation } from './planarViewPresentation.js';
import { cloneDisplayArea, normalizePlanarViewState } from './planarViewState.js';
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);
}