@cornerstonejs/core 4.22.13 → 5.0.0

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

@@ -0,0 +1,42 @@
+import { ViewportType } from '../../../enums';
+import type { ICamera, Point2, Point3 } from '../../../types';
+import type { ProjectionPresentation, ProjectionRequest, ProjectionSnapshot } from '../ViewportProjectionTypes';
+import type { ECGViewState } from './ECGViewportTypes';
+export declare const ECG_PROJECTION_ID = "ecg";
+export type ECGResolvedViewLike = {
+    state?: {
+        canvas?: HTMLCanvasElement;
+        viewState: ECGViewState;
+    };
+    pan: Point2;
+    zoom: number;
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getFrameOfReferenceUID(): string | undefined;
+    toICamera(): ICamera;
+    withPan(pan: Point2): ECGResolvedViewLike;
+    withZoom(zoom: number, canvasPoint?: Point2): ECGResolvedViewLike;
+};
+export type ECGProjectionViewport = {
+    type: ViewportType | string;
+    canvas?: HTMLCanvasElement;
+    element?: HTMLDivElement;
+    getFrameOfReferenceUID?(): string | undefined;
+    getResolvedView?(): ECGResolvedViewLike | undefined;
+    getViewState?(): ECGViewState;
+};
+export interface ECGProjectionPresentation extends ProjectionPresentation<never> {
+    rawPan: Point2;
+}
+export interface ECGProjectionSnapshot extends ProjectionSnapshot<ECGViewState, ECGProjectionPresentation> {
+    canvasHeight: number;
+    canvasWidth: number;
+    resolvedView?: ECGResolvedViewLike;
+}
+export interface ECGProjectionRequest extends ProjectionRequest<ECGProjectionViewport> {
+    canvasHeight?: number;
+    canvasWidth?: number;
+    frameOfReferenceUID?: string;
+    resolvedView?: ECGResolvedViewLike;
+    viewState?: ECGViewState;
+}

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

@@ -0,0 +1,2 @@
+import { ViewportType } from '../../../enums';
+export const ECG_PROJECTION_ID = 'ecg';

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

@@ -0,0 +1,4 @@
+import { DefaultRenderPathResolver } from '../DefaultRenderPathResolver';
+import type { RenderPathDefinition } from '../ViewportArchitectureTypes';
+export declare function createDefaultECGRenderPaths(): RenderPathDefinition[];
+export declare function createECGRenderPathResolver(paths?: ReadonlyArray<RenderPathDefinition>): DefaultRenderPathResolver;

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

@@ -0,0 +1,8 @@
+import { DefaultRenderPathResolver } from '../DefaultRenderPathResolver';
+import { CanvasECGPath } from './CanvasECGRenderPath';
+export function createDefaultECGRenderPaths() {
+    return [new CanvasECGPath()];
+}
+export function createECGRenderPathResolver(paths = createDefaultECGRenderPaths()) {
+    return new DefaultRenderPathResolver(paths);
+}

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

@@ -0,0 +1,27 @@
+import type { ICamera, Point2, Point3 } from '../../../types';
+import ResolvedViewportView from '../ResolvedViewportView';
+import type { ECGViewState, ECGDataPresentation, ECGWaveformPayload, RenderWindowMetrics } from './ECGViewportTypes';
+type ECGResolvedViewState = {
+    viewState: ECGViewState;
+    canvas: HTMLCanvasElement;
+    dataPresentation?: ECGDataPresentation;
+    frameOfReferenceUID: string;
+    metrics: RenderWindowMetrics;
+    waveform: ECGWaveformPayload;
+};
+declare class ECGResolvedView extends ResolvedViewportView<ECGResolvedViewState> {
+    private cachedCanvasMapping?;
+    get zoom(): number;
+    get pan(): Point2;
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getFrameOfReferenceUID(): string | undefined;
+    withZoom(zoom: number, canvasPoint?: Point2): ECGResolvedView;
+    withPan(pan: Point2): ECGResolvedView;
+    protected buildICamera(): ICamera;
+    private getCanvasMapping;
+    private getChannelLayouts;
+    private cloneWithViewState;
+}
+export type { ECGResolvedViewState };
+export default ECGResolvedView;

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

