@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/RenderingEngine/GenericViewport/ECG/ECGViewportTypes.d.ts

@@ -0,0 +1,69 @@
+import type { BaseViewportRenderContext, BasePresentationProps, DataProvider, MountedRendering, RenderPathResolver } from '../ViewportArchitectureTypes';
+import type { ViewportCameraBase } from '../ViewportCameraTypes';
+export interface ECGChannelData {
+    name: string;
+    data: Int16Array;
+    min: number;
+    max: number;
+}
+export interface ECGWaveformPayload {
+    channels: ECGChannelData[];
+    numberOfChannels: number;
+    numberOfSamples: number;
+    samplingFrequency: number;
+    bitsAllocated: number;
+    sampleInterpretation: string;
+    multiplexGroupLabel?: string;
+    calibration?: unknown;
+}
+export interface ECGPresentationProps extends BasePresentationProps {
+    visibleChannels?: number[];
+}
+export interface ECGViewState extends ViewportCameraBase<[number, number]> {
+    timeRange: [number, number];
+    valueRange: [number, number];
+    scrollOffset?: number;
+}
+export interface ECGProperties {
+    lineWidth?: number;
+    sweepSpeed?: number;
+    amplitudeScale?: number;
+    showGrid?: boolean;
+}
+export type ECGDataPresentation = ECGPresentationProps & ECGProperties;
+export interface ECGViewportInput {
+    id: string;
+    element: HTMLDivElement;
+    renderingEngineId: string;
+    dataProvider?: DataProvider;
+    renderPathResolver?: RenderPathResolver;
+}
+export type ECGGenericViewportInput = ECGViewportInput;
+export interface ChannelLayout {
+    channel: ECGChannelData;
+    itemHeight: number;
+    yOffset: number;
+    baseline: number;
+}
+export interface RenderWindowMetrics {
+    ecgWidth: number;
+    ecgHeight: number;
+    channelScale: number;
+    worldToCanvasRatio: number;
+    xOffsetCanvas: number;
+    yOffsetCanvas: number;
+}
+export interface ECGCanvasRenderContext extends BaseViewportRenderContext {
+    type: 'ecg';
+    element: HTMLDivElement;
+    canvas: HTMLCanvasElement;
+    canvasContext: CanvasRenderingContext2D;
+}
+export type ECGCanvasRendering = MountedRendering<{
+    renderMode: 'signal2d';
+    canvas: HTMLCanvasElement;
+    canvasContext: CanvasRenderingContext2D;
+    metrics: RenderWindowMetrics;
+    currentCamera?: ECGViewState;
+    currentDataPresentation?: ECGDataPresentation;
+}>;

package/dist/esm/RenderingEngine/GenericViewport/ECG/ecgProjectionAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { ViewPresentation } from '../../../types';
+import type { ViewportProjectionAdapter } from '../ViewportProjectionTypes';
+import { getECGProjectionSnapshot } from './ecgProjectionSnapshot';
+import { type ECGProjectionSnapshot } from './ECGProjectionTypes';
+import type { ECGViewState } from './ECGViewportTypes';
+export { getECGProjectionSnapshot };
+export type { ECGProjectionPresentation, ECGProjectionRequest, ECGProjectionSnapshot, } from './ECGProjectionTypes';
+export declare const ecgProjectionAdapter: ViewportProjectionAdapter<ECGViewState, ViewPresentation, ECGProjectionSnapshot>;

package/dist/esm/RenderingEngine/GenericViewport/ECG/ecgProjectionAdapter.js

@@ -0,0 +1,12 @@
+import { ViewportType } from '../../../enums';
+import { getECGProjectionPresentation, withECGProjectionPresentation, } from './ecgProjectionPresentation';
+import { getECGProjectionSnapshot } from './ecgProjectionSnapshot';
+import { ECG_PROJECTION_ID, } from './ECGProjectionTypes';
+export { getECGProjectionSnapshot };
+export const ecgProjectionAdapter = {
+    id: ECG_PROJECTION_ID,
+    viewportTypes: [ViewportType.ECG_NEXT],
+    getSnapshot: (request) => getECGProjectionSnapshot(request),
+    getPresentation: (snapshot, selector) => getECGProjectionPresentation(snapshot, selector),
+    withPresentation: (snapshot, presentation, options) => withECGProjectionPresentation(snapshot, presentation, options),
+};

