dicom-synth 1.0.1 → 1.2.0

package/dist/esm/collection/writer.js

@@ -0,0 +1,484 @@
+// src/collection/writer.ts
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { dirname, resolve as resolve2 } from "node:path";
+
+// src/loadDcmjs.ts
+import dcmjsDefaultImport, * as dcmjsNamespace from "dcmjs";
+function loadDcmjs() {
+  if (dcmjsNamespace.data?.DicomDict) {
+    return dcmjsNamespace;
+  }
+  const d = dcmjsDefaultImport;
+  if (d?.data?.DicomDict) {
+    return d;
+  }
+  if (d?.default?.data?.DicomDict) {
+    return d.default;
+  }
+  throw new Error(
+    "dcmjs failed to load (missing data.DicomDict). Install dcmjs >= 0.29."
+  );
+}
+var dcmjs = loadDcmjs();
+
+// src/nonStandardDicom/dicomdir.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+var DICOMDIR_SOP_CLASS_UID = "1.2.840.10008.1.3.10";
+function buildDicomdirBuffer() {
+  const uid = DICOMDIR_SOP_CLASS_UID;
+  const buf = Buffer.alloc(256, 0);
+  buf.write("DICM", 128, 4, "ascii");
+  let off = 132;
+  buf.writeUInt16LE(2, off);
+  off += 2;
+  buf.writeUInt16LE(2, off);
+  off += 2;
+  buf.write("UI", off, 2, "ascii");
+  off += 2;
+  buf.writeUInt16LE(uid.length, off);
+  off += 2;
+  buf.write(uid, off, uid.length, "ascii");
+  off += uid.length;
+  return buf.subarray(0, off);
+}
+
+// src/schema/validate.ts
+var MAX_PIXEL_BYTES = 512 * 1024 * 1024;
+var HEX_TAG_RE = /^[0-9a-fA-F]{8}$/;
+
+// src/syntheticFixtures/generator.ts
+var CT_SOP_CLASS = "1.2.840.10008.5.1.4.1.1.2";
+var TRANSFER_SYNTAX_UID = {
+  "explicit-vr-little-endian": "1.2.840.10008.1.2.1",
+  "implicit-vr-little-endian": "1.2.840.10008.1.2"
+};
+function buildTagToKeyword() {
+  const map = /* @__PURE__ */ new Map();
+  const nm = dcmjs.data?.DicomMetaDictionary?.nameMap;
+  if (!nm) return map;
+  for (const [keyword, info] of Object.entries(nm)) {
+    if (info?.tag) {
+      const hex = info.tag.replace(/[(,)]/g, "").toUpperCase();
+      if (hex.length === 8) map.set(hex, keyword);
+    }
+  }
+  return map;
+}
+var tagToKeyword = buildTagToKeyword();
+function applyTagOverrides(dataset, tags) {
+  if (!tags) return;
+  for (const [key, value] of Object.entries(tags)) {
+    if (HEX_TAG_RE.test(key)) {
+      const keyword = tagToKeyword.get(key.toUpperCase());
+      if (keyword) {
+        dataset[keyword] = value;
+      } else {
+        console.warn(`dicom-synth: unknown hex tag "${key}" \u2014 skipping`);
+      }
+    } else {
+      dataset[key] = value;
+    }
+  }
+}
+function buildMeta(uid, transferSyntax = "explicit-vr-little-endian") {
+  return {
+    FileMetaInformationVersion: new Uint8Array([0, 1]).buffer,
+    MediaStorageSOPClassUID: CT_SOP_CLASS,
+    MediaStorageSOPInstanceUID: uid.sop,
+    TransferSyntaxUID: TRANSFER_SYNTAX_UID[transferSyntax],
+    ImplementationClassUID: "1.2.3.4",
+    ImplementationVersionName: "SYNTH"
+  };
+}
+function buildBaseCtDataset(uid) {
+  return {
+    PatientName: "SYNTH^SUBJECT",
+    PatientID: "SYNTH_PID",
+    Modality: "CT",
+    SOPClassUID: CT_SOP_CLASS,
+    SOPInstanceUID: uid.sop,
+    SeriesInstanceUID: uid.series,
+    StudyInstanceUID: uid.study,
+    StudyDescription: "Synthetic study",
+    SeriesDescription: "Synthetic series",
+    Rows: 1,
+    Columns: 1,
+    BitsAllocated: 16,
+    BitsStored: 16,
+    HighBit: 15,
+    SamplesPerPixel: 1,
+    PhotometricInterpretation: "MONOCHROME2",
+    PixelRepresentation: 0,
+    PixelData: new Uint8Array([0, 0]).buffer,
+    // Declares PixelData's VR explicitly — without it dcmjs logs
+    // "No value representation given for PixelData" and falls back to OW anyway.
+    _vrMap: { PixelData: "OW" }
+  };
+}
+function serializeDict(meta, dataset) {
+  const dicomDict = new dcmjs.data.DicomDict(
+    dcmjs.data.DicomMetaDictionary.denaturalizeDataset(
+      meta
+    )
+  );
+  dicomDict.dict = dcmjs.data.DicomMetaDictionary.denaturalizeDataset(
+    dataset
+  );
+  return Buffer.from(dicomDict.write({ allowInvalidVRLength: true }));
+}
+function buildValidCtBuffer(uid, tags, transferSyntax) {
+  const dataset = buildBaseCtDataset(uid);
+  applyTagOverrides(dataset, tags);
+  return serializeDict(buildMeta(uid, transferSyntax), dataset);
+}
+function buildInvalidUidCtBuffer(uid, tags, transferSyntax) {
+  const invalidUid = {
+    study: `2.25.invalid.study.${uid.study.slice(-6)}`,
+    series: `2.25.invalid.series.${uid.series.slice(-6)}`,
+    sop: `2.25.invalid.sop.${uid.sop.slice(-6)}`
+  };
+  const dataset = buildBaseCtDataset(invalidUid);
+  applyTagOverrides(dataset, tags);
+  return serializeDict(buildMeta(invalidUid, transferSyntax), dataset);
+}
+function buildVendorCtBuffer(uid, tags, transferSyntax) {
+  const dataset = buildBaseCtDataset(uid);
+  dataset.Laterality = "";
+  dataset.PatientWeight = "0";
+  applyTagOverrides(dataset, tags);
+  return serializeDict(buildMeta(uid, transferSyntax), dataset);
+}
+function buildLargeCtBuffer(uid, rows, columns, frames, tags, transferSyntax) {
+  const dataset = buildBaseCtDataset(uid);
+  dataset.Rows = rows;
+  dataset.Columns = columns;
+  dataset.NumberOfFrames = frames;
+  dataset.PixelData = new Uint8Array(rows * columns * frames * 2).buffer;
+  applyTagOverrides(dataset, tags);
+  return serializeDict(buildMeta(uid, transferSyntax), dataset);
+}
+function buildFakeSignatureBuffer() {
+  const buf = Buffer.alloc(200, 0);
+  buf.write("XXXX", 128, 4, "ascii");
+  return buf;
+}
+function buildNonDicomBuffer(content = "not dicom") {
+  return Buffer.from(content, "utf8");
+}
+function buildBufferForSpec(spec, uid) {
+  switch (spec.type) {
+    case "valid-ct":
+      return buildValidCtBuffer(uid, spec.tags, spec.transferSyntax);
+    case "invalid-uid-ct":
+      return buildInvalidUidCtBuffer(uid, spec.tags, spec.transferSyntax);
+    case "vendor-warnings-ct":
+      return buildVendorCtBuffer(uid, spec.tags, spec.transferSyntax);
+    case "large-ct":
+      return buildLargeCtBuffer(
+        uid,
+        spec.rows,
+        spec.columns,
+        spec.frames ?? 1,
+        spec.tags,
+        spec.transferSyntax
+      );
+    case "fake-signature":
+      return buildFakeSignatureBuffer();
+    case "non-dicom":
+      return buildNonDicomBuffer(spec.content);
+    case "dicomdir":
+      return buildDicomdirBuffer();
+  }
+}
+
+// src/syntheticFixtures/uid.ts
+import { randomBytes } from "node:crypto";
+var ROLE_CODE = { study: 1, series: 2, sop: 3 };
+function lcg(seed) {
+  let s = seed >>> 0;
+  return () => {
+    s = Math.imul(1664525, s) + 1013904223 >>> 0;
+    return s;
+  };
+}
+function formatUid(a, b, role) {
+  return `2.25.${a}.${b}.${ROLE_CODE[role]}`;
+}
+function randomUid(role) {
+  const buf = randomBytes(8);
+  return formatUid(buf.readUInt32BE(0), buf.readUInt32BE(4), role);
+}
+function seededUid(next, role) {
+  return formatUid(next(), next(), role);
+}
+var GROUP_STREAM_OFFSET = 2654435769;
+function seededStream(seed, offset, a, b) {
+  return lcg(seed * 999983 + offset + a * 1000003 + b * 7919 >>> 0);
+}
+function makeGroupUidGenerator(seed) {
+  if (seed === void 0) {
+    return {
+      study: () => randomUid("study"),
+      series: () => randomUid("series")
+    };
+  }
+  return {
+    study: (studyIndex) => seededUid(
+      seededStream(seed, GROUP_STREAM_OFFSET, studyIndex + 1, 0),
+      "study"
+    ),
+    series: (studyIndex, seriesIndex) => seededUid(
+      seededStream(
+        seed,
+        GROUP_STREAM_OFFSET,
+        studyIndex + 1,
+        seriesIndex + 1
+      ),
+      "series"
+    )
+  };
+}
+function makeUidGenerator(seed) {
+  if (seed === void 0) {
+    return () => ({
+      study: randomUid("study"),
+      series: randomUid("series"),
+      sop: randomUid("sop")
+    });
+  }
+  return (fileIndex) => {
+    const next = seededStream(seed, 0, fileIndex, 0);
+    return {
+      study: seededUid(next, "study"),
+      series: seededUid(next, "series"),
+      sop: seededUid(next, "sop")
+    };
+  };
+}
+
+// src/syntheticFixtures/violations.ts
+var dcmjsAny = dcmjs;
+function parseBuffer(buffer) {
+  const ab = buffer.buffer.slice(
+    buffer.byteOffset,
+    buffer.byteOffset + buffer.byteLength
+  );
+  return dcmjsAny.data.DicomMessage.readFile(ab);
+}
+function reserialize(parsed) {
+  return Buffer.from(parsed.write({ allowInvalidVRLength: true }));
+}
+var OVERLONG_UID = `2.25.${"0".repeat(60)}`;
+var VIOLATION_LEVEL = {
+  "uid-too-long": "tag",
+  "non-conformant-uid": "tag",
+  "vr-max-length-exceeded": "tag",
+  "missing-type1-tag": "tag",
+  "missing-meta-header": "byte",
+  "malformed-sq-delimiter": "byte"
+};
+function applyTagLevel(buffer, violations) {
+  if (violations.length === 0) return buffer;
+  let parsed;
+  try {
+    parsed = parseBuffer(buffer);
+  } catch {
+    console.warn(
+      "dicom-synth: could not parse buffer for tag-level violations \u2014 skipping"
+    );
+    return buffer;
+  }
+  const natural = dcmjsAny.data.DicomMetaDictionary.naturalizeDataset(
+    parsed.dict
+  );
+  for (const v of violations) {
+    switch (v) {
+      case "uid-too-long":
+        break;
+      case "non-conformant-uid":
+        natural.SOPInstanceUID = "2.25.01.234.567";
+        break;
+      case "vr-max-length-exceeded":
+        natural.StudyDescription = "X".repeat(65);
+        break;
+      case "missing-type1-tag":
+        delete natural.SOPClassUID;
+        break;
+      default:
+        throw new Error(
+          `dicom-synth: unhandled tag-level violation "${v}"`
+        );
+    }
+  }
+  parsed.dict = dcmjsAny.data.DicomMetaDictionary.denaturalizeDataset(natural);
+  if (violations.includes("uid-too-long")) {
+    ;
+    parsed.dict["00080018"] = {
+      vr: "UI",
+      Value: [OVERLONG_UID]
+    };
+  }
+  return reserialize(parsed);
+}
+function applyByteLevel(buffer, violations) {
+  let result = buffer;
+  for (const v of violations) {
+    switch (v) {
+      case "missing-meta-header":
+        result = result.subarray(132);
+        break;
+      case "malformed-sq-delimiter": {
+        const delimiter = Buffer.alloc(8);
+        delimiter.writeUInt16LE(65534, 0);
+        delimiter.writeUInt16LE(57565, 2);
+        delimiter.writeUInt32LE(4, 4);
+        result = Buffer.concat([result, delimiter]);
+        break;
+      }
+      default:
+        throw new Error(
+          `dicom-synth: unhandled byte-level violation "${v}"`
+        );
+    }
+  }
+  return result;
+}
+function applyViolations(buffer, violations) {
+  if (violations.length === 0) return buffer;
+  const tagViolations = violations.filter((v) => VIOLATION_LEVEL[v] === "tag");
+  const byteViolations = violations.filter((v) => VIOLATION_LEVEL[v] === "byte");
+  return applyByteLevel(applyTagLevel(buffer, tagViolations), byteViolations);
+}
+
+// src/collection/writer.ts
+var NO_EXTENSION_TYPES = /* @__PURE__ */ new Set([
+  "fake-signature",
+  "non-dicom"
+]);
+function filename(type, index, padWidth) {
+  const padded = String(index).padStart(padWidth, "0");
+  const base = `${type}-${padded}`;
+  return NO_EXTENSION_TYPES.has(type) ? base : `${base}.dcm`;
+}
+function entryCount(entries) {
+  return entries.reduce((sum, e) => sum + (e.count ?? 1), 0);
+}
+function studyFileCount(studies) {
+  return studies.reduce(
+    (sum, study) => sum + (study.count ?? 1) * study.series.reduce((s, series) => s + entryCount(series.entries), 0),
+    0
+  );
+}
+async function generateFile(spec, options) {
+  const index = options?.index ?? 0;
+  const padWidth = options?.padWidth ?? 3;
+  const uidGen = makeUidGenerator(options?.seed);
+  const uid = { ...uidGen(index), ...options?.uid };
+  let buffer = buildBufferForSpec(spec, uid);
+  const violations = "violations" in spec ? spec.violations : void 0;
+  if (violations?.length) {
+    buffer = applyViolations(buffer, violations);
+  }
+  const name = filename(spec.type, index, padWidth);
+  return {
+    filename: name,
+    relativePath: name,
+    buffer,
+    type: spec.type,
+    index
+  };
+}
+function hierarchicalName(studyOrdinal, seriesIndex, instanceNumber) {
+  const pad3 = (n) => String(n).padStart(3, "0");
+  const name = `${String(instanceNumber).padStart(5, "0")}.dcm`;
+  return {
+    filename: name,
+    relativePath: `study-${pad3(studyOrdinal + 1)}/series-${pad3(seriesIndex + 1)}/${name}`
+  };
+}
+async function* generateCollectionFromSpec(spec) {
+  const flatEntries = spec.entries ?? [];
+  const studies = spec.studies ?? [];
+  const totalFiles = entryCount(flatEntries) + studyFileCount(studies);
+  const padWidth = String(totalFiles).length;
+  const hierarchical = spec.layout === "hierarchical";
+  let globalIndex = 0;
+  for (const entry of flatEntries) {
+    const { count = 1, ...fileSpec } = entry;
+    for (let i = 0; i < count; i++) {
+      yield generateFile(fileSpec, {
+        index: globalIndex,
+        seed: spec.seed,
+        padWidth
+      });
+      globalIndex++;
+    }
+  }
+  const groupUids = makeGroupUidGenerator(spec.seed);
+  let studyOrdinal = 0;
+  for (const study of studies) {
+    const copies = study.count ?? 1;
+    for (let copy = 0; copy < copies; copy++) {
+      const studyUid = groupUids.study(studyOrdinal);
+      for (const [seriesIndex, series] of study.series.entries()) {
+        const seriesUid = groupUids.series(studyOrdinal, seriesIndex);
+        let instanceNumber = 0;
+        for (const entry of series.entries) {
+          const { count = 1, ...fileSpec } = entry;
+          for (let i = 0; i < count; i++) {
+            instanceNumber++;
+            const tags = {
+              InstanceNumber: instanceNumber,
+              ...study.tags,
+              ...series.tags,
+              ...fileSpec.tags
+            };
+            const file = await generateFile(
+              { ...fileSpec, tags },
+              {
+                index: globalIndex,
+                seed: spec.seed,
+                padWidth,
+                uid: { study: studyUid, series: seriesUid }
+              }
+            );
+            yield hierarchical ? {
+              ...file,
+              ...hierarchicalName(
+                studyOrdinal,
+                seriesIndex,
+                instanceNumber
+              )
+            } : file;
+            globalIndex++;
+          }
+        }
+      }
+      studyOrdinal++;
+    }
+  }
+}
+async function writeCollectionFromSpec(spec, outDir) {
+  const root = resolve2(outDir);
+  mkdirSync2(root, { recursive: true });
+  const manifest = [];
+  const createdDirs = /* @__PURE__ */ new Set([root]);
+  for await (const file of generateCollectionFromSpec(spec)) {
+    const filePath = resolve2(root, file.relativePath);
+    const dir = dirname(filePath);
+    if (!createdDirs.has(dir)) {
+      mkdirSync2(dir, { recursive: true });
+      createdDirs.add(dir);
+    }
+    await writeFile(filePath, file.buffer);
+    manifest.push({ path: filePath, type: file.type, index: file.index });
+  }
+  return manifest;
+}
+export {
+  generateCollectionFromSpec,
+  generateFile,
+  writeCollectionFromSpec
+};