Trim padding byte from numeric strings if they exceed VR max length

Author: Craig Berry

src/ValueRepresentation.js

@@ -661,22 +661,33 @@ class DateValue extends AsciiStringRepresentation {
     }
 }
 
-class DecimalString extends AsciiStringRepresentation {
-    constructor() {
-        super("DS");
-        this.maxLength = 16;
-        this.padByte = PADDING_SPACE;
-    }
+class NumericStringRepresentation extends AsciiStringRepresentation {
 
     readBytes(stream, length) {
         const BACKSLASH = String.fromCharCode(VM_DELIMITER);
-        const ds = stream.readAsciiString(length);
-        if (ds.indexOf(BACKSLASH) !== -1) {
-            // handle decimal string with multiplicity
-            return ds.split(BACKSLASH);
+        const numStr = stream.readAsciiString(length);
+        const nums = numStr.split(BACKSLASH);
+
+        // final element in list may have a padding byte for even length, this should be removed as it is not part of
+        // the original value and prevents max length issues during write
+        if (nums.length > 1) {
+            const last = nums[nums.length - 1];
+
+            // trim padding byte if last element exceeds length
+            if (last.length > this.maxLength) {
+                nums[nums.length - 1] = last.substring(0, this.maxLength);
+            }
         }
 
-        return [ds];
+        return nums;
+    }
+}
+
+class DecimalString extends NumericStringRepresentation {
+    constructor() {
+        super("DS");
+        this.maxLength = 16;
+        this.padByte = PADDING_SPACE;
     }
 
     applyFormatting(value) {
@@ -694,6 +705,7 @@ class DecimalString extends AsciiStringRepresentation {
 
     convertToString(value) {
         if (value === null) return "";
+        if (typeof value === 'string') return value;
 
         let str = String(value);
         if (str.length > this.maxLength) {
@@ -798,25 +810,13 @@ class FloatingPointDouble extends ValueRepresentation {
     }
 }
 
-class IntegerString extends AsciiStringRepresentation {
+class IntegerString extends NumericStringRepresentation {
     constructor() {
         super("IS");
         this.maxLength = 12;
         this.padByte = PADDING_SPACE;
     }
 
-    readBytes(stream, length) {
-        const BACKSLASH = String.fromCharCode(VM_DELIMITER);
-        const is = stream.readAsciiString(length);
-
-        if (is.indexOf(BACKSLASH) !== -1) {
-            // handle integer string with multiplicity
-            return is.split(BACKSLASH);
-        }
-
-        return [is];
-    }
-
     applyFormatting(value) {
         const formatNumber = (numberStr) => {
             let returnVal = numberStr.trim().replace(/[^0-9.\\\-+e]/gi, "");
@@ -831,6 +831,7 @@ class IntegerString extends AsciiStringRepresentation {
     }
 
     convertToString(value) {
+        if (typeof value === 'string') return value;
         return value === null ? "" : String(value);
     }
 

test/lossless-read-write.test.js

@@ -128,6 +128,70 @@ describe('lossless-read-write', () => {
         expect(outputDicomDict.dict['00181041'].Value).toEqual([9007199254740992])
     });
 
+    test('test DS with multiplicity > 1 and added space for even padding is read and written correctly', () => {
+        const dataset = {
+            '00200037': {
+                vr: 'DS',
+                Value: [0.99924236548978, -0.0322633220972, -0.0217663285287, 0.02949870928067, 0.99267261121054, -0.1171789789306]
+            }
+        };
+
+        const dicomDict = new DicomDict({});
+        dicomDict.dict = dataset;
+
+        // write and re-read
+        const outputDicomDict = DicomMessage.readFile(dicomDict.write());
+
+        // ensure _rawValue strings have no added trailing spaces
+        const expectedDataset = {
+            '00200037': {
+                vr: 'DS',
+                Value: [0.99924236548978, -0.0322633220972, -0.0217663285287, 0.02949870928067, 0.99267261121054, -0.1171789789306],
+                _rawValue: ["0.99924236548978", "-0.0322633220972", "-0.0217663285287", "0.02949870928067", "0.99267261121054", "-0.1171789789306"]
+            }
+        };
+
+        expect(deepEqual(expectedDataset, outputDicomDict.dict)).toBeTruthy();
+
+        // re-write should succeeed
+        const outputDicomDictPass2 = DicomMessage.readFile(dicomDict.write());
+
+        // dataset should still be equal
+        expect(deepEqual(expectedDataset, outputDicomDictPass2.dict)).toBeTruthy();
+    });
+
+    test('test IS with multiplicity > 1 and added space for even padding is read and written correctly', () => {
+        const dataset = {
+            '00081160': {
+                vr: 'IS',
+                Value: [1234, 5678]
+            }
+        };
+
+        const dicomDict = new DicomDict({});
+        dicomDict.dict = dataset;
+
+        // write and re-read
+        const outputDicomDict = DicomMessage.readFile(dicomDict.write());
+
+        // ensure _rawValue strings have no added trailing spaces
+        const expectedDataset = {
+            '00081160': {
+                vr: 'IS',
+                Value: [1234, 5678],
+                _rawValue: ["1234", "5678 "]
+            }
+        };
+
+        expect(deepEqual(expectedDataset, outputDicomDict.dict)).toBeTruthy();
+
+        // re-write should succeeed
+        const outputDicomDictPass2 = DicomMessage.readFile(dicomDict.write());
+
+        // dataset should still be equal
+        expect(deepEqual(expectedDataset, outputDicomDictPass2.dict)).toBeTruthy();
+    });
+
     describe('Individual VR comparisons', () => {
 
         const unchangedTestCases = [