dcmjs 0.49.4 → 0.50.0

package/test/sr-tid.test.js

@@ -1,251 +0,0 @@
-import { utilities } from "../src";
-
-const {
-    Length,
-    Circle,
-    Polygon,
-    Polyline,
-    Ellipse,
-    Bidirectional,
-    Calibration
-} = utilities.TID300;
-
-describe("DICOM SR TID 300/1500 tests", () => {
-    describe("TID300 Creation", () => {
-        it("Polygon Create", () => {
-            const props = {
-                points: [
-                    { x: 3, y: 5 },
-                    { x: 6, y: 1 }
-                ],
-                unit: "mm",
-                areaUnit: "mm2",
-                area: 3.14,
-                perimeter: 25
-            };
-            const polyline = new Polygon(props);
-            const value = polyline.contentItem();
-            expect(value.length).toBe(4);
-            const measured = value[2].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(props.perimeter);
-            expect(value[3].MeasuredValueSequence.NumericValue).toBe(
-                props.area
-            );
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("mm");
-        });
-
-        it("Polyline Create", () => {
-            const props = {
-                points: [
-                    { x: 3, y: 5 },
-                    { x: 6, y: 1 }
-                ],
-                unit: "mm",
-                areaUnit: "mm2",
-                area: 3.14,
-                perimeter: 25
-            };
-            const polyline = new Polyline(props);
-            const value = polyline.contentItem();
-            expect(value.length).toBe(4);
-            const measured = value[2].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(props.perimeter);
-            expect(value[3].MeasuredValueSequence.NumericValue).toBe(
-                props.area
-            );
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("mm");
-        });
-
-        it("Ellipse Create", () => {
-            const r = 10;
-            const props = {
-                points: [
-                    { x: 3, y: 5 },
-                    { x: 6, y: 1 }
-                ],
-                areaUnit: "mm\xB2",
-                area: 3.141592 * r * r
-            };
-            const circle = new Ellipse(props);
-            const value = circle.contentItem();
-            expect(value.length).toBe(3);
-            const measured = value[2].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(props.area);
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("mm2");
-        });
-
-        it("Bidirectional Create", () => {
-            const bidir = new Bidirectional({
-                longAxis: {
-                    point1: { x: 3, y: 5 },
-                    point2: { x: 6, y: 1 }
-                },
-                shortAxis: {
-                    point1: { x: 3, y: 5 },
-                    point2: { x: 6, y: 1 }
-                },
-                unit: "mm",
-                longAxisLength: 3.14,
-                shortAxisLenght: 1.5
-            });
-            const value = bidir.contentItem();
-            expect(value.length).toBe(4);
-            const measured = value[2].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(3.14);
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("mm");
-        });
-
-        it("Length Create", () => {
-            const length = new Length({
-                point1: { x: 3, y: 5 },
-                point2: { x: 6, y: 1 },
-                unit: "mm",
-                distance: 3.14
-            });
-            const value = length.contentItem();
-            expect(value.length).toBe(3);
-            const measured = value[2].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(3.14);
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("mm");
-        });
-
-        it("Circle Create", () => {
-            const r = 10;
-            const props = {
-                points: [
-                    { x: 3, y: 5 },
-                    { x: 6, y: 1 }
-                ],
-                unit: "mm",
-                areaUnit: "mm\xB2",
-                perimeter: 2 * 3.141592 * r,
-                area: 3.141592 * r * r
-            };
-            const circle = new Circle(props);
-            const value = circle.contentItem();
-            expect(value.length).toBe(4);
-            const measured = value[3].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(props.area);
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("mm2");
-        });
-
-        it("Calibration Create", () => {
-            const calibration = new Calibration({
-                point1: { x: 3, y: 5 },
-                point2: { x: 6, y: 1 },
-                unit: "mm",
-                distance: 3.14
-            });
-            const value = calibration.contentItem();
-            expect(value.length).toBe(3);
-            const measured = value[2].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(3.14);
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("mm");
-        });
-    });
-
-    describe("Use Units", () => {
-        it("Length Units", () => {
-            const length = new Length({
-                point1: { x: 3, y: 5 },
-                point2: { x: 6, y: 1 },
-                unit: "px",
-                distance: 3.14
-            });
-            const value = length.contentItem();
-            expect(value.length).toBe(3);
-            const measured = value[2].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(3.14);
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("1");
-        });
-
-        it("Polygon Units", () => {
-            const props = {
-                points: [
-                    { x: 3, y: 5 },
-                    { x: 6, y: 1 }
-                ],
-                unit: "px",
-                areaUnit: "px\xB2",
-                area: 3.14,
-                perimeter: 25
-            };
-            const polyline = new Polygon(props);
-            const value = polyline.contentItem();
-            expect(value.length).toBe(4);
-            const measured = value[2].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(props.perimeter);
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("1");
-        });
-
-        it("Polyline Units", () => {
-            const props = {
-                points: [
-                    { x: 3, y: 5 },
-                    { x: 6, y: 1 }
-                ],
-                unit: "px",
-                areaUnit: "px\xB2",
-                area: 3.14,
-                perimeter: 25
-            };
-            const polyline = new Polyline(props);
-            const value = polyline.contentItem();
-            expect(value.length).toBe(4);
-            const measured = value[2].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(props.perimeter);
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("1");
-        });
-
-        it("Ellipse Unit", () => {
-            const r = 10;
-            const props = {
-                points: [
-                    { x: 3, y: 5 },
-                    { x: 6, y: 1 }
-                ],
-                areaUnit: "px\xB2",
-                area: 3.141592 * r * r
-            };
-            const circle = new Ellipse(props);
-            const value = circle.contentItem();
-            expect(value.length).toBe(3);
-            const measured = value[2].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(props.area);
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("1");
-        });
-
-        it("Bidirectional Create", () => {
-            const bidir = new Bidirectional({
-                longAxis: {
-                    point1: { x: 3, y: 5 },
-                    point2: { x: 6, y: 1 }
-                },
-                shortAxis: {
-                    point1: { x: 3, y: 5 },
-                    point2: { x: 6, y: 1 }
-                },
-                unit: "px",
-                longAxisLength: 3.14,
-                shortAxisLenght: 1.5
-            });
-            const value = bidir.contentItem();
-            expect(value.length).toBe(4);
-            const measured = value[2].MeasuredValueSequence;
-            expect(measured.NumericValue).toBe(3.14);
-            const units = measured.MeasurementUnitsCodeSequence;
-            expect(units.CodeValue).toBe("1");
-        });
-    });
-});

