dcmjs 0.23.1 → 0.24.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcmjs",
-  "version": "0.23.1",
+  "version": "0.24.2",
   "description": "Javascript implementation of DICOM manipulation",
   "main": "build/dcmjs.js",
   "module": "build/dcmjs.es.js",

package/test/data-options.test.js

@@ -0,0 +1,237 @@
+import "regenerator-runtime/runtime.js";
+
+import dcmjs from "../src/index.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import followRedirects from "follow-redirects";
+const { https } = followRedirects;
+import { promisify } from "util";
+import unzipper from "unzipper";
+import fsPromises from "fs/promises";
+
+const {
+    DicomMetaDictionary,
+    DicomDict,
+    DicomMessage,
+    ReadBufferStream
+} = dcmjs.data;
+
+function downloadToFile(url, filePath) {
+    return new Promise((resolve, reject) => {
+        const fileStream = fs.createWriteStream(filePath);
+        https
+            .get(url, response => {
+                response.pipe(fileStream);
+                fileStream.on("finish", () => {
+                    resolve(filePath);
+                });
+            })
+            .on("error", reject);
+    });
+}
+
+const areEqual = (first, second) =>
+    first.byteLength === second.byteLength &&
+    first.every((value, index) => value === second[index]);
+
+it("test_untilTag", () => {
+    const buffer = fs.readFileSync("test/sample-dicom.dcm");
+    console.time("readFile");
+    const fullData = DicomMessage.readFile(buffer.buffer);
+    console.timeEnd("readFile");
+
+    console.time("readFile without untilTag");
+    const dicomData = DicomMessage.readFile(buffer.buffer, {
+        untilTag: "7FE00010",
+        includeUntilTagValue: false
+    });
+    console.timeEnd("readFile without untilTag");
+
+    console.time("readFile with untilTag");
+    const dicomData2 = DicomMessage.readFile(buffer.buffer, {
+        untilTag: "7FE00010",
+        includeUntilTagValue: true
+    });
+    console.timeEnd("readFile with untilTag");
+
+    const full_dataset = DicomMetaDictionary.naturalizeDataset(fullData.dict);
+    full_dataset._meta = DicomMetaDictionary.namifyDataset(fullData.meta);
+
+    const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+    dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+
+    const dataset2 = DicomMetaDictionary.naturalizeDataset(dicomData2.dict);
+    dataset2._meta = DicomMetaDictionary.namifyDataset(dicomData2.meta);
+
+    expect(full_dataset.PixelData).toEqual(dataset2.PixelData);
+    expect(dataset.PixelData).toEqual(0);
+});
+
+it("noCopy multiframe DICOM which has trailing padding", async () => {
+    const dicomUrl =
+        "https://github.com/dcmjs-org/data/releases/download/binary-parsing-stressors/multiframe-ultrasound.dcm";
+    const dicomPath = path.join(os.tmpdir(), "multiframe-ultrasound.dcm");
+
+    await downloadToFile(dicomUrl, dicomPath);
+
+    const dicomDictNoCopy = DicomMessage.readFile(
+        fs.readFileSync(dicomPath).buffer,
+        {
+            noCopy: true
+        }
+    );
+
+    const dicomDict = DicomMessage.readFile(fs.readFileSync(dicomPath).buffer, {
+        noCopy: false
+    });
+
+    Object.keys(dicomDict.dict).map(key => {
+        const value = dicomDict.dict[key].Value;
+        if (value[0] instanceof ArrayBuffer) {
+            value.map((e, idx) => {
+                const noCopyValue = dicomDictNoCopy.dict[key].Value[idx];
+                const copyValue = new Uint8Array(e);
+                expect(areEqual(noCopyValue, copyValue)).toEqual(true);
+            });
+        }
+    });
+});
+
+it("noCopy multiframe DICOM with large private tags before and after the image data", async () => {
+    const dicomUrl =
+        "https://github.com/dcmjs-org/data/releases/download/binary-parsing-stressors/large-private-tags.dcm";
+    const dicomPath = path.join(os.tmpdir(), "large-private-tags.dcm");
+
+    await downloadToFile(dicomUrl, dicomPath);
+
+    const dicomDictNoCopy = DicomMessage.readFile(
+        fs.readFileSync(dicomPath).buffer,
+        {
+            noCopy: true
+        }
+    );
+
+    const dicomDict = DicomMessage.readFile(fs.readFileSync(dicomPath).buffer, {
+        noCopy: false
+    });
+
+    Object.keys(dicomDict.dict).map(key => {
+        const value = dicomDict.dict[key].Value;
+        if (value[0] instanceof ArrayBuffer) {
+            value.map((e, idx) => {
+                const noCopyValue = dicomDictNoCopy.dict[key].Value[idx];
+                const copyValue = new Uint8Array(e);
+                expect(areEqual(noCopyValue, copyValue)).toEqual(true);
+            });
+        }
+    });
+});
+
+it("noCopy binary data into an ArrayBuffer", async () => {
+    const dicomUrl =
+        "https://github.com/dcmjs-org/data/releases/download/binary-tag/binary-tag.dcm";
+    const dicomPath = path.join(os.tmpdir(), "binary-tag.dcm");
+
+    await downloadToFile(dicomUrl, dicomPath);
+    const fileData = await promisify(fs.readFile)(dicomPath);
+
+    const dicomDictNoCopy = DicomMessage.readFile(fileData.buffer, {
+        noCopy: true
+    });
+
+    const dicomDict = DicomMessage.readFile(fileData.buffer, {
+        noCopy: false
+    });
+
+    Object.keys(dicomDict.dict).map(key => {
+        const value = dicomDict.dict[key].Value;
+        if (value[0] instanceof ArrayBuffer) {
+            value.map((e, idx) => {
+                const noCopyValue = dicomDictNoCopy.dict[key].Value[idx];
+                const copyValue = new Uint8Array(e);
+                expect(areEqual(noCopyValue, copyValue)).toEqual(true);
+            });
+        }
+    });
+});
+
+it("noCopy test_multiframe_1", async () => {
+    const url =
+        "https://github.com/dcmjs-org/data/releases/download/MRHead/MRHead.zip";
+    const zipFilePath = path.join(os.tmpdir(), "MRHead.zip");
+    const unzipPath = path.join(os.tmpdir(), "test_multiframe_1");
+
+    await downloadToFile(url, zipFilePath);
+
+    await new Promise(resolve => {
+        fs.createReadStream(zipFilePath).pipe(
+            unzipper.Extract({ path: unzipPath }).on("close", resolve)
+        );
+    });
+
+    const mrHeadPath = path.join(unzipPath, "MRHead");
+    const fileNames = await fsPromises.readdir(mrHeadPath);
+
+    const datasets = [];
+    fileNames.forEach(fileName => {
+        const arrayBuffer = fs.readFileSync(path.join(mrHeadPath, fileName))
+            .buffer;
+        const dicomDictNoCopy = DicomMessage.readFile(arrayBuffer, {
+            noCopy: true
+        });
+        const dicomDict = DicomMessage.readFile(arrayBuffer, {
+            noCopy: false
+        });
+
+        Object.keys(dicomDict.dict).map(key => {
+            const value = dicomDict.dict[key].Value;
+            if (value[0] instanceof ArrayBuffer) {
+                value.map((e, idx) => {
+                    const noCopyValue = dicomDictNoCopy.dict[key].Value[idx];
+                    const copyValue = new Uint8Array(e);
+                    expect(areEqual(noCopyValue, copyValue)).toEqual(true);
+                });
+            }
+        });
+    });
+});
+
+it("noCopy test_fragment_multiframe", async () => {
+    const url =
+        "https://github.com/dcmjs-org/data/releases/download/encapsulation/encapsulation-fragment-multiframe.dcm";
+    const dcmPath = path.join(
+        os.tmpdir(),
+        "encapsulation-fragment-multiframe.dcm"
+    );
+
+    await downloadToFile(url, dcmPath);
+    const file = fs.readFileSync(dcmPath);
+
+    const dicomDict = dcmjs.data.DicomMessage.readFile(file.buffer, {
+        // ignoreErrors: true,
+    });
+
+    const dicomDictNoCopy = DicomMessage.readFile(file.buffer, {
+        noCopy: true
+    });
+
+    Object.keys(dicomDict.dict).map(key => {
+        const value = dicomDict.dict[key].Value;
+        if (value[0] instanceof ArrayBuffer) {
+            value.map((e, idx) => {
+                const noCopyValue = dicomDictNoCopy.dict[key].Value[idx];
+                const copyValue = new Uint8Array(e);
+                const areEqual = (first, second) =>
+                    first.every((value, index) => value === second[index]);
+
+                const totalSize = noCopyValue.reduce(
+                    (sum, arr) => sum + arr.byteLength,
+                    0
+                );
+                expect(totalSize).toEqual(copyValue.length);
+                expect(areEqual(noCopyValue[0], copyValue)).toEqual(true);
+            });
+        }
+    });
+});