@@ -0,0 +1,121 @@
+import { computeECGChannelLayouts, getVisibleECGChannels, } from '../../../utilities/ECGUtilities';
+import ResolvedViewportView from '../ResolvedViewportView';
+import { getAnchorWorldForCanvasPoint, getAnchorWorldForPan, resolveECGCanvasMapping, getPanForECGCanvasMapping, } from './ecgViewportCamera';
+class ECGResolvedView extends ResolvedViewportView {
+    get zoom() {
+        return Math.max(this.state.viewState.scale ?? 1, 0.001);
+    }
+    get pan() {
+        return getPanForECGCanvasMapping(this.getCanvasMapping());
+    }
+    canvasToWorld(canvasPos) {
+        const mapping = this.getCanvasMapping();
+        const channelLayouts = this.getChannelLayouts();
+        const subCanvasPos = [
+            (canvasPos[0] - mapping.xOffset) / mapping.effectiveRatio,
+            (canvasPos[1] - mapping.yOffset) / mapping.effectiveRatio,
+        ];
+        let z = 0;
+        for (let index = 0; index < channelLayouts.length; index++) {
+            const channelLayout = channelLayouts[index];
+            if (subCanvasPos[1] <= channelLayout.yOffset ||
+                index === channelLayouts.length - 1) {
+                z = index;
+                break;
+            }
+        }
+        const channelLayout = channelLayouts[z];
+        return [
+            Math.max(0, Math.min(this.state.waveform.numberOfSamples - 1, (subCanvasPos[0] * this.state.waveform.numberOfSamples) /
+                this.state.metrics.ecgWidth)),
+            (channelLayout.baseline - subCanvasPos[1]) /
+                this.state.metrics.channelScale,
+            z,
+        ];
+    }
+    worldToCanvas(worldPos) {
+        const mapping = this.getCanvasMapping();
+        const channelLayouts = this.getChannelLayouts();
+        const z = Math.round(worldPos[2]);
+        if (z < 0 || z >= channelLayouts.length) {
+            return [0, 0];
+        }
+        return [
+            (worldPos[0] / this.state.waveform.numberOfSamples) *
+                this.state.metrics.ecgWidth *
+                mapping.effectiveRatio +
+                mapping.xOffset,
+            (channelLayouts[z].baseline -
+                worldPos[1] * this.state.metrics.channelScale) *
+                mapping.effectiveRatio +
+                mapping.yOffset,
+        ];
+    }
+    getFrameOfReferenceUID() {
+        return this.state.frameOfReferenceUID;
+    }
+    withZoom(zoom, canvasPoint) {
+        const nextZoom = Math.max(zoom, 0.001);
+        if (!canvasPoint) {
+            return this.cloneWithViewState({
+                ...this.state.viewState,
+                scale: nextZoom,
+                scaleMode: 'fit',
+            });
+        }
+        return this.cloneWithViewState({
+            ...this.state.viewState,
+            anchorWorld: getAnchorWorldForCanvasPoint(canvasPoint, this.getCanvasMapping()),
+            anchorCanvas: [
+                canvasPoint[0] / Math.max(this.state.canvas.clientWidth, 1),
+                canvasPoint[1] / Math.max(this.state.canvas.clientHeight, 1),
+            ],
+            scale: nextZoom,
+            scaleMode: 'fit',
+        });
+    }
+    withPan(pan) {
+        return this.cloneWithViewState({
+            ...this.state.viewState,
+            anchorWorld: getAnchorWorldForPan([pan[0], pan[1]], this.getCanvasMapping()),
+        });
+    }
+    buildICamera() {
+        const mapping = this.getCanvasMapping();
+        const canvasCenter = [
+            this.state.canvas.clientWidth / 2,
+            this.state.canvas.clientHeight / 2,
+        ];
+        return {
+            parallelProjection: true,
+            focalPoint: this.canvasToWorld(canvasCenter),
+            position: [0, 0, 0],
+            viewUp: [0, -1, 0],
+            parallelScale: this.state.canvas.clientHeight /
+                2 /
+                Math.max(mapping.effectiveRatio, 0.001),
+            viewPlaneNormal: [0, 0, 1],
+        };
+    }
+    getCanvasMapping() {
+        this.cachedCanvasMapping ||= resolveECGCanvasMapping({
+            canvas: this.state.canvas,
+            camera: this.state.viewState,
+            metrics: this.state.metrics,
+        });
+        return this.cachedCanvasMapping;
+    }
+    getChannelLayouts() {
+        return computeECGChannelLayouts({
+            visibleChannels: getVisibleECGChannels(this.state.waveform.channels, this.state.dataPresentation?.visibleChannels),
+            channelScale: this.state.metrics.channelScale,
+        });
+    }
+    cloneWithViewState(viewState) {
+        return new ECGResolvedView({
+            ...this.state,
+            viewState,
+        });
+    }
+}
+export default ECGResolvedView;

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

