@cornerstonejs/core 5.0.0-beta.1 → 5.0.1

package/dist/esm/RenderingEngine/ECGViewport.js

@@ -1,31 +1,10 @@
-import { Events as EVENTS, MetadataModules } from '../enums';
+import { Events as EVENTS } from '../enums';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
 import triggerEvent from '../utilities/triggerEvent';
 import Viewport from './Viewport';
 import { getOrCreateCanvas } from './helpers';
-import * as metaData from '../metaData';
-const SECONDS_WIDTH = 150;
-const CHANNEL_SPACING = 5;
+import { ECG_CHANNEL_SPACING, computeECGChannelLayouts, computeECGHeight, drawECGGrid, drawECGLabels, drawECGTraces, ECG_RENDERING_COLORS, ECG_SECONDS_WIDTH, getVisibleECGChannelsByFlag, loadECGWaveform, } from '../utilities/ECGUtilities';
 const ECG_AMPLITUDE_INDEX_SIZE = 65536;
-const COLOR_GRID_MAJOR = '#7f0000';
-const COLOR_GRID_MINOR = '#3f0000';
-const COLOR_BASELINE = '#7F4C00';
-const COLOR_TRACE = '#ffffff';
-const COLOR_LABEL = '#ffff00';
-const COLOR_BACKGROUND = '#000000';
-function computeMinMax(data) {
-    let min = 0;
-    let max = 0;
-    for (let i = 0; i < data.length; i++) {
-        if (data[i] < min) {
-            min = data[i];
-        }
-        if (data[i] > max) {
-            max = data[i];
-        }
-    }
-    return { min, max };
-}
 class ECGViewport extends Viewport {
     constructor(props) {
         super({
@@ -155,7 +134,7 @@ class ECGViewport extends Viewport {
             const m = transform.getMatrix();
             const ctx = this.canvasContext;
             ctx.resetTransform();
-            ctx.fillStyle = COLOR_BACKGROUND;
+            ctx.fillStyle = ECG_RENDERING_COLORS.background;
             ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
             ctx.setTransform(m[0] / dpr, m[1] / dpr, m[2] / dpr, m[3] / dpr, m[4] / dpr, m[5] / dpr);
             const layouts = this.computeChannelLayouts();
@@ -163,6 +142,7 @@ class ECGViewport extends Viewport {
             this.drawTraces(ctx, layouts);
             this.drawLabels(ctx, layouts);
             ctx.resetTransform();
+            this.setRendered();
             triggerEvent(this.element, EVENTS.IMAGE_RENDERED, {
                 element: this.element,
                 viewportId: this.id,
@@ -194,33 +174,19 @@ class ECGViewport extends Viewport {
     }
     async setEcg(imageId) {
         this.imageId = imageId;
-        const ecgModule = metaData.get(MetadataModules.ECG, imageId);
-        if (!ecgModule?.waveformData?.retrieveBulkData) {
-            throw new Error(`[ECGViewport] No ECG waveform data for imageId: ${imageId}`);
-        }
-        const { numberOfWaveformChannels: numberOfChannels, numberOfWaveformSamples: numberOfSamples, samplingFrequency, waveformBitsAllocated: bitsAllocated = 16, waveformSampleInterpretation: sampleInterpretation = 'SS', multiplexGroupLabel, channelDefinitionSequence: channelDefinitions = [], } = ecgModule;
-        const channelArrays = await ecgModule.waveformData.retrieveBulkData();
-        this.channels = [];
-        for (let i = 0; i < numberOfChannels; i++) {
-            const channelDef = channelDefinitions[i] || {};
-            const name = channelDef.channelSourceSequence?.codeMeaning ||
-                channelDef.ChannelSourceSequence?.CodeMeaning ||
-                `Channel ${i + 1}`;
-            const data = channelArrays[i] || new Int16Array(0);
-            const { min, max } = computeMinMax(data);
-            this.channels.push({ name, data, visible: true, min, max });
-        }
+        const { waveform, calibration } = await loadECGWaveform(imageId);
+        this.channels = waveform.channels.map((channel) => ({
+            ...channel,
+            visible: true,
+        }));
         this.waveformData = {
+            ...waveform,
             channels: this.channels,
-            numberOfChannels,
-            numberOfSamples,
-            samplingFrequency,
-            bitsAllocated,
-            sampleInterpretation,
-            multiplexGroupLabel,
+            multiplexGroupLabel: waveform.multiplexGroupLabel,
         };
-        this.calibration = metaData.get(MetadataModules.CALIBRATION, imageId);
-        this.ecgWidth = Math.ceil((numberOfSamples * SECONDS_WIDTH) / samplingFrequency);
+        this.calibration = calibration;
+        this.ecgWidth = Math.ceil((this.waveformData.numberOfSamples * ECG_SECONDS_WIDTH) /
+            this.waveformData.samplingFrequency);
         this.computeChannelScale();
         this.recalculateHeight();
         this.refreshRenderValues();
@@ -248,7 +214,7 @@ class ECGViewport extends Viewport {
         return { width: this.ecgWidth, height: this.ecgHeight };
     }
     computeChannelScale() {
-        const visibleChannels = this.channels.filter((c) => c.visible && c.data.length > 0);
+        const visibleChannels = getVisibleECGChannelsByFlag(this.channels);
         if (visibleChannels.length === 0 || this.ecgWidth === 0) {
             this.channelScale = 0;
             return;
@@ -262,36 +228,18 @@ class ECGViewport extends Viewport {
             ? this.canvas.offsetHeight / this.canvas.offsetWidth
             : 2 / 3;
         const targetTotalHeight = this.ecgWidth * canvasAspect;
-        const totalSpacing = CHANNEL_SPACING * visibleChannels.length;
+        const totalSpacing = ECG_CHANNEL_SPACING * visibleChannels.length;
         const heightPerChannel = (targetTotalHeight - totalSpacing) / visibleChannels.length;
         this.channelScale = heightPerChannel / (maxRange * 1.25);
     }
     recalculateHeight() {
-        const scale = this.channelScale;
-        let totalHeight = 0;
-        for (const channel of this.channels) {
-            if (!channel.visible || channel.data.length === 0) {
-                continue;
-            }
-            const itemHeight = (channel.max - channel.min) * scale * 1.25;
-            totalHeight += itemHeight + CHANNEL_SPACING;
-        }
-        this.ecgHeight = totalHeight;
+        this.ecgHeight = computeECGHeight(getVisibleECGChannelsByFlag(this.channels), this.channelScale);
     }
     computeChannelLayouts() {
-        const scale = this.channelScale;
-        const layouts = [];
-        let yOffset = 0;
-        for (const channel of this.channels) {
-            if (!channel.visible || channel.data.length === 0) {
-                continue;
-            }
-            const itemHeight = (channel.max - channel.min) * scale * 1.25;
-            yOffset += itemHeight + CHANNEL_SPACING;
-            const baseline = yOffset + channel.min * scale;
-            layouts.push({ channel, itemHeight, yOffset, baseline });
-        }
-        return layouts;
+        return computeECGChannelLayouts({
+            visibleChannels: getVisibleECGChannelsByFlag(this.channels),
+            channelScale: this.channelScale,
+        });
     }
     setProperties(props) {
         if (props.visibleChannels !== undefined) {
@@ -334,7 +282,7 @@ class ECGViewport extends Viewport {
                 this.ecgCamera.panWorld[1] - panWorldDelta[1],
             ];
         }
-        this.canvasContext.fillStyle = COLOR_BACKGROUND;
+        this.canvasContext.fillStyle = ECG_RENDERING_COLORS.background;
         this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
         this.renderFrame();
     }
@@ -415,96 +363,22 @@ class ECGViewport extends Viewport {
         return transform;
     }
     drawGrid(ctx) {
-        const scale = this.channelScale;
-        const pxWidth = this.ecgWidth;
-        const pxHeight = this.ecgHeight;
-        if (scale <= 0) {
-            return;
-        }
-        const MIN_LINE_SPACING = 8;
-        let hGridUnit = 100;
-        while (hGridUnit * scale < MIN_LINE_SPACING) {
-            hGridUnit *= 2;
-        }
-        const minorH = hGridUnit * scale;
-        const majorH = minorH * 5;
-        const minorV = SECONDS_WIDTH / 25;
-        const majorV = SECONDS_WIDTH / 5;
-        ctx.strokeStyle = COLOR_GRID_MINOR;
-        ctx.lineWidth = 0.5;
-        ctx.beginPath();
-        const hLines = Math.floor(pxHeight / minorH);
-        for (let h = 1; h <= hLines; h++) {
-            if (h % 5 !== 0) {
-                const y = h * minorH;
-                ctx.moveTo(0, y);
-                ctx.lineTo(pxWidth, y);
-            }
-        }
-        const vLines = Math.floor(pxWidth / minorV);
-        for (let v = 1; v <= vLines; v++) {
-            if (v % 5 !== 0) {
-                const x = v * minorV;
-                ctx.moveTo(x, 0);
-                ctx.lineTo(x, pxHeight);
-            }
-        }
-        ctx.stroke();
-        ctx.strokeStyle = COLOR_GRID_MAJOR;
-        ctx.lineWidth = 1;
-        ctx.beginPath();
-        const hMajorLines = Math.floor(pxHeight / majorH);
-        for (let h = 1; h <= hMajorLines; h++) {
-            const y = h * majorH;
-            ctx.moveTo(0, y);
-            ctx.lineTo(pxWidth, y);
-        }
-        const vMajorLines = Math.floor(pxWidth / majorV);
-        for (let v = 1; v <= vMajorLines; v++) {
-            const x = v * majorV;
-            ctx.moveTo(x, 0);
-            ctx.lineTo(x, pxHeight);
-        }
-        ctx.stroke();
+        drawECGGrid(ctx, {
+            ecgWidth: this.ecgWidth,
+            ecgHeight: this.ecgHeight,
+            channelScale: this.channelScale,
+        });
     }
     drawTraces(ctx, layouts) {
-        const scale = this.channelScale;
-        const pxWidth = this.ecgWidth;
-        for (const { channel, baseline } of layouts) {
-            ctx.strokeStyle = COLOR_BASELINE;
-            ctx.lineWidth = 2;
-            ctx.beginPath();
-            ctx.moveTo(0, baseline);
-            ctx.lineTo(pxWidth, baseline);
-            ctx.stroke();
-            ctx.strokeStyle = COLOR_TRACE;
-            ctx.lineWidth = 1;
-            ctx.beginPath();
-            for (let i = 0; i < channel.data.length; i++) {
-                const x = (i * pxWidth) / channel.data.length;
-                const y = baseline - channel.data[i] * scale;
-                if (i === 0) {
-                    ctx.moveTo(x, y);
-                }
-                else {
-                    ctx.lineTo(x, y);
-                }
-            }
-            ctx.stroke();
-        }
+        drawECGTraces({
+            ctx,
+            layouts,
+            ecgWidth: this.ecgWidth,
+            channelScale: this.channelScale,
+        });
     }
     drawLabels(ctx, layouts) {
-        const worldToCanvas = this.getWorldToCanvasRatio();
-        const fontSize = 14 / worldToCanvas;
-        for (const { channel, itemHeight, yOffset } of layouts) {
-            const labelY = yOffset - itemHeight + fontSize;
-            ctx.font = `${fontSize}px monospace`;
-            const textWidth = ctx.measureText(channel.name).width;
-            ctx.fillStyle = COLOR_BACKGROUND;
-            ctx.fillRect(5, labelY - fontSize, textWidth + 4, fontSize + 4);
-            ctx.fillStyle = COLOR_LABEL;
-            ctx.fillText(channel.name, 5, labelY);
-        }
+        drawECGLabels(ctx, layouts, this.getWorldToCanvasRatio());
     }
     getImageData() {
         if (!this.waveformData) {

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

@@ -0,0 +1,10 @@
+import type { BaseViewportRenderContext, DataAddOptions, LoadedData, RenderPathDefinition, RenderPathResolver } from './ViewportArchitectureTypes';
+import type ViewportType from '../../enums/ViewportType';
+export declare class DefaultRenderPathResolver implements RenderPathResolver {
+    private paths;
+    constructor(paths?: ReadonlyArray<RenderPathDefinition>);
+    register<TRootContext extends BaseViewportRenderContext, TAdapterContext extends BaseViewportRenderContext>(path: RenderPathDefinition<TRootContext, TAdapterContext>): void;
+    private add;
+    resolve<TContext extends BaseViewportRenderContext>(type: ViewportType, data: LoadedData, options: DataAddOptions): RenderPathDefinition<TContext, BaseViewportRenderContext>;
+}
+export declare const defaultRenderPathResolver: DefaultRenderPathResolver;

package/dist/esm/RenderingEngine/GenericViewport/DefaultRenderPathResolver.js

@@ -0,0 +1,25 @@
+export class DefaultRenderPathResolver {
+    constructor(paths = []) {
+        this.paths = [];
+        paths.forEach((path) => this.add(path));
+    }
+    register(path) {
+        this.add(path);
+    }
+    add(path) {
+        const existingPath = this.paths.find((candidate) => candidate.id === path.id);
+        if (existingPath) {
+            console.debug(`[DefaultRenderPathResolver] Duplicate render path registration ignored for "${path.id}"`);
+            return;
+        }
+        this.paths.push(path);
+    }
+    resolve(type, data, options) {
+        const path = this.paths.find((candidate) => candidate.type === type && candidate.matches(data, options));
+        if (!path) {
+            throw new Error(`No render path for ${type}/${data.type}/${options.renderMode}`);
+        }
+        return path;
+    }
+}
+export const defaultRenderPathResolver = new DefaultRenderPathResolver();

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

@@ -0,0 +1,17 @@
+import { ViewportType } from '../../../enums';
+import type { DataAddOptions, LoadedData, RenderPathAttachment, RenderPathDefinition, RenderPath } from '../ViewportArchitectureTypes';
+import type { ECGCanvasRenderContext, ECGDataPresentation } from './ECGViewportTypes';
+export declare class CanvasECGRenderPath implements RenderPath<ECGCanvasRenderContext> {
+    addData(ctx: ECGCanvasRenderContext, data: LoadedData, options: DataAddOptions): Promise<RenderPathAttachment<ECGDataPresentation>>;
+    private updateDataPresentation;
+    private applyViewState;
+    private getFrameOfReferenceUID;
+    private render;
+    private removeData;
+}
+export declare class CanvasECGPath implements RenderPathDefinition<ECGCanvasRenderContext> {
+    readonly id = "ecg:canvas-signal";
+    readonly type = ViewportType.ECG_NEXT;
+    matches(data: LoadedData, options: DataAddOptions): boolean;
+    createRenderPath(): CanvasECGRenderPath;
+}

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

@@ -0,0 +1,144 @@
+import { Events as EVENTS, ViewportType } from '../../../enums';
+import triggerEvent from '../../../utilities/triggerEvent';
+import { computeECGChannelLayouts, computeECGRenderMetrics, drawECGGrid, drawECGLabels, drawECGTraces, ensureECGCanvasSize, getVisibleECGChannels, } from '../../../utilities/ECGUtilities';
+import { resolveECGCanvasMapping } from './ecgViewportCamera';
+export class CanvasECGRenderPath {
+    async addData(ctx, data, options) {
+        const waveform = data;
+        const rendering = {
+            renderMode: 'signal2d',
+            canvas: ctx.canvas,
+            canvasContext: ctx.canvasContext,
+            metrics: {
+                ecgWidth: 1,
+                ecgHeight: 1,
+                channelScale: 1,
+                worldToCanvasRatio: 1,
+                xOffsetCanvas: 0,
+                yOffsetCanvas: 0,
+            },
+        };
+        return {
+            rendering,
+            updateDataPresentation: (props) => {
+                this.updateDataPresentation(rendering, props);
+            },
+            applyViewState: (camera) => {
+                this.applyViewState(rendering, camera);
+            },
+            getFrameOfReferenceUID: () => {
+                return this.getFrameOfReferenceUID(ctx);
+            },
+            render: () => {
+                this.render(ctx, rendering, waveform);
+            },
+            removeData: () => {
+                this.removeData();
+            },
+        };
+    }
+    updateDataPresentation(rendering, props) {
+        rendering.currentDataPresentation = props;
+    }
+    applyViewState(rendering, camera) {
+        rendering.currentCamera = camera;
+    }
+    getFrameOfReferenceUID(ctx) {
+        return `ecg-viewport-${ctx.viewportId}`;
+    }
+    render(ctx, rendering, waveform) {
+        drawFrame(ctx, rendering, waveform);
+    }
+    removeData() {
+    }
+}
+export class CanvasECGPath {
+    constructor() {
+        this.id = 'ecg:canvas-signal';
+        this.type = ViewportType.ECG_NEXT;
+    }
+    matches(data, options) {
+        return data.type === 'ecg' && options.renderMode === 'signal2d';
+    }
+    createRenderPath() {
+        return new CanvasECGRenderPath();
+    }
+}
+function getEffectiveTransform(metrics, camera, canvas) {
+    const mapping = resolveECGCanvasMapping({
+        metrics,
+        camera,
+        canvas,
+    });
+    return {
+        effectiveRatio: mapping.effectiveRatio,
+        xOffset: mapping.xOffset,
+        yOffset: mapping.yOffset,
+    };
+}
+function computeTimeWindow(waveform, camera) {
+    const durationMs = (waveform.numberOfSamples / waveform.samplingFrequency) * 1000;
+    const startMs = Math.max(0, Math.min(camera.timeRange[0], durationMs));
+    const requestedEnd = Math.max(startMs + 1, camera.timeRange[1]);
+    const endMs = Math.max(startMs + 1, Math.min(requestedEnd, durationMs));
+    const startIndex = Math.max(0, Math.min(waveform.numberOfSamples - 1, Math.floor((startMs / 1000) * waveform.samplingFrequency)));
+    const endIndex = Math.max(startIndex + 1, Math.min(waveform.numberOfSamples, Math.ceil((endMs / 1000) * waveform.samplingFrequency)));
+    return {
+        startMs,
+        endMs,
+        startIndex,
+        endIndex,
+    };
+}
+function drawFrame(ecgCtx, ecgRendering, waveform) {
+    const { canvas, canvasContext, currentCamera, currentDataPresentation } = ecgRendering;
+    if (!currentCamera) {
+        return;
+    }
+    const visibleChannels = getVisibleECGChannels(waveform.channels, currentDataPresentation?.visibleChannels);
+    ensureECGCanvasSize(canvas);
+    const metrics = computeECGRenderMetrics({
+        canvas,
+        visibleChannels,
+        windowMs: Math.max(1, currentCamera.timeRange[1] - currentCamera.timeRange[0]),
+        valueRange: currentCamera.valueRange,
+    });
+    const layouts = computeECGChannelLayouts({
+        visibleChannels,
+        channelScale: metrics.channelScale,
+    });
+    const timeWindow = computeTimeWindow(waveform, currentCamera);
+    const dpr = window.devicePixelRatio || 1;
+    ecgRendering.metrics = metrics;
+    const { effectiveRatio, xOffset, yOffset } = getEffectiveTransform(metrics, currentCamera, canvas);
+    canvasContext.resetTransform();
+    canvasContext.fillStyle = '#000000';
+    canvasContext.fillRect(0, 0, canvas.width, canvas.height);
+    if (currentDataPresentation?.visible === false) {
+        return;
+    }
+    canvasContext.globalAlpha = currentDataPresentation?.opacity ?? 1;
+    canvasContext.setTransform(effectiveRatio * dpr, 0, 0, effectiveRatio * dpr, xOffset * dpr, yOffset * dpr);
+    drawECGGrid(canvasContext, metrics, {
+        showGrid: currentDataPresentation?.showGrid,
+    });
+    drawECGTraces({
+        ctx: canvasContext,
+        layouts,
+        ecgWidth: metrics.ecgWidth,
+        channelScale: metrics.channelScale,
+        startIndex: timeWindow.startIndex,
+        endIndex: timeWindow.endIndex,
+        lineWidth: currentDataPresentation?.lineWidth,
+        amplitudeScale: currentDataPresentation?.amplitudeScale,
+    });
+    drawECGLabels(canvasContext, layouts, metrics.worldToCanvasRatio);
+    canvasContext.resetTransform();
+    canvasContext.globalAlpha = 1;
+    triggerEvent(ecgCtx.element, EVENTS.IMAGE_RENDERED, {
+        element: ecgCtx.element,
+        viewportId: ecgCtx.viewportId,
+        renderingEngineId: ecgCtx.renderingEngineId,
+        rendering: ecgRendering,
+    });
+}

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

@@ -0,0 +1,5 @@
+import type { DataProvider, LoadedData } from '../ViewportArchitectureTypes';
+import type { ECGWaveformPayload } from './ECGViewportTypes';
+export declare class DefaultECGDataProvider implements DataProvider {
+    load(dataId: string): Promise<LoadedData<ECGWaveformPayload>>;
+}

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

@@ -0,0 +1,13 @@
+import { loadECGWaveform } from '../../../utilities/ECGUtilities';
+import { getGenericViewportSourceDataId } from '../genericViewportDataSetAccess';
+export class DefaultECGDataProvider {
+    async load(dataId) {
+        const sourceDataId = getGenericViewportSourceDataId(dataId);
+        const { waveform } = await loadECGWaveform(sourceDataId);
+        return {
+            id: dataId,
+            type: 'ecg',
+            ...waveform,
+        };
+    }
+}

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;