@radicalimaging/static-wado-creator 1.5.0 → 1.6.10

package/lib/serverMain.js

@@ -0,0 +1,27 @@
+const readline = require("node:readline");
+const {
+  argv,
+  argv0,
+  exit,
+  stdin: input,
+  stdout: output,
+} = require("node:process");
+
+const StaticWado = require("./StaticWado");
+const adaptProgramOpts = require("./util/adaptProgramOpts");
+
+module.exports = async function createMain(options, program) {
+  const rl = readline.createInterface({ input, output });
+  for await (const line of rl) {
+    if (!line) continue;
+    if (line.startsWith("exit")) {
+      exit(0);
+    }
+    argv.splice(2, argv.length - 2, ...line.split(" "));
+    console.verbose("exec mkdicomweb", JSON.stringify(argv));
+
+    // Configure program commander
+    await StaticWado.configureProgram(StaticWado.mkdicomwebConfig);
+    output.write("mkdicomweb server -->\n");
+  }
+};

package/lib/util/IdCreator.js

@@ -1,14 +1,40 @@
 const path = require("path");
+const {
+  getStudyUIDPathAndSubPath,
+} = require("@radicalimaging/static-wado-util");
 
-function IdCreator({ directoryName, deduplicatedRoot, deduplicatedInstancesRoot }) {
+function IdCreator({
+  directoryName,
+  deduplicatedRoot,
+  deduplicatedInstancesRoot,
+  hashStudyUidPath,
+}) {
   return (uids, filename) => {
-    const studyPath = path.join(directoryName, "studies", uids.studyInstanceUid);
-    const seriesRootPath = path.join(studyPath, "series", uids.seriesInstanceUid);
-    const sopInstanceRootPath = path.join(studyPath, "series", uids.seriesInstanceUid, "instances", uids.sopInstanceUid);
-    const deduplicatedPath = path.join(deduplicatedRoot, uids.studyInstanceUid);
-    const deduplicatedInstancesPath = path.join(deduplicatedInstancesRoot, uids.studyInstanceUid);
+    const { studyInstanceUid, seriesInstanceUid, sopInstanceUid } = uids;
+
+    const { path: hashPath = "", subpath: hashSubpath = "" } = hashStudyUidPath
+      ? getStudyUIDPathAndSubPath(studyInstanceUid)
+      : {};
+
+    const studySubDir = hashStudyUidPath
+      ? path.join(hashPath, hashSubpath, studyInstanceUid)
+      : studyInstanceUid;
+
+    const studyPath = path.join(directoryName, "studies", studySubDir);
+    const seriesRootPath = path.join(studyPath, "series", seriesInstanceUid);
+    const sopInstanceRootPath = path.join(
+      seriesRootPath,
+      "instances",
+      sopInstanceUid,
+    );
     const imageFrameRootPath = path.join(sopInstanceRootPath, "frames");
 
+    const deduplicatedPath = path.join(deduplicatedRoot, studySubDir);
+    const deduplicatedInstancesPath = path.join(
+      deduplicatedInstancesRoot,
+      studySubDir,
+    );
+
     return {
       ...uids,
       studyPath,

package/lib/util/adaptProgramOpts.js

@@ -34,6 +34,6 @@ module.exports = function adaptProgramOpts(programOpts, defaults) {
       encapsulatedImage: encapsulatedImage ?? singlePartImage !== true,
       singlePartImage: singlePartImage ?? encapsulatedImage === false,
       delete: deleteInstances,
-    }
+    },
   );
 };

package/lib/util/compressionOptionParser.js

@@ -1,13 +1,22 @@
 const { program } = require("@radicalimaging/static-wado-util");
-const { getDestinationTranscoder } = require("../operation/adapter/transcodeImage");
+const {
+  getDestinationTranscoder,
+} = require("../operation/adapter/transcodeImage");
 
 module.exports = function compressionOptionParser(value) {
   const destination = getDestinationTranscoder(value);
   if (destination) {
-    console.log("Found destination transferSyntax ", destination.transferSyntaxUid, "for ", value);
+    console.log(
+      "Found destination transferSyntax ",
+      destination.transferSyntaxUid,
+      "for ",
+      value,
+    );
   } else {
     console.log("No transcoder destination for ", value);
-    throw new program.InvalidArgumentError(`No transcoder destination for ${value}`);
+    throw new program.InvalidArgumentError(
+      `No transcoder destination for ${value}`,
+    );
   }
   return destination.transferSyntaxUid;
 };

package/lib/util/resultsReport.ts

@@ -0,0 +1,88 @@
+import fs from "fs";
+
+const results = [];
+let sopResponse = null;
+
+function ensureSOPResponse(data) {
+    if( !data.ReferencedSOPSequence && !data.FailedSOPSequence ) {
+        return;
+    }
+    if( !sopResponse ) {
+        sopResponse = {
+            ...data,
+            FailedSOPSequence: undefined,
+            ReferencedSOPSequence: undefined,
+        }
+        results.push(sopResponse);
+    }
+    if( data.ReferencedSOPSequence ) {
+        sopResponse.ReferencedSOPSequence ||= [];
+        sopResponse.ReferencedSOPSequence.push(...data.ReferencedSOPSequence);
+    }
+    if( data.FailedSOPSequence ) {
+        sopResponse.FailedSOPSequence ||= [];
+        sopResponse.FailedSOPSequence.push(...data.FailedSOPSequence);
+    }
+
+}
+export function Success(options) {
+    const { deleteInput = false } = options;
+
+    return (_action, data, file) => {
+      if( data.ReferencedSOPSequence ) {
+        ensureSOPResponse(data);
+      } else {
+        results.push(data);
+      }
+      if (file && deleteInput) {
+        console.noQuiet("Deleting", file);
+        fs.unlinkSync(file);
+    } else if( file ) {
+        console.verbose("Not deleting", file);
+      }
+    };
+}
+
+export function Failure(options) {
+    const { deleteFailed } = options;
+
+    return (_action, data, file) => {
+        if (data.FailedSOPSequence) {
+          ensureSOPResponse(data);
+        } else {
+            results.push(data);
+        }
+        if( file && deleteFailed ) {
+            console.noQuiet("Deleting failure", file);
+            fs.unlinkSync(file);
+        } else if( file ) {
+            console.verbose("Not deleting failure file", file);
+        }
+    };
+}
+
+export function clearResults() {
+    results.splice(0,results.length);
+    sopResponse = null;
+}
+
+export function WriteResults(options) {
+    const { multipart } = options;
+
+    return function () {
+      if (multipart) {
+        const str =
+          results.length === 1
+            ? JSON.stringify(results[0])
+            : `[\n${results.map((r) => JSON.stringify(r, null, 2)).join(",\n")}\n]`;
+        console.log(
+          "\r\n--boundary-response\r\n" +
+            "content-type: application/json\r\n\r\n" +
+            str +
+            "\r\n--boundary-response--\r\n"
+        );
+      }
+
+      clearResults();
+    };
+}

package/lib/writer/CompleteStudyWriter.js

@@ -1,4 +1,8 @@
-const { JSONReader, JSONWriter, Stats } = require("@radicalimaging/static-wado-util");
+const {
+  JSONReader,
+  JSONWriter,
+  Stats,
+} = require("@radicalimaging/static-wado-util");
 const { Tags } = require("@radicalimaging/static-wado-util");
 const StudyData = require("../operation/StudyData");
 
@@ -22,48 +26,77 @@ const CompleteStudyWriter = (options) => {
     if (options.isGroup) {
       if (studyData.dirty) {
         await studyData.writeDeduplicatedGroup();
-        console.log("Wrote updated deduplicated data for study", studyData.studyInstanceUid);
+        console.noQuiet(
+          "Wrote updated deduplicated data for study",
+          studyData.studyInstanceUid,
+        );
       } else {
-        console.log("Not writing new deduplicated data because it is clean:", studyData.studyInstanceUid);
+        console.noQuiet(
+          "Not writing new deduplicated data because it is clean:",
+          studyData.studyInstanceUid,
+        );
+        const message = {
+          text: "Metadata clean, not updating",
+          status: 0,
+          studyInstanceUid: studyData.studyInstanceUid,
+        };
+        this.success("metadataClean", message);
       }
       await studyData.deleteInstancesReferenced();
     }
 
     if (!options.isStudyData) {
-      console.verbose("Not configured to write study metadata", studyData.studyInstanceUid);
-      if (options.notifications) this.notificationService.notifyStudy(studyData.studyInstanceUid);
+      if (options.notifications)
+        this.notificationService.notifyStudy(studyData.studyInstanceUid);
       delete this.studyData;
       Stats.StudyStats.summarize();
       return;
     }
 
     const isDirtyMetadata = await studyData.dirtyMetadata();
-    if (!isDirtyMetadata) {
+    if (!isDirtyMetadata && !options.force) {
       console.log("Study metadata", studyData.studyInstanceUid, "is clean.");
       delete this.studyData;
-      Stats.StudyStats.summarize(`Study metadata ${studyData.studyInstanceUid} has clean metadata, not writing`);
+      Stats.StudyStats.summarize(
+        `Study metadata ${studyData.studyInstanceUid} has clean metadata, not writing`,
+      );
       return;
     }
-    console.log("Writing study metadata", studyData.studyInstanceUid);
+    console.noQuiet("Writing study metadata", studyData.studyInstanceUid);
 
     const studyQuery = await studyData.writeMetadata();
 
-    const allStudies = await JSONReader(options.directoryName, "studies/index.json.gz", []);
+    const allStudies = await JSONReader(
+      options.directoryName,
+      "studies/index.json.gz",
+      [],
+    );
     const studyUID = Tags.getValue(studyQuery, Tags.StudyInstanceUID);
     if (!studyUID) {
       console.error("studyQuery=", studyQuery);
       throw new Error("Study query has null studyUID");
     }
-    const studyIndex = allStudies.findIndex((item) => Tags.getValue(item, Tags.StudyInstanceUID) == studyUID);
+    const studyIndex = allStudies.findIndex(
+      (item) => Tags.getValue(item, Tags.StudyInstanceUID) == studyUID,
+    );
     if (studyIndex == -1) {
       allStudies.push(studyQuery);
     } else {
       allStudies[studyIndex] = studyQuery;
     }
     await JSONWriter(options.directoryName, "studies", allStudies);
-    if (options.notifications) this.notificationService.notifyStudy(studyData.studyInstanceUid);
+    if (options.notifications)
+      this.notificationService.notifyStudy(studyData.studyInstanceUid);
+    const message = {
+      action: "metadata",
+      status: 0,
+      studyInstanceUid: studyData.studyInstanceUid,
+    };
+    this.success("completeStudyWriter", message);
     delete this.studyData;
-    Stats.StudyStats.summarize(`Wrote study metadata/query files for ${studyData.studyInstanceUid}`);
+    Stats.StudyStats.summarize(
+      `Wrote study metadata/query files for ${studyData.studyInstanceUid}`,
+    );
   }
 
   /**
@@ -81,7 +114,10 @@ const CompleteStudyWriter = (options) => {
       await callback.completeStudy(studyData);
     }
     callback.setStudyData(new StudyData(id, options));
-    await callback.studyData.init(options);
+    if (!options.isSkipStudyScan) {
+      console.verbose("Initiate StudyData");
+      await callback.studyData.init(options);
+    }
     return callback.studyData;
   };
 

package/lib/writer/DeduplicateWriter.js

@@ -24,7 +24,8 @@ const DeduplicateWriter = (options) =>
     const studyData = await this.completeStudy.getCurrentStudyData(this, id);
 
     if (options.isDeduplicate) {
-      if (options.verbose) console.log("Writing single instance", id.studyInstanceUid);
+      if (options.verbose)
+        console.log("Writing single instance", id.studyInstanceUid);
       await perInstanceWriter(id, data);
     } else if (options.verbose) {
       console.log("Not writing single instance deduplicated");

package/lib/writer/ExpandUriPath.js

@@ -8,7 +8,10 @@ const ExpandUriPath = (id, path, options) => {
     }
     expandedRelative = `studies/${id.studyInstanceUid}/${expandedRelativeSeries}`;
   }
-  if (options.verbose) console.log(`Expanded path returned: ${prependBulkDataUri}${expandedRelative}${path}`);
+  if (options.verbose)
+    console.log(
+      `Expanded path returned: ${prependBulkDataUri}${expandedRelative}${path}`,
+    );
   return `${prependBulkDataUri}${expandedRelative}${path}`;
 };
 

package/lib/writer/HashDataWriter.js

@@ -43,7 +43,11 @@ const HashDataWriter =
       gzip,
     });
     if (isRaw) {
-      await WriteMultipart(writeStream, [new MultipartHeader("Content-Type", "application/octet-stream")], rawData);
+      await WriteMultipart(
+        writeStream,
+        [new MultipartHeader("Content-Type", "application/octet-stream")],
+        rawData,
+      );
     } else {
       await writeStream.write(rawData);
     }

package/lib/writer/ImageFrameWriter.js

@@ -18,29 +18,54 @@ const ImageFrameWriter = (options) => {
     }
 
     if (encapsulatedImage || !extension) {
-      const writeStream = WriteStream(id.imageFrameRootPath, `${1 + index}.mht`, {
-        gzip: type.gzip,
-        mkdir: true,
-      });
+      const writeStream = WriteStream(
+        id.imageFrameRootPath,
+        `${1 + index}.mht`,
+        {
+          gzip: type.gzip,
+          mkdir: true,
+        },
+      );
       await WriteMultipart(
         writeStream,
-        [new MultipartHeader("Content-Type", type.contentType, [new MultipartAttribute("transfer-syntax", transferSyntaxUid)])],
-        content
+        [
+          new MultipartHeader("Content-Type", type.contentType, [
+            new MultipartAttribute("transfer-syntax", transferSyntaxUid),
+          ]),
+        ],
+        content,
       );
       await writeStream.close();
-      console.verbose("Wrote encapsulated image frame", id.sopInstanceUid, index + 1, type.contentType);
+      console.verbose(
+        "Wrote encapsulated image frame",
+        id.sopInstanceUid,
+        index + 1,
+        type.contentType,
+      );
     }
     if (extension && singlePartImage) {
-      const writeStreamSingle = WriteStream(id.imageFrameRootPath, `${1 + index}${extension}`, {
-        gzip: type.gzip,
-        mkdir: true,
-      });
+      const writeStreamSingle = WriteStream(
+        id.imageFrameRootPath,
+        `${1 + index}${extension}`,
+        {
+          gzip: type.gzip,
+          mkdir: true,
+        },
+      );
       await writeStreamSingle.write(content);
       await writeStreamSingle.close();
-      console.verbose("Wrote single part image frame", id.sopInstanceUid, index + 1, extension);
+      console.verbose(
+        "Wrote single part image frame",
+        id.sopInstanceUid,
+        index + 1,
+        extension,
+      );
     }
     const includeSeries = true;
-    return ExpandUriPath(id, `instances/${id.sopInstanceUid}/frames`, { includeSeries, ...options });
+    return ExpandUriPath(id, `instances/${id.sopInstanceUid}/frames`, {
+      includeSeries,
+      ...options,
+    });
   };
 };
 

package/lib/writer/RawDicomWriter.js

@@ -4,10 +4,15 @@ const WriteMultipart = require("./WriteMultipart");
 const { MultipartHeader } = require("./MultipartHeader");
 
 const modalitiesToRawWrite = ["SEG", "SR"];
+const sopClassesToRawWrite = ["1.2.840.10008.5.1.4.1.1.30"];
 
 const defaultSelector = (instance) => {
   const modality = instance.metadata[Tags.Modality]?.Value?.[0];
-  return modalitiesToRawWrite.indexOf(modality) !== -1;
+  const sopClass = instance.metadata[Tags.SOPClassUID]?.Value?.[0];
+  return (
+    modalitiesToRawWrite.indexOf(modality) !== -1 ||
+    sopClassesToRawWrite.indexOf(sopClass) !== -1
+  );
 };
 
 /** Writes out raw DICOM files, encapsulated in multipart and gzipped - currently just DICOM SR and SEG */
@@ -28,7 +33,11 @@ const RawDicomWriter =
     });
     const { length } = content;
     const buffer = content.slice(0, length);
