@cornerstonejs/core 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/utilities/isVideoTransferSyntax.js

@@ -0,0 +1,25 @@
+export const videoUIDs = new Set([
+    '1.2.840.10008.1.2.4.100',
+    '1.2.840.10008.1.2.4.100.1',
+    '1.2.840.10008.1.2.4.101',
+    '1.2.840.10008.1.2.4.101.1',
+    '1.2.840.10008.1.2.4.102',
+    '1.2.840.10008.1.2.4.102.1',
+    '1.2.840.10008.1.2.4.103',
+    '1.2.840.10008.1.2.4.103.1',
+    '1.2.840.10008.1.2.4.104',
+    '1.2.840.10008.1.2.4.104.1',
+    '1.2.840.10008.1.2.4.105',
+    '1.2.840.10008.1.2.4.105.1',
+    '1.2.840.10008.1.2.4.106',
+    '1.2.840.10008.1.2.4.106.1',
+    '1.2.840.10008.1.2.4.107',
+    '1.2.840.10008.1.2.4.108',
+]);
+export default function isVideoTransferSyntax(uidOrUids) {
+    if (!uidOrUids) {
+        return false;
+    }
+    const uids = Array.isArray(uidOrUids) ? uidOrUids : [uidOrUids];
+    return uids.find((uid) => videoUIDs.has(uid));
+}

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

@@ -1,11 +1,31 @@
+import type { ViewPresentation, ViewReference, ViewportInputOptions, Point3 } from '../types';
 import { RequestType } from '../enums';
-interface LoadImageOptions {
-    canvas: HTMLCanvasElement;
+export interface StackLoadImageOptions {
     imageId: string;
+}
+export interface FullImageLoadOptions {
+    viewReference: ViewReference;
+    viewPresentation: ViewPresentation;
+    imageId: undefined;
+}
+export interface CanvasLoadPosition {
+    origin: Point3;
+    topRight: Point3;
+    bottomLeft: Point3;
+    thicknessMm: number;
+}
+export type LoadImageOptions = {
+    canvas: HTMLCanvasElement;
+    imageId?: string;
+    viewReference?: ViewReference;
+    viewPresentation?: ViewPresentation;
     requestType?: RequestType;
     priority?: number;
     renderingEngineId?: string;
     useCPURendering?: boolean;
-}
-export default function loadImageToCanvas(options: LoadImageOptions): Promise<string>;
-export {};
+    thumbnail?: boolean;
+    imageAspect?: boolean;
+    physicalPixels?: boolean;
+    viewportOptions?: ViewportInputOptions;
+} & (StackLoadImageOptions | FullImageLoadOptions);
+export default function loadImageToCanvas(options: LoadImageOptions): Promise<CanvasLoadPosition>;

package/dist/esm/utilities/loadImageToCanvas.js

@@ -5,16 +5,36 @@ import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
 import renderToCanvasGPU from './renderToCanvasGPU';
 import renderToCanvasCPU from './renderToCanvasCPU';
 import { getConfiguration } from '../init';
