@radicalimaging/static-wado-creator 1.6.10 → 1.6.12

package/lib/DeleteStudy.js

@@ -1,21 +1,16 @@
-const { JSONReader } = require("@radicalimaging/static-wado-util");
-const { JSONWriter } = require("@radicalimaging/static-wado-util");
-const { Tags } = require("@radicalimaging/static-wado-util");
+const { JSONReader } = require('@radicalimaging/static-wado-util');
+const { JSONWriter } = require('@radicalimaging/static-wado-util');
+const { Tags } = require('@radicalimaging/static-wado-util');
 
-module.exports = (options) =>
+module.exports = options =>
   async function (studyInstanceUid) {
-    console.log("Delete Study", studyInstanceUid);
-    const studyData = await this.scanStudy("studies", studyInstanceUid);
+    console.log('Delete Study', studyInstanceUid);
+    const studyData = await this.scanStudy('studies', studyInstanceUid);
     studyData.delete();
-    const allStudies = await JSONReader(
-      options.directoryName,
-      "studies/index.json.gz",
-      [],
-    );
+    const allStudies = await JSONReader(options.directoryName, 'studies/index.json.gz', []);
     const studiesWithoutDeleted = allStudies.filter(
-      (study) =>
-        studyInstanceUid != Tags.getValue(study, Tags.StudyInstanceUID),
+      study => studyInstanceUid != Tags.getValue(study, Tags.StudyInstanceUID)
     );
-    await JSONWriter(options.directoryName, "studies", studiesWithoutDeleted);
+    await JSONWriter(options.directoryName, 'studies', studiesWithoutDeleted);
     delete this.studyData;
   };

package/lib/RejectInstance.js

@@ -6,30 +6,19 @@ module.exports = () =>
     let studyInstanceUid = args[0];
     let seriesInstanceUid;
     let sopInstanceUid;
-    const reason = args[2] || "REJECT";
+    const reason = args[2] || 'REJECT';
     const extracted = args[0].match(dataExtractor);
     if (extracted) {
       studyInstanceUid = extracted[2];
       seriesInstanceUid = extracted[4];
       sopInstanceUid = extracted[6];
-      console.log(
-        "Extracted",
-        studyInstanceUid,
-        seriesInstanceUid,
-        sopInstanceUid,
-        reason,
-      );
+      console.log('Extracted', studyInstanceUid, seriesInstanceUid, sopInstanceUid, reason);
     } else {
-      console.log(
-        "Not extracting from URL",
-        studyInstanceUid,
-        seriesInstanceUid,
-        reason,
-      );
+      console.log('Not extracting from URL', studyInstanceUid, seriesInstanceUid, reason);
       seriesInstanceUid = args[1];
     }
     const studyData = await this.scanStudy(studyInstanceUid);
-    console.verbose("Trying to reject", seriesInstanceUid, "because", reason);
+    console.verbose('Trying to reject', seriesInstanceUid, 'because', reason);
     await studyData.reject(seriesInstanceUid, sopInstanceUid, reason);
     await studyData.writeDeduplicatedGroup();
     return studyData.writeMetadata();

package/lib/StaticWado.js

