@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/utilities/ECGUtilities.d.ts

@@ -0,0 +1,83 @@
+export declare const ECG_SECONDS_WIDTH = 150;
+export declare const ECG_CHANNEL_SPACING = 5;
+export declare const ECG_RENDERING_COLORS: {
+    readonly gridMajor: "#7f0000";
+    readonly gridMinor: "#3f0000";
+    readonly baseline: "#7f4c00";
+    readonly trace: "#ffffff";
+    readonly label: "#ffff00";
+    readonly background: "#000000";
+};
+export interface ECGChannelLike {
+    name: string;
+    data: Int16Array;
+    min: number;
+    max: number;
+    visible?: boolean;
+}
+export interface ECGWaveformLike<TChannel extends ECGChannelLike = ECGChannelLike> {
+    channels: TChannel[];
+    numberOfChannels: number;
+    numberOfSamples: number;
+    samplingFrequency: number;
+    bitsAllocated: number;
+    sampleInterpretation: string;
+    multiplexGroupLabel?: string;
+    calibration?: unknown;
+}
+export interface ECGChannelLayout<TChannel extends ECGChannelLike = ECGChannelLike> {
+    channel: TChannel;
+    itemHeight: number;
+    yOffset: number;
+    baseline: number;
+}
+export interface ECGRenderMetrics {
+    ecgWidth: number;
+    ecgHeight: number;
+    channelScale: number;
+    worldToCanvasRatio: number;
+    xOffsetCanvas: number;
+    yOffsetCanvas: number;
+}
+export interface ECGGridMetrics {
+    ecgWidth: number;
+    ecgHeight: number;
+    channelScale: number;
+}
+export declare function loadECGWaveform(dataId: string): Promise<{
+    waveform: ECGWaveformLike;
+    calibration: unknown;
+}>;
+export declare function computeECGMinMax(data: Int16Array): {
+    min: number;
+    max: number;
+};
+export declare function getDefaultECGValueRange(waveform: ECGWaveformLike): [number, number];
+export declare function getVisibleECGChannels<TChannel extends ECGChannelLike>(channels: TChannel[], visibleChannels?: number[]): TChannel[];
+export declare function getVisibleECGChannelsByFlag<TChannel extends ECGChannelLike>(channels: TChannel[]): TChannel[];
+export declare function computeECGHeight<TChannel extends ECGChannelLike>(visibleChannels: TChannel[], channelScale: number): number;
+export declare function computeECGChannelLayouts<TChannel extends ECGChannelLike>(args: {
+    visibleChannels: TChannel[];
+    channelScale: number;
+}): ECGChannelLayout<TChannel>[];
+export declare function computeECGRenderMetrics<TChannel extends ECGChannelLike>(args: {
+    canvas: HTMLCanvasElement;
+    visibleChannels: TChannel[];
+    windowMs: number;
+    valueRange: [number, number];
+}): ECGRenderMetrics;
+export declare function drawECGGrid(ctx: CanvasRenderingContext2D, metrics: ECGGridMetrics, options?: {
+    showGrid?: boolean;
+}): void;
+export declare function drawECGTraces<TChannel extends ECGChannelLike>(args: {
+    ctx: CanvasRenderingContext2D;
+    layouts: ECGChannelLayout<TChannel>[];
+    ecgWidth: number;
+    channelScale: number;
+    startIndex?: number;
+    endIndex?: number;
+    lineWidth?: number;
+    amplitudeScale?: number;
+}): void;
+export declare function drawECGLabels<TChannel extends ECGChannelLike>(ctx: CanvasRenderingContext2D, layouts: ECGChannelLayout<TChannel>[], worldToCanvasRatio: number): void;
+export declare function ensureECGCanvasSize(canvas: HTMLCanvasElement): void;

package/dist/esm/utilities/ECGUtilities.js