@@ -0,0 +1,55 @@
+import GenericViewport from '../GenericViewport';
+import { ViewportType } from '../../../enums';
+import type { CPUIImageData, Point2, ViewReference, ViewReferenceSpecifier } from '../../../types';
+import type { GenericViewportReferenceContext } from '../genericViewportReferenceCompatibility';
+import type { ECGViewState, ECGCanvasRenderContext, ECGDataPresentation, ECGViewportInput, ECGWaveformPayload } from './ECGViewportTypes';
+import ECGResolvedView from './ECGResolvedView';
+declare class ECGViewport extends GenericViewport<ECGViewState, ECGDataPresentation, ECGCanvasRenderContext> {
+    readonly type = ViewportType.ECG_NEXT;
+    readonly renderingEngineId: string;
+    readonly canvas: HTMLCanvasElement;
+    readonly canvasContext: CanvasRenderingContext2D;
+    protected renderContext: ECGCanvasRenderContext;
+    static get useCustomRenderingPipeline(): boolean;
+    getUseCustomRenderingPipeline(): boolean;
+    constructor(args: ECGViewportInput);
+    setDisplaySets(...entries: Array<{
+        displaySetId: string;
+    }>): Promise<void>;
+    getWaveformData(): ECGWaveformPayload | null;
+    getViewReference(_specifier?: ViewReferenceSpecifier): ViewReference;
+    getViewReferenceId(_specifier?: ViewReferenceSpecifier): string;
+    setViewReference(_viewRef: ViewReference): void;
+    getSliceIndex(): number;
+    getZoom(): number;
+    protected normalizeViewState(viewState: ECGViewState): ECGViewState;
+    protected getReferenceViewContexts(): GenericViewportReferenceContext[];
+    setZoom(zoom: number, canvasPoint?: Point2): void;
+    getPan(): Point2;
+    setPan(pan: Point2): void;
+    getVisibleChannels(): {
+        name: string;
+        visible: boolean;
+    }[];
+    getContentDimensions(): {
+        width: number;
+        height: number;
+    };
+    resize(): void;
+    render(): void;
+    customRenderViewportToCanvas(): void;
+    resetViewState(): boolean;
+    getRotation(): number;
+    scroll(): void;
+    getCurrentImageId(): string | undefined;
+    getCurrentImageIdIndex(): number;
+    getImageIds(): string[];
+    getImageData(): CPUIImageData | null;
+    private setScaleAtCanvasPoint;
+    private loadWaveformData;
+    private getWaveformBindingData;
+    private getCurrentRendering;
+    getResolvedView(): ECGResolvedView | undefined;
+    private applyResolvedViewState;
+}
+export default ECGViewport;

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