+import cache from '../cache/cache';
 export default function loadImageToCanvas(options) {
-    const { canvas, imageId, requestType = RequestType.Thumbnail, priority = -5, renderingEngineId = '_thumbnails', useCPURendering = false, } = options;
+    const { canvas, imageId, viewReference, requestType = RequestType.THUMBNAIL, priority = -5, renderingEngineId = '_thumbnails', useCPURendering = false, thumbnail = false, imageAspect = false, viewportOptions: baseViewportOptions, } = options;
+    const volumeId = viewReference?.volumeId;
+    const isVolume = volumeId && !imageId;
+    const viewportOptions = viewReference && baseViewportOptions
+        ? { ...baseViewportOptions, viewReference }
+        : baseViewportOptions;
     const renderFn = useCPURendering ? renderToCanvasCPU : renderToCanvasGPU;
     return new Promise((resolve, reject) => {
-        function successCallback(image, imageId) {
+        function successCallback(imageOrVolume, imageId) {
             const { modality } = metaData.get('generalSeriesModule', imageId) || {};
-            image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
-            renderFn(canvas, image, modality, renderingEngineId).then(() => {
-                resolve(imageId);
-            });
+            const image = !isVolume && imageOrVolume;
+            const volume = isVolume && imageOrVolume;
+            if (image) {
+                image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
+            }
+            if (thumbnail) {
+                canvas.height = 256;
+                canvas.width = 256;
+            }
+            if (imageAspect && image) {
+                canvas.width = image && (canvas.height * image.width) / image.height;
+            }
+            canvas.style.width = `${canvas.width / devicePixelRatio}px`;
+            canvas.style.height = `${canvas.height / devicePixelRatio}px`;
+            if (volume && useCPURendering) {
+                reject(new Error('CPU rendering of volume not supported'));
+            }
+            renderFn(canvas, imageOrVolume, modality, renderingEngineId, viewportOptions).then(resolve);
         }
         function errorCallback(error, imageId) {
             console.error(error, imageId);
@@ -27,18 +47,20 @@ export default function loadImageToCanvas(options) {
                 errorCallback.call(this, error, imageId);
             });
         }
-        const { useNorm16Texture } = getConfiguration().rendering;
         const options = {
-            targetBuffer: {
-                type: useNorm16Texture ? undefined : 'Float32Array',
-            },
-            preScale: {
-                enabled: true,
-            },
             useRGBA: !!useCPURendering,
             requestType,
         };
-        imageLoadPoolManager.addRequest(sendRequest.bind(null, imageId, null, options), requestType, { imageId }, priority);
+        if (volumeId) {
+            const volume = cache.getVolume(volumeId);
+            if (!volume) {
+                reject(new Error(`Volume id ${volumeId} not found in cache`));
+            }
+            const useImageId = volume.imageIds[0];
+            successCallback(volume, useImageId);
+        }
+        else {
+            imageLoadPoolManager.addRequest(sendRequest.bind(null, imageId, null, options), requestType, { imageId }, priority);
+        }
     });
 }
-//# sourceMappingURL=loadImageToCanvas.js.map

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

@@ -0,0 +1,2 @@
+import type { Metadata } from '../types';
+export default function makeVolumeMetadata(imageIds: string[]): Metadata;

package/dist/esm/utilities/makeVolumeMetadata.js

@@ -0,0 +1,51 @@
+import { get } from '../metaData';
+export default function makeVolumeMetadata(imageIds) {
+    const imageId0 = imageIds[0];
+    const { pixelRepresentation, bitsAllocated, bitsStored, highBit, photometricInterpretation, samplesPerPixel, } = get('imagePixelModule', imageId0);
+    const voiLut = [];
+    const voiLutModule = get('voiLutModule', imageId0);
+    let voiLUTFunction;
+    if (voiLutModule) {
+        const { windowWidth, windowCenter } = voiLutModule;
+        voiLUTFunction = voiLutModule?.voiLUTFunction;
+        if (Array.isArray(windowWidth)) {
+            for (let i = 0; i < windowWidth.length; i++) {
+                voiLut.push({
+                    windowWidth: windowWidth[i],
+                    windowCenter: windowCenter[i],
+                });
+            }
+        }
+        else {
+            voiLut.push({
+                windowWidth: windowWidth,
+                windowCenter: windowCenter,
+            });
+        }
+    }
+    else {
+        voiLut.push({
+            windowWidth: undefined,
+            windowCenter: undefined,
+        });
+    }
+    const { modality, seriesInstanceUID } = get('generalSeriesModule', imageId0);
+    const { imageOrientationPatient, pixelSpacing, frameOfReferenceUID, columns, rows, } = get('imagePlaneModule', imageId0);
+    return {
+        BitsAllocated: bitsAllocated,
+        BitsStored: bitsStored,
+        SamplesPerPixel: samplesPerPixel,
+        HighBit: highBit,
+        PhotometricInterpretation: photometricInterpretation,
+        PixelRepresentation: pixelRepresentation,
+        Modality: modality,
+        ImageOrientationPatient: imageOrientationPatient,
+        PixelSpacing: pixelSpacing,
+        FrameOfReferenceUID: frameOfReferenceUID,
+        Columns: columns,
+        Rows: rows,
+        voiLut,
+        VOILUTFunction: voiLUTFunction,
+        SeriesInstanceUID: seriesInstanceUID,
+    };
+}

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