package/dist/esm/RenderingEngine/GenericViewport/ECG/ecgProjectionPresentation.d.ts

@@ -0,0 +1,7 @@
+import type { ViewPresentation } from '../../../types';
+import type { ViewPresentationSelector } from '../../../types/IViewport';
+import type { ProjectionWriteOptions } from '../ViewportProjectionTypes';
+import type { ECGProjectionSnapshot } from './ECGProjectionTypes';
+import type { ECGViewState } from './ECGViewportTypes';
+export declare function getECGProjectionPresentation(snapshot: ECGProjectionSnapshot, selector: ViewPresentationSelector | undefined): ViewPresentation;
+export declare function withECGProjectionPresentation(snapshot: ECGProjectionSnapshot, presentation: Partial<ViewPresentation>, options?: ProjectionWriteOptions): ECGViewState;

package/dist/esm/RenderingEngine/GenericViewport/ECG/ecgProjectionPresentation.js

@@ -0,0 +1,52 @@
+import { normalizeECGViewState } from './ecgViewportCamera';
+const DEFAULT_SELECTOR = {
+    zoom: true,
+    pan: true,
+};
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+export function getECGProjectionPresentation(snapshot, selector) {
+    const target = {};
+    const ecgSelector = selector ?? DEFAULT_SELECTOR;
+    const zoom = snapshot.presentation.zoom ?? 1;
+    if (ecgSelector.zoom) {
+        target.zoom = zoom;
+    }
+    if (ecgSelector.pan) {
+        const pan = snapshot.presentation.rawPan;
+        target.pan = [pan[0] / zoom, pan[1] / zoom];
+    }
+    return target;
+}
+export function withECGProjectionPresentation(snapshot, presentation, options = {}) {
+    const viewState = snapshot.viewState;
+    const hasZoom = hasOwn(presentation, 'zoom');
+    const hasPan = hasOwn(presentation, 'pan');
+    const nextZoom = Math.max(presentation.zoom ?? snapshot.presentation.zoom ?? viewState.scale ?? 1, 0.001);
+    let resolvedView = snapshot.resolvedView;
+    let nextViewState = normalizeECGViewState(viewState);
+    if (hasZoom) {
+        if (resolvedView) {
+            resolvedView = resolvedView.withZoom(nextZoom, options.anchorCanvas);
+            nextViewState = normalizeECGViewState(resolvedView.state.viewState);
+        }
+        else {
+            nextViewState = normalizeECGViewState({
+                ...nextViewState,
+                scale: nextZoom,
+                scaleMode: 'fit',
+            });
+        }
+    }
+    if (hasPan && presentation.pan) {
+        const targetPan = [
+            presentation.pan[0] * nextZoom,
+            presentation.pan[1] * nextZoom,
+        ];
+        if (resolvedView) {
+            nextViewState = normalizeECGViewState(resolvedView.withPan(targetPan).state.viewState);
+        }
+    }
+    return nextViewState;
+}

package/dist/esm/RenderingEngine/GenericViewport/ECG/ecgProjectionSnapshot.d.ts

@@ -0,0 +1,2 @@
+import { type ECGProjectionRequest, type ECGProjectionSnapshot } from './ECGProjectionTypes';
+export declare function getECGProjectionSnapshot(request: ECGProjectionRequest): ECGProjectionSnapshot | undefined;

package/dist/esm/RenderingEngine/GenericViewport/ECG/ecgProjectionSnapshot.js