package/test/testUtils.js

@@ -1,85 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import followRedirects from "follow-redirects";
-import AdmZip from "adm-zip";
-import { validationLog } from "./../src/log.js";
-
-const { https } = followRedirects;
-
-// Don't show validation errors, as those are normally tested
-validationLog.setLevel(5);
-
-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);
-    });
-}
-
-function unzip(zipFilePath, targetPath) {
-    return new Promise((resolve, reject) => {
-        try {
-            // reading archives
-            var zip = new AdmZip(zipFilePath);
-            // extracts everything
-            zip.extractAllTo(targetPath, true);
-            resolve();
-        } catch (e) {
-            reject(e);
-        }
-    });
-
-    // This code is broken in Node 18+, creating garbage output
-    // return new Promise(resolve => {
-    //       fs.createReadStream(zipFilePath).pipe(
-    //           unzipper.Extract({ path: targetPath }).on("close", resolve)
-    //       );
-    //   });
-}
-
-function ensureTestDataDir() {
-    var targetPath = path.join(os.tmpdir(), "dcmjs-test");
-    if (!fs.existsSync(targetPath)) {
-        fs.mkdirSync(targetPath);
-    }
-    return targetPath;
-}
-
-async function getZippedTestDataset(url, filename, unpackDirectory) {
-    const dir = ensureTestDataDir();
-    const targetPath = path.join(dir, filename);
-    const unpackPath = path.join(dir, unpackDirectory);
-    if (!fs.existsSync(unpackPath)) {
-        await downloadToFile(url, targetPath);
-        await unzip(targetPath, unpackPath);
-    }
-    return unpackPath;
-}
-
-/**
- * Stores the required downloads to prevent async reading before download completed.
- */
-const asyncDownloadMap = new Map();
-
-async function getTestDataset(url, filename) {
-    const dir = ensureTestDataDir();
-    const targetPath = path.join(dir, filename);
-    let filePromise = asyncDownloadMap.get(targetPath);
-    if (!filePromise && !fs.existsSync(targetPath)) {
-        filePromise = downloadToFile(url, targetPath);
-        asyncDownloadMap.set(targetPath, filePromise);
-    }
-    // This returns immediately if filePromise is undefined - eg if the file already downloaded.
-    await filePromise;
-    return targetPath;
-}
-
-export { getTestDataset, getZippedTestDataset };

