@ohif/app 3.13.0-beta.24 → 3.13.0-beta.26

package/dist/{app.bundle.000d2cfe6893ffbe84b7.js → app.bundle.62a1aba454cfbd708929.js}

@@ -5700,6 +5700,571 @@ function isCompatible(viewPlaneNormal, vector) {
 /* harmony default export */ const RenderingEngine_BaseVolumeViewport = (BaseVolumeViewport);
 
 
+/***/ },
+
+/***/ 95307
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(71851);
+/* harmony import */ var _helpers_cpuFallback_rendering_transform__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(45354);
+/* harmony import */ var _utilities_triggerEvent__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(69372);
+/* harmony import */ var _Viewport__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10056);
+/* harmony import */ var _helpers__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(40661);
+/* harmony import */ var _metaData__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(74876);
+
+
+
+
+
+
+const SECONDS_WIDTH = 150;
+const CHANNEL_SPACING = 5;
+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__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A {
+    constructor(props) {
+        super({
+            ...props,
+            canvas: props.canvas || (0,_helpers__WEBPACK_IMPORTED_MODULE_4__/* .getOrCreateCanvas */ .oI)(props.element),
+        });
+        this.imageId = null;
+        this.channels = [];
+        this.waveformData = null;
+        this.ecgWidth = 0;
+        this.ecgHeight = 0;
+        this.channelScale = 0;
+        this.ecgCamera = {
+            panWorld: [0, 0],
+            parallelScale: 1,
+        };
+        this.getProperties = () => {
+            return {
+                visibleChannels: this.channels
+                    .map((ch, i) => (ch.visible ? i : -1))
+                    .filter((i) => i >= 0),
+            };
+        };
+        this.resetCamera = () => {
+            this.refreshRenderValues();
+            this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
+            this.renderFrame();
+            return true;
+        };
+        this.getFrameOfReferenceUID = () => {
+            return `ecg-viewport-${this.id}`;
+        };
+        this.resize = () => {
+            const canvas = this.canvas;
+            const { clientWidth, clientHeight } = canvas;
+            if (canvas.width !== clientWidth || canvas.height !== clientHeight) {
+                canvas.width = clientWidth;
+                canvas.height = clientHeight;
+            }
+            if (this.waveformData) {
+                this.computeChannelScale();
+                this.recalculateHeight();
+            }
+            this.refreshRenderValues();
+            this.renderFrame();
+        };
+        this.canvasToWorld = (canvasPos, destPos = [0, 0, 0]) => {
+            if (!this.waveformData) {
+                destPos[0] = 0;
+                destPos[1] = 0;
+                destPos[2] = 0;
+                return destPos;
+            }
+            const scale = this.getWorldToCanvasRatio();
+            const pan = this.ecgCamera.panWorld;
+            const layouts = this.computeChannelLayouts();
+            const subCanvasPos = [
+                canvasPos[0] / scale - pan[0],
+                canvasPos[1] / scale - pan[1],
+            ];
+            let z = 0;
+            for (let i = 0; i < layouts.length; i++) {
+                const layout = layouts[i];
+                if (subCanvasPos[1] <= layout.yOffset) {
+                    z = i;
+                    break;
+                }
+                if (i === layouts.length - 1) {
+                    z = i;
+                }
+            }
+            const x = Math.max(0, Math.min(this.waveformData.numberOfSamples - 1, (subCanvasPos[0] * this.waveformData.numberOfSamples) / this.ecgWidth));
+            const layout = layouts[z];
+            const y = (layout.baseline - subCanvasPos[1]) / this.channelScale;
+            destPos[0] = x;
+            destPos[1] = y;
+            destPos[2] = z;
+            return destPos;
+        };
+        this.worldToCanvas = (worldPos) => {
+            if (!this.waveformData) {
+                return [0, 0];
+            }
+            const scale = this.getWorldToCanvasRatio();
+            const pan = this.ecgCamera.panWorld;
+            const layouts = this.computeChannelLayouts();
+            const z = Math.round(worldPos[2]);
+            if (z < 0 || z >= layouts.length) {
+                return [0, 0];
+            }
+            const layout = layouts[z];
+            const canvasX = (worldPos[0] / this.waveformData.numberOfSamples) *
+                this.ecgWidth *
+                scale +
+                pan[0] * scale;
+            const canvasY = (layout.baseline - worldPos[1] * this.channelScale) * scale +
+                pan[1] * scale;
+            return [canvasX, canvasY];
+        };
+        this.getRotation = () => 0;
+        this.getNumberOfSlices = () => {
+            return 1;
+        };
+        this.getCurrentImageIdIndex = () => {
+            return 0;
+        };
+        this.getCurrentImageId = () => {
+            return this.imageId;
+        };
+        this.getSliceIndex = () => {
+            return 0;
+        };
+        this.getImageIds = () => {
+            return this.imageId ? [this.imageId] : [];
+        };
+        this.scroll = () => {
+        };
+        this.customRenderViewportToCanvas = () => {
+            this.renderFrame();
+        };
+        this.renderFrame = () => {
+            if (!this.waveformData) {
+                return;
+            }
+            const dpr = window.devicePixelRatio || 1;
+            const transform = this.getTransform();
+            const m = transform.getMatrix();
+            const ctx = this.canvasContext;
+            ctx.resetTransform();
+            ctx.fillStyle = COLOR_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();
+            this.drawGrid(ctx);
+            this.drawTraces(ctx, layouts);
+            this.drawLabels(ctx, layouts);
+            ctx.resetTransform();
+            (0,_utilities_triggerEvent__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(this.element, _enums__WEBPACK_IMPORTED_MODULE_0__.Events.IMAGE_RENDERED, {
+                element: this.element,
+                viewportId: this.id,
+                viewport: this,
+                renderingEngineId: this.renderingEngineId,
+            });
+        };
+        this.getMiddleSliceData = () => {
+            throw new Error('Method not implemented for ECG viewport.');
+        };
+        this.canvasContext = this.canvas.getContext('2d');
+        this.renderingEngineId = props.renderingEngineId;
+        this.element.setAttribute('data-viewport-uid', this.id);
+        this.element.setAttribute('data-rendering-engine-uid', this.renderingEngineId);
+        this.addEventListeners();
+        this.resize();
+    }
+    static get useCustomRenderingPipeline() {
+        return true;
+    }
+    addEventListeners() {
+        this.canvas.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_0__.Events.ELEMENT_DISABLED, this.elementDisabledHandler);
+    }
+    removeEventListeners() {
+        this.canvas.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_0__.Events.ELEMENT_DISABLED, this.elementDisabledHandler);
+    }
+    elementDisabledHandler() {
+        this.removeEventListeners();
+    }
+    async setEcg(imageId) {
+        this.imageId = imageId;
+        const ecgModule = _metaData__WEBPACK_IMPORTED_MODULE_5__.get(_enums__WEBPACK_IMPORTED_MODULE_0__.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 });
+        }
+        this.waveformData = {
+            channels: this.channels,
+            numberOfChannels,
+            numberOfSamples,
+            samplingFrequency,
+            bitsAllocated,
+            sampleInterpretation,
+            multiplexGroupLabel,
+        };
+        this.calibration = _metaData__WEBPACK_IMPORTED_MODULE_5__.get(_enums__WEBPACK_IMPORTED_MODULE_0__.MetadataModules.CALIBRATION, imageId);
+        this.ecgWidth = Math.ceil((numberOfSamples * SECONDS_WIDTH) / samplingFrequency);
+        this.computeChannelScale();
+        this.recalculateHeight();
+        this.refreshRenderValues();
+        this.renderFrame();
+    }
+    setChannelVisibility(index, visible) {
+        if (index >= 0 && index < this.channels.length) {
+            this.channels[index].visible = visible;
+            this.computeChannelScale();
+            this.recalculateHeight();
+            this.refreshRenderValues();
+            this.renderFrame();
+        }
+    }
+    getVisibleChannels() {
+        return this.channels.map((ch) => ({
+            name: ch.name,
+            visible: ch.visible,
+        }));
+    }
+    getWaveformData() {
+        return this.waveformData;
+    }
+    getContentDimensions() {
+        return { width: this.ecgWidth, height: this.ecgHeight };
+    }
+    computeChannelScale() {
+        const visibleChannels = this.channels.filter((c) => c.visible && c.data.length > 0);
+        if (visibleChannels.length === 0 || this.ecgWidth === 0) {
+            this.channelScale = 0;
+            return;
+        }
+        let maxRange = 1;
+        for (const channel of visibleChannels) {
+            const range = channel.max - channel.min;
+            maxRange = Math.max(maxRange, range);
+        }
+        const canvasAspect = this.canvas.offsetHeight && this.canvas.offsetWidth
+            ? this.canvas.offsetHeight / this.canvas.offsetWidth
+            : 2 / 3;
+        const targetTotalHeight = this.ecgWidth * canvasAspect;
+        const totalSpacing = 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;
+    }
+    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;
+    }
+    setProperties(props) {
+        if (props.visibleChannels !== undefined) {
+            for (let i = 0; i < this.channels.length; i++) {
+                this.channels[i].visible = props.visibleChannels.includes(i);
+            }
+            this.computeChannelScale();
+            this.recalculateHeight();
+            this.refreshRenderValues();
+            this.renderFrame();
+        }
+    }
+    resetProperties() {
+        for (const channel of this.channels) {
+            channel.visible = true;
+        }
+        this.computeChannelScale();
+        this.recalculateHeight();
+        this.refreshRenderValues();
+        this.renderFrame();
+    }
+    setCamera(camera) {
+        const { parallelScale, focalPoint } = camera;
+        if (parallelScale) {
+            this.ecgCamera.parallelScale =
+                this.element.clientHeight / 2 / parallelScale;
+        }
+        if (focalPoint !== undefined) {
+            const focalPointCanvas = this.worldToCanvas(focalPoint);
+            const canvasCenter = [
+                this.element.clientWidth / 2,
+                this.element.clientHeight / 2,
+            ];
+            const panWorldDelta = [
+                (focalPointCanvas[0] - canvasCenter[0]) / this.ecgCamera.parallelScale,
+                (focalPointCanvas[1] - canvasCenter[1]) / this.ecgCamera.parallelScale,
+            ];
+            this.ecgCamera.panWorld = [
+                this.ecgCamera.panWorld[0] - panWorldDelta[0],
+                this.ecgCamera.panWorld[1] - panWorldDelta[1],
+            ];
+        }
+        this.canvasContext.fillStyle = COLOR_BACKGROUND;
+        this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
+        this.renderFrame();
+    }
+    getCamera() {
+        const { parallelScale } = this.ecgCamera;
+        const canvasCenter = [
+            this.element.clientWidth / 2,
+            this.element.clientHeight / 2,
+        ];
+        const canvasCenterWorld = this.canvasToWorld(canvasCenter);
+        return {
+            parallelProjection: true,
+            focalPoint: canvasCenterWorld,
+            position: [0, 0, 0],
+            viewUp: [0, -1, 0],
+            parallelScale: this.element.clientHeight / 2 / parallelScale,
+            viewPlaneNormal: [0, 0, 1],
+        };
+    }
+    getPan() {
+        const panWorld = this.ecgCamera.panWorld;
+        return [panWorld[0], panWorld[1]];
+    }
+    getViewReferenceId(_specifier) {
+        return `imageId:${this.imageId}`;
+    }
+    hasImageURI(imageURI) {
+        return this.imageId?.includes(imageURI) ?? false;
+    }
+    isReferenceViewable(viewRef) {
+        if (viewRef.FrameOfReferenceUID &&
+            viewRef.FrameOfReferenceUID !== this.getFrameOfReferenceUID()) {
+            return false;
+        }
+        return true;
+    }
+    updateCameraClippingPlanesAndRange() {
+    }
+    refreshRenderValues() {
+        if (!this.ecgWidth || !this.ecgHeight) {
+            return;
+        }
+        let worldToCanvasRatio = this.canvas.offsetWidth / this.ecgWidth;
+        if (this.ecgHeight * worldToCanvasRatio > this.canvas.offsetHeight) {
+            worldToCanvasRatio = this.canvas.offsetHeight / this.ecgHeight;
+        }
+        const drawWidth = Math.floor(this.ecgWidth * worldToCanvasRatio);
+        const drawHeight = Math.floor(this.ecgHeight * worldToCanvasRatio);
+        const xOffsetCanvas = (this.canvas.offsetWidth - drawWidth) / 2;
+        const yOffsetCanvas = (this.canvas.offsetHeight - drawHeight) / 2;
+        const xOffsetWorld = xOffsetCanvas / worldToCanvasRatio;
+        const yOffsetWorld = yOffsetCanvas / worldToCanvasRatio;
+        this.ecgCamera.panWorld = [xOffsetWorld, yOffsetWorld];
+        this.ecgCamera.parallelScale = worldToCanvasRatio;
+    }
+    getWorldToCanvasRatio() {
+        return this.ecgCamera.parallelScale;
+    }
+    getTransform() {
+        const panWorld = this.ecgCamera.panWorld;
+        const dpr = window.devicePixelRatio || 1;
+        const worldToCanvasRatio = this.getWorldToCanvasRatio();
+        const canvasToWorldRatio = 1.0 / worldToCanvasRatio;
+        const halfCanvas = [
+            this.canvas.offsetWidth / 2,
+            this.canvas.offsetHeight / 2,
+        ];
+        const halfCanvasWorldCoordinates = [
+            halfCanvas[0] * canvasToWorldRatio,
+            halfCanvas[1] * canvasToWorldRatio,
+        ];
+        const transform = new _helpers_cpuFallback_rendering_transform__WEBPACK_IMPORTED_MODULE_1__/* .Transform */ .d();
+        transform.scale(dpr, dpr);
+        transform.translate(halfCanvas[0], halfCanvas[1]);
+        transform.scale(worldToCanvasRatio, worldToCanvasRatio);
+        transform.translate(panWorld[0], panWorld[1]);
+        transform.translate(-halfCanvasWorldCoordinates[0], -halfCanvasWorldCoordinates[1]);
+        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();
+    }
+    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();
+        }
+    }
+    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);
+        }
+    }
+    getImageData() {
+        if (!this.waveformData) {
+            return null;
+        }
+        const nSamples = this.waveformData.numberOfSamples;
+        const nChannels = this.waveformData.numberOfChannels;
+        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 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,
+            hasPixelSpacing: false,
+            calibration: this.calibration,
+            preScale: { scaled: false },
+            metadata: { Modality: 'ECG' },
+        };
+    }
+    getSliceViewInfo() {
+        throw new Error('Method not implemented for ECG viewport.');
+    }
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ECGViewport);
+
+
 /***/ },
 
 /***/ 4785