@@ -0,0 +1,228 @@
+import { MetadataModules } from '../enums';
+import * as metaData from '../metaData';
+export const ECG_SECONDS_WIDTH = 150;
+export const ECG_CHANNEL_SPACING = 5;
+export const ECG_RENDERING_COLORS = {
+    gridMajor: '#7f0000',
+    gridMinor: '#3f0000',
+    baseline: '#7f4c00',
+    trace: '#ffffff',
+    label: '#ffff00',
+    background: '#000000',
+};
+export async function loadECGWaveform(dataId) {
+    const ecgModule = metaData.get(MetadataModules.ECG, dataId);
+    if (!ecgModule?.waveformData?.retrieveBulkData) {
+        throw new Error(`[ECG] No ECG waveform data for ${dataId}`);
+    }
+    const { numberOfWaveformChannels: numberOfChannels, numberOfWaveformSamples: numberOfSamples, samplingFrequency, waveformBitsAllocated: bitsAllocated = 16, waveformSampleInterpretation: sampleInterpretation = 'SS', multiplexGroupLabel, channelDefinitionSequence: channelDefinitions = [], } = ecgModule;
+    const channelArrays = await ecgModule.waveformData.retrieveBulkData();
+    const calibration = metaData.get(MetadataModules.CALIBRATION, dataId);
+    const channels = [];
+    for (let index = 0; index < numberOfChannels; index++) {
+        const channelDefinition = channelDefinitions[index] || {};
+        const name = channelDefinition.channelSourceSequence?.codeMeaning ||
+            channelDefinition.ChannelSourceSequence?.CodeMeaning ||
+            `Channel ${index + 1}`;
+        const data = channelArrays[index] || new Int16Array(0);
+        const { min, max } = computeECGMinMax(data);
+        channels.push({
+            name,
+            data,
+            min,
+            max,
+        });
+    }
+    return {
+        waveform: {
+            channels,
+            numberOfChannels,
+            numberOfSamples,
+            samplingFrequency,
+            bitsAllocated,
+            sampleInterpretation,
+            multiplexGroupLabel,
+            calibration,
+        },
+        calibration,
+    };
+}
+export function computeECGMinMax(data) {
+    let min = 0;
+    let max = 0;
+    for (let index = 0; index < data.length; index++) {
+        if (data[index] < min) {
+            min = data[index];
+        }
+        if (data[index] > max) {
+            max = data[index];
+        }
+    }
+    return { min, max };
+}
+export function getDefaultECGValueRange(waveform) {
+    let min = 0;
+    let max = 0;
+    waveform.channels.forEach((channel) => {
+        min = Math.min(min, channel.min);
+        max = Math.max(max, channel.max);
+    });
+    if (min === max) {
+        return [-1, 1];
+    }
+    return [min, max];
+}
+export function getVisibleECGChannels(channels, visibleChannels) {
+    if (!visibleChannels) {
+        return channels.filter((channel) => channel.data.length > 0);
+    }
+    const visible = new Set(visibleChannels);
+    return channels.filter((_channel, index) => visible.has(index) && channels[index].data.length > 0);
+}
+export function getVisibleECGChannelsByFlag(channels) {
+    return channels.filter((channel) => channel.visible !== false && channel.data.length > 0);
+}
+export function computeECGHeight(visibleChannels, channelScale) {
+    let totalHeight = 0;
+    visibleChannels.forEach((channel) => {
+        totalHeight += (channel.max - channel.min) * channelScale * 1.25;
+        totalHeight += ECG_CHANNEL_SPACING;
+    });
+    return totalHeight || 1;
+}
+export function computeECGChannelLayouts(args) {
+    const { visibleChannels, channelScale } = args;
+    const layouts = [];
+    let yOffset = 0;
+    visibleChannels.forEach((channel) => {
+        const itemHeight = (channel.max - channel.min) * channelScale * 1.25;
+        yOffset += itemHeight + ECG_CHANNEL_SPACING;
+        const baseline = yOffset + channel.min * channelScale;
+        layouts.push({
+            channel,
+            itemHeight,
+            yOffset,
+            baseline,
+        });
+    });
+    return layouts;
+}
+export function computeECGRenderMetrics(args) {
+    const { canvas, visibleChannels, windowMs, valueRange } = args;
+    const ecgWidth = Math.max(1, Math.ceil((windowMs / 1000) * ECG_SECONDS_WIDTH));
+    const [minValue, maxValue] = valueRange;
+    const range = Math.max(1, maxValue - minValue);
+    const canvasAspect = canvas.clientHeight && canvas.clientWidth
+        ? canvas.clientHeight / canvas.clientWidth
+        : 2 / 3;
+    const targetTotalHeight = ecgWidth * canvasAspect;
+    const totalSpacing = ECG_CHANNEL_SPACING * Math.max(1, visibleChannels.length);
+    const heightPerChannel = (targetTotalHeight - totalSpacing) / Math.max(1, visibleChannels.length);
+    const channelScale = heightPerChannel / (range * 1.25);
+    const ecgHeight = computeECGHeight(visibleChannels, channelScale);
+    const worldToCanvasRatio = Math.min(canvas.clientWidth / Math.max(1, ecgWidth), canvas.clientHeight / Math.max(1, ecgHeight));
+    const drawWidth = ecgWidth * worldToCanvasRatio;
+    const drawHeight = ecgHeight * worldToCanvasRatio;
+    return {
+        ecgWidth,
+        ecgHeight,
+        channelScale,
+        worldToCanvasRatio,
+        xOffsetCanvas: (canvas.clientWidth - drawWidth) / 2,
+        yOffsetCanvas: (canvas.clientHeight - drawHeight) / 2,
+    };
+}
+export function drawECGGrid(ctx, metrics, options) {
+    if (options?.showGrid === false || metrics.channelScale <= 0) {
+        return;
+    }
+    const { ecgWidth, ecgHeight, channelScale } = metrics;
+    const minLineSpacing = 8;
+    let horizontalGridUnit = 100;
+    while (horizontalGridUnit * channelScale < minLineSpacing) {
+        horizontalGridUnit *= 2;
+    }
+    const minorH = horizontalGridUnit * channelScale;
+    const majorH = minorH * 5;
+    const minorV = ECG_SECONDS_WIDTH / 25;
+    const majorV = ECG_SECONDS_WIDTH / 5;
+    ctx.strokeStyle = ECG_RENDERING_COLORS.gridMinor;
+    ctx.lineWidth = 0.5;
+    ctx.beginPath();
+    for (let y = minorH; y <= ecgHeight; y += minorH) {
+        if (Math.round(y / minorH) % 5 !== 0) {
+            ctx.moveTo(0, y);
+            ctx.lineTo(ecgWidth, y);
+        }
+    }
+    for (let x = minorV; x <= ecgWidth; x += minorV) {
+        if (Math.round(x / minorV) % 5 !== 0) {
+            ctx.moveTo(x, 0);
+            ctx.lineTo(x, ecgHeight);
+        }
+    }
+    ctx.stroke();
+    ctx.strokeStyle = ECG_RENDERING_COLORS.gridMajor;
+    ctx.lineWidth = 1;
+    ctx.beginPath();
+    for (let y = majorH; y <= ecgHeight; y += majorH) {
+        ctx.moveTo(0, y);
+        ctx.lineTo(ecgWidth, y);
+    }
+    for (let x = majorV; x <= ecgWidth; x += majorV) {
+        ctx.moveTo(x, 0);
+        ctx.lineTo(x, ecgHeight);
+    }
+    ctx.stroke();
+}
+export function drawECGTraces(args) {
+    const { ctx, layouts, ecgWidth, channelScale, startIndex = 0, endIndex, lineWidth = 1, amplitudeScale = 1, } = args;
+    layouts.forEach(({ channel, baseline }) => {
+        const resolvedEndIndex = Math.min(endIndex ?? channel.data.length, channel.data.length);
+        const resolvedStartIndex = Math.max(0, Math.min(startIndex, resolvedEndIndex - 1));
+        const sampleCount = Math.max(1, resolvedEndIndex - resolvedStartIndex);
+        ctx.strokeStyle = ECG_RENDERING_COLORS.baseline;
+        ctx.lineWidth = 2;
+        ctx.beginPath();
+        ctx.moveTo(0, baseline);
+        ctx.lineTo(ecgWidth, baseline);
+        ctx.stroke();
+        ctx.strokeStyle = ECG_RENDERING_COLORS.trace;
+        ctx.lineWidth = lineWidth;
+        ctx.beginPath();
+        for (let index = resolvedStartIndex; index < resolvedEndIndex; index++) {
+            const x = ((index - resolvedStartIndex) * ecgWidth) / sampleCount;
+            const y = baseline - channel.data[index] * channelScale * amplitudeScale;
+            if (index === resolvedStartIndex) {
+                ctx.moveTo(x, y);
+            }
+            else {
+                ctx.lineTo(x, y);
+            }
+        }
+        ctx.stroke();
+    });
+}
+export function drawECGLabels(ctx, layouts, worldToCanvasRatio) {
+    const fontSize = 14 / (worldToCanvasRatio || 1);
+    layouts.forEach(({ channel, itemHeight, yOffset }) => {
+        const labelY = yOffset - itemHeight + fontSize;
+        ctx.font = `${fontSize}px monospace`;
+        const textWidth = ctx.measureText(channel.name).width;
+        ctx.fillStyle = ECG_RENDERING_COLORS.background;
+        ctx.fillRect(5, labelY - fontSize, textWidth + 4, fontSize + 4);
+        ctx.fillStyle = ECG_RENDERING_COLORS.label;
+        ctx.fillText(channel.name, 5, labelY);
+    });
+}
+export function ensureECGCanvasSize(canvas) {
+    const dpr = window.devicePixelRatio || 1;
+    const width = Math.max(1, canvas.clientWidth || canvas.width || 1);
+    const height = Math.max(1, canvas.clientHeight || canvas.height || 1);
+    const nextWidth = Math.floor(width * dpr);
+    const nextHeight = Math.floor(height * dpr);
+    if (canvas.width !== nextWidth || canvas.height !== nextHeight) {
+        canvas.width = nextWidth;
+        canvas.height = nextHeight;
+    }
+}