@@ -0,0 +1,94 @@
+import { ECG_PROJECTION_ID, } from './ECGProjectionTypes';
+import { normalizeECGViewState } from './ecgViewportCamera';
+function clonePoint2(point) {
+    return [point[0], point[1]];
+}
+function getCenterCanvasPoint(canvasWidth, canvasHeight) {
+    return [canvasWidth / 2, canvasHeight / 2];
+}
+function getSignalScale(resolvedView) {
+    const origin = resolvedView.canvasToWorld([0, 0]);
+    const nextSample = resolvedView.canvasToWorld([1, 0]);
+    const nextValue = resolvedView.canvasToWorld([0, 1]);
+    return {
+        kind: 'signal',
+        samplesPerCanvasPixel: Math.abs(nextSample[0] - origin[0]) || 0,
+        valueUnitsPerCanvasPixel: Math.abs(nextValue[1] - origin[1]) || 0,
+    };
+}
+function getScale(resolvedView, zoom) {
+    if (!resolvedView) {
+        return { kind: 'fit', value: zoom };
+    }
+    return getSignalScale(resolvedView);
+}
+function getSignalPosition(worldPoint, canvasPoint) {
+    if (!worldPoint) {
+        return;
+    }
+    return {
+        kind: 'signalPoint',
+        sampleIndex: worldPoint[0],
+        value: worldPoint[1],
+        channelIndex: worldPoint[2],
+        canvasPoint,
+    };
+}
+export function getECGProjectionSnapshot(request) {
+    const { viewport } = request;
+    const currentViewState = request.viewState ?? viewport.getViewState?.();
+    if (!currentViewState) {
+        return;
+    }
+    const viewState = normalizeECGViewState(currentViewState);
+    const resolvedView = request.resolvedView ?? viewport.getResolvedView?.();
+    const canvasWidth = request.canvasWidth ??
+        resolvedView?.state?.canvas?.clientWidth ??
+        viewport.canvas?.clientWidth ??
+        viewport.element?.clientWidth ??
+        1;
+    const canvasHeight = request.canvasHeight ??
+        resolvedView?.state?.canvas?.clientHeight ??
+        viewport.canvas?.clientHeight ??
+        viewport.element?.clientHeight ??
+        1;
+    const canvasPoint = getCenterCanvasPoint(canvasWidth, canvasHeight);
+    const signalPoint = resolvedView?.canvasToWorld(canvasPoint);
+    const zoom = resolvedView?.zoom ?? Math.max(viewState.scale ?? 1, 0.001);
+    const rawPan = resolvedView?.pan ?? [0, 0];
+    const rendererCamera = resolvedView?.toICamera();
+    const frameOfReferenceUID = request.frameOfReferenceUID ??
+        resolvedView?.getFrameOfReferenceUID() ??
+        viewport.getFrameOfReferenceUID?.();
+    return {
+        kind: ECG_PROJECTION_ID,
+        adapterId: ECG_PROJECTION_ID,
+        canvasHeight,
+        canvasWidth,
+        dataId: request.dataId,
+        frameOfReferenceUID,
+        presentation: {
+            pan: clonePoint2(rawPan),
+            position: getSignalPosition(signalPoint, canvasPoint),
+            rawPan: clonePoint2(rawPan),
+            scale: getScale(resolvedView, zoom),
+            zoom,
+        },
+        rendererCamera,
+        resolvedView,
+        spaces: {
+            canvas: true,
+            image: false,
+            renderer: Boolean(rendererCamera),
+            world: Boolean(resolvedView),
+        },
+        transforms: resolvedView
+            ? {
+                canvasToWorld: (point) => resolvedView.canvasToWorld(point),
+                worldToCanvas: (point) => resolvedView.worldToCanvas(point),
+            }
+            : undefined,
+        viewState,
+        viewportType: viewport.type,
+    };
+}

package/dist/esm/RenderingEngine/GenericViewport/ECG/ecgViewportCamera.d.ts