@@ -1,7 +1,7 @@
-import { Point3, Plane } from '../types';
-import { vec3 } from 'gl-matrix';
+import type { Point3, Plane } from '../types';
+import type { vec3 } from 'gl-matrix';
 declare function linePlaneIntersection(p0: Point3, p1: Point3, plane: Plane): Point3;
-declare function planeEquation(normal: Point3, point: Point3 | vec3): Plane;
+declare function planeEquation(normal: Point3, point: Point3 | vec3, normalized?: boolean): Plane;
 declare function threePlaneIntersection(firstPlane: Plane, secondPlane: Plane, thirdPlane: Plane): Point3;
 declare function planeDistanceToPoint(plane: Plane, point: Point3, signed?: boolean): number;
 export { linePlaneIntersection, planeEquation, threePlaneIntersection, planeDistanceToPoint, };

package/dist/esm/utilities/planar.js

@@ -12,9 +12,13 @@ function linePlaneIntersection(p0, p1, plane) {
     const Z = c * t + z0;
     return [X, Y, Z];
 }
-function planeEquation(normal, point) {
+function planeEquation(normal, point, normalized = false) {
     const [A, B, C] = normal;
     const D = A * point[0] + B * point[1] + C * point[2];
+    if (normalized) {
+        const length = Math.sqrt(A * A + B * B + C * C);
+        return [A / length, B / length, C / length, D / length];
+    }
     return [A, B, C, D];
 }
 function threePlaneIntersection(firstPlane, secondPlane, thirdPlane) {
@@ -39,4 +43,3 @@ function planeDistanceToPoint(plane, point, signed = false) {
     return sign * distance;
 }
 export { linePlaneIntersection, planeEquation, threePlaneIntersection, planeDistanceToPoint, };
-//# sourceMappingURL=planar.js.map

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

@@ -0,0 +1,24 @@
+import { vec3 } from 'gl-matrix';
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type BoundsIJK from '../types/BoundsIJK';
+import type { CPUImageData, Point3 } from '../types';
+export type PointInShape = {
+    value: number;
+    index: number;
+    pointIJK: vec3;
+    pointLPS: vec3 | number[];
+};
+export type PointInShapeCallback = ({ value, index, pointIJK, pointLPS, }: {
+    value: number;
+    index: number;
+    pointIJK: Point3;
+    pointLPS: Point3;
+}) => void;
+export type ShapeFnCriteria = (pointLPS: vec3, pointIJK: vec3) => boolean;
+export interface PointInShapeOptions {
+    pointInShapeFn: ShapeFnCriteria;
+    callback?: PointInShapeCallback;
+    boundsIJK?: BoundsIJK;
+    returnPoints?: boolean;
+}
+export declare function pointInShapeCallback(imageData: vtkImageData | CPUImageData, options: PointInShapeOptions): Array<PointInShape> | undefined;

package/dist/esm/utilities/pointInShapeCallback.js

@@ -0,0 +1,92 @@
+import { vec3 } from 'gl-matrix';
+export function pointInShapeCallback(imageData, options) {
+    const { pointInShapeFn, callback, boundsIJK, returnPoints = false, } = options;
+    let iMin, iMax, jMin, jMax, kMin, kMax;
+    let scalarData;
+    const { numComps } = imageData;
+    if (imageData.getScalarData) {
+        scalarData = imageData.getScalarData();
+    }
+    else {
+        scalarData = imageData
+            .getPointData()
+            .getScalars()
+            .getData();
+    }
+    if (!scalarData) {
+        console.warn('No scalar data found for imageData', imageData);
+        return;
+    }
+    const dimensions = imageData.getDimensions();
+    if (!boundsIJK) {
+        iMin = 0;
+        iMax = dimensions[0];
+        jMin = 0;
+        jMax = dimensions[1];
+        kMin = 0;
+        kMax = dimensions[2];
+    }
+    else {
+        [[iMin, iMax], [jMin, jMax], [kMin, kMax]] = boundsIJK;
+    }
+    const start = vec3.fromValues(iMin, jMin, kMin);
+    const direction = imageData.getDirection();
+    const rowCosines = direction.slice(0, 3);
+    const columnCosines = direction.slice(3, 6);
+    const scanAxisNormal = direction.slice(6, 9);
+    const spacing = imageData.getSpacing();
+    const [rowSpacing, columnSpacing, scanAxisSpacing] = spacing;
+    const worldPosStart = imageData.indexToWorld(start);
+    const rowStep = vec3.fromValues(rowCosines[0] * rowSpacing, rowCosines[1] * rowSpacing, rowCosines[2] * rowSpacing);
+    const columnStep = vec3.fromValues(columnCosines[0] * columnSpacing, columnCosines[1] * columnSpacing, columnCosines[2] * columnSpacing);
+    const scanAxisStep = vec3.fromValues(scanAxisNormal[0] * scanAxisSpacing, scanAxisNormal[1] * scanAxisSpacing, scanAxisNormal[2] * scanAxisSpacing);
+    const xMultiple = numComps ||
+        scalarData.length / dimensions[2] / dimensions[1] / dimensions[0];
+    const yMultiple = dimensions[0] * xMultiple;
+    const zMultiple = dimensions[1] * yMultiple;
+    const pointsInShape = [];
+    const currentPos = vec3.clone(worldPosStart);
+    for (let k = kMin; k <= kMax; k++) {
+        const startPosJ = vec3.clone(currentPos);
+        for (let j = jMin; j <= jMax; j++) {
+            const startPosI = vec3.clone(currentPos);
+            for (let i = iMin; i <= iMax; i++) {
+                const pointIJK = [i, j, k];
+                if (pointInShapeFn(currentPos, pointIJK)) {
+                    const index = k * zMultiple + j * yMultiple + i * xMultiple;
+                    let value;
+                    if (xMultiple > 2) {
+                        value = [
+                            scalarData[index],
+                            scalarData[index + 1],
+                            scalarData[index + 2],
+                        ];
+                    }
+                    else {
+                        value = scalarData[index];
+                    }
+                    pointsInShape.push({
+                        value,
+                        index,
+                        pointIJK,
+                        pointLPS: currentPos.slice(),
+                    });
+                    if (callback) {
+                        callback({
+                            value,
+                            index,
+                            pointIJK,
+                            pointLPS: currentPos,
+                        });
+                    }
+                }
+                vec3.add(currentPos, currentPos, rowStep);
+            }
+            vec3.copy(currentPos, startPosI);
+            vec3.add(currentPos, currentPos, columnStep);
+        }
+        vec3.copy(currentPos, startPosJ);
+        vec3.add(currentPos, currentPos, scanAxisStep);
+    }
+    return returnPoints ? pointsInShape : undefined;
+}

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

@@ -1,2 +1,3 @@
-import { IImage } from '../types';
-export default function renderToCanvasCPU(canvas: HTMLCanvasElement, image: IImage, modality?: string, renderingEngineId?: string): Promise<string>;
+import type { IImage, ViewportInputOptions, IVolume } from '../types';
+import type { CanvasLoadPosition } from './loadImageToCanvas';
+export default function renderToCanvasCPU(canvas: HTMLCanvasElement, imageOrVolume: IImage | IVolume, modality?: string, _renderingEngineId?: string, _viewportOptions?: ViewportInputOptions): Promise<CanvasLoadPosition>;

package/dist/esm/utilities/renderToCanvasCPU.js

@@ -1,7 +1,12 @@
 import getDefaultViewport from '../RenderingEngine/helpers/cpuFallback/rendering/getDefaultViewport';
 import calculateTransform from '../RenderingEngine/helpers/cpuFallback/rendering/calculateTransform';
 import drawImageSync from '../RenderingEngine/helpers/cpuFallback/drawImageSync';
-export default function renderToCanvasCPU(canvas, image, modality, renderingEngineId) {
+export default function renderToCanvasCPU(canvas, imageOrVolume, modality, _renderingEngineId, _viewportOptions) {
+    const volume = imageOrVolume;
+    if (volume.volumeId) {
+        throw new Error('Unsupported volume rendering for CPU');
+    }
+    const image = imageOrVolume;
     const viewport = getDefaultViewport(canvas, image, modality);
     const enabledElement = {
         canvas,
@@ -13,7 +18,6 @@ export default function renderToCanvasCPU(canvas, image, modality, renderingEngi
     const invalidated = true;
     return new Promise((resolve, reject) => {
         drawImageSync(enabledElement, invalidated);
-        resolve(image.imageId);
+        resolve(null);
     });
 }
-//# sourceMappingURL=renderToCanvasCPU.js.map

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

@@ -1,2 +1,5 @@
-import { IImage } from '../types';
-export default function renderToCanvasGPU(canvas: HTMLCanvasElement, image: IImage, modality?: any, renderingEngineId?: string): Promise<string>;
+import type { IImage, IVolume, ViewportInputOptions, ViewReference } from '../types';
+import type { CanvasLoadPosition } from './loadImageToCanvas';
+export default function renderToCanvasGPU(canvas: HTMLCanvasElement, imageOrVolume: IImage | IVolume, modality?: any, renderingEngineId?: string, viewportOptions?: ViewportInputOptions & {
+    viewReference?: ViewReference;
+}): Promise<CanvasLoadPosition>;

package/dist/esm/utilities/renderToCanvasGPU.js

@@ -1,54 +1,76 @@
-import getOrCreateCanvas from '../RenderingEngine/helpers/getOrCreateCanvas';
+import getOrCreateCanvas, { EPSILON, } from '../RenderingEngine/helpers/getOrCreateCanvas';
 import { ViewportType, Events } from '../enums';
 import { getRenderingEngine } from '../RenderingEngine/getRenderingEngine';
 import RenderingEngine from '../RenderingEngine';
 import isPTPrescaledWithSUV from './isPTPrescaledWithSUV';
-export default function renderToCanvasGPU(canvas, image, modality = undefined, renderingEngineId = '_thumbnails') {
+export default function renderToCanvasGPU(canvas, imageOrVolume, modality = undefined, renderingEngineId = '_thumbnails', viewportOptions = {
+    displayArea: { imageArea: [1, 1] },
+}) {
     if (!canvas || !(canvas instanceof HTMLCanvasElement)) {
         throw new Error('canvas element is required');
     }
-    const imageIdToPrint = image.imageId;
+    const isVolume = !imageOrVolume.imageId;
+    const image = !isVolume && imageOrVolume;
+    const volume = isVolume && imageOrVolume;
+    const imageIdToPrint = image.imageId || volume.volumeId;
     const viewportId = `renderGPUViewport-${imageIdToPrint}`;
-    const imageId = image.imageId;
     const element = document.createElement('div');
-    element.style.width = `${canvas.width}px`;
-    element.style.height = `${canvas.height}px`;
-    element.style.visibility = 'hidden';
-    element.style.position = 'absolute';
     const devicePixelRatio = window.devicePixelRatio || 1;
+    if (!viewportOptions.displayArea) {
+        viewportOptions.displayArea = { imageArea: [1, 1] };
+    }
     const originalWidth = canvas.width;
     const originalHeight = canvas.height;
-    canvas.width = originalWidth * devicePixelRatio;
-    canvas.height = originalHeight * devicePixelRatio;
-    canvas.style.width = `${originalWidth}px`;
-    canvas.style.height = `${originalHeight}px`;
+    element.style.width = `${originalWidth / devicePixelRatio + EPSILON}px`;
+    element.style.height = `${originalHeight / devicePixelRatio + EPSILON}px`;
+    element.style.visibility = 'hidden';
+    element.style.position = 'absolute';
     document.body.appendChild(element);
     const uniqueId = viewportId.split(':').join('-');
     element.setAttribute('viewport-id-for-remove', uniqueId);
+    const temporaryCanvas = getOrCreateCanvas(element);
     const renderingEngine = getRenderingEngine(renderingEngineId) ||
         new RenderingEngine(renderingEngineId);
     let viewport = renderingEngine.getViewport(viewportId);
     if (!viewport) {
-        const stackViewportInput = {
+        const viewportInput = {
             viewportId,
-            type: ViewportType.STACK,
+            type: isVolume ? ViewportType.ORTHOGRAPHIC : ViewportType.STACK,
             element,
             defaultOptions: {
+                ...viewportOptions,
                 suppressEvents: true,
             },
         };
-        renderingEngine.enableElement(stackViewportInput);
+        renderingEngine.enableElement(viewportInput);
         viewport = renderingEngine.getViewport(viewportId);
     }
     return new Promise((resolve) => {
         let elementRendered = false;
+        let { viewReference } = viewportOptions;
         const onImageRendered = (eventDetail) => {
             if (elementRendered) {
                 return;
             }
-            const temporaryCanvas = getOrCreateCanvas(element);
+            if (viewReference) {
+                const useViewRef = viewReference;
+                viewReference = null;
+                viewport.setViewReference(useViewRef);
+                viewport.render();
+                return;
+            }
             const context = canvas.getContext('2d');
             context.drawImage(temporaryCanvas, 0, 0, temporaryCanvas.width, temporaryCanvas.height, 0, 0, canvas.width, canvas.height);
+            const origin = viewport.canvasToWorld([0, 0]);
+            const topRight = viewport.canvasToWorld([
+                temporaryCanvas.width / devicePixelRatio,
+                0,
+            ]);
+            const bottomLeft = viewport.canvasToWorld([
+                0,
+                temporaryCanvas.height / devicePixelRatio,
+            ]);
+            const thicknessMm = 1;
             elementRendered = true;
             element.removeEventListener(Events.IMAGE_RENDERED, onImageRendered);
             setTimeout(() => {
@@ -58,10 +80,20 @@ export default function renderToCanvasGPU(canvas, image, modality = undefined, r
                     element.remove();
                 });
             }, 0);
-            resolve(imageId);
+            resolve({
+                origin,
+                bottomLeft,
+                topRight,
+                thicknessMm,
+            });
         };
         element.addEventListener(Events.IMAGE_RENDERED, onImageRendered);
-        viewport.renderImageObject(image);
+        if (isVolume) {
+            viewport.setVolumes([volume], false, true);
+        }
+        else {
+            viewport.renderImageObject(imageOrVolume);
+        }
         viewport.resetCamera();
         if (modality === 'PT' && !isPTPrescaledWithSUV(image)) {
             viewport.setProperties({
@@ -74,4 +106,3 @@ export default function renderToCanvasGPU(canvas, image, modality = undefined, r
         viewport.render();
     });
 }
-//# sourceMappingURL=renderToCanvasGPU.js.map

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

@@ -0,0 +1,4 @@
+declare function roundNumber(value: string | number | (string | number)[], precision?: number): string;
+declare function roundToPrecision(value: any): number;
+export { roundToPrecision };
+export default roundNumber;

package/dist/esm/utilities/roundNumber.js

@@ -0,0 +1,33 @@
+import { EPSILON } from '../constants';
+function roundNumber(value, precision = 2) {
+    if (Array.isArray(value)) {
+        return value.map((v) => roundNumber(v, precision)).join(', ');
+    }
+    if (value === undefined || value === null || value === '') {
+        return 'NaN';
+    }
+    value = Number(value);
+    const absValue = Math.abs(value);
+    if (absValue < 0.0001) {
+        return `${value}`;
+    }
+    const fixedPrecision = absValue >= 100
+        ? precision - 2
+        : absValue >= 10
+            ? precision - 1
+            : absValue >= 1
+                ? precision
+                : absValue >= 0.1
+                    ? precision + 1
+                    : absValue >= 0.01
+                        ? precision + 2
+                        : absValue >= 0.001
+                            ? precision + 3
+                            : precision + 4;
+    return value.toFixed(fixedPrecision);
+}
+function roundToPrecision(value) {
+    return Math.round(value / EPSILON) * EPSILON;
+}
+export { roundToPrecision };
+export default roundNumber;

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

@@ -0,0 +1,2 @@
+import type { ScalingParameters } from '../types';
+export default function scaleArray(array: Float32Array | Uint8Array | Uint16Array | Int16Array, scalingParameters: ScalingParameters): Float32Array | Uint8Array | Uint16Array | Int16Array;

package/dist/esm/utilities/scaleArray.js

@@ -0,0 +1,15 @@
+export default function scaleArray(array, scalingParameters) {
+    const arrayLength = array.length;
+    const { rescaleSlope, rescaleIntercept, suvbw } = scalingParameters;
+    if (scalingParameters.modality === 'PT' && typeof suvbw === 'number') {
+        for (let i = 0; i < arrayLength; i++) {
+            array[i] = suvbw * (array[i] * rescaleSlope + rescaleIntercept);
+        }
+    }
+    else {
+        for (let i = 0; i < arrayLength; i++) {
+            array[i] = array[i] * rescaleSlope + rescaleIntercept;
+        }
+    }
+    return array;
+}

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

@@ -1 +1,2 @@
-export default function scaleRGBTransferFunction(rgbTransferFunction: any, scalingFactor: number): void;
+import type ColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+export default function scaleRGBTransferFunction(rgbTransferFunction: ColorTransferFunction, scalingFactor: number): void;

package/dist/esm/utilities/scaleRgbTransferFunction.js

@@ -9,4 +9,3 @@ export default function scaleRGBTransferFunction(rgbTransferFunction, scalingFac
         rgbTransferFunction.setNodeValue(index, nodeValue1);
     }
 }
-//# sourceMappingURL=scaleRgbTransferFunction.js.map

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

@@ -1,4 +1,4 @@
-import { ActorSliceRange, Point3 } from '../types';
+import type { ActorSliceRange, Point3 } from '../types';
 export default function snapFocalPointToSlice(focalPoint: Point3, position: Point3, sliceRange: ActorSliceRange, viewPlaneNormal: Point3, spacingInNormalDirection: number, deltaFrames: number): {
     newFocalPoint: Point3;
     newPosition: Point3;

package/dist/esm/utilities/snapFocalPointToSlice.js

@@ -35,4 +35,3 @@ export default function snapFocalPointToSlice(focalPoint, position, sliceRange,
     ];
     return { newFocalPoint, newPosition };
 }
-//# sourceMappingURL=snapFocalPointToSlice.js.map

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

@@ -0,0 +1,9 @@
+import { vec3 } from 'gl-matrix';
+import type { Point3 } from '../types';
+interface SortedImageIdsItem {
+    zSpacing: number;
+    origin: Point3;
+    sortedImageIds: string[];
+}
+export default function sortImageIdsAndGetSpacing(imageIds: string[], scanAxisNormal?: vec3): SortedImageIdsItem;
+export {};