@cornerstonejs/dicom-image-loader 3.10.30 → 3.11.0

package/dist/esm/decodeImageFrameWorker.js

@@ -23,6 +23,7 @@ const typedArrayConstructors = {
     Uint16Array,
     Int16Array,
     Float32Array,
+    Uint32Array,
 };
 function postProcessDecodedPixels(imageFrame, options, start, decodeConfig) {
     const shouldShift = imageFrame.pixelRepresentation !== undefined &&
@@ -69,8 +70,8 @@ function postProcessDecodedPixels(imageFrame, options, start, decodeConfig) {
         const scalingParameters = options.preScale.scalingParameters;
         _validateScalingParameters(scalingParameters);
         const { rescaleSlope, rescaleIntercept } = scalingParameters;
-        const isSlopeAndInterceptNumbers = typeof rescaleSlope === 'number' && typeof rescaleIntercept === 'number';
-        if (isSlopeAndInterceptNumbers) {
+        const isRequiredScaling = _isRequiredScaling(scalingParameters);
+        if (isRequiredScaling) {
             applyModalityLUT(pixelDataArray, scalingParameters);
             imageFrame.preScale = {
                 ...options.preScale,
@@ -100,6 +101,13 @@ function postProcessDecodedPixels(imageFrame, options, start, decodeConfig) {
     imageFrame.decodeTimeInMS = end - start;
     return imageFrame;
 }
+function _isRequiredScaling(scalingParameters) {
+    const { rescaleSlope, rescaleIntercept, modality, doseGridScaling, suvbw } = scalingParameters;
+    const hasRescaleValues = typeof rescaleSlope === 'number' && typeof rescaleIntercept === 'number';
+    const isRTDOSEWithScaling = modality === 'RTDOSE' && typeof doseGridScaling === 'number';
+    const isPTWithSUV = modality === 'PT' && typeof suvbw === 'number';
+    return hasRescaleValues || isRTDOSEWithScaling || isPTWithSUV;
+}
 function _handleTargetBuffer(options, imageFrame, typedArrayConstructors, pixelDataArray) {
     const { arrayBuffer, type, offset: rawOffset = 0, length: rawLength, rows, } = options.targetBuffer;
     const TypedArrayConstructor = typedArrayConstructors[type];

package/dist/esm/imageLoader/createImage.js

@@ -61,6 +61,7 @@ function createImage(imageId, pixelData, transferSyntax, options = {}) {
                     Uint16Array,
                     Int16Array,
                     Float32Array,
+                    Uint32Array,
                 };
                 if (length !== imageFrame.pixelDataLength) {
                     throw new Error(`target array for image does not have the same length (${length}) as the decoded image length (${imageFrame.pixelDataLength}).`);

package/dist/esm/imageLoader/getScalingParameters.d.ts

@@ -1,4 +1,8 @@
 export default function getScalingParameters(metaData: any, imageId: string): {
+    doseGridScaling: any;
+    doseSummation: any;
+    doseType: any;
+    doseUnit: any;
     suvbw: any;
     rescaleSlope: any;
     rescaleIntercept: any;

package/dist/esm/imageLoader/getScalingParameters.js

@@ -8,9 +8,15 @@ export default function getScalingParameters(metaData, imageId) {
         rescaleIntercept: modalityLutModule.rescaleIntercept,
         modality,
     };
-    const suvFactor = metaData.get('scalingModule', imageId) || {};
+    const scalingModules = metaData.get('scalingModule', imageId) || {};
     return {
         ...scalingParameters,
-        ...(modality === 'PT' && { suvbw: suvFactor.suvbw }),
+        ...(modality === 'PT' && { suvbw: scalingModules.suvbw }),
+        ...(modality === 'RTDOSE' && {
+            doseGridScaling: scalingModules.DoseGridScaling,
+            doseSummation: scalingModules.DoseSummation,
+            doseType: scalingModules.DoseType,
+            doseUnit: scalingModules.DoseUnit,
+        }),
     };
 }

package/dist/esm/imageLoader/wadors/combineFrameInstance.js

@@ -3,12 +3,12 @@ function getFrameInformation(PerFrameFunctionalGroupsSequence, SharedFunctionalG
     const shared = (SharedFunctionalGroupsSequence
         ? Object.values(SharedFunctionalGroupsSequence[0])
         : [])
-        .map((it) => it[0])
+        .map((it) => it['Value']?.[0])
         .filter((it) => it !== undefined && typeof it === 'object');
     const perFrame = (PerFrameFunctionalGroupsSequence
         ? Object.values(PerFrameFunctionalGroupsSequence[frameNumber - 1])
         : [])
-        .map((it) => it.Value[0])
+        .map((it) => it['Value']?.[0])
         .filter((it) => it !== undefined && typeof it === 'object');
     return {
         shared,

package/dist/esm/shared/decoders/decodeLittleEndian.js

@@ -22,7 +22,18 @@ async function decodeLittleEndian(imageFrame, pixelData) {
             arrayBuffer = arrayBuffer.slice(offset);
             offset = 0;
         }
-        imageFrame.pixelData = new Float32Array(arrayBuffer, offset, length / 4);
+        if (imageFrame.floatPixelData || imageFrame.doubleFloatPixelData) {
+            throw new Error('Float pixel data is not supported for parsing into ImageFrame');
+        }
+        if (imageFrame.pixelRepresentation === 0) {
+            imageFrame.pixelData = new Uint32Array(arrayBuffer, offset, length / 4);
+        }
+        else if (imageFrame.pixelRepresentation === 1) {
+            imageFrame.pixelData = new Int32Array(arrayBuffer, offset, length / 4);
+        }
+        else {
+            imageFrame.pixelData = new Float32Array(arrayBuffer, offset, length / 4);
+        }
     }
     return imageFrame;
 }

package/dist/esm/shared/getPixelDataTypeFromMinMax.js

@@ -8,6 +8,9 @@ export default function getPixelDataTypeFromMinMax(min, max) {
             else if (max <= 65535) {
                 pixelDataType = Uint16Array;
             }
+            else if (max <= 4294967295) {
+                pixelDataType = Uint32Array;
+            }
         }
         else {
             if (min >= -128 && max <= 127) {

package/dist/esm/shared/scaling/scaleArray.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/dicom-image-loader",
-  "version": "3.10.30",
+  "version": "3.11.0",
   "description": "Cornerstone Image Loader for DICOM WADO-URI and WADO-RS and Local file",
   "keywords": [
     "DICOM",
@@ -116,7 +116,7 @@
     "uuid": "^9.0.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.10.30",
+    "@cornerstonejs/core": "^3.11.0",
     "dicom-parser": "^1.8.9"
   },
   "lint-staged": {
@@ -131,5 +131,5 @@
       "path": "./node_modules/cz-conventional-changelog"
     }
   },
-  "gitHead": "884fc7a5c0a10dc9b10dbfe43dda583ad48c3f17"
+  "gitHead": "e051da49a8fb4e7559861e9d3de08fdeb108c53b"
 }