@@ -1,5 +1,5 @@
-const dicomCodec = require("@cornerstonejs/dicom-codec");
-const staticCS = require("@radicalimaging/cs3d");
+const dicomCodec = require('@cornerstonejs/dicom-codec');
+const staticCS = require('@radicalimaging/cs3d');
 const {
   Stats,
   handleHomeRelative,
@@ -8,41 +8,36 @@ const {
   JSONWriter,
   asyncIterableToBuffer,
   Tags,
-} = require("@radicalimaging/static-wado-util");
-const dicomParser = require("dicom-parser");
-const fs = require("fs");
-const path = require("path");
-const { NotificationService } = require("@radicalimaging/static-wado-util");
-const getDataSet = require("./operation/getDataSet");
-const InstanceDeduplicate = require("./operation/InstanceDeduplicate");
-const DeduplicateWriter = require("./writer/DeduplicateWriter");
-const ImageFrameWriter = require("./writer/ImageFrameWriter");
-const WriteStream = require("./writer/WriteStream");
-const CompleteStudyWriter = require("./writer/CompleteStudyWriter");
-const IdCreator = require("./util/IdCreator");
-const ScanStudy = require("./operation/ScanStudy");
-const HashDataWriter = require("./writer/HashDataWriter");
-const VideoWriter = require("./writer/VideoWriter");
+} = require('@radicalimaging/static-wado-util');
+const dicomParser = require('dicom-parser');
+const fs = require('fs');
+const path = require('path');
+const { NotificationService } = require('@radicalimaging/static-wado-util');
+const getDataSet = require('./operation/getDataSet');
+const InstanceDeduplicate = require('./operation/InstanceDeduplicate');
+const DeduplicateWriter = require('./writer/DeduplicateWriter');
+const ImageFrameWriter = require('./writer/ImageFrameWriter');
+const WriteStream = require('./writer/WriteStream');
+const CompleteStudyWriter = require('./writer/CompleteStudyWriter');
+const IdCreator = require('./util/IdCreator');
+const ScanStudy = require('./operation/ScanStudy');
+const HashDataWriter = require('./writer/HashDataWriter');
+const VideoWriter = require('./writer/VideoWriter');
 const {
   transcodeImageFrame,
   generateLossyImage,
   transcodeId,
   transcodeMetadata,
-} = require("./operation/adapter/transcodeImage");
-const ThumbnailWriter = require("./writer/ThumbnailWriter");
-const decodeImage = require("./operation/adapter/decodeImage");
-const ThumbnailService = require("./operation/ThumbnailService");
-const DeleteStudy = require("./DeleteStudy");
-const RejectInstance = require("./RejectInstance");
-const RawDicomWriter = require("./writer/RawDicomWriter");
-const { isVideo } = require("./writer/VideoWriter");
-const validateMetadata = require("./operation/validateMetadata.js");
-const {
-  Success,
-  Failure,
-  clearResults,
-  WriteResults,
-} = require("./util/resultsReport");
+} = require('./operation/adapter/transcodeImage');
+const ThumbnailWriter = require('./writer/ThumbnailWriter');
+const decodeImage = require('./operation/adapter/decodeImage');
+const ThumbnailService = require('./operation/ThumbnailService');
+const DeleteStudy = require('./DeleteStudy');
+const RejectInstance = require('./RejectInstance');
+const RawDicomWriter = require('./writer/RawDicomWriter');
+const { isVideo } = require('./writer/VideoWriter');
+const validateMetadata = require('./operation/validateMetadata.js');
+const { Success, Failure, clearResults, WriteResults } = require('./util/resultsReport');
 
 function setStudyData(studyData) {
   this.studyData = studyData;
@@ -53,31 +48,24 @@ async function cs3dThumbnail(
   dataset,
   metadata,
   transferSyntaxUid,
-  doneCallback,
+  doneCallback
 ) {
   if (!originalImageFrame) {
     throw new Error(`No originalImageFrame data available`);
   }
   if (!dataset && !metadata) {
-    throw new Error(
-      `Neither dataset ${!!dataset} nor metadata ${!!metadata} available.`,
-    );
+    throw new Error(`Neither dataset ${!!dataset} nor metadata ${!!metadata} available.`);
   }
   if (isVideo(transferSyntaxUid)) {
-    console.log("Video data - no thumbnail generator yet");
+    console.log('Video data - no thumbnail generator yet');
     return;
   }
 
   let decodeResult;
   try {
-    decodeResult = await decodeImage(
-      originalImageFrame,
-      dataset,
-      metadata,
-      transferSyntaxUid,
-    );
+    decodeResult = await decodeImage(originalImageFrame, dataset, metadata, transferSyntaxUid);
   } catch (error) {
-    console.log("Error while decoding image:", error);
+    console.noQuiet('Error while decoding image:', error);
     return;
   }
 
@@ -87,25 +75,20 @@ async function cs3dThumbnail(
   }
 
   const { imageFrame, imageInfo } = decodeResult;
-  const pixelData = dicomCodec.getPixelData(
-    imageFrame,
-    imageInfo,
-    transferSyntaxUid,
-  );
-  return staticCS.getRenderedBuffer(
-    transferSyntaxUid,
-    pixelData,
-    metadata,
-    doneCallback,
-  );
+  const pixelData = dicomCodec.getPixelData(imageFrame, imageInfo, transferSyntaxUid);
+  return staticCS.getRenderedBuffer(transferSyntaxUid, pixelData, metadata, doneCallback, {
+    quality: 0.6,
+    width: 256,
+    height: 256,
+  });
 }
 
 class StaticWado {
   constructor(configuration) {
     const {
-      rootDir = "~/dicomweb",
-      pathDeduplicated = "deduplicated",
-      pathInstances = "instances",
+      rootDir = '~/dicomweb',
+      pathDeduplicated = 'deduplicated',
+      pathInstances = 'instances',
       verbose,
       quiet = false,
       multipart = false,
@@ -124,7 +107,7 @@ class StaticWado {
       deduplicatedRoot: path.join(directoryName, pathDeduplicated),
       deduplicatedInstancesRoot: path.join(directoryName, pathInstances),
       // TODO - make this configurable and auto-detect by updating the parseDicom library
-      TransferSyntaxUID: "1.2.840.10008.1.2.1",
+      TransferSyntaxUID: '1.2.840.10008.1.2.1',
     };
     this.callback = {
       uids: IdCreator(this.options),
@@ -145,9 +128,7 @@ class StaticWado {
       clearResults,
       setStudyData,
       rawDicomWriter: RawDicomWriter(this.options),
-      notificationService: new NotificationService(
-        this.options.notificationDir,
-      ),
+      notificationService: new NotificationService(this.options.notificationDir),
       internalGenerateImage: cs3dThumbnail,
     };
   }
@@ -169,7 +150,7 @@ class StaticWado {
    * @param {string[]} args listing the studies to remove
    */
   async delete(args) {
-    args.forEach((studyUID) => this.callback.delete(studyUID));
+    args.forEach(studyUID => this.callback.delete(studyUID));
   }
 
   /**
@@ -183,14 +164,11 @@ class StaticWado {
   updateProgress() {
     if (!this.showProgress) return;
     this.processedFiles++;
-    const percentage = Math.round(
-      (this.processedFiles / this.totalFiles) * 100,
-    );
+    const percentage = Math.round((this.processedFiles / this.totalFiles) * 100);
     const progressBar =
-      "=".repeat(Math.floor(percentage / 4)) +
-      "-".repeat(25 - Math.floor(percentage / 4));
+      '='.repeat(Math.floor(percentage / 4)) + '-'.repeat(25 - Math.floor(percentage / 4));
     process.stdout.write(
-      `\r[${progressBar}] ${percentage}% | ${this.processedFiles}/${this.totalFiles} files`,
+      `\r[${progressBar}] ${percentage}% | ${this.processedFiles}/${this.totalFiles} files`
     );
   }
 
@@ -202,20 +180,19 @@ class StaticWado {
           if (fs.statSync(file).isDirectory()) {
             const dirFiles = fs.readdirSync(file, { recursive: true });
             this.totalFiles += dirFiles.filter(
-              (f) => !fs.statSync(path.join(file, f)).isDirectory(),
+              f => !fs.statSync(path.join(file, f)).isDirectory()
             ).length;
           } else {
             this.totalFiles++;
           }
         } catch (e) {
+          console.verbose('File not dicom', e);
           this.callback.failure(
-            "File not DICOM",
+            'File not DICOM',
             {
-              FailedSOPSequence: [
-                { FailureReason: 0xd000, TextValue: "File not DICOM" },
-              ],
+              FailedSOPSequence: [{ FailureReason: 0xd000, TextValue: 'File not DICOM' }],
             },
-            file,
+            file
           );
         }
       }
@@ -225,40 +202,41 @@ class StaticWado {
     let filesProcessed = 0;
     const result = await dirScanner(files, {
       ...params,
-      callback: async (file) => {
+      callback: async file => {
         try {
           const dicomp10stream = fs.createReadStream(file);
           await this.importBinaryDicom(dicomp10stream, { ...params, file });
           filesProcessed++;
-          Stats.StudyStats.add("DICOM P10", "Parse DICOM P10 file");
+          Stats.StudyStats.add('DICOM P10', 'Parse DICOM P10 file');
           this.updateProgress();
         } catch (e) {
+          console.noQuiet('Create failure', e);
           this.updateProgress();
           const message = {
             FailedSOPSequence: [
               {
                 FailureReason: 0xd000,
-                TextValue: "File not DICOM",
+                TextValue: 'File not DICOM',
                 StorageURL: file,
               },
             ],
           };
-          this.callback.failure("Not DICOM", message, file, e);
+          this.callback.failure('Not DICOM', message, file, e);
         }
       },
     });
 
     if (!filesProcessed) {
       const message = {
-        action: "metadata",
+        action: 'metadata',
         count: 0,
         status: -1,
       };
-      this.callback.failure("No files processed", message);
+      this.callback.failure('No files processed', message);
     }
 
     if (this.showProgress) {
-      console.log("\n"); // Move to next line after progress bar
+      console.log('\n'); // Move to next line after progress bar
     }
     return result;
   }
@@ -271,7 +249,7 @@ class StaticWado {
   async processStudyDir(studyUids /* , options */) {
     for (const studyUid of studyUids) {
       const study = await this.callback.scanStudy(studyUid);
-      console.log("Processed study", study.studyInstanceUid);
+      console.log('Processed study', study.studyInstanceUid);
     }
   }
 
@@ -282,7 +260,7 @@ class StaticWado {
     // Parse it
     const dataSet = dicomParser.parseDicom(buffer, params);
 
-    const studyInstanceUid = dataSet.string("x0020000d");
+    const studyInstanceUid = dataSet.string('x0020000d');
 
     if (!studyInstanceUid) {
       console.log("No study UID, can't import file", params.file);
@@ -293,18 +271,14 @@ class StaticWado {
     const id = this.callback.uids(
       {
         studyInstanceUid,
-        seriesInstanceUid: dataSet.string("x0020000e"),
-        sopInstanceUid: dataSet.string("x00080018"),
-        transferSyntaxUid: dataSet.string("x00020010"),
+        seriesInstanceUid: dataSet.string('x0020000e'),
+        sopInstanceUid: dataSet.string('x00080018'),
+        transferSyntaxUid: dataSet.string('x00020010'),
       },
-      params.file,
+      params.file
     );
 
-    const targetId = transcodeId(
-      id,
-      this.options,
-      dataSet.uint16(Tags.RawSamplesPerPixel),
-    );
+    const targetId = transcodeId(id, this.options, dataSet.uint16(Tags.RawSamplesPerPixel));
 
     let bulkDataIndex = 0;
     let imageFrameIndex = 0;
@@ -315,38 +289,23 @@ class StaticWado {
         const _bulkDataIndex = bulkDataIndex;
         bulkDataIndex += 1;
         // TODO - handle other types here too as single part rendered
-        if (options?.mimeType === "application/pdf") {
-          console.log("Writing rendered mimeType", options.mimeType);
-          const writeStream = WriteStream(
-            id.sopInstanceRootPath,
-            "rendered.pdf",
-            {
-              gzip: false,
-              mkdir: true,
-            },
-          );
+        if (options?.mimeType === 'application/pdf') {
+          console.verbose('Writing rendered mimeType', options.mimeType);
+          const writeStream = WriteStream(id.sopInstanceRootPath, 'rendered.pdf', {
+            gzip: false,
+            mkdir: true,
+          });
           await writeStream.write(bulkData);
           await writeStream.close();
         }
-        return this.callback.bulkdata(
-          targetId,
-          _bulkDataIndex,
-          bulkData,
-          options,
-        );
+        return this.callback.bulkdata(targetId, _bulkDataIndex, bulkData, options);
       },
-      imageFrame: async (originalImageFrame) => {
+      imageFrame: async originalImageFrame => {
         const {
           imageFrame: transcodedImageFrame,
           decoded,
           id: transcodedId,
-        } = await transcodeImageFrame(
-          id,
-          targetId,
-          originalImageFrame,
-          dataSet,
-          this.options,
-        );
+        } = await transcodeImageFrame(id, targetId, originalImageFrame, dataSet, this.options);
 
         const lossyImage = await generateLossyImage(id, decoded, this.options);
 
@@ -357,7 +316,7 @@ class StaticWado {
           await this.callback.imageFrame(
             lossyImage.id,
             currentImageFrameIndex,
-            lossyImage.imageFrame,
+            lossyImage.imageFrame
           );
         }
 
@@ -369,16 +328,12 @@ class StaticWado {
             id,
             frameIndex: currentImageFrameIndex,
           },
-          this.options,
+          this.options
         );
 
-        return this.callback.imageFrame(
-          transcodedId,
-          currentImageFrameIndex,
-          transcodedImageFrame,
-        );
+        return this.callback.imageFrame(transcodedId, currentImageFrameIndex, transcodedImageFrame);
       },
-      videoWriter: async (_dataSet) => this.callback.videoWriter(id, _dataSet),
+      videoWriter: async _dataSet => this.callback.videoWriter(id, _dataSet),
     };
 
     // convert to DICOMweb MetaData and BulkData
@@ -394,14 +349,14 @@ class StaticWado {
       dataSet,
       transcodedMeta,
       this.callback,
-      this.options,
+      this.options
     );
     await thumbnailService.generateRendered(
       id,
       dataSet,
       transcodedMeta,
       this.callback,
-      this.options,
+      this.options
     );
     await this.callback.metadata(targetId, transcodedMeta);
 
@@ -418,15 +373,9 @@ class StaticWado {
     dataSet,
     metadata,
     transferSyntaxUid,
-    doneCallback,
+    doneCallback
   ) {
-    return cs3dThumbnail(
-      originalImageFrame,
-      dataSet,
-      metadata,
-      transferSyntaxUid,
-      doneCallback,
-    );
+    return cs3dThumbnail(originalImageFrame, dataSet, metadata, transferSyntaxUid, doneCallback);
   }
 
   /**
@@ -437,11 +386,11 @@ class StaticWado {
   async executeCommand(input) {
     this.callback.clearResults();
     if (this.options.scanStudies) {
-      console.log("Scanning study dir", input);
+      console.log('Scanning study dir', input);
       // Scan one of the study directories - in this case, files is a set of study directories
       await this.processStudyDir(input, this.options);
     } else {
-      console.noQuiet("Scanning files", input);
+      console.noQuiet('Scanning files', input);
       await this.processFiles(input, this.options);
     }
     await this.close();
@@ -450,30 +399,26 @@ class StaticWado {
 
   async close() {
     await this.callback.completeStudy(this.callback);
-    Stats.OverallStats.summarize("Completed Study Processing");
+    Stats.OverallStats.summarize('Completed Study Processing');
   }
 
   async reindex() {
     const { directoryName } = this.options;
     const studiesDir = `${directoryName}/studies/`;
 
-    console.log("Re-indexing", studiesDir);
+    console.noQuiet('Re-indexing', studiesDir);
     const dirs = await fs.promises.readdir(studiesDir);
     const studies = [];
     for (const dir of dirs) {
-      const study = await JSONReader(
-        `${studiesDir}/${dir}`,
-        "index.json.gz",
-        null,
-      );
+      const study = await JSONReader(`${studiesDir}/${dir}`, 'index.json.gz', null);
       if (study === null) {
-        console.log("No study found in", dir);
+        console.log('No study found in', dir);
         continue;
       }
-      console.log("Adding study", dir);
+      console.log('Adding study', dir);
       studies.push(...study);
     }
-    return JSONWriter(directoryName, "studies", studies);
+    return JSONWriter(directoryName, 'studies', studies);
   }
 }
 module.exports = StaticWado;

package/lib/createMain.js

@@ -1,11 +1,11 @@
-const StaticWado = require("./StaticWado");
-const adaptProgramOpts = require("./util/adaptProgramOpts");
+const StaticWado = require('./StaticWado');
+const adaptProgramOpts = require('./util/adaptProgramOpts');
 
 module.exports = function createMain(options, program) {
   const finalOptions = adaptProgramOpts(options, {
     ...this,
     // Instance metadata is the instances/<sopUID>/metadata.gz files
-    isInstance: true,
+    isInstance: false,
     // Deduplicated data is single instance deduplicated data
     isDeduplicate: false,
     // Group data is the group file directories

package/lib/createPart10.js

@@ -1,32 +1,28 @@
-const { Tags, readBulkData } = require("@radicalimaging/static-wado-util");
-const dcmjs = require("dcmjs");
+const { Tags, readBulkData } = require('@radicalimaging/static-wado-util');
+const dcmjs = require('dcmjs');
 
-const StaticWado = require("./StaticWado");
-const adaptProgramOpts = require("./util/adaptProgramOpts");
-const WriteStream = require("./writer/WriteStream");
+const StaticWado = require('./StaticWado');
+const adaptProgramOpts = require('./util/adaptProgramOpts');
+const WriteStream = require('./writer/WriteStream');
 
-const UncompressedLEIExplicit = "1.2.840.10008.1.2.1";
+const UncompressedLEIExplicit = '1.2.840.10008.1.2.1';
 const { DicomDict, DicomMetaDictionary } = dcmjs.data;
 
 const fileMetaInformationVersionArray = new Uint8Array(2);
 fileMetaInformationVersionArray[1] = 1;
 
-const createFmi = (instance) => {
+const createFmi = instance => {
   // Assume the TSUID is in the value 0
   const TransferSyntaxUID =
-    Tags.getValue(instance, Tags.AvailableTransferSyntaxUID) ||
-    UncompressedLEIExplicit;
-  const MediaStorageSOPClassUID = Tags.getValue(
-    instance,
-    Tags.MediaStorageSOPClassUID,
-  );
+    Tags.getValue(instance, Tags.AvailableTransferSyntaxUID) || UncompressedLEIExplicit;
+  const MediaStorageSOPClassUID = Tags.getValue(instance, Tags.MediaStorageSOPClassUID);
   const SOPInstanceUID = Tags.getValue(instance, Tags.SOPInstanceUID);
   const naturalFmi = {
     MediaStorageSOPClassUID,
     MediaStorageSOPInstanceUID: SOPInstanceUID,
-    ImplementationVersionName: "mkdicomweb",
+    ImplementationVersionName: 'mkdicomweb',
     TransferSyntaxUID,
-    ImplementationClassUID: "2.25.984723498557234098.001",
+    ImplementationClassUID: '2.25.984723498557234098.001',
     FileMetaInformationVersion: fileMetaInformationVersionArray.buffer,
   };
   const denaturalized = DicomMetaDictionary.denaturalizeDataset(naturalFmi);
@@ -35,11 +31,11 @@ const createFmi = (instance) => {
 
 const readBulkDataValue = async (studyDir, instance, value) => {
   const { BulkDataURI } = value;
-  value.vr = "OB";
+  value.vr = 'OB';
   const seriesUid = Tags.getValue(instance, Tags.SeriesInstanceUID);
   const numberOfFrames = Tags.getValue(instance, Tags.NumberOfFrames) || 1;
   const dir = `${studyDir}/series/${seriesUid}`;
-  if (BulkDataURI.indexOf("/frames") !== -1) {
+  if (BulkDataURI.indexOf('/frames') !== -1) {
     // Really only support a limited number of frames based on memory size
     value.Value = [];
     for (let frame = 1; frame <= numberOfFrames; frame++) {
@@ -61,15 +57,15 @@ const readBinaryData = async (dir, instance) => {
     }
     if (!v.vr) {
       const value0 = v.Value?.[0];
-      if (typeof value0 === "string") {
-        v.vr = "LT";
+      if (typeof value0 === 'string') {
+        v.vr = 'LT';
       } else {
-        console.log("Deleting", tag, v.Value, v);
+        console.log('Deleting', tag, v.Value, v);
         delete instance[tag];
       }
       continue;
     }
-    if (v.vr === "SQ") {
+    if (v.vr === 'SQ') {
       await Promise.all(v.Values.map(readBinaryData));
       continue;
     }
@@ -100,14 +96,14 @@ module.exports = async function createMain(options, program) {
   const importer = new StaticWado(finalOptions);
   const studyInstanceUid = program.args[0];
   const dir = `${importer.options.rootDir}/studies/${studyInstanceUid}`;
-  console.log("Creating part 10 for", studyInstanceUid, dir);
+  console.log('Creating part 10 for', studyInstanceUid, dir);
   const study = await importer.callback.scanStudy(studyInstanceUid);
   const outputPath = `./studies/${studyInstanceUid}`;
   for (const sop of study.getSopUids()) {
     const instance = await study.recombine(sop);
     const fmi = createFmi(instance);
 
-    console.noQuiet("Processing sop", sop);
+    console.noQuiet('Processing sop', sop);
     const dicomDict = new DicomDict(fmi);
     await readBinaryData(dir, instance);
     dicomDict.dict = instance;