@@ -0,0 +1,27 @@
+import type { Point2 } from '../../../types';
+import type { ViewAnchor } from '../ViewportCameraTypes';
+import type { ECGViewState, RenderWindowMetrics } from './ECGViewportTypes';
+export interface ECGCanvasMapping {
+    anchorWorld: [number, number];
+    anchorCanvas: ViewAnchor;
+    canvasHeight: number;
+    canvasWidth: number;
+    centeredXOffset: number;
+    centeredYOffset: number;
+    effectiveRatio: number;
+    xOffset: number;
+    yOffset: number;
+}
+export declare function createDefaultECGViewState(args: {
+    timeRange: [number, number];
+    valueRange: [number, number];
+}): ECGViewState;
+export declare function normalizeECGViewState(camera: ECGViewState): ECGViewState;
+export declare function resolveECGCanvasMapping(args: {
+    metrics: RenderWindowMetrics;
+    camera?: ECGViewState;
+    canvas: HTMLCanvasElement;
+}): ECGCanvasMapping;
+export declare function getPanForECGCanvasMapping(mapping: ECGCanvasMapping): Point2;
+export declare function getAnchorWorldForPan(pan: Point2, mapping: ECGCanvasMapping): [number, number];
+export declare function getAnchorWorldForCanvasPoint(canvasPoint: Point2, mapping: ECGCanvasMapping): [number, number];

package/dist/esm/RenderingEngine/GenericViewport/ECG/ecgViewportCamera.js

@@ -0,0 +1,82 @@
+export function createDefaultECGViewState(args) {
+    return {
+        timeRange: [...args.timeRange],
+        valueRange: [...args.valueRange],
+        scrollOffset: 0,
+        anchorCanvas: [0.5, 0.5],
+        scale: 1,
+        scaleMode: 'fit',
+        rotation: 0,
+    };
+}
+export function normalizeECGViewState(camera) {
+    return {
+        timeRange: [...camera.timeRange],
+        valueRange: [...camera.valueRange],
+        ...(camera.scrollOffset !== undefined
+            ? { scrollOffset: camera.scrollOffset }
+            : {}),
+        anchorCanvas: cloneAnchorCanvas(camera.anchorCanvas ?? [0.5, 0.5]),
+        scale: Math.max(camera.scale ?? 1, 0.001),
+        scaleMode: 'fit',
+        rotation: 0,
+        ...(camera.anchorWorld
+            ? {
+                anchorWorld: clonePoint(camera.anchorWorld),
+            }
+            : {}),
+    };
+}
+export function resolveECGCanvasMapping(args) {
+    const { metrics, camera, canvas } = args;
+    const scale = Math.max(camera?.scale ?? 1, 0.001);
+    const effectiveRatio = metrics.worldToCanvasRatio * scale;
+    const drawWidth = metrics.ecgWidth * effectiveRatio;
+    const drawHeight = metrics.ecgHeight * effectiveRatio;
+    const centeredXOffset = (canvas.clientWidth - drawWidth) / 2;
+    const centeredYOffset = (canvas.clientHeight - drawHeight) / 2;
+    const anchorCanvas = cloneAnchorCanvas(camera?.anchorCanvas ?? [0.5, 0.5]);
+    const anchorWorld = clonePoint(camera?.anchorWorld) ??
+        [metrics.ecgWidth / 2, metrics.ecgHeight / 2];
+    const xOffset = canvas.clientWidth * anchorCanvas[0] - anchorWorld[0] * effectiveRatio;
+    const yOffset = canvas.clientHeight * anchorCanvas[1] - anchorWorld[1] * effectiveRatio;
+    return {
+        anchorWorld,
+        anchorCanvas,
+        canvasHeight: canvas.clientHeight,
+        canvasWidth: canvas.clientWidth,
+        centeredXOffset,
+        centeredYOffset,
+        effectiveRatio,
+        xOffset,
+        yOffset,
+    };
+}
+export function getPanForECGCanvasMapping(mapping) {
+    return [
+        mapping.xOffset - mapping.centeredXOffset,
+        mapping.yOffset - mapping.centeredYOffset,
+    ];
+}
+export function getAnchorWorldForPan(pan, mapping) {
+    return [
+        (mapping.canvasWidth * mapping.anchorCanvas[0] -
+            (mapping.centeredXOffset + pan[0])) /
+            mapping.effectiveRatio,
+        (mapping.canvasHeight * mapping.anchorCanvas[1] -
+            (mapping.centeredYOffset + pan[1])) /
+            mapping.effectiveRatio,
+    ];
+}
+export function getAnchorWorldForCanvasPoint(canvasPoint, mapping) {
+    return [
+        (canvasPoint[0] - mapping.xOffset) / mapping.effectiveRatio,
+        (canvasPoint[1] - mapping.yOffset) / mapping.effectiveRatio,
+    ];
+}
+function clonePoint(point) {
+    return point ? [point[0], point[1]] : undefined;
+}
+function cloneAnchorCanvas(anchorCanvas) {
+    return [anchorCanvas[0], anchorCanvas[1]];
+}