package/test/utilities/deepEqual.test.js

@@ -1,87 +0,0 @@
-import { deepEqual } from "../../src/utilities/deepEqual";
-
-describe("deepEqual", () => {
-    test("returns true for identical primitives", () => {
-        expect(deepEqual(42, 42)).toBe(true);
-        expect(deepEqual("hello", "hello")).toBe(true);
-        expect(deepEqual(true, true)).toBe(true);
-        expect(deepEqual(null, null)).toBe(true);
-    });
-
-    test("returns false for different primitives", () => {
-        expect(deepEqual(42, 43)).toBe(false);
-        expect(deepEqual("hello", "world")).toBe(false);
-        expect(deepEqual(true, false)).toBe(false);
-        expect(deepEqual(null, undefined)).toBe(false);
-    });
-
-    test("returns same value check for signed zeros and special numbers", () => {
-        expect(deepEqual(Math.NaN, Math.NaN)).toBe(true);
-        expect(deepEqual(-0, 0)).toBe(false);
-        expect(deepEqual(-0, +0)).toBe(false);
-    });
-
-    test("returns true for deeply equal objects", () => {
-        const obj1 = { a: 1, b: { c: 2 } };
-        const obj2 = { a: 1, b: { c: 2 } };
-        expect(deepEqual(obj1, obj2)).toBe(true);
-    });
-
-    test("returns false for objects with different structures", () => {
-        const obj1 = { a: 1, b: { c: 2 } };
-        const obj2 = { a: 1, b: { d: 2 } };
-        expect(deepEqual(obj1, obj2)).toBe(false);
-    });
-
-    test("returns false for objects with different values", () => {
-        const obj1 = { a: 1, b: { c: 2 } };
-        const obj2 = { a: 1, b: { c: 3 } };
-        expect(deepEqual(obj1, obj2)).toBe(false);
-    });
-
-    test("returns true for deeply equal arrays", () => {
-        const arr1 = [1, 2, { a: 3 }];
-        const arr2 = [1, 2, { a: 3 }];
-        expect(deepEqual(arr1, arr2)).toBe(true);
-    });
-
-    test("returns false for arrays with different values", () => {
-        const arr1 = [1, 2, { a: 3 }];
-        const arr2 = [1, 2, { a: 4 }];
-        expect(deepEqual(arr1, arr2)).toBe(false);
-    });
-
-    test("returns false for objects compared with arrays", () => {
-        const obj = { a: 1, b: 2 };
-        const arr = [1, 2];
-        expect(deepEqual(obj, arr)).toBe(false);
-    });
-
-    test("returns false for different object types", () => {
-        const date1 = new Date(2024, 0, 1);
-        const obj1 = { a: 1, b: 2 };
-        expect(deepEqual(date1, obj1)).toBe(false);
-    });
-
-    test("returns true for nested objects with arrays", () => {
-        const obj1 = { a: 1, b: [1, 2, { c: 3 }] };
-        const obj2 = { a: 1, b: [1, 2, { c: 3 }] };
-        expect(deepEqual(obj1, obj2)).toBe(true);
-    });
-
-    test("returns false for functions, as they should not be equal", () => {
-        const obj1 = {
-            a: 1,
-            b: function () {
-                return 2;
-            }
-        };
-        const obj2 = {
-            a: 1,
-            b: function () {
-                return 2;
-            }
-        };
-        expect(deepEqual(obj1, obj2)).toBe(false);
-    });
-});

package/test/utilities.test.js