package/dist/esm/utilities/FrameRange.js

@@ -1,5 +1,4 @@
-export default class FrameRange {
-    static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
+class FrameRange {
     static imageIdToFrames(imageId) {
         const match = imageId.match(this.frameRangeExtractor);
         if (!match || !match[2]) {
@@ -34,3 +33,5 @@ export default class FrameRange {
         return imageId.replace(this.frameRangeExtractor, `${match[1]}${newRangeString}`);
     }
 }
+FrameRange.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i;
+export default FrameRange;

package/dist/esm/utilities/RLEVoxelMap.js

@@ -1,3 +1,4 @@
+import { deepClone } from './deepClone';
 const ADJACENT_ALL = [
     [0, -1, 0],
     [0, 1, 0],
@@ -18,10 +19,10 @@ const ADJACENT_OUT = [
     [0, 1, 0],
     [0, 0, 1],
 ];
-export default class RLEVoxelMap {
+class RLEVoxelMap {
     static copyMap(destination, source) {
         for (const [index, row] of source.rows) {
-            destination.rows.set(index, structuredClone(row));
+            destination.rows.set(index, deepClone(row));
         }
     }
     constructor(width, height, depth = 1) {
@@ -145,11 +146,6 @@ export default class RLEVoxelMap {
         this.jMultiple = width;
         this.kMultiple = this.jMultiple * height;
     }
-    static { this.getScalarData = function (ArrayType = Uint8ClampedArray) {
-        const scalarData = new ArrayType(this.frameSize);
-        this.map.updateScalarData(scalarData);
-        return scalarData;
-    }; }
     toIJK(index) {
         const i = index % this.jMultiple;
         const j = ((index - i) / this.jMultiple) % this.height;
@@ -373,3 +369,9 @@ export default class RLEVoxelMap {
         return adjacents;
     }
 }
+RLEVoxelMap.getScalarData = function (ArrayType = Uint8ClampedArray) {
+    const scalarData = new ArrayType(this.frameSize);
+    this.map.updateScalarData(scalarData);
+    return scalarData;
+};
+export default RLEVoxelMap;

package/dist/esm/utilities/VideoUtilities.d.ts

@@ -0,0 +1,34 @@
+import type { Point3 } from '../types';
+export interface VideoImageMetadata {
+    bitsAllocated: number;
+    numberOfComponents: number;
+    origin: Point3;
+    rows: number;
+    columns: number;
+    direction: number[];
+    dimensions: [number, number, number];
+    spacing: [number, number, number];
+    hasPixelSpacing: boolean;
+    numVoxels: number;
+    imagePlaneModule: Record<string, unknown>;
+}
+export interface LoadedVideoStreamMetadata {
+    renderedUrl: string;
+    modality?: string;
+    metadata: VideoImageMetadata;
+    cineRate?: number;
+    numberOfFrames?: number;
+}
+export declare function getVideoImageDataMetadata(imageId: string): VideoImageMetadata;
+export declare function loadVideoStreamMetadata(imageId: string): LoadedVideoStreamMetadata;
+export declare function normalizeVideoPlaybackInfo(args: {
+    durationSeconds: number;
+    cineRate?: number;
+    numberOfFrames?: number;
+}): {
+    fps: number;
+    numberOfFrames: number;
+    frameRange: [number, number];
+};
+export declare function frameNumberToTimeSeconds(frameNumber: number, fps: number): number;
+export declare function timeSecondsToFrameNumber(timeSeconds: number, fps: number): number;

package/dist/esm/utilities/VideoUtilities.js

@@ -0,0 +1,102 @@
+import { vec3 } from 'gl-matrix';
+import { MetadataModules } from '../enums';
+import * as metaData from '../metaData';
+import isVideoTransferSyntax from './isVideoTransferSyntax';
+export function getVideoImageDataMetadata(imageId) {
+    const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
+    let rowCosines = imagePlaneModule.rowCosines;
+    let columnCosines = imagePlaneModule.columnCosines;
+    const usingDefaultValues = imagePlaneModule.usingDefaultValues;
+    if (usingDefaultValues || rowCosines == null || columnCosines == null) {
+        rowCosines = [1, 0, 0];
+        columnCosines = [0, 1, 0];
+    }
+    const rowCosineVec = vec3.fromValues(rowCosines[0], rowCosines[1], rowCosines[2]);
+    const colCosineVec = vec3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
+    const scanAxisNormal = vec3.create();
+    vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+    const rows = imagePlaneModule.rows;
+    const columns = imagePlaneModule.columns;
+    const origin = (imagePlaneModule.imagePositionPatient || [0, 0, 0]);
+    const xSpacing = imagePlaneModule.columnPixelSpacing || 1;
+    const ySpacing = imagePlaneModule.rowPixelSpacing || 1;
+    const zSpacing = 1;
+    const xVoxels = imagePlaneModule.columns;
+    const yVoxels = imagePlaneModule.rows;
+    const zVoxels = 1;
+    return {
+        bitsAllocated: 8,
+        numberOfComponents: 3,
+        origin,
+        rows,
+        columns,
+        direction: [...rowCosineVec, ...colCosineVec, ...scanAxisNormal],
+        dimensions: [xVoxels, yVoxels, zVoxels],
+        spacing: [xSpacing, ySpacing, zSpacing],
+        hasPixelSpacing: !!imagePlaneModule.columnPixelSpacing,
+        numVoxels: xVoxels * yVoxels * zVoxels,
+        imagePlaneModule,
+    };
+}
+export function loadVideoStreamMetadata(imageId) {
+    const renderedUrl = getRenderedVideoUrl(imageId);
+    if (!renderedUrl) {
+        throw new Error(`Video Image ID ${imageId} does not have a rendered video view`);
+    }
+    const generalSeries = metaData.get(MetadataModules.GENERAL_SERIES, imageId);
+    const cine = metaData.get(MetadataModules.CINE, imageId) || {};
+    const instance = metaData.get(MetadataModules.INSTANCE, imageId);
+    const frameTime = cine.frameTime ?? cine.FrameTime;
+    return {
+        renderedUrl,
+        modality: generalSeries?.Modality ?? generalSeries?.modality,
+        metadata: getVideoImageDataMetadata(imageId),
+        cineRate: cine.cineRate ??
+            cine.recommendedDisplayFrameRate ??
+            (frameTime ? 1000 / Number(frameTime) : undefined),
+        numberOfFrames: cine.numberOfFrames ?? instance?.NumberOfFrames,
+    };
+}
+function getRenderedVideoUrl(imageId) {
+    const imageUrlModule = metaData.get(MetadataModules.IMAGE_URL, imageId);
+    if (imageUrlModule?.rendered) {
+        return imageUrlModule.rendered;
+    }
+    const transferSyntax = metaData.get(MetadataModules.TRANSFER_SYNTAX, imageId);
+    const isVideo = transferSyntax?.isVideo ||
+        isVideoTransferSyntax(transferSyntax?.transferSyntaxUID);
+    if (!isVideo) {
+        return;
+    }
+    const imageUrl = imageId.startsWith('wadors:')
+        ? imageId.substring(7)
+        : imageId;
+    if (!imageUrl.includes('/frames/')) {
+        return;
+    }
+    return imageUrl
+        .replace('/frames/', '/rendered/')
+        .replace(/\/rendered\/\d+($|[?#])/, '/rendered$1');
+}
+export function normalizeVideoPlaybackInfo(args) {
+    const durationSeconds = Math.max(args.durationSeconds || 0, 0.001);
+    let numberOfFrames = args.numberOfFrames;
+    let fps = args.cineRate;
+    if (!numberOfFrames || numberOfFrames === 1) {
+        numberOfFrames = Math.max(1, Math.round(durationSeconds * (fps || 30)));
+    }
+    if (!fps) {
+        fps = Math.max(1, Math.round(numberOfFrames / durationSeconds));
+    }
+    return {
+        fps,
+        numberOfFrames,
+        frameRange: [1, numberOfFrames],
+    };
+}
+export function frameNumberToTimeSeconds(frameNumber, fps) {
+    return Math.max(0, frameNumber - 1) / Math.max(1, fps);
+}
+export function timeSecondsToFrameNumber(timeSeconds, fps) {
+    return 1 + Math.round(Math.max(0, timeSeconds) * Math.max(1, fps));
+}

package/dist/esm/utilities/VoxelManager.d.ts

@@ -1,5 +1,15 @@
-import type { BoundsIJK, Point3, PixelDataTypedArray, IImage, RGB, CPUImageData, IVoxelManager, IRLEVoxelMap, Point2 } from '../types';
+import { InterpolationType } from '../enums';
+import type { BoundsIJK, Mat3, Point3, PixelDataTypedArray, IImage, RGB, CPUImageData, IVoxelManager, IRLEVoxelMap, Point2 } from '../types';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+type VoxelVolumeGeometry = {
+    origin: Point3;
+    spacing: Point3;
+    direction: Mat3;
+};
+type SampleableVoxelVolume = VoxelVolumeGeometry & {
+    dimensions: Point3;
+    voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
+};
 export default class VoxelManager<T> {
     modifiedSlices: Set<number>;
     private boundsIJK;
@@ -10,6 +20,7 @@ export default class VoxelManager<T> {
     readonly numberOfComponents: number;
     getCompleteScalarDataArray?: () => ArrayLike<number>;
     setCompleteScalarDataArray?: (scalarData: ArrayLike<number>) => void;
+    invalidateCache?: () => void;
     getRange: () => [number, number];
     private scalarData;
     private _sliceDataCache;
@@ -77,6 +88,14 @@ export default class VoxelManager<T> {
     resetModifiedSlices(): void;
     setBounds(bounds: BoundsIJK): void;
     static addBounds(bounds: BoundsIJK, point: Point3): void;
+    private static getWorldToIndexTransform;
+    static worldToIndexContinuous(volumeGeometry: VoxelVolumeGeometry, worldPos: Point3): Point3;
+    static sampleAtWorldCoordinates(volume: SampleableVoxelVolume, worldX: number, worldY: number, worldZ: number, interpolationType?: InterpolationType): number;
+    static sampleAtWorld(volume: SampleableVoxelVolume, worldPos: Point3, interpolationType?: InterpolationType): number;
+    static sampleAtContinuousIndex(voxelManager: IVoxelManager<number> | IVoxelManager<RGB>, dimensions: Point3, continuousIndex: Point3, interpolationType?: InterpolationType): number;
+    private static sampleAtContinuousCoordinates;
+    private static sampleNearestAtContinuousCoordinates;
+    private static sampleLinearAtContinuousCoordinates;
     addPoint(point: Point3 | number): void;
     getPoints(): Point3[];
     getSliceData: ({ sliceIndex, slicePlane, }: {