package/dist/esm/RenderingEngine/GenericViewport/ECG/index.d.ts

@@ -0,0 +1,10 @@
+import { getECGProjectionSnapshot } from './ecgProjectionAdapter';
+export { createDefaultECGRenderPaths, createECGRenderPathResolver, } from './ECGRenderPathResolver';
+export { DefaultECGDataProvider } from './DefaultECGDataProvider';
+export declare const ecgProjection: {
+    adapter: import("..").ViewportProjectionAdapter<import("./ECGViewportTypes").ECGViewState, import("../../../types").ViewPresentation, import("./ECGProjectionTypes").ECGProjectionSnapshot>;
+    getSnapshot: typeof getECGProjectionSnapshot;
+};
+export type { ECGProjectionPresentation, ECGProjectionRequest, ECGProjectionSnapshot, } from './ecgProjectionAdapter';
+export { default } from './ECGViewport';
+export type { ECGViewState, ECGDataPresentation, ECGChannelData, ECGPresentationProps, ECGProperties, ECGViewportInput, ECGGenericViewportInput, } from './ECGViewportTypes';

package/dist/esm/RenderingEngine/GenericViewport/ECG/index.js

@@ -0,0 +1,8 @@
+import { ecgProjectionAdapter, getECGProjectionSnapshot, } from './ecgProjectionAdapter';
+export { createDefaultECGRenderPaths, createECGRenderPathResolver, } from './ECGRenderPathResolver';
+export { DefaultECGDataProvider } from './DefaultECGDataProvider';
+export const ecgProjection = {
+    adapter: ecgProjectionAdapter,
+    getSnapshot: getECGProjectionSnapshot,
+};
+export { default } from './ECGViewport';

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