@@ -1,205 +0,0 @@
-import dcmjs from "../src/index.js";
-import dicomJson from "../src/utilities/dicomJson.js";
-
-const { utilities } = dcmjs;
-const { addAccessors } = utilities;
-
-describe("dicomJson", () => {
-    describe("pnAddValueAccessors", () => {
-        it("recreates json object from string input", () => {
-            const value = new String("One\\Two");
-            const accessorValue = dicomJson.pnAddValueAccessors(value);
-
-            expect(value).toBe(accessorValue);
-            expect(JSON.stringify(value)).toEqual(
-                JSON.stringify([{ Alphabetic: "One" }, { Alphabetic: "Two" }])
-            );
-            expect(String(accessorValue)).toEqual("One\\Two");
-        });
-
-        it("recreates dicom string from json object", () => {
-            const value = [{ Alphabetic: "One" }, { Alphabetic: "Two" }];
-            const accessorValue = dicomJson.pnAddValueAccessors(value);
-
-            expect(value).toBe(accessorValue);
-            expect(JSON.stringify(value)).toEqual(
-                JSON.stringify([{ Alphabetic: "One" }, { Alphabetic: "Two" }])
-            );
-            expect(String(accessorValue)).toEqual("One\\Two");
-        });
-    });
-
-    describe("pnObjectToString", () => {
-        it("accepts undefined and empty", () => {
-            expect(dicomJson.pnObjectToString(undefined)).toEqual("");
-            expect(dicomJson.pnObjectToString(null)).toEqual("");
-            expect(dicomJson.pnObjectToString("")).toEqual("");
-        });
-
-        it("accepts json PNs", () => {
-            expect(dicomJson.pnObjectToString({ Alphabetic: "One" })).toEqual(
-                "One"
-            );
-            expect(dicomJson.pnObjectToString([{ Alphabetic: "One" }])).toEqual(
-                "One"
-            );
-            expect(
-                dicomJson.pnObjectToString([
-                    {
-                        Alphabetic: "One",
-                        Ideographic: undefined,
-                        Phonetic: undefined
-                    }
-                ])
-            ).toEqual("One");
-            expect(
-                dicomJson.pnObjectToString([
-                    { Alphabetic: "One", Ideographic: "Two", Phonetic: "Three" }
-                ])
-            ).toEqual("One=Two=Three");
-            expect(
-                dicomJson.pnObjectToString([
-                    { Alphabetic: "One" },
-                    { Alphabetic: "Two" }
-                ])
-            ).toEqual("One\\Two");
-        });
-
-        it("accepts strings", () => {
-            expect(dicomJson.pnObjectToString("One")).toEqual("One");
-            expect(dicomJson.pnObjectToString(String("One"))).toEqual("One");
-            expect(dicomJson.pnObjectToString("One=Two\\Three\\Four")).toEqual(
-                "One=Two\\Three\\Four"
-            );
-        });
-    });
-
-    describe("pnConvertToJsonObject", () => {
-        it("accepts undefined", () => {
-            expect(dicomJson.pnConvertToJsonObject(undefined)).toEqual([]);
-            expect(dicomJson.pnConvertToJsonObject(undefined, false)).toEqual(
-                undefined
-            );
-        });
-
-        it("accepts a single name string", () => {
-            expect(dicomJson.pnConvertToJsonObject("One")).toEqual([
-                { Alphabetic: "One" }
-            ]);
-            expect(dicomJson.pnConvertToJsonObject("One==")).toEqual([
-                { Alphabetic: "One" }
-            ]);
-            expect(dicomJson.pnConvertToJsonObject("One=Two=")).toEqual([
-                { Alphabetic: "One", Ideographic: "Two" }
-            ]);
-            expect(dicomJson.pnConvertToJsonObject("One==Three")).toEqual([
-                { Alphabetic: "One", Phonetic: "Three" }
-            ]);
-            expect(dicomJson.pnConvertToJsonObject("One=Two=Three")).toEqual([
-                { Alphabetic: "One", Ideographic: "Two", Phonetic: "Three" }
-            ]);
-            expect(
-                dicomJson.pnConvertToJsonObject("One=Two=Three", false)
-            ).toEqual({
-                Alphabetic: "One",
-                Ideographic: "Two",
-                Phonetic: "Three"
-            });
-            // Discard extraneous or empty values
-            expect(
-                dicomJson.pnConvertToJsonObject("One=Two=Three\\Four", false)
-            ).toEqual({
-                Alphabetic: "One",
-                Ideographic: "Two",
-                Phonetic: "Three"
-            });
-            expect(dicomJson.pnConvertToJsonObject("\\One=Two=Three")).toEqual([
-                {
-                    Alphabetic: "One",
-                    Ideographic: "Two",
-                    Phonetic: "Three"
-                }
-            ]);
-            expect(
-                dicomJson.pnConvertToJsonObject("\\One=Two=Three", false)
-            ).toEqual({
-                Alphabetic: "One",
-                Ideographic: "Two",
-                Phonetic: "Three"
-            });
-        });
-
-        it("accepts multiple name string", () => {
-            expect(
-                dicomJson.pnConvertToJsonObject("One=Two=Three\\Four=Five=Six")
-            ).toEqual([
-                { Alphabetic: "One", Ideographic: "Two", Phonetic: "Three" },
-                { Alphabetic: "Four", Ideographic: "Five", Phonetic: "Six" }
-            ]);
-        });
-
-        it("accepts objects", () => {
-            const jsonObj = {
-                Alphabetic: "One",
-                Ideographic: "Two",
-                Phonetic: "Three"
-            };
-            expect(dicomJson.pnConvertToJsonObject(jsonObj)).toEqual([jsonObj]);
-            expect(dicomJson.pnConvertToJsonObject(jsonObj, false)).toEqual(
-                jsonObj
-            );
-            expect(dicomJson.pnConvertToJsonObject([jsonObj])).toEqual([
-                jsonObj
-            ]);
-            expect(dicomJson.pnConvertToJsonObject([jsonObj], false)).toEqual([
-                jsonObj
-            ]);
-        });
-    });
-});
-
-describe("addAccessor", () => {
-    it("testAddAccessor", () => {
-        const baseValue = { a: 1, b: 2 };
-        const arrValue = [baseValue];
-        const val = addAccessors(arrValue);
-        expect(val.a).toEqual(1);
-        baseValue.a = 3;
-        expect(val.a).toEqual(3);
-        val.b = 4;
-        expect(baseValue.b).toEqual(4);
-
-        // Check that we can iterate as an array
-        const forArr = [];
-        val.forEach(item => forArr.push(item));
-        expect(forArr.length).toEqual(1);
-        expect(forArr[0]).toEqual(baseValue);
-    });
-
-    it("testAddAccessor-adds_children", () => {
-        const baseValue = { a: 1, b: 2 };
-        const arrValue = [baseValue];
-        const val = addAccessors(arrValue, baseValue);
-        val.push({ a: "two" });
-        expect(val.length).toBe(2);
-        expect(val[1].a).toBe("two");
-        expect(val.a).toBe(1);
-        expect(val[0].a).toBe(1);
-    });
-
-    it("Does not double proxy", () => {
-        const baseValue = { a: 1, b: 2 };
-        const arrValue = [baseValue];
-        const val = addAccessors(arrValue, baseValue);
-        expect(val).toEqual(addAccessors(val));
-        expect(val.__isProxy).toBe(true);
-    });
-
-    it("Handles non-array dest with no sqzero", () => {
-        const baseValue = { a: 1, b: 2 };
-        expect(Array.isArray(addAccessors(baseValue))).toBe(true);
-        expect(addAccessors("Hello")).toBe("Hello");
-        expect(addAccessors([baseValue])[0]).toBe(baseValue);
-        expect(addAccessors([baseValue, 2])[1]).toBe(2);
-    });
-});