@@ -0,0 +1,289 @@
+import getOrCreateCanvas from '../../helpers/getOrCreateCanvas';
+import GenericViewport from '../GenericViewport';
+import { ViewportType } from '../../../enums';
+import { getDefaultECGValueRange } from '../../../utilities/ECGUtilities';
+import { DefaultECGDataProvider } from './DefaultECGDataProvider';
+import { createECGRenderPathResolver } from './ECGRenderPathResolver';
+import { createDefaultECGViewState, normalizeECGViewState, } from './ecgViewportCamera';
+import ECGResolvedView from './ECGResolvedView';
+const ECG_AMPLITUDE_INDEX_SIZE = 65536;
+class ECGViewport extends GenericViewport {
+    static get useCustomRenderingPipeline() {
+        return true;
+    }
+    getUseCustomRenderingPipeline() {
+        return true;
+    }
+    constructor(args) {
+        super(args);
+        this.type = ViewportType.ECG_NEXT;
+        this.renderingEngineId = args.renderingEngineId;
+        this.canvas = getOrCreateCanvas(this.element);
+        this.canvasContext = this.canvas.getContext('2d');
+        this.dataProvider = args.dataProvider || new DefaultECGDataProvider();
+        this.renderPathResolver =
+            args.renderPathResolver || createECGRenderPathResolver();
+        this.renderContext = {
+            viewportId: this.id,
+            type: 'ecg',
+            renderingEngineId: this.renderingEngineId,
+            element: this.element,
+            canvas: this.canvas,
+            canvasContext: this.canvasContext,
+        };
+        this.viewState = createDefaultECGViewState({
+            timeRange: [0, 1],
+            valueRange: [-1, 1],
+        });
+        this.element.setAttribute('data-viewport-uid', this.id);
+        this.element.setAttribute('data-rendering-engine-uid', this.renderingEngineId);
+        this.resize();
+    }
+    async setDisplaySets(...entries) {
+        this.removeAllData();
+        for (const { displaySetId } of entries) {
+            const waveform = await this.loadWaveformData(displaySetId);
+            const durationMs = (waveform.numberOfSamples / waveform.samplingFrequency) * 1000;
+            this.setDefaultDataPresentation(displaySetId, {
+                visible: true,
+                opacity: 1,
+                visibleChannels: waveform.channels.map((_channel, index) => index),
+                lineWidth: 1,
+                amplitudeScale: 1,
+                showGrid: true,
+            });
+            this.viewState = createDefaultECGViewState({
+                timeRange: [0, durationMs],
+                valueRange: getDefaultECGValueRange(waveform),
+            });
+            await this.addLoadedData(displaySetId, waveform, {
+                renderMode: 'signal2d',
+            });
+        }
+    }
+    getWaveformData() {
+        return this.getWaveformBindingData() ?? null;
+    }
+    getViewReference(_specifier = {}) {
+        const dataId = this.getFirstBinding()?.data.id;
+        return {
+            FrameOfReferenceUID: this.getFrameOfReferenceUID(),
+            dataId,
+            referencedImageId: this.getCurrentImageId(),
+            sliceIndex: 0,
+        };
+    }
+    getViewReferenceId(_specifier = {}) {
+        return `imageId:${this.getCurrentImageId()}`;
+    }
+    setViewReference(_viewRef) {
+    }
+    getSliceIndex() {
+        return 0;
+    }
+    getZoom() {
+        return (this.getResolvedView()?.zoom ?? Math.max(this.viewState.scale ?? 1, 0.001));
+    }
+    normalizeViewState(viewState) {
+        return normalizeECGViewState(viewState);
+    }
+    getReferenceViewContexts() {
+        const binding = this.getFirstBinding();
+        if (!binding) {
+            return super.getReferenceViewContexts();
+        }
+        return [
+            {
+                dataId: binding.data.id,
+                dataIds: [binding.data.id],
+                frameOfReferenceUID: this.getFrameOfReferenceUID(),
+                imageIds: [binding.data.id],
+                currentImageIdIndex: 0,
+            },
+        ];
+    }
+    setZoom(zoom, canvasPoint) {
+        const resolvedView = this.getResolvedView();
+        if (resolvedView) {
+            this.applyResolvedViewState(resolvedView.withZoom(zoom, canvasPoint).state.viewState);
+            return;
+        }
+        this.setViewState({
+            scale: Math.max(zoom, 0.001),
+            scaleMode: 'fit',
+        });
+    }
+    getPan() {
+        return this.getResolvedView()?.pan ?? [0, 0];
+    }
+    setPan(pan) {
+        const resolvedView = this.getResolvedView();
+        if (!resolvedView) {
+            return;
+        }
+        this.applyResolvedViewState(resolvedView.withPan(pan).state.viewState);
+    }
+    getVisibleChannels() {
+        const waveform = this.getWaveformBindingData();
+        if (!waveform) {
+            return [];
+        }
+        const dataId = waveform.id;
+        const visibleChannels = new Set(this.getDisplaySetPresentation(dataId)?.visibleChannels ||
+            waveform.channels.map((_channel, index) => index));
+        return waveform.channels.map((channel, index) => ({
+            name: channel.name,
+            visible: visibleChannels.has(index),
+        }));
+    }
+    getContentDimensions() {
+        const rendering = this.getCurrentRendering();
+        if (!rendering) {
+            return { width: 0, height: 0 };
+        }
+        return {
+            width: rendering.metrics.ecgWidth,
+            height: rendering.metrics.ecgHeight,
+        };
+    }
+    resize() {
+        const { clientWidth, clientHeight } = this.canvas;
+        if (this.canvas.width !== clientWidth ||
+            this.canvas.height !== clientHeight) {
+            const dpr = window.devicePixelRatio || 1;
+            this.canvas.width = Math.floor(Math.max(1, clientWidth) * dpr);
+            this.canvas.height = Math.floor(Math.max(1, clientHeight) * dpr);
+        }
+        this.render();
+    }
+    render() {
+        this.renderBindings();
+    }
+    customRenderViewportToCanvas() {
+        this.render();
+    }
+    resetViewState() {
+        const previousCamera = this.getCameraForEvent();
+        this.viewState = createDefaultECGViewState({
+            timeRange: this.viewState.timeRange,
+            valueRange: this.viewState.valueRange,
+        });
+        this.modified(previousCamera);
+        this.triggerCameraResetEvent();
+        return true;
+    }
+    getRotation() {
+        return 0;
+    }
+    scroll() {
+    }
+    getCurrentImageId() {
+        const binding = this.getFirstBinding();
+        return binding?.data.id;
+    }
+    getCurrentImageIdIndex() {
+        return 0;
+    }
+    getImageIds() {
+        const binding = this.getFirstBinding();
+        return binding ? [binding.data.id] : [];
+    }
+    getImageData() {
+        const waveform = this.getWaveformBindingData();
+        if (!waveform) {
+            return null;
+        }
+        const nSamples = waveform.numberOfSamples;
+        const nChannels = waveform.channels.length;
+        const dimensions = [nSamples, ECG_AMPLITUDE_INDEX_SIZE, nChannels];
+        const spacing = [1, 1, 1];
+        const origin = [0, 0, 0];
+        const direction = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+        const amplitudeOffset = ECG_AMPLITUDE_INDEX_SIZE / 2;
+        const scalarData = new Int16Array(0);
+        const imageData = {
+            getDirection: () => direction,
+            getDimensions: () => dimensions,
+            getRange: () => [0, 1],
+            getSpacing: () => spacing,
+            worldToIndex: (point) => {
+                return [point[0], point[1] + amplitudeOffset, point[2]];
+            },
+            indexToWorld: (point) => {
+                return [point[0], point[1] - amplitudeOffset, point[2]];
+            },
+        };
+        return {
+            dimensions,
+            spacing,
+            origin,
+            direction,
+            imageData,
+            scalarData,
+            hasPixelSpacing: false,
+            preScale: { scaled: false },
+            metadata: { Modality: 'ECG', FrameOfReferenceUID: '' },
+        };
+    }
+    setScaleAtCanvasPoint(scale, canvasPoint) {
+        const resolvedView = this.getResolvedView();
+        if (!resolvedView) {
+            this.setZoom(scale);
+            return;
+        }
+        this.applyResolvedViewState(resolvedView.withZoom(scale, canvasPoint).state.viewState);
+    }
+    async loadWaveformData(dataId) {
+        const waveform = await this.dataProvider.load(dataId);
+        if (!isECGWaveformData(waveform)) {
+            throw new Error(`[ECGViewport] Loaded data for ${dataId} is not a valid ECG waveform`);
+        }
+        return waveform;
+    }
+    getWaveformBindingData() {
+        const binding = this.getFirstBinding();
+        if (!binding || !isECGWaveformData(binding.data)) {
+            return;
+        }
+        return binding.data;
+    }
+    getCurrentRendering() {
+        const binding = this.getFirstBinding();
+        if (!binding || !isECGCanvasRendering(binding.rendering)) {
+            return;
+        }
+        return binding.rendering;
+    }
+    getResolvedView() {
+        const waveform = this.getWaveformBindingData();
+        const rendering = this.getCurrentRendering();
+        if (!waveform || !rendering) {
+            return;
+        }
+        return new ECGResolvedView({
+            viewState: this.viewState,
+            canvas: this.canvas,
+            dataPresentation: this.getDisplaySetPresentation(waveform.id),
+            frameOfReferenceUID: `ecg-viewport-${this.id}`,
+            metrics: rendering.metrics,
+            waveform,
+        });
+    }
+    applyResolvedViewState(nextViewState) {
+        this.setViewState(nextViewState);
+    }
+}
+export default ECGViewport;
+function isECGWaveformData(data) {
+    if (typeof data !== 'object' || data === null || data.type !== 'ecg') {
+        return false;
+    }
+    const waveform = data;
+    return (Array.isArray(waveform.channels) &&
+        typeof waveform.numberOfSamples === 'number' &&
+        typeof waveform.samplingFrequency === 'number' &&
+        typeof waveform.numberOfChannels === 'number');
+}
+function isECGCanvasRendering(rendering) {
+    return rendering.renderMode === 'signal2d';
+}

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