-    await WriteMultipart(writeStream, [new MultipartHeader("Content-Type", contentType, [])], buffer);
+    await WriteMultipart(
+      writeStream,
+      [new MultipartHeader("Content-Type", contentType, [])],
+      buffer,
+    );
     await writeStream.close();
   };
 RawDicomWriter.defaultSelector = defaultSelector;

package/lib/writer/VideoWriter.js

@@ -34,7 +34,7 @@ const VideoWriter = () =>
       filename,
       {
         mkdir: true,
-      }
+      },
     );
     let length = 0;
     const { fragments } = dataSet.elements.x7fe00010;
@@ -48,14 +48,14 @@ const VideoWriter = () =>
       const fragment = fragments[i];
       const blob = dataSet.byteArray.slice(
         fragment.position,
-        fragment.position + fragment.length
+        fragment.position + fragment.length,
       );
       length += blob.length;
       await writeStream.write(blob);
     }
     await writeStream.close();
     console.log(
-      `Done video ${id.sopInstanceRootPath}\\${filename} of length ${length}`
+      `Done video ${id.sopInstanceRootPath}\\${filename} of length ${length}`,
     );
     return `series/${id.seriesInstanceUid}/instances/${id.sopInstanceUid}/rendered?length=${length}&offset=0&accept=video/mp4`;
   };