package/test/video-test-dict.js

@@ -1,40 +0,0 @@
-import { TagHex } from "../src/constants/dicom.js";
-
-/**
- * DICOM meta dict for video transfer syntax test
- * This contains the file meta information (group 0002)
- * Pixel data fragments are added separately in the test
- */
-export const videoTestMeta = {
-    [TagHex.TransferSyntaxUID]: {
-        vr: "UI",
-        Value: ["1.2.840.10008.1.2.4.102"] // MPEG-4 AVC/H.264 High Profile / Level 4.1
-    },
-    [TagHex.MediaStorageSOPInstanceUID]: {
-        vr: "UI",
-        Value: ["1.2.3.4.5.6.7.8.9"]
-    },
-    [TagHex.MediaStorageSOPClassUID]: {
-        vr: "UI",
-        Value: ["1.2.840.10008.5.1.4.1.1.1"] // CR Image Storage
-    }
-};
-
-/**
- * DICOM dataset dict for video transfer syntax test
- * This contains the dataset elements (group 0008+)
- */
-export const videoTestDict = {
-    [TagHex.Rows]: {
-        vr: "US",
-        Value: [512]
-    },
-    [TagHex.Columns]: {
-        vr: "US",
-        Value: [512]
-    },
-    [TagHex.NumberOfFrames]: {
-        vr: "IS",
-        Value: ["137"]
-    }
-};