@@ -15592,7 +16157,8 @@ function getAcquisitionPlaneReformatOrientation(imageOrientationPatient) {
 /* harmony export */   V0: () => (/* binding */ createViewportElement),
 /* harmony export */   oI: () => (/* binding */ getOrCreateCanvas),
 /* harmony export */   p8: () => (/* binding */ EPSILON),
-/* harmony export */   vV: () => (/* binding */ setCanvasCreator)
+/* harmony export */   vV: () => (/* binding */ setCanvasCreator),
+/* harmony export */   zV: () => (/* binding */ updateCanvasSizeAndAspectRatio)
 /* harmony export */ });
 const VIEWPORT_ELEMENT = 'viewport-element';
 const CANVAS_CSS_CLASS = 'cornerstone-canvas';
@@ -15626,6 +16192,32 @@ function createViewportElement(element) {
 function setCanvasCreator(canvasCreatorArg) {
     canvasCreator = canvasCreatorArg;
 }
+function updateCanvasSizeAndAspectRatio(canvas, extentOrOffscreen) {
+    if (extentOrOffscreen === undefined) {
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const rect = canvas.getBoundingClientRect();
+        const w = Math.round(rect.width * devicePixelRatio);
+        const h = Math.round(rect.height * devicePixelRatio);
+        if (w > 0 && h > 0) {
+            canvas.width = w;
+            canvas.height = h;
+            canvas.style.aspectRatio = `${w} / ${h}`;
+        }
+        return undefined;
+    }
+    const { width: targetW, height: targetH } = extentOrOffscreen;
+    if (targetW < 1 || targetH < 1) {
+        return false;
+    }
+    const needsUpdate = canvas.width !== targetW || canvas.height !== targetH;
+    if (needsUpdate) {
+        canvas.width = targetW;
+        canvas.height = targetH;
+        canvas.style.aspectRatio = `${targetW} / ${targetH}`;
+        return true;
+    }
+    return false;
+}
 function getOrCreateCanvas(element) {
     const canvasSelector = `canvas.${CANVAS_CSS_CLASS}`;
     const viewportElement = `div.${VIEWPORT_ELEMENT}`;
@@ -15639,8 +16231,11 @@ function getOrCreateCanvas(element) {
     const devicePixelRatio = window.devicePixelRatio || 1;
     const width = Math.ceil(rect.width * devicePixelRatio);
     const height = Math.ceil(rect.height * devicePixelRatio);
-    canvas.width = width;
-    canvas.height = height;
+    if (width > 0 && height > 0) {
+        canvas.width = width;
+        canvas.height = height;
+        canvas.style.aspectRatio = `${width} / ${height}`;
+    }
     return canvas;
 }
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getOrCreateCanvas);
@@ -15661,7 +16256,7 @@ __webpack_require__.d(__webpack_exports__, {
   A7: () => (/* reexport */ helpers_setVolumesForViewports)
 });
 
-// UNUSED EXPORTS: EPSILON, createCanvas, createViewportElement, createVolumeActor, createVolumeMapper, setCanvasCreator, volumeNewImageEventDispatcher
+// UNUSED EXPORTS: EPSILON, createCanvas, createViewportElement, createVolumeActor, createVolumeMapper, setCanvasCreator, updateCanvasSizeAndAspectRatio, volumeNewImageEventDispatcher
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/helpers/createVolumeActor.js + 2 modules
 var createVolumeActor = __webpack_require__(11836);
@@ -15920,6 +16515,8 @@ function _isCurrentImagePTPrescaled(modality, imageVolume) {
 /* harmony import */ var _VolumeViewport3D__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(40893);
 /* harmony import */ var _VideoViewport__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(32501);
 /* harmony import */ var _WSIViewport__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(81466);
+/* harmony import */ var _ECGViewport__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(95307);
+
 
 
 
@@ -15933,6 +16530,7 @@ const viewportTypeToViewportClass = {
     [_enums_ViewportType__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.VOLUME_3D]: _VolumeViewport3D__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A,
     [_enums_ViewportType__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.VIDEO]: _VideoViewport__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A,
     [_enums_ViewportType__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.WHOLE_SLIDE]: _WSIViewport__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A,
+    [_enums_ViewportType__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.ECG]: _ECGViewport__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A,
 };
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (viewportTypeToViewportClass);
 
@@ -16025,7 +16623,7 @@ __webpack_require__.d(__webpack_exports__, {
   Ay: () => (/* binding */ esm_RenderingEngine)
 });
 
-// UNUSED EXPORTS: EPSILON, RenderingEngine, VolumeViewport3D, addImageSlicesToViewports, addVolumesToViewports, createCanvas, createViewportElement, createVolumeActor, createVolumeMapper, getOrCreateCanvas, getRenderingEngine, setCanvasCreator, setVolumesForViewports, volumeNewImageEventDispatcher
+// UNUSED EXPORTS: EPSILON, RenderingEngine, VolumeViewport3D, addImageSlicesToViewports, addVolumesToViewports, createCanvas, createViewportElement, createVolumeActor, createVolumeMapper, getOrCreateCanvas, getRenderingEngine, setCanvasCreator, setVolumesForViewports, updateCanvasSizeAndAspectRatio, volumeNewImageEventDispatcher
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/init.js + 2 modules
 var init = __webpack_require__(26896);
@@ -16196,6 +16794,7 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine/* default */.A {
         const viewportsDrivenByVtkJs = viewports.filter((vp) => (0,viewportTypeUsesCustomRenderingPipeline/* default */.A)(vp.type) === false);
         const canvasesDrivenByVtkJs = viewportsDrivenByVtkJs.map((vp) => vp.canvas);
         const canvas = (0,getOrCreateCanvas/* default */.Ay)(viewportInputEntry.element);
+        (0,getOrCreateCanvas/* updateCanvasSizeAndAspectRatio */.zV)(canvas);
         canvasesDrivenByVtkJs.push(canvas);
         const internalViewportEntry = { ...viewportInputEntry, canvas };
         this.addVtkjsDrivenViewport(internalViewportEntry);
@@ -16262,12 +16861,7 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine/* default */.A {
     setVtkjsDrivenViewports(viewportInputEntries) {
         if (viewportInputEntries.length) {
             const vtkDrivenCanvases = viewportInputEntries.map((vp) => (0,getOrCreateCanvas/* default */.Ay)(vp.element));
-            vtkDrivenCanvases.forEach((canvas) => {
-                const devicePixelRatio = window.devicePixelRatio || 1;
-                const rect = canvas.getBoundingClientRect();
-                canvas.width = rect.width * devicePixelRatio;
-                canvas.height = rect.height * devicePixelRatio;
-            });
+            vtkDrivenCanvases.forEach((canvas) => (0,getOrCreateCanvas/* updateCanvasSizeAndAspectRatio */.zV)(canvas));
             for (let i = 0; i < viewportInputEntries.length; i++) {
                 const vtkDrivenViewportInputEntry = viewportInputEntries[i];
                 const canvas = vtkDrivenCanvases[i];
@@ -16280,15 +16874,39 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine/* default */.A {
         }
     }
     _resizeVTKViewports(vtkDrivenViewports, keepCamera = true, immediate = true) {
-        const canvasesDrivenByVtkJs = vtkDrivenViewports.map((vp) => {
-            return (0,getOrCreateCanvas/* default */.Ay)(vp.element);
-        });
-        canvasesDrivenByVtkJs.forEach((canvas) => {
-            const devicePixelRatio = window.devicePixelRatio || 1;
-            canvas.width = canvas.clientWidth * devicePixelRatio;
-            canvas.height = canvas.clientHeight * devicePixelRatio;
-        });
-        if (canvasesDrivenByVtkJs.length) {
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const viewportsNeedingResize = [];
+        for (const vp of vtkDrivenViewports) {
+            const canvas = (0,getOrCreateCanvas/* default */.Ay)(vp.element);
+            const displayedWidth = Math.round(canvas.clientWidth * devicePixelRatio);
+            const displayedHeight = Math.round(canvas.clientHeight * devicePixelRatio);
+            if (displayedWidth === 0 || displayedHeight === 0) {
+                continue;
+            }
+            const renderedWidth = canvas.width;
+            const renderedHeight = canvas.height;
+            if (displayedWidth === renderedWidth &&
+                displayedHeight === renderedHeight) {
+                continue;
+            }
+            viewportsNeedingResize.push(vp);
+        }
+        if (viewportsNeedingResize.length === 0) {
+            return;
+        }
+        if (this._animationFrameSet) {
+            return;
+        }
+        for (const vp of viewportsNeedingResize) {
+            const canvas = (0,getOrCreateCanvas/* default */.Ay)(vp.element);
+            const displayedWidth = Math.round(canvas.clientWidth * devicePixelRatio);
+            const displayedHeight = Math.round(canvas.clientHeight * devicePixelRatio);
+            const targetWidth = Math.max(BaseRenderingEngine/* VIEWPORT_MIN_SIZE */.i, displayedWidth);
+            const targetHeight = Math.max(BaseRenderingEngine/* VIEWPORT_MIN_SIZE */.i, displayedHeight);
+            vp.sWidth = targetWidth;
+            vp.sHeight = targetHeight;
+        }
+        if (vtkDrivenViewports.length) {
             this._resize(vtkDrivenViewports);
         }
         vtkDrivenViewports.forEach((vp) => {
@@ -16330,6 +16948,10 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine/* default */.A {
         return eventDetail;
     }
     _renderViewportWithContext(viewport, offscreenMultiRenderWindow, offScreenCanvasContainer) {
+        if (viewport.canvas.clientWidth === 0 ||
+            viewport.canvas.clientHeight === 0) {
+            return;
+        }
         if (viewport.sWidth < BaseRenderingEngine/* VIEWPORT_MIN_SIZE */.i ||
             viewport.sHeight < BaseRenderingEngine/* VIEWPORT_MIN_SIZE */.i) {
             console.warn('Viewport is too small', viewport.sWidth, viewport.sHeight);
@@ -16359,8 +16981,8 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine/* default */.A {
         const renderer = offscreenMultiRenderWindow.getRenderer(viewport.id);
         const contextIndex = this.contextPool.getContextIndexForViewport(viewport.id);
         const maxSize = this.contextPool.getMaxSizeForContext(contextIndex);
-        const viewportWidth = viewport.canvas.width;
-        const viewportHeight = viewport.canvas.height;
+        const viewportWidth = viewport.sWidth;
+        const viewportHeight = viewport.sHeight;
         const xEnd = Math.min(1, viewportWidth / maxSize.width);
         const yEnd = Math.min(1, viewportHeight / maxSize.height);
         renderer.setViewport(0, 0, xEnd, yEnd);
@@ -16394,7 +17016,7 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine/* default */.A {
         if (contextIndex === undefined) {
             return;
         }
-        const maxSizeChanged = this.contextPool.updateViewportSize(viewport.id, viewport.canvas.width, viewport.canvas.height);
+        const maxSizeChanged = this.contextPool.updateViewportSize(viewport.id, viewport.sWidth, viewport.sHeight);
         if (!maxSizeChanged) {
             return;
         }
@@ -16409,7 +17031,9 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine/* default */.A {
     }
     _copyToOnscreenCanvas(viewport, offScreenCanvas) {
         const { element, canvas, id: viewportId, renderingEngineId, suppressEvents, } = viewport;
-        const { width: dWidth, height: dHeight } = canvas;
+        const dWidth = viewport.sWidth;
+        const dHeight = viewport.sHeight;
+        (0,getOrCreateCanvas/* updateCanvasSizeAndAspectRatio */.zV)(canvas, { width: dWidth, height: dHeight });
         const onScreenContext = canvas.getContext('2d');
         const contextIndex = this.contextPool.getContextIndexForViewport(viewportId);
         const maxSize = this.contextPool.getMaxSizeForContext(contextIndex);
@@ -16428,10 +17052,8 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine/* default */.A {
         for (const viewport of viewportsDrivenByVtkJs) {
             viewport.sx = 0;
             viewport.sy = 0;
-            viewport.sWidth = viewport.canvas.width;
-            viewport.sHeight = viewport.canvas.height;
             const contextIndex = this.contextPool.getContextIndexForViewport(viewport.id);
-            const maxSizeChanged = this.contextPool.updateViewportSize(viewport.id, viewport.canvas.width, viewport.canvas.height);
+            const maxSizeChanged = this.contextPool.updateViewportSize(viewport.id, viewport.sWidth, viewport.sHeight);
             if (maxSizeChanged) {
                 contextsToResize.add(contextIndex);
             }
@@ -16439,8 +17061,8 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine/* default */.A {
             const { context: offscreenMultiRenderWindow } = contextData;
             const renderer = offscreenMultiRenderWindow.getRenderer(viewport.id);
             const maxSize = this.contextPool.getMaxSizeForContext(contextIndex);
-            const xEnd = Math.min(1, viewport.canvas.width / maxSize.width);
-            const yEnd = Math.min(1, viewport.canvas.height / maxSize.height);
+            const xEnd = Math.min(1, viewport.sWidth / maxSize.width);
+            const yEnd = Math.min(1, viewport.sHeight / maxSize.height);
             renderer.setViewport(0, 0, xEnd, yEnd);
         }
         contextsToResize.forEach((contextIndex) => {
@@ -28185,6 +28807,7 @@ var MetadataModules;
     MetadataModules["PET_SERIES"] = "petSeriesModule";
     MetadataModules["SOP_COMMON"] = "sopCommonModule";
     MetadataModules["ULTRASOUND_ENHANCED_REGION"] = "ultrasoundEnhancedRegionModule";
+    MetadataModules["ECG"] = "ecgModule";
     MetadataModules["VOI_LUT"] = "voiLutModule";
     MetadataModules["FRAME_MODULE"] = "frameModule";
     MetadataModules["WADO_WEB_CLIENT"] = "wadoWebClient";
@@ -28336,6 +28959,7 @@ var ViewportType;
     ViewportType["VOLUME_3D"] = "volume3d";
     ViewportType["VIDEO"] = "video";
     ViewportType["WHOLE_SLIDE"] = "wholeSlide";
+    ViewportType["ECG"] = "ecg";
 })(ViewportType || (ViewportType = {}));
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ViewportType);
 
@@ -28632,6 +29256,7 @@ __webpack_require__.d(__webpack_exports__, {
   BaseVolumeViewport: () => (/* reexport */ BaseVolumeViewport/* default */.A),
   CONSTANTS: () => (/* reexport */ constants),
   ContextPoolRenderingEngine: () => (/* reexport */ RenderingEngine/* ContextPoolRenderingEngine */.Ou),
+  ECGViewport: () => (/* reexport */ ECGViewport/* default */.A),
   EPSILON: () => (/* reexport */ getOrCreateCanvas/* EPSILON */.p8),
   EVENTS: () => (/* reexport */ enums.Events),
   Enums: () => (/* reexport */ enums),
@@ -28691,6 +29316,7 @@ __webpack_require__.d(__webpack_exports__, {
   setUseCPURendering: () => (/* reexport */ init/* setUseCPURendering */.qc),
   setVolumesForViewports: () => (/* reexport */ helpers/* setVolumesForViewports */.A7),
   triggerEvent: () => (/* reexport */ triggerEvent/* default */.A),
+  updateCanvasSizeAndAspectRatio: () => (/* reexport */ getOrCreateCanvas/* updateCanvasSizeAndAspectRatio */.zV),
   utilities: () => (/* reexport */ utilities),
   version: () => (/* reexport */ version/* version */.r),
   volumeLoader: () => (/* reexport */ volumeLoader)
@@ -28720,6 +29346,8 @@ var StackViewport = __webpack_require__(4785);
 var VideoViewport = __webpack_require__(32501);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/WSIViewport.js + 1 modules
 var WSIViewport = __webpack_require__(81466);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/ECGViewport.js
+var ECGViewport = __webpack_require__(95307);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/Viewport.js
 var Viewport = __webpack_require__(10056);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/eventTarget.js
@@ -29000,6 +29628,7 @@ var helpers = __webpack_require__(40661);
 
 
 
+
 
 
 /***/ },
@@ -45768,7 +46397,7 @@ function toLowHighRange(windowWidth, windowCenter, voiLUTFunction = _enums_VOILU
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   r: () => (/* binding */ version)
 /* harmony export */ });
-const version = '4.17.2';
+const version = '4.18.2';
 
 
 /***/ },
@@ -46191,7 +46820,7 @@ const obj = {
 
 /***/ },
 
-/***/ 68750
+/***/ 76318
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -49072,6 +49701,187 @@ function USHelpers_getUSEnhancedRegions(metadata) {
 }
 
 
+;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/imageLoader/wadors/metaData/ECGHelpers.js
+
+
+
+const TAG = {
+    WaveformSequence: '54000100',
+    NumberOfWaveformChannels: '003A0005',
+    NumberOfWaveformSamples: '003A0010',
+    SamplingFrequency: '003A001A',
+    MultiplexGroupLabel: '003A0020',
+    ChannelDefinitionSequence: '003A0200',
+    ChannelSourceSequence: '003A0208',
+    CodeMeaning: '00080104',
+    WaveformBitsAllocated: '54001004',
+    WaveformSampleInterpretation: '54001006',
+    WaveformData: '54001010',
+};
+function base64ToUint8Array(base64) {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+function convertBuffer(dataSrc, numberOfChannels, numberOfSamples, bits, type) {
+    const data = new Uint8Array(dataSrc);
+    if (bits === 16 && type === 'SS') {
+        const ret = [];
+        const bytesPerSample = 2;
+        const totalBytes = bytesPerSample * numberOfChannels * numberOfSamples;
+        const length = Math.min(data.length, totalBytes);
+        for (let channel = 0; channel < numberOfChannels; channel++) {
+            const buffer = new Int16Array(numberOfSamples);
+            ret.push(buffer);
+            let sampleI = 0;
+            for (let sample = 2 * channel; sample < length; sample += 2 * numberOfChannels) {
+                const highByte = data[sample + 1];
+                const lowByte = data[sample];
+                const sign = highByte & 0x80;
+                buffer[sampleI++] = sign
+                    ? 0xffff0000 | (highByte << 8) | lowByte
+                    : (highByte << 8) | lowByte;
+            }
+        }
+        return ret;
+    }
+    console.warn(`[ECGHelpers] Unsupported waveform format: ${bits}-bit ${type}. Only 16-bit SS is supported.`);
+    return [];
+}
+function multipartDecode(response) {
+    const message = new Uint8Array(response);
+    const separator = new TextEncoder().encode('\r\n\r\n');
+    const headerIndex = findToken(message, separator, 0, 1000);
+    if (headerIndex === -1) {
+        return [response];
+    }
+    const headerStr = new TextDecoder().decode(message.slice(0, headerIndex));
+    const boundaryString = identifyBoundary(headerStr);
+    if (!boundaryString) {
+        return [response];
+    }
+    const boundary = new TextEncoder().encode(boundaryString);
+    const components = [];
+    let offset = headerIndex + separator.length;
+    let boundaryIndex = findToken(message, boundary, offset);
+    while (boundaryIndex !== -1) {
+        const contentStart = findToken(message, separator, boundaryIndex, 1000);
+        if (contentStart === -1) {
+            break;
+        }
+        const dataStart = contentStart + separator.length;
+        const nextBoundary = findToken(message, boundary, dataStart);
+        const dataEnd = nextBoundary === -1 ? message.length : nextBoundary - 2;
+        components.push(response.slice(dataStart, dataEnd));
+        if (nextBoundary === -1) {
+            break;
+        }
+        offset = nextBoundary;
+        boundaryIndex = findToken(message, boundary, offset + boundary.length);
+        if (boundaryIndex === -1) {
+            break;
+        }
+    }
+    return components.length > 0 ? components : [response];
+}
+function findToken(message, token, startIndex, maxLength) {
+    const end = maxLength
+        ? Math.min(message.length, startIndex + maxLength)
+        : message.length;
+    for (let i = startIndex; i < end - token.length + 1; i++) {
+        let found = true;
+        for (let j = 0; j < token.length; j++) {
+            if (message[i + j] !== token[j]) {
+                found = false;
+                break;
+            }
+        }
+        if (found) {
+            return i;
+        }
+    }
+    return -1;
+}
+function identifyBoundary(header) {
+    const match = header.match(/boundary=([^\s;]+)/i);
+    if (match) {
+        return `--${match[1].replace(/"/g, '')}`;
+    }
+    return null;
+}
+function makeRetrieveBulkData(waveformData, numberOfChannels, numberOfSamples, bitsAllocated, sampleInterpretation, wadoRsRoot, studyUID) {
+    return async () => {
+        if (waveformData.Value) {
+            return waveformData.Value;
+        }
+        if (waveformData.InlineBinary) {
+            const raw = base64ToUint8Array(waveformData.InlineBinary);
+            return convertBuffer(raw, numberOfChannels, numberOfSamples, bitsAllocated, sampleInterpretation);
+        }
+        if (typeof waveformData.retrieveBulkData === 'function') {
+            const bulkdata = await waveformData.retrieveBulkData();
+            return convertBuffer(bulkdata, numberOfChannels, numberOfSamples, bitsAllocated, sampleInterpretation);
+        }
+        if (waveformData.BulkDataURI) {
+            let url = waveformData.BulkDataURI;
+            if (url.indexOf(':') === -1 && wadoRsRoot) {
+                url = studyUID
+                    ? `${wadoRsRoot}/studies/${studyUID}/${url}`
+                    : `${wadoRsRoot}/${url}`;
+            }
+            const response = await fetch(url);
+            const buffer = await response.arrayBuffer();
+            const contentType = response.headers.get('content-type') || '';
+            const decoded = contentType.includes('multipart')
+                ? multipartDecode(buffer)[0]
+                : buffer;
+            return convertBuffer(decoded, numberOfChannels, numberOfSamples, bitsAllocated, sampleInterpretation);
+        }
+        throw new Error('[ECGHelpers] No data source found in WaveformData');
+    };
+}
+function getECGModule(metadata, wadoRsRoot, studyUID) {
+    const waveformSeqItems = metaData_getSequenceItems(metadata[TAG.WaveformSequence]);
+    if (!waveformSeqItems || waveformSeqItems.length === 0) {
+        return null;
+    }
+    const waveform = waveformSeqItems[0];
+    const numberOfChannels = metaData_getNumberValue(waveform[TAG.NumberOfWaveformChannels]);
+    const numberOfSamples = metaData_getNumberValue(waveform[TAG.NumberOfWaveformSamples]);
+    const samplingFrequency = metaData_getNumberValue(waveform[TAG.SamplingFrequency]);
+    const waveformBitsAllocated = metaData_getNumberValue(waveform[TAG.WaveformBitsAllocated]) ?? 16;
+    const waveformSampleInterpretation = metaData_getValue(waveform[TAG.WaveformSampleInterpretation]) ?? 'SS';
+    const multiplexGroupLabel = metaData_getValue(waveform[TAG.MultiplexGroupLabel]) ?? 'ECG';
+    const channelDefItems = metaData_getSequenceItems(waveform[TAG.ChannelDefinitionSequence]);
+    const channelDefinitionSequence = (channelDefItems || []).map((channelDef) => {
+        const channelDefRecord = channelDef;
+        const sourceSeqItems = metaData_getSequenceItems(channelDefRecord[TAG.ChannelSourceSequence]);
+        const sourceSeq = sourceSeqItems?.[0] || {};
+        const codeMeaning = metaData_getValue(sourceSeq[TAG.CodeMeaning]);
+        return {
+            channelSourceSequence: {
+                codeMeaning: codeMeaning || 'Unknown',
+            },
+        };
+    });
+    const waveformDataObj = waveform[TAG.WaveformData] || {};
+    return {
+        numberOfWaveformChannels: numberOfChannels,
+        numberOfWaveformSamples: numberOfSamples,
+        samplingFrequency,
+        waveformBitsAllocated,
+        waveformSampleInterpretation,
+        multiplexGroupLabel,
+        channelDefinitionSequence,
+        waveformData: {
+            retrieveBulkData: makeRetrieveBulkData(waveformDataObj, numberOfChannels, numberOfSamples, waveformBitsAllocated, waveformSampleInterpretation, wadoRsRoot, studyUID),
+        },
+    };
+}
+
 ;// ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/imageLoader/wadors/metaData/metaDataProvider.js
 
 
@@ -49229,6 +50039,20 @@ function metaDataProvider_metaDataProvider(type, imageId) {
     if (type === MetadataModules.ULTRASOUND_ENHANCED_REGION) {
         return USHelpers_getUSEnhancedRegions(metaData);
     }
+    if (type === MetadataModules.ECG) {
+        const imageUri = imageId.replace('wadors:', '');
+        const studiesIndex = imageUri.indexOf('/studies/');
+        let wadoRsRoot;
+        let studyUID;
+        if (studiesIndex !== -1) {
+            wadoRsRoot = imageUri.substring(0, studiesIndex);
+            const afterStudies = imageUri.substring(studiesIndex + 9);
+            const nextSlash = afterStudies.indexOf('/');
+            studyUID =
+                nextSlash !== -1 ? afterStudies.substring(0, nextSlash) : afterStudies;
+        }
+        return getECGModule(metaData, wadoRsRoot, studyUID);
+    }
     if (type === MetadataModules.CALIBRATION) {
         const modality = metaData_getValue(metaData['00080060']);
         if (modality === 'US') {
@@ -49237,6 +50061,42 @@ function metaDataProvider_metaDataProvider(type, imageId) {
                 sequenceOfUltrasoundRegions: enhancedRegion,
             };
         }
+        const imageUri = imageId.replace('wadors:', '');
+        const studiesIndex = imageUri.indexOf('/studies/');
+        let wadoRsRoot;
+        let studyUID;
+        if (studiesIndex !== -1) {
+            wadoRsRoot = imageUri.substring(0, studiesIndex);
+            const afterStudies = imageUri.substring(studiesIndex + 9);
+            const nextSlash = afterStudies.indexOf('/');
+            studyUID =
+                nextSlash !== -1 ? afterStudies.substring(0, nextSlash) : afterStudies;
+        }
+        const ecgModule = getECGModule(metaData, wadoRsRoot, studyUID);
+        if (ecgModule) {
+            const { numberOfWaveformSamples, samplingFrequency } = ecgModule;
+            const physicalDeltaX = 1 / (samplingFrequency || 1);
+            const physicalDeltaY = 0.001;
+            const ECG_AMPLITUDE_INDEX_SIZE = 65536;
+            const ECG_AMPLITUDE_OFFSET = 32768;
+            return {
+                sequenceOfUltrasoundRegions: [
+                    {
+                        regionLocationMinX0: 0,
+                        regionLocationMaxX1: numberOfWaveformSamples,
+                        regionLocationMinY0: 0,
+                        regionLocationMaxY1: ECG_AMPLITUDE_INDEX_SIZE - 1,
+                        referencePixelX0: 0,
+                        referencePixelY0: ECG_AMPLITUDE_OFFSET,
+                        physicalDeltaX,
+                        physicalDeltaY,
+                        physicalUnitsXDirection: 4,
+                        physicalUnitsYDirection: -1,
+                        regionDataType: 1,
+                    },
+                ],
+            };
+        }
     }
     if (type === MetadataModules.IMAGE_URL) {
         return getImageUrlModule(imageId, metaData);
@@ -79844,7 +80704,7 @@ const detectionOptions = {
   }
 });
 ;// ../../i18n/package.json
-const package_namespaceObject = /*#__PURE__*/JSON.parse('{"rE":"3.13.0-beta.23"}');
+const package_namespaceObject = /*#__PURE__*/JSON.parse('{"rE":"3.13.0-beta.25"}');
 ;// ../../i18n/src/utils.js
 const languagesMap = {
   ar: 'Arabic',
@@ -239915,8 +240775,8 @@ function _sortStringDates(s1, s2, sortModifier) {
 
 // EXTERNAL MODULE: ../../../node_modules/react-dropzone/dist/es/index.js + 4 modules
 var dist_es = __webpack_require__(85252);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/index.js + 79 modules
-var esm = __webpack_require__(68750);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/dicom-image-loader/dist/esm/index.js + 80 modules
+var esm = __webpack_require__(76318);
 ;// ./routes/Local/fileLoader.js
 class FileLoader {
   constructor() {
@@ -395660,7 +396520,7 @@ function __rewriteRelativeImportExtension(path, preserveJsx) {
 /******/ 		// This function allow to reference async chunks
 /******/ 		__webpack_require__.u = (chunkId) => {
 /******/ 			// return url for filenames based on template
-/******/ 			return "" + ({"572":"polySeg","2007":"interpolation","3054":"histogram-worker","3694":"compute"}[chunkId] || chunkId) + ".bundle." + {"85":"058fe8907052935c7ff9","147":"15c3dffbc73dab1085f5","213":"393be8a0d3a201634ac1","572":"f15c8d2cc2559db627cf","581":"2bb402f7316b6e8c735b","732":"ea6f9d8504e37e01a208","933":"a6220d057519db0b7651","1459":"5b7a328ae89a35622205","1608":"7a4a3b49cae10f6ba2cf","1927":"be67b3aafe238ca9f191","1933":"1d1345d08f29ad45a14b","2007":"072a28b303f2dbafe05c","2018":"d6cdff8149ad69a965cc","2075":"a9783d07b48ca241486e","2108":"f1ef8e8746eb3936bb47","2424":"f18df7bc54510ab32a35","2701":"8abdc7f6578c00d4539f","3054":"5b679ce4142c803c80a4","3081":"9342d2003030eb3c9541","3138":"79170d908a4106874093","3461":"9502d3707ecc5d0323c1","3694":"0fa6bd11224eb79e7474","4202":"dd592e5575b8e302689a","4287":"c6bd6cf991e2dae32044","4406":"573d234b4641d23cf8db","4507":"8969b09dd3f576cddfcf","4819":"e581d194b62f08c4eb77","5015":"81781390053c546e29be","5028":"9e63b5082d8856ee41d3","5261":"2655560097e9250eac44","5457":"7bd5092726bacbd503aa","5485":"334868b4aca965dfacf5","5802":"70600f8f701ac920b932","6027":"ac07b32905cbdd321fb5","6939":"41fbdef87597b5172ec6","7159":"fb9df255868960f69765","7431":"8ddbd21f7b2b8528a14a","7639":"78557dd05ae0f5511807","8094":"148a66619607e37cbf19","8305":"301fbc7d0a3183da4f42","8499":"f8ea964333994b9ff842","8558":"7be97925dbf90ed792f9","8583":"93f05da9435c53fa229b","9195":"a49c44d839f09c1190c1","9205":"a37976b4f3ded2cbb2ab","9845":"d52e8993eb5cde995219","9862":"4704bce0c5b039dfdec3","9927":"9e5cecd52ac87d90649e"}[chunkId] + ".js";
+/******/ 			return "" + ({"572":"polySeg","2007":"interpolation","3054":"histogram-worker","3694":"compute"}[chunkId] || chunkId) + ".bundle." + {"85":"d5ec46ba8fc649b50106","147":"9c245011849e09bd7904","213":"39a9594920f69cf117c6","572":"cdcc2c3d11009ccf112c","581":"b70e5d2d0f3958df69f0","732":"ea6f9d8504e37e01a208","933":"ea9db108b8a4e3d51904","1459":"78c0d3f68c7bf270e668","1608":"7a4a3b49cae10f6ba2cf","1927":"be67b3aafe238ca9f191","1933":"ff45b34115749da319d2","2007":"072a28b303f2dbafe05c","2018":"b9d2ac618c23377cb6cd","2075":"16215ba94d714a1c905f","2108":"f1ef8e8746eb3936bb47","2424":"d867beac3dc2f248ff98","2701":"8abdc7f6578c00d4539f","3054":"5b679ce4142c803c80a4","3081":"3d1e707778f5869e8872","3138":"e25464a30fe01479228a","3461":"2aa5281a8cc683555852","3694":"6016de6e5f7c25749422","4202":"dd592e5575b8e302689a","4287":"d2d09ffd5cd8680fad8d","4406":"573d234b4641d23cf8db","4507":"601f253b00068ad2f069","4819":"c4b011e10d490b51636c","5015":"cb3361fcdff254ae2cb7","5028":"ffc3a7161b888b6fd0b0","5261":"2655560097e9250eac44","5457":"83e615e3bd63f68a3c5c","5485":"392fae4541d15edf92cf","5802":"70d423c8b488cc56cc36","6027":"de9008a750326fb298b5","6939":"41fbdef87597b5172ec6","7159":"fb9df255868960f69765","7431":"84b3d88ef94b97c84298","7639":"4b2f5183bb9f9eac3214","8094":"148a66619607e37cbf19","8305":"a1c83d47b477b2d67008","8499":"9398ee8f733b93220248","8558":"26dd566d92fc189baa48","8583":"82a7c9293ae0b8e396d9","9195":"5a1973df57059bc8dc68","9205":"09c52845b43bd8513d50","9845":"d52e8993eb5cde995219","9862":"126a8a8c84421a076527","9927":"2d2dd3bd5ee63121a527"}[chunkId] + ".js";
 /******/ 		};
 /******/ 	})();
 /******/