@cornerstonejs/core 2.0.0-beta.21 → 2.0.0-beta.23

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/sortImageIdsAndGetSpacing.js

@@ -1,5 +1,6 @@
 import { vec3 } from 'gl-matrix';
-import { metaData, getConfiguration } from '../';
+import * as metaData from '../metaData';
+import { getConfiguration } from '../init';
 export default function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
     const { imagePositionPatient: referenceImagePositionPatient, imageOrientationPatient, } = metaData.get('imagePlaneModule', imageIds[0]);
     if (!scanAxisNormal) {

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

@@ -0,0 +1,5 @@
+declare function splitImageIdsBy4DTags(imageIds: string[]): {
+    imageIdGroups: string[][];
+    splittingTag: string | null;
+};
+export default splitImageIdsBy4DTags;

package/dist/esm/utilities/splitImageIdsBy4DTags.js

@@ -0,0 +1,161 @@
+import * as metaData from '../metaData';
+const groupBy = (array, key) => {
+    return array.reduce((rv, x) => {
+        (rv[x[key]] = rv[x[key]] || []).push(x);
+        return rv;
+    }, {});
+};
+function getIPPGroups(imageIds) {
+    const ippMetadata = imageIds.map((imageId) => {
+        const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId) || {};
+        return { imageId, imagePositionPatient };
+    });
+    if (!ippMetadata.every((item) => item.imagePositionPatient)) {
+        return null;
+    }
+    const positionGroups = groupBy(ippMetadata, 'imagePositionPatient');
+    const positions = Object.keys(positionGroups);
+    const frame_count = positionGroups[positions[0]].length;
+    if (frame_count === 1) {
+        return null;
+    }
+    const frame_count_equal = positions.every((k) => positionGroups[k].length === frame_count);
+    if (!frame_count_equal) {
+        return null;
+    }
+    return positionGroups;
+}
+function test4DTag(IPPGroups, value_getter) {
+    const frame_groups = {};
+    let first_frame_value_set = [];
+    const positions = Object.keys(IPPGroups);
+    for (let i = 0; i < positions.length; i++) {
+        const frame_value_set = new Set();
+        const frames = IPPGroups[positions[i]];
+        for (let j = 0; j < frames.length; j++) {
+            const frame_value = value_getter(frames[j].imageId) || 0;
+            frame_groups[frame_value] = frame_groups[frame_value] || [];
+            frame_groups[frame_value].push({ imageId: frames[j].imageId });
+            frame_value_set.add(frame_value);
+            if (frame_value_set.size - 1 < j) {
+                return undefined;
+            }
+        }
+        if (i == 0) {
+            first_frame_value_set = Array.from(frame_value_set);
+        }
+        else if (!setEquals(first_frame_value_set, frame_value_set)) {
+            return undefined;
+        }
+    }
+    return frame_groups;
+}
+function getTagValue(imageId, tag) {
+    const value = metaData.get(tag, imageId);
+    try {
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getPhilipsPrivateBValue(imageId) {
+    const value = metaData.get('20011003', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            const value_bytes = atob(InlineBinary);
+            const ary_buf = new ArrayBuffer(value_bytes.length);
+            const dv = new DataView(ary_buf);
+            for (let i = 0; i < value_bytes.length; i++) {
+                dv.setUint8(i, value_bytes.charCodeAt(i));
+            }
+            return new Float32Array(ary_buf)[0];
+        }
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getSiemensPrivateBValue(imageId) {
+    let value = metaData.get('0019100c', imageId) || metaData.get('0019100C', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            value = atob(InlineBinary);
+        }
+        return parseFloat(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getGEPrivateBValue(imageId) {
+    let value = metaData.get('00431039', imageId);
+    try {
+        const { InlineBinary } = value;
+        if (InlineBinary) {
+            value = atob(InlineBinary).split('//');
+        }
+        return parseFloat(value[0]) % 100000;
+    }
+    catch {
+        return undefined;
+    }
+}
+function setEquals(set_a, set_b) {
+    if (set_a.length != set_b.size) {
+        return false;
+    }
+    for (let i = 0; i < set_a.length; i++) {
+        if (!set_b.has(set_a[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function getPetFrameReferenceTime(imageId) {
+    const moduleInfo = metaData.get('petImageModule', imageId);
+    return moduleInfo ? moduleInfo['frameReferenceTime'] : 0;
+}
+function splitImageIdsBy4DTags(imageIds) {
+    const positionGroups = getIPPGroups(imageIds);
+    if (!positionGroups) {
+        return { imageIdGroups: [imageIds], splittingTag: null };
+    }
+    const tags = [
+        'TemporalPositionIdentifier',
+        'DiffusionBValue',
+        'TriggerTime',
+        'EchoTime',
+        'EchoNumber',
+        'PhilipsPrivateBValue',
+        'SiemensPrivateBValue',
+        'GEPrivateBValue',
+        'PetFrameReferenceTime',
+    ];
+    const fncList2 = [
+        (imageId) => getTagValue(imageId, tags[0]),
+        (imageId) => getTagValue(imageId, tags[1]),
+        (imageId) => getTagValue(imageId, tags[2]),
+        (imageId) => getTagValue(imageId, tags[3]),
+        (imageId) => getTagValue(imageId, tags[4]),
+        getPhilipsPrivateBValue,
+        getSiemensPrivateBValue,
+        getGEPrivateBValue,
+        getPetFrameReferenceTime,
+    ];
+    for (let i = 0; i < fncList2.length; i++) {
+        const frame_groups = test4DTag(positionGroups, fncList2[i]);
+        if (frame_groups) {
+            const sortedKeys = Object.keys(frame_groups)
+                .map(Number.parseFloat)
+                .sort((a, b) => a - b);
+            const imageIdGroups = sortedKeys.map((key) => frame_groups[key].map((item) => item.imageId));
+            return { imageIdGroups, splittingTag: tags[i] };
+        }
+    }
+    return { imageIdGroups: [imageIds], splittingTag: null };
+}
+export default splitImageIdsBy4DTags;

package/dist/esm/utilities/worldToImageCoords.js

@@ -1,7 +1,7 @@
 import { vec3 } from 'gl-matrix';
-import { metaData } from '..';
+import { get } from '../metaData';
 function worldToImageCoords(imageId, worldCoords) {
-    const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
+    const imagePlaneModule = get('imagePlaneModule', imageId);
     if (!imagePlaneModule) {
         throw new Error(`No imagePlaneModule found for imageId: ${imageId}`);
     }