package/test/data.test.js

@@ -8,6 +8,7 @@ import os from "os";
 import path from "path";
 import unzipper from "unzipper";
 import followRedirects from "follow-redirects";
+import { promisify } from "util";
 
 const { https } = followRedirects;
 
@@ -16,8 +17,12 @@ import minimalDataset from "./mocks/minimal_fields_dataset.json";
 import arrayItem from "./arrayItem.json";
 import { rawTags } from "./rawTags";
 
-const { DicomMetaDictionary, DicomDict, DicomMessage, ReadBufferStream } =
-    dcmjs.data;
+const {
+    DicomMetaDictionary,
+    DicomDict,
+    DicomMessage,
+    ReadBufferStream
+} = dcmjs.data;
 
 const EXPLICIT_LITTLE_ENDIAN = "1.2.840.10008.1.2.1";
 
@@ -170,8 +175,9 @@ it("test_json_1", () => {
     //
     // make a natural version of a dataset with sequence tags and confirm it has correct values
     //
-    const naturalSequence =
-        DicomMetaDictionary.naturalizeDataset(sequenceMetadata);
+    const naturalSequence = DicomMetaDictionary.naturalizeDataset(
+        sequenceMetadata
+    );
 
     // The match object needs to be done on the actual element, not the proxied value
     expect(naturalSequence.ProcedureCodeSequence[0]).toMatchObject({
@@ -233,17 +239,17 @@ it("test_multiframe_1", async () => {
 
     const datasets = [];
     fileNames.forEach(fileName => {
-        const arrayBuffer = fs.readFileSync(
-            path.join(mrHeadPath, fileName)
-        ).buffer;
+        const arrayBuffer = fs.readFileSync(path.join(mrHeadPath, fileName))
+            .buffer;
         const dicomDict = DicomMessage.readFile(arrayBuffer);
         const dataset = DicomMetaDictionary.naturalizeDataset(dicomDict.dict);
 
         datasets.push(dataset);
     });
 
-    const multiframe =
-        dcmjs.normalizers.Normalizer.normalizeToDataset(datasets);
+    const multiframe = dcmjs.normalizers.Normalizer.normalizeToDataset(
+        datasets
+    );
     const spacing =
         multiframe.SharedFunctionalGroupsSequence.PixelMeasuresSequence
             .SpacingBetweenSlices;
@@ -279,9 +285,8 @@ it("test_oneslice_seg", async () => {
 
     const datasets = [];
     fileNames.forEach(fileName => {
-        const arrayBuffer = fs.readFileSync(
-            path.join(ctPelvisPath, fileName)
-        ).buffer;
+        const arrayBuffer = fs.readFileSync(path.join(ctPelvisPath, fileName))
+            .buffer;
         const dicomDict = DicomMessage.readFile(arrayBuffer);
         const dataset = DicomMetaDictionary.naturalizeDataset(dicomDict.dict);
         datasets.push(dataset);
@@ -307,8 +312,9 @@ it("test_oneslice_seg", async () => {
 });
 
 it("test_normalizer_smaller", () => {
-    const naturalizedTags =
-        dcmjs.data.DicomMetaDictionary.naturalizeDataset(rawTags);
+    const naturalizedTags = dcmjs.data.DicomMetaDictionary.naturalizeDataset(
+        rawTags
+    );
 
     const rawTagsLen = JSON.stringify(rawTags).length;
     const naturalizedTagsLen = JSON.stringify(naturalizedTags).length;
@@ -451,39 +457,6 @@ it("test_invalid_vr_length", () => {
     }
 });
 
-it("test_untiltag", () => {
-    const buffer = fs.readFileSync("test/sample-dicom.dcm");
-    console.time("readFile");
-    const fullData = DicomMessage.readFile(buffer.buffer);
-    console.timeEnd("readFile");
-
-    console.time("readFile without untilTag");
-    const dicomData = DicomMessage.readFile(buffer.buffer, {
-        untilTag: "7FE00010",
-        includeUntilTagValue: false
-    });
-    console.timeEnd("readFile without untilTag");
-
-    console.time("readFile with untilTag");
-    const dicomData2 = DicomMessage.readFile(buffer.buffer, {
-        untilTag: "7FE00010",
-        includeUntilTagValue: true
-    });
-    console.timeEnd("readFile with untilTag");
-
-    const full_dataset = DicomMetaDictionary.naturalizeDataset(fullData.dict);
-    full_dataset._meta = DicomMetaDictionary.namifyDataset(fullData.meta);
-
-    const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
-    dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
-
-    const dataset2 = DicomMetaDictionary.naturalizeDataset(dicomData2.dict);
-    dataset2._meta = DicomMetaDictionary.namifyDataset(dicomData2.meta);
-
-    expect(full_dataset.PixelData).toEqual(dataset2.PixelData);
-    expect(dataset.PixelData).toEqual(0);
-});
-
 it("test_encapsulation", async () => {
     const url =
         "https://github.com/dcmjs-org/data/releases/download/encapsulation/encapsulation.dcm";
@@ -530,10 +503,10 @@ it("test_encapsulation", async () => {
         throw new Error("Invalid a dicom file");
     }
 
-    const el = DicomMessage.readTag(stream, useSyntax),
+    const el = DicomMessage._readTag(stream, useSyntax),
         metaLength = el.values[0]; //read header buffer
     const metaStream = stream.more(metaLength);
-    const metaHeader = DicomMessage.read(metaStream, useSyntax, false); //get the syntax
+    const metaHeader = DicomMessage._read(metaStream, useSyntax); //get the syntax
     let mainSyntax = metaHeader["00020010"].Value[0];
 
     mainSyntax = DicomMessage._normalizeSyntax(mainSyntax);
@@ -564,7 +537,7 @@ it("test_encapsulation", async () => {
             lengths.push(length);
         }
 
-        DicomMessage.readTag(stream, mainSyntax, null, false);
+        DicomMessage._readTag(stream, mainSyntax);
     }
 
     // then
@@ -595,3 +568,76 @@ it("test_custom_dictionary", () => {
     //check that all other fields were preserved, 15 original + 1 for _vr and +1 for "TrialName"
     expect(Object.keys(dataset).length).toEqual(17);
 });
+
+it("Reads DICOM with multiplicity", async () => {
+    const url =
+        "https://github.com/dcmjs-org/data/releases/download/multiplicity/multiplicity.dcm";
+    const dcmPath = path.join(os.tmpdir(), "multiplicity.dcm");
+
+    await downloadToFile(url, dcmPath);
+
+    const file = await promisify(fs.readFile)(dcmPath);
+    const dicomDict = DicomMessage.readFile(file.buffer);
+
+    expect(dicomDict.dict["00101020"].Value).toEqual([1, 2]);
+    expect(dicomDict.dict["0018100B"].Value).toEqual(["1.2", "3.4"]);
+});
+
+it("Reads binary data into an ArrayBuffer", async () => {
+    const dicomUrl =
+        "https://github.com/dcmjs-org/data/releases/download/binary-tag/binary-tag.dcm";
+    const dicomPath = path.join(os.tmpdir(), "binary-tag.dcm");
+
+    await downloadToFile(dicomUrl, dicomPath);
+
+    const fileData = await promisify(fs.readFile)(dicomPath);
+    const dicomDict = DicomMessage.readFile(fileData.buffer);
+    const dataset = dcmjs.data.DicomMetaDictionary.naturalizeDataset(
+        dicomDict.dict
+    );
+
+    expect(dataset.PixelData).toBeInstanceOf(Array);
+    expect(dataset.PixelData[0]).toBeInstanceOf(ArrayBuffer);
+    expect([...new Uint8Array(dataset.PixelData[0])]).toEqual([2, 3, 4, 5, 6]);
+});
+
+it("Reads a multiframe DICOM which has trailing padding", async () => {
+    const dicomUrl =
+        "https://github.com/dcmjs-org/data/releases/download/binary-parsing-stressors/multiframe-ultrasound.dcm";
+    const dicomPath = path.join(os.tmpdir(), "multiframe-ultrasound.dcm");
+
+    await downloadToFile(dicomUrl, dicomPath);
+
+    const dicomDict = DicomMessage.readFile(fs.readFileSync(dicomPath).buffer);
+    const dataset = dcmjs.data.DicomMetaDictionary.naturalizeDataset(
+        dicomDict.dict
+    );
+
+    expect(dataset.PixelData.length).toEqual(29);
+    expect(dataset.PixelData[0]).toBeInstanceOf(ArrayBuffer);
+    expect(dataset.PixelData[0].byteLength).toEqual(104976);
+    expect(dataset.PixelData[1].byteLength).toEqual(104920);
+    expect(dataset.PixelData[27].byteLength).toEqual(103168);
+    expect(dataset.PixelData[28].byteLength).toEqual(103194);
+});
+
+it("Reads a multiframe DICOM with large private tags before and after the image data", async () => {
+    const dicomUrl =
+        "https://github.com/dcmjs-org/data/releases/download/binary-parsing-stressors/large-private-tags.dcm";
+    const dicomPath = path.join(os.tmpdir(), "large-private-tags.dcm");
+
+    await downloadToFile(dicomUrl, dicomPath);
+
+    const dicomDict = DicomMessage.readFile(fs.readFileSync(dicomPath).buffer);
+    const dataset = dcmjs.data.DicomMetaDictionary.naturalizeDataset(
+        dicomDict.dict
+    );
+
+    expect(dataset.PixelData).toBeInstanceOf(Array);
+    expect(dataset.PixelData.length).toEqual(130);
+    expect(dataset.PixelData[0]).toBeInstanceOf(ArrayBuffer);
+    expect(dataset.PixelData[0].byteLength).toEqual(61518);
+    expect(dataset.PixelData[1].byteLength).toEqual(61482);
+    expect(dataset.PixelData[128].byteLength).toEqual(62144);
+    expect(dataset.PixelData[129].byteLength).toEqual(62148);
+});

package/test/untilTag.test.js

@@ -1,44 +0,0 @@
-import dcmjs from "../src/index.js";
-import fs from "fs";
-
-it("test_untilTag", () => {
-    const buffer = fs.readFileSync("test/sample-dicom.dcm");
-
-    const { DicomMessage, DicomMetaDictionary } = dcmjs.data;
-
-    console.time("readFile");
-    const fullData = DicomMessage.readFile(buffer.buffer);
-    console.timeEnd("readFile");
-
-    console.time("readFile without untilTag");
-    const dicomData = DicomMessage.readFile(buffer.buffer, {
-        untilTag: "7FE00010",
-        includeUntilTagValue: false
-    });
-    console.timeEnd("readFile without untilTag");
-
-    console.time("readFile with untilTag");
-    const dicomData2 = DicomMessage.readFile(buffer.buffer, {
-        untilTag: "7FE00010",
-        includeUntilTagValue: true
-    });
-    console.timeEnd("readFile with untilTag");
-
-    const full_dataset = DicomMetaDictionary.naturalizeDataset(fullData.dict);
-    full_dataset._meta = DicomMetaDictionary.namifyDataset(fullData.meta);
-
-    // console.log(full_dataset.PixelData);
-
-    const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
-    dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
-
-    // console.log(dataset.PixelData);
-
-    const dataset2 = DicomMetaDictionary.naturalizeDataset(dicomData2.dict);
-    dataset2._meta = DicomMetaDictionary.namifyDataset(dicomData2.meta);
-
-    // console.log(dataset2.PixelData);
-
-    expect(full_dataset.PixelData).toEqual(dataset2.PixelData);
-    expect(dataset.PixelData).toEqual(0);
-});