@@ -0,0 +1,13 @@
+import type { ECGViewportProperties, ViewPresentation, ViewPresentationSelector } from '../../../types';
+import ECGViewport from './ECGViewport';
+declare class ECGViewportLegacyAdapter extends ECGViewport {
+    setEcg(imageId: string): Promise<void>;
+    setChannelVisibility(index: number, visible: boolean): void;
+    setProperties(props: ECGViewportProperties): void;
+    getProperties(): ECGViewportProperties;
+    resetProperties(): void;
+    getViewPresentation(selector?: ViewPresentationSelector): ViewPresentation | undefined;
+    setViewPresentation(viewPres?: ViewPresentation): void;
+    resetCamera(): boolean;
+}
+export default ECGViewportLegacyAdapter;

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

@@ -0,0 +1,70 @@
+import { viewportProjection } from '../viewportProjection';
+import ECGViewport from './ECGViewport';
+class ECGViewportLegacyAdapter extends ECGViewport {
+    async setEcg(imageId) {
+        await this.setDisplaySets({ displaySetId: imageId });
+    }
+    setChannelVisibility(index, visible) {
+        const waveform = this.getWaveformData();
+        const dataId = this.getFirstBinding()?.data.id;
+        if (!waveform || !dataId) {
+            return;
+        }
+        const current = this.getDisplaySetPresentation(dataId) || {};
+        const nextVisibleChannels = new Set(current.visibleChannels || waveform.channels.map((_channel, i) => i));
+        if (visible) {
+            nextVisibleChannels.add(index);
+        }
+        else {
+            nextVisibleChannels.delete(index);
+        }
+        this.setDisplaySetPresentation(dataId, {
+            visibleChannels: Array.from(nextVisibleChannels).sort((a, b) => a - b),
+        });
+    }
+    setProperties(props) {
+        const dataId = this.getFirstBinding()?.data.id;
+        if (!dataId) {
+            return;
+        }
+        this.setDisplaySetPresentation(dataId, {
+            visibleChannels: props.visibleChannels,
+        });
+    }
+    getProperties() {
+        const dataId = this.getFirstBinding()?.data.id;
+        return {
+            visibleChannels: dataId
+                ? this.getDisplaySetPresentation(dataId)?.visibleChannels
+                : undefined,
+        };
+    }
+    resetProperties() {
+        const waveform = this.getWaveformData();
+        const dataId = this.getFirstBinding()?.data.id;
+        if (!waveform || !dataId) {
+            return;
+        }
+        this.setDisplaySetPresentation(dataId, {
+            visibleChannels: waveform.channels.map((_channel, index) => index),
+        });
+    }
+    getViewPresentation(selector) {
+        return viewportProjection.getPresentation(this, {
+            selector,
+        });
+    }
+    setViewPresentation(viewPres) {
+        if (!viewPres) {
+            return;
+        }
+        const nextViewState = viewportProjection.withPresentation(this, viewPres);
+        if (nextViewState) {
+            this.setViewState(nextViewState);
+        }
+    }
+    resetCamera() {
+        return this.resetViewState();
+    }
+}
+export default ECGViewportLegacyAdapter;