@@ -0,0 +1,82 @@
+import type ICamera from '../../types/ICamera';
+import type { Point2, Point3 } from '../../types';
+import ViewportStatus from '../../enums/ViewportStatus';
+import type { BaseViewportRenderContext, BindingRole, DataAddOptions, DataId, DataProvider, LoadedData, ViewportDataBinding, RenderPathResolver, ViewportController, ViewportId } from './ViewportArchitectureTypes';
+import type ViewportType from '../../enums/ViewportType';
+import type ResolvedViewportView from './ResolvedViewportView';
+import type { ReferenceCompatibleOptions, ViewReference, ViewReferenceSpecifier, RenderingEngineResizeOptions } from '../../types/IViewport';
+import { type GenericViewportReferenceContext } from './genericViewportReferenceCompatibility';
+declare abstract class GenericViewport<TViewState extends object, TDataPresentation = unknown, TContext extends BaseViewportRenderContext = BaseViewportRenderContext> implements ViewportController<TViewState, TDataPresentation> {
+    readonly id: ViewportId;
+    readonly element: HTMLDivElement;
+    abstract readonly type: ViewportType;
+    abstract readonly renderingEngineId: string;
+    viewportStatus: ViewportStatus;
+    protected dataProvider: DataProvider;
+    protected renderPathResolver: RenderPathResolver;
+    protected renderContext: TContext;
+    protected bindings: Map<string, ViewportDataBinding<TDataPresentation>>;
+    protected dataPresentation: Map<string, TDataPresentation>;
+    protected viewState: TViewState;
+    protected isDestroyed: boolean;
+    readonly _debug: {
+        renderModes: Record<string, string>;
+    };
+    constructor(args: {
+        id: ViewportId;
+        element: HTMLDivElement;
+    });
+    setDisplaySets(...entries: Array<{
+        displaySetId: DataId;
+        options?: unknown;
+    }>): Promise<void>;
+    addDisplaySet(displaySetId: DataId, options: DataAddOptions): Promise<void>;
+    removeData(displaySetId: DataId): void;
+    setDisplaySetPresentation(props: Partial<TDataPresentation>): void;
+    setDisplaySetPresentation(displaySetId: DataId, props: Partial<TDataPresentation>): void;
+    getDisplaySetPresentation(displaySetId: DataId): TDataPresentation | undefined;
+    getViewReference(_specifier?: ViewReferenceSpecifier): ViewReference;
+    getViewReferenceId(_specifier?: ViewReferenceSpecifier): string;
+    setViewReference(_viewReference: ViewReference): void;
+    isReferenceViewable(viewReference: ViewReference, options?: ReferenceCompatibleOptions): boolean;
+    getFrameOfReferenceUID(): string;
+    abstract getResolvedView(): ResolvedViewportView<unknown, ICamera<unknown>> | undefined;
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getAspectRatio(): Point2;
+    setViewState(viewStatePatch: Partial<TViewState>): void;
+    getViewState(): TViewState;
+    updateViewState(updater: Partial<TViewState> | ((viewState: TViewState) => Partial<TViewState> | void)): void;
+    removeWidgets(): void;
+    destroy(): void;
+    dispose(): void;
+    setRendered(): void;
+    setNeedsRender(): void;
+    abstract render(): void;
+    resize(): void;
+    resetViewState(_options?: unknown): boolean;
+    resizeForRenderingEngine({ keepCamera, }?: RenderingEngineResizeOptions): void;
+    protected addLoadedData(displaySetId: DataId, data: LoadedData, options: DataAddOptions, shouldIgnore?: () => boolean): Promise<boolean>;
+    protected removeAllData(): void;
+    protected setDataPresentationState(displaySetId: DataId, props: TDataPresentation): void;
+    protected getDataPresentationState(displaySetId: DataId): TDataPresentation | undefined;
+    protected setDefaultDataPresentation(displaySetId: DataId, defaults: TDataPresentation): TDataPresentation;
+    protected mergeDataPresentation(displaySetId: DataId, props: Partial<TDataPresentation>): TDataPresentation;
+    protected normalizeViewState(viewState: TViewState): TViewState;
+    protected modified(previousCamera?: ICamera): void;
+    protected getCameraForEvent(): ICamera;
+    protected triggerCameraModifiedEvent(previousCamera: ICamera): void;
+    protected triggerCameraResetEvent(): void;
+    protected getBinding(displaySetId: DataId): ViewportDataBinding<TDataPresentation> | undefined;
+    protected getDisplaySetRenderMode(displaySetId: DataId): string | undefined;
+    protected getDisplaySetRole(displaySetId: DataId): BindingRole | undefined;
+    protected getFirstBinding(): ViewportDataBinding<TDataPresentation> | undefined;
+    protected getCurrentBinding(): ViewportDataBinding<TDataPresentation> | undefined;
+    protected forEachBinding(visitor: (binding: ViewportDataBinding<TDataPresentation>) => void): void;
+    protected getReferenceViewContexts(_viewReference?: ViewReference): GenericViewportReferenceContext[];
+    protected renderBindings(): boolean;
+    protected resizeBindings(): void;
+    protected destroyBindings(): void;
+    protected onDestroy(): void;
+}
+export default GenericViewport;