package/lib/writer/WriteMultipart.js

@@ -9,7 +9,9 @@ const WriteMultipart = async (writeStream, headers, content) => {
     if (header.attributes) {
       for (let j = 0; j < header.attributes.length; j++) {
         const attribute = header.attributes[j];
-        await writeStream.write(`;${attribute.attributeName}=${attribute.attributeValue}`);
+        await writeStream.write(
+          `;${attribute.attributeName}=${attribute.attributeValue}`,
+        );
       }
     }
     await writeStream.write("\r\n");

package/lib/writer/WriteStream.js

@@ -11,17 +11,25 @@ let writeCount = 0;
  */
 const WriteStream = (dir, nameSrc, options = {}) => {
   const isGzip = nameSrc.indexOf(".gz") != -1 || options.gzip;
-  const name = (isGzip && nameSrc.indexOf(".gz") === -1 && `${nameSrc}.gz`) || nameSrc;
-  if (options.mkdir) fs.mkdirSync(dir, { recursive: true });
+  const name =
+    (isGzip && nameSrc.indexOf(".gz") === -1 && `${nameSrc}.gz`) || nameSrc;
+  if (options.mkdir) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
 
-  const tempName = path.join(dir, `tempFile-${Math.round(Math.random() * 1000000000)}`);
+  const tempName = path.join(
+    dir,
+    `tempFile-${Math.round(Math.random() * 1000000000)}`,
+  );
   const finalName = path.join(dir, name);
   writeCount++;
   if (writeCount > 10) {
     console.log("Write count", tempName, finalName, writeCount);
     if (writeCount > 100) {
       console.error("Too many open writes", new Error());
-      throw new Error(`Write count too high ${writeCount} destination ${finalName}`);
+      throw new Error(
+        `Write count too high ${writeCount} destination ${finalName}`,
+      );
     }
   }
   const rawStream = fs.createWriteStream(tempName);

package/lib/writer/static-dicomweb.code-workspace

@@ -0,0 +1,8 @@
+{
+	"folders": [
+		{
+			"path": "../../../.."
+		}
+	],
+	"settings": {}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radicalimaging/static-wado-creator",
-  "version": "1.5.0",
+  "version": "1.6.10",
   "description": "Library to convert DICOMP10 to DICOMweb format. Original upstream: https://github.com/chafey/dicomp10-to-dicomweb-js",
   "publishConfig": {
     "access": "public"
@@ -10,11 +10,9 @@
     "DICOM",
     "DICOMweb"
   ],
-  "author": [
-    "Chris Hafey <chafey@gmail.com>",
-    "Bill Wallace <bill.wallace@radicalimaging.com>"
-  ],
+  "author": "Bill Wallace <bill.wallace@radicalimaging.com>",
   "contributors": [
+    "Chris Hafey <chafey@gmail.com>",
     "Rodolfo Costa <rodolfo.costa@radicalimaging.com>"
   ],
   "engines": {
@@ -24,48 +22,54 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/OHIF/static-wado",
+    "url": "https://github.com/radicalimaging/static-dicomweb",
     "directory": "packages/static-wado-creator"
   },
   "bugs": {
-    "url": "https://github.com/OHIF/static-wado/issues"
+    "url": "https://github.com/radicalimaging/static-dicomweb/issues"
   },
-  "homepage": "https://github.com/OHIF/static-wado#readme",
+  "homepage": "https://github.com/radicalimaging/static-dicomweb#readme",
   "license": "ISC",
   "main": "lib/index.js",
+  "module": "dist/index.js",
   "directories": {
     "lib": "lib",
+    "dist": "dist",
     "bin": "bin"
   },
   "files": [
     "bin",
+    "dist",
     "lib"
   ],
   "bin": {
-    "mkdicomweb": "bin/mkdicomweb.js"
+    "mkdicomweb": "bin/mkdicomweb.mjs"
   },
   "scripts": {
     "test": "jest --config ./jest.config.js",
-    "build": "echo \"No build yet\" && exit 0",
+    "build": "bun run build:esm",
+    "build:esm": "bun build lib/index.js --target node --outdir dist --",
+    "clean": "rimraf dist",
     "link:exec": "npm install -g && npm link",
     "lint": "npx eslint --color \"**/*.{js,mjs,cjs}\"",
+    "mkdicomweb": "bun bin/mkdicomwebDev.mjs --",
+    "pack:js": "npm pack --",
+    "publishJS": "yarn publish  --no-git-tag-version",
     "lint:fix": "npx eslint --fix --color \"**/*.{js,mjs,cjs}\""
   },
   "jest": {
     "verbose": true
   },
   "dependencies": {
-    "@cornerstonejs/dicom-codec": ">=1.0.5",
-    "@radicalimaging/static-cs-lite": "^1.5.0",
-    "@radicalimaging/static-wado-util": "^1.5.0",
-    "canvas": "^2.11.1",
+    "@radicalimaging/cs3d": ">=1.6.1",
+    "@radicalimaging/static-wado-util": ">=1.6.1",
+    "canvas": ">=3.1.0",
     "config-point": ">=0.5.1",
-    "dcmjs": "^0.29.5",
+    "dcmjs": "0.35.0",
     "dicom-parser": "^1.8.13",
-    "glob": "^7.2.0",
+    "glob": "^11.0.0",
     "node-object-hash": "^3.0.0",
-    "npmjs": "npm publish",
-    "uuid": "^8.3.2"
+    "uuid": "^11.0.2"
   },
   "devDependencies": {
     "must": "^0.13.4"

package/bin/mkdicomweb.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-
-const { mkdicomwebConfig } = require("../lib");
-const { configureProgram } = require("../lib/program");
-
-// Configure program commander
-configureProgram(mkdicomwebConfig).then(() => {
-  console.verbose("done");
-});