@radicalimaging/static-wado-creator 1.1.0 → 1.2.0

package/lib/operation/ThumbnailService.js

@@ -1,13 +1,8 @@
 const path = require("path");
 const glob = require("glob");
-const dicomCodec = require("@cornerstonejs/dicom-codec");
-const staticCS = require("@radicalimaging/static-cs-lite");
 const fs = require("fs");
-const { exec } = require("child_process");
-const { Tags } = require("@radicalimaging/static-wado-util");
-const decodeImage = require("./adapter/decodeImage");
+const { Tags, execSpawn, Stats } = require("@radicalimaging/static-wado-util");
 const { shouldThumbUseTranscoded } = require("./adapter/transcodeImage");
-const { isVideo } = require("../writer/VideoWriter");
 
 /**
  * Return the middle index of given list
@@ -17,21 +12,6 @@ const { isVideo } = require("../writer/VideoWriter");
 function getThumbIndex(listThumbs) {
   return Math.trunc(listThumbs / 2);
 }
-function internalGenerateThumbnail(originalImageFrame, dataset, metadata, transferSyntaxUid, doneCallback) {
-  decodeImage(originalImageFrame, dataset, transferSyntaxUid)
-    .then((decodeResult = {}) => {
-      if (isVideo(transferSyntaxUid)) {
-        console.log("Video data - no thumbnail generator yet");
-      } else {
-        const { imageFrame, imageInfo } = decodeResult;
-        const pixelData = dicomCodec.getPixelData(imageFrame, imageInfo, transferSyntaxUid);
-        staticCS.getRenderedBuffer(transferSyntaxUid, pixelData, metadata, doneCallback);
-      }
-    })
-    .catch((error) => {
-      console.log(`Error while generating thumbnail:: ${error}`);
-    });
-}
 
 /**
  * ThumbObj wrapper containing both original and transcoded content.
@@ -97,21 +77,11 @@ class ThumbnailService {
   }
 
   ffmpeg(input, output) {
-    exec(`ffmpeg -i "${input}" -vf  "thumbnail,scale=640:360" -frames:v 1 -f singlejpeg "${output}"`, (error, stdout, stderr) => {
-      if (error) {
-        console.log(`error: ${error.message}`);
-        return;
-      }
-      if (stderr) {
-        console.log(`stderr: ${stderr}`);
-        return;
-      }
-      console.log(`stdout: ${stdout}`);
-    });
+    execSpawn(`ffmpeg -i "${input}" -vf  "thumbnail,scale=640:360" -frames:v 1 -f singlejpeg "${output}"`);
   }
 
   /**
-   * Generates thumbnails for the levels: instances, series, study
+   * Generates thumbnails for the levels: instances, series, study.  This is asynchronous
    *
    * @param {*} dataSet
    * @param {*} metadata
@@ -127,7 +97,8 @@ class ThumbnailService {
         const { BulkDataURI } = pixelData;
         if (BulkDataURI?.indexOf("mp4")) {
           const mp4Path = path.join(itemId.sopInstanceRootPath, "pixeldata.mp4");
-          const thumbPath = path.join(itemId.sopInstanceRootPath, "thumbnail");
+          // Generate as rendered, as more back ends support that.
+          const thumbPath = path.join(itemId.sopInstanceRootPath, "rendered");
           console.log("MP4 - converting video format", mp4Path);
           this.ffmpeg(mp4Path, thumbPath);
         } else {
@@ -136,15 +107,23 @@ class ThumbnailService {
       } else {
         console.log("Series is of other type...", metadata[Tags.Modality]);
       }
-      return;
+      return null;
     }
-    internalGenerateThumbnail(imageFrame, dataSet, metadata, id.transferSyntaxUid, async (thumbBuffer) => {
-      if (thumbBuffer) {
-        await callback.thumbWriter(id.sopInstanceRootPath, this.thumbFileName, thumbBuffer);
-
-        this.copySyncThumbnail(id.sopInstanceRootPath, id.seriesRootPath);
-        this.copySyncThumbnail(id.seriesRootPath, id.studyPath);
-      }
+    return new Promise((resolve, reject) => {
+      callback.internalGenerateImage(imageFrame, dataSet, metadata, id.transferSyntaxUid, async (thumbBuffer) => {
+        try {
+          if (thumbBuffer) {
+            await callback.thumbWriter(id.sopInstanceRootPath, this.thumbFileName, thumbBuffer);
+
+            this.copySyncThumbnail(id.sopInstanceRootPath, id.seriesRootPath);
+            this.copySyncThumbnail(id.seriesRootPath, id.studyPath);
+            Stats.StudyStats.add("Thumbnail Write", `Write thumbnail ${this.thumbFileName}`, 100);
+          }
+          resolve(this.thumbFileName);
+        } catch (e) {
+          reject(e);
+        }
+      });
     });
   }
 

package/lib/operation/adapter/transcodeImage.js

@@ -2,6 +2,8 @@ const dicomCodec = require("@cornerstonejs/dicom-codec");
 const { Tags } = require("@radicalimaging/static-wado-util");
 const getImageInfo = require("./getImageInfo");
 
+dicomCodec.setConfig("verbose: false");
+
 const transcodeOp = {
   none: 0,
   decode: 1,
@@ -37,6 +39,10 @@ const transcodeDestinationMap = {
     transferSyntaxUid: "3.2.840.10008.1.2.4.96",
     transcodeOp: transcodeOp.encode,
   },
+  jpeg: {
+    transferSyntaxUid: "1.2.840.10008.1.2.4.50",
+    transcodeOp: transcodeOp.encode,
+  },
 };
 
 const transcodeSourceMap = {
@@ -52,6 +58,10 @@ const transcodeSourceMap = {
     transcodeOp: transcodeOp.decode,
     alias: "uncompressed",
   },
+  "1.2.840.10008.1.2.4.50": {
+    transcodeOp: transcodeOp.decode,
+    alias: "jpeg",
+  },
   "1.2.840.10008.1.2.4.57": {
     transcodeOp: transcodeOp.decode,
     alias: "jls",
@@ -98,10 +108,8 @@ function getDestinationTranscoder(id) {
  * @param {*} transferSyntaxUid
  * @returns
  */
-function getTranscoder(transferSyntaxUid, { contentType, verbose }) {
-  if (verbose) {
-    console.log('getTranscoder for', transferSyntaxUid, 'source to', contentType);
-  }
+function getTranscoder(transferSyntaxUid, { contentType: greyContentType, colorContentType }, samplesPerPixel) {
+  const contentType = samplesPerPixel===3 ? colorContentType : greyContentType;
   const sourceTranscoder = transcodeSourceMap[transferSyntaxUid];
   const destinationTranscoder = getDestinationTranscoder(contentType);
   if (!sourceTranscoder || !destinationTranscoder) {
@@ -120,22 +128,23 @@ function getTranscoder(transferSyntaxUid, { contentType, verbose }) {
  * @param {*} id object containing transferSyntaxUid
  * @param {*} options runner options
  */
-function shouldTranscodeImageFrame(id, options) {
-  const { recompress } = options;
+function shouldTranscodeImageFrame(id, options, samplesPerPixel) {
+  const { recompress: recompressGrey, recompressColor } = options;
+  const recompress = samplesPerPixel === 3 ? recompressColor : recompressGrey;
   if (!recompress) {
-    if( options.verbose ) console.log("Not transcoding because recompress not set");
+    console.verbose("Not transcoding because recompress not set");
     return false;
   }
 
   function isValidTranscoder() {
     const { transferSyntaxUid } = id;
-    const transcoder = getTranscoder(transferSyntaxUid, options);
+    const transcoder = getTranscoder(transferSyntaxUid, options, samplesPerPixel);
     return transcoder && transcoder.transferSyntaxUid && (recompress.includes("true") || recompress.includes(transcoder.alias));
   }
 
-  const ret  = isValidTranscoder();
-  if( !ret && options.verbose ) {
-    console.log("Not transcoding");
+  const ret = isValidTranscoder();
+  if (!ret) {
+    console.verbose("Not transcoding");
   }
   return ret;
 }
@@ -154,7 +163,8 @@ function shouldThumbUseTranscoded(id, options) {
 
   function isValidTranscoder() {
     const { transferSyntaxUid } = id;
-    const transcoder = getTranscoder(transferSyntaxUid, options);
+    // Ignore the samples per pixel for thumbnails
+    const transcoder = getTranscoder(transferSyntaxUid, options, "thumbnail");
     const result = transcoder && transcoder.transferSyntaxUid && options.recompress.includes(transcoder.alias) && options.recompressThumb.includes(transcoder.alias);
 
     return result;
@@ -183,8 +193,9 @@ async function transcodeImageFrame(id, targetIdSrc, imageFrame, dataSet, options
   let targetId = targetIdSrc;
   let result = {};
 
-  if (!shouldTranscodeImageFrame(id, options)) {
-    console.log("Shouldn't transcode");
+  const samplesPerPixel = dataSet.uint16(Tags.RawSamplesPerPixel);
+  if (!shouldTranscodeImageFrame(id, options, samplesPerPixel)) {
+    console.verbose("Shouldn't transcode");
     return {
       id,
       imageFrame,
@@ -192,11 +203,11 @@ async function transcodeImageFrame(id, targetIdSrc, imageFrame, dataSet, options
     };
   }
 
-  const transcoder = getTranscoder(id.transferSyntaxUid, options);
+  const transcoder = getTranscoder(id.transferSyntaxUid, options, samplesPerPixel);
 
   // last chance to prevent transcoding
   if (targetId.transferSyntaxUid !== transcoder.transferSyntaxUid) {
-     console.log("Image is already in", targetId.transferSyntaxUid, "not transcoding");
+    console.verbose("Image is already in", targetId.transferSyntaxUid, "not transcoding");
     return {
       id,
       imageFrame,
@@ -204,8 +215,8 @@ async function transcodeImageFrame(id, targetIdSrc, imageFrame, dataSet, options
     };
   }
 
-  if( options.verbose ) console.log("Transcoding to", transcoder.transferSyntaxUid);
-  
+  console.verbose("Transcoding to", transcoder.transferSyntaxUid);
+
   const imageInfo = getImageInfo(dataSet);
   let done = false;
   let processResultMsg = "";
@@ -269,13 +280,13 @@ async function transcodeImageFrame(id, targetIdSrc, imageFrame, dataSet, options
  * @param {*} options runner options.
  * @returns Transcoded id object
  */
-function transcodeId(id, options) {
-  if (!shouldTranscodeImageFrame(id, options)) {
+function transcodeId(id, options, samplesPerPixel) {
+  if (!shouldTranscodeImageFrame(id, options, samplesPerPixel)) {
     return id;
   }
 
   const targetId = { ...id };
-  const { transferSyntaxUid } = getTranscoder(id.transferSyntaxUid, options);
+  const { transferSyntaxUid } = getTranscoder(id.transferSyntaxUid, options, samplesPerPixel);
 
   targetId.transferSyntaxUid = transferSyntaxUid;
 
@@ -294,19 +305,18 @@ function transcodeId(id, options) {
  * @returns Transcoded metadata.
  */
 function transcodeMetadata(metadata, id, options) {
-  if (!shouldTranscodeImageFrame(id, options)) {
+  const samplesPerPixel = Tags.getValue(metadata, Tags.SamplesPerPixel);
+  if (!shouldTranscodeImageFrame(id, options, samplesPerPixel)) {
     return metadata;
   }
 
-  const transcodedId = transcodeId(id, options);
+  const transcodedId = transcodeId(id, options, samplesPerPixel);
 
   const result = { ...metadata };
 
   if (result[Tags.AvailableTransferSyntaxUID]) {
     Tags.setValue(result, Tags.AvailableTransferSyntaxUID, transcodedId.transferSyntaxUid);
-    if( this.verbose ) {
-      console.log("Apply available tsuid", transcodeId.transferSyntaxUid);
-    }
+    console.verbose("Apply available tsuid", transcodeId.transferSyntaxUid);
   }
 
   return result;

package/lib/operation/extractImageFrames.js

@@ -1,3 +1,5 @@
+const { Stats } = require("@radicalimaging/static-wado-util");
+
 const getNumberOfFrames = require("./getNumberOfFrames");
 const getUncompressedImageFrame = require("./getUncompressedImageFrame");
 const getEncapsulatedImageFrame = require("./getEncapsulatedImageFrame");
@@ -30,6 +32,7 @@ const extractImageFrames = async (dataSet, attr, vr, callback) => {
     if (attr.encapsulatedPixelData) {
       const compressedFrame = getEncapsulatedImageFrame(dataSet, attr, frameIndex, framesAreFragmented);
       BulkDataURI = await callback.imageFrame(compressedFrame, { dataSet });
+      Stats.OverallStats.add("Image Write", `Write image frame ${frameIndex + 1}`, 5000);
     } else {
       const uncompressedFrame = getUncompressedImageFrame(dataSet, attr, frameIndex, uncompressedFrameSize);
       BulkDataURI = await callback.imageFrame(uncompressedFrame, { dataSet });

package/lib/operation/getDataSet.js

@@ -13,8 +13,9 @@ const getValue = require("./getValue");
  * @param {*} parentAttr Parent reference for sequence element tags.
  * @returns
  */
-async function getDataSet(dataSet, callback, options, parentAttr = undefined) {
+async function getDataSet(dataSet, callback, optionsOrig, parentAttr = undefined) {
   const metadata = {};
+  let options = optionsOrig;
 
   // iterate over dataSet attributes in order
   for (const tag in dataSet.elements) {
@@ -22,6 +23,10 @@ async function getDataSet(dataSet, callback, options, parentAttr = undefined) {
     if (tag != Tags.RawTransferSyntaxUID && tag >= Tags.RawMinTag && tag < Tags.RawFirstBodyTag) {
       continue;
     }
+    if (tag === Tags.RawSpecificCharacterSet) {
+      const SpecificCharacterSet = dataSet.string(tag);
+      options = { ...options, SpecificCharacterSet };
+    }
     const attr = dataSet.elements[tag];
     /* eslint-disable-next-line no-use-before-define */
     await attributeToJS(metadata, tag, dataSet, attr, callback, options, parentAttr);

package/lib/operation/getValue.js

@@ -1,10 +1,21 @@
 const extractImageFrames = require("./extractImageFrames");
 
-const getValueInlineString = (dataSet, attr) => [dataSet.string(attr.tag)];
+function decodeUtf8(s, options) {
+  if (options?.SpecificCharacterSet === "ISO_IR 192") {
+    return decodeURIComponent(escape(s));
+  }
+  return s;
+}
+
+/** Gets a value as a UTF-8 string - todo, make UTF-8 decode optional. */
+const getValueInlineString = (dataSet, attr, options) => [decodeUtf8(dataSet.string(attr.tag), options)];
 
-const getStrings = (dataSet, attr) => {
+const getStrings = (dataSet, attr, options) => {
   const ret = dataSet.string(attr.tag);
-  return (ret && ret.split(/\\/)) || undefined;
+  if (ret) {
+    return ret.split(/\\/).map(decodeUtf8, options);
+  }
+  return undefined;
 };
 
 const getValuePatientName = (dataSet, attr) => {
@@ -78,7 +89,7 @@ const getValueInlineAttributeTag = (dataSet, attr) => {
   return groupHexStr + elementHexStr;
 };
 
-const getValueInline = (dataSet, attr, vr) => {
+const getValueInline = (dataSet, attr, vr, options) => {
   if (attr.length == 0) {
     return [];
   }
@@ -86,7 +97,7 @@ const getValueInline = (dataSet, attr, vr) => {
   switch (vr) {
     case "AE":
     case "AS":
-      return getValueInlineString(dataSet, attr);
+      return getValueInlineString(dataSet, attr, options);
     case "AT":
       return getValueInlineAttributeTag(dataSet, attr);
     case "DS":
@@ -94,7 +105,7 @@ const getValueInline = (dataSet, attr, vr) => {
     case "CS":
     case "DA":
     case "DT":
-      return getValueInlineString(dataSet, attr);
+      return getValueInlineString(dataSet, attr, options);
     case "FL":
       return getValueInlineFloat(dataSet, attr);
     case "FD":
@@ -103,7 +114,7 @@ const getValueInline = (dataSet, attr, vr) => {
       return getValueInlineIntString(dataSet, attr);
     case "LO":
     case "LT":
-      return getValueInlineString(dataSet, attr);
+      return getValueInlineString(dataSet, attr, options);
     case "OB":
     case "OF":
     case "OW":
@@ -111,7 +122,7 @@ const getValueInline = (dataSet, attr, vr) => {
     case "PN":
       return getValuePatientName(dataSet, attr);
     case "SH":
-      return getValueInlineString(dataSet, attr);
+      return getValueInlineString(dataSet, attr, options);
     case "SL":
       return getValueInlineSignedLong(dataSet, attr);
     case "SS":
@@ -119,7 +130,7 @@ const getValueInline = (dataSet, attr, vr) => {
     case "ST":
     case "TM":
     case "UI":
-      return getValueInlineString(dataSet, attr);
+      return getValueInlineString(dataSet, attr, options);
     case "UL":
       return getValueInlineUnsignedLong(dataSet, attr);
     case "UN":
@@ -127,7 +138,7 @@ const getValueInline = (dataSet, attr, vr) => {
     case "US":
       return getValueInlineUnsignedShort(dataSet, attr);
     case "UT":
-      return getValueInlineString(dataSet, attr);
+      return getValueInlineString(dataSet, attr, options);
     default:
       return getValueInlineBinary(dataSet, attr);
   }
@@ -183,7 +194,7 @@ const getValue = async (dataSet, attr, vr, getDataSet, callback, options, parent
   }
   // non sequence item
   if (isValueInline(attr, options)) {
-    return getValueInline(dataSet, attr, vr);
+    return getValueInline(dataSet, attr, vr, options);
   }
   const binaryValue = dataSet.byteArray.slice(attr.dataOffset, attr.dataOffset + attr.length);
   const mimeType = attr.tag == "x00420011" && dataSet.string("x00420012");

package/lib/rejectMain.js

@@ -1,12 +1,12 @@
 const StaticWado = require("./StaticWado");
 const adaptProgramOpts = require("./util/adaptProgramOpts");
 
-module.exports = function rejectMain(options, program) {
+module.exports = function rejectMain(args, options) {
   const finalOptions = adaptProgramOpts(options, {
     ...this,
     isGroup: true,
     isStudyData: true,
   });
   const importer = new StaticWado(finalOptions);
-  return importer.reject(program.args);
+  return importer.reject(args);
 };

package/lib/util/adaptProgramOpts.js

@@ -10,51 +10,30 @@ const assignDefined = (dest, src) => {
 
 module.exports = function adaptProgramOpts(programOpts, defaults) {
   const {
-    maximumInlinePublicLength,
-    maximumInlinePrivateLength,
     group: isGroup,
     instances: isInstanceMetadata,
     deduplicate: isDeduplicate,
     study: isStudyData,
     clean: isClean,
-    recompress,
-    recompressThumb,
-    contentType,
-    colourContentType,
     dir: rootDir,
-    pathDeduplicated,
-    pathInstances,
-    removeDeduplicatedInstances,
-    storeMultipartBulkData,
-    prependBulkDataUri,
-    expandBulkDataUri,
-    verbose,
-    scpPort,
+    delete: deleteInstances,
+    singlePartImage,
+    encapsulatedImage,
   } = programOpts;
 
   return assignDefined(
     { ...defaults },
     {
-      maximumInlinePublicLength,
-      maximumInlinePrivateLength,
-      isGroup,
-      isInstanceMetadata,
-      isDeduplicate,
+      ...programOpts,
       isStudyData,
       isClean,
-      recompress,
-      recompressThumb,
-      contentType,
-      colourContentType,
+      isInstanceMetadata,
+      isDeduplicate,
+      isGroup,
       rootDir,
-      pathDeduplicated,
-      pathInstances,
-      removeDeduplicatedInstances,
-      storeMultipartBulkData,
-      scpPort,
-      prependBulkDataUri,
-      expandBulkDataUri,
-      verbose,
+      encapsulatedImage: encapsulatedImage ?? singlePartImage !== true,
+      singlePartImage: singlePartImage ?? encapsulatedImage === false,
+      delete: deleteInstances,
     }
   );
 };

package/lib/writer/CompleteStudyWriter.js

@@ -26,9 +26,12 @@ const CompleteStudyWriter = (options) => {
       } else {
         console.log("Not writing new deduplicated data because it is clean:", studyData.studyInstanceUid);
       }
+      await studyData.deleteInstancesReferenced();
     }
 
     if (!options.isStudyData) {
+      console.verbose("Not configured to write study metadata", studyData.studyInstanceUid);
+      if (options.notifications) this.notificationService.notifyStudy(studyData.studyInstanceUid);
       delete this.studyData;
       Stats.StudyStats.summarize();
       return;
@@ -36,11 +39,12 @@ const CompleteStudyWriter = (options) => {
 
     const isDirtyMetadata = await studyData.dirtyMetadata();
     if (!isDirtyMetadata) {
-      console.log("Study metadata", studyData.studyInstanceUid, "has clean metadata, not writing");
+      console.log("Study metadata", studyData.studyInstanceUid, "is clean.");
       delete this.studyData;
       Stats.StudyStats.summarize(`Study metadata ${studyData.studyInstanceUid} has clean metadata, not writing`);
       return;
     }
+    console.log("Writing study metadata", studyData.studyInstanceUid);
 
     const studyQuery = await studyData.writeMetadata();
 
@@ -57,6 +61,7 @@ const CompleteStudyWriter = (options) => {
       allStudies[studyIndex] = studyQuery;
     }
     await JSONWriter(options.directoryName, "studies", allStudies);
+    if (options.notifications) this.notificationService.notifyStudy(studyData.studyInstanceUid);
     delete this.studyData;
     Stats.StudyStats.summarize(`Wrote study metadata/query files for ${studyData.studyInstanceUid}`);
   }

package/lib/writer/DeduplicateWriter.js

@@ -24,7 +24,10 @@ const DeduplicateWriter = (options) =>
     const studyData = await this.completeStudy.getCurrentStudyData(this, id);
 
     if (options.isDeduplicate) {
+      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");
     }
     studyData.addDeduplicated(data, id.filename);
   };

package/lib/writer/HashDataWriter.js

@@ -20,7 +20,6 @@ const HashDataWriter =
   (options) =>
   async (id, key, data, additionalOptions = {}) => {
     const isRaw = ArrayBuffer.isView(data);
-    const { storeMultipartBulkData } = options;
     const { mimeType } = additionalOptions;
     // If the file has an extension, it should be directly accessible as that file type.
     const gzip = !isRaw || (data.length > 1024 && !mimeType);
@@ -31,7 +30,7 @@ const HashDataWriter =
       mkdir: true,
       gzip,
     });
-    if (isRaw && storeMultipartBulkData) {
+    if (isRaw) {
       await WriteMultipart(writeStream, [new MultipartHeader("Content-Type", "application/octet-stream")], rawData);
     } else {
       await writeStream.write(rawData);

package/lib/writer/ImageFrameWriter.js

@@ -5,8 +5,7 @@ const ExpandUriPath = require("./ExpandUriPath");
 const { MultipartHeader, MultipartAttribute } = require("./MultipartHeader");
 
 const ImageFrameWriter = (options) => {
-  const { verbose, encapsulatedImageFrame = true } = options;
-
+  const { encapsulatedImage, singlePartImage } = options;
   return async (id, index, imageFrame) => {
     const { transferSyntaxUid } = id;
     const type = uids[transferSyntaxUid] || uids.default;
@@ -18,7 +17,7 @@ const ImageFrameWriter = (options) => {
       content = Buffer.from(imageFrame.buffer);
     }
 
-    if (encapsulatedImageFrame || !extension) {
+    if (encapsulatedImage || !extension) {
       const writeStream = WriteStream(id.imageFrameRootPath, `${1 + index}`, {
         gzip: type.gzip,
         mkdir: true,
@@ -28,19 +27,17 @@ const ImageFrameWriter = (options) => {
         [new MultipartHeader("Content-Type", type.contentType, [new MultipartAttribute("transfer-syntax", transferSyntaxUid)])],
         content
       );
-      writeStream.close();
-      if (verbose) {
-        console.log("Wrote encapsulated image frame", id.sopInstanceUid, index + 1, type.contentType);
-      }
+      await writeStream.close();
+      console.verbose("Wrote encapsulated image frame", id.sopInstanceUid, index + 1, type.contentType);
     }
-    if (extension) {
+    if (extension && singlePartImage) {
       const writeStreamSingle = WriteStream(id.imageFrameRootPath, `${1 + index}${extension}`, {
         gzip: type.gzip,
         mkdir: true,
       });
       await writeStreamSingle.write(content);
-      writeStreamSingle.close();
-      if (verbose) console.log("Wrote single part image frame", id.sopInstanceUid, index + 1, extension);
+      await writeStreamSingle.close();
+      console.verbose("Wrote single part image frame", id.sopInstanceUid, index + 1, extension);
     }
     const includeSeries = true;
     return ExpandUriPath(id, `instances/${id.sopInstanceUid}/frames`, { includeSeries, ...options });

package/lib/writer/ThumbnailWriter.js

@@ -1,21 +1,14 @@
 const WriteStream = require("./WriteStream");
 
-const ThumbnailWriter = (options) => {
-  const { verbose } = options;
+const ThumbnailWriter = () => async (filePath, fileName, thumbBuffer) => {
+  const writeStream = WriteStream(filePath, fileName, {
+    mkdir: true,
+  });
 
-  return async (filePath, fileName, thumbBuffer) => {
-    const writeStream = WriteStream(filePath, fileName, {
-      mkdir: true,
-    });
+  await writeStream.write(thumbBuffer);
 
-    await writeStream.write(thumbBuffer);
-
-    await writeStream.close();
-
-    if (verbose) {
-      console.log("Wrote thumbnail frame", filePath, fileName);
-    }
-  };
+  console.verbose("Wrote thumbnail frame", filePath, fileName);
+  return writeStream.close();
 };
 
 module.exports = ThumbnailWriter;

package/lib/writer/WriteStream.js

@@ -2,6 +2,8 @@ const fs = require("fs");
 const zlib = require("zlib");
 const path = require("path");
 
+let writeCount = 0;
+
 /** Create an optionally gzipped stream,
  * where the write operations are performed in order executed,
  * and don't require synchronization, only the 'close' operation
@@ -14,6 +16,14 @@ const WriteStream = (dir, nameSrc, options = {}) => {
 
   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}`);
+    }
+  }
   const rawStream = fs.createWriteStream(tempName);
   const closePromise = new Promise((resolve) => {
     rawStream.on("close", () => {
@@ -33,7 +43,8 @@ const WriteStream = (dir, nameSrc, options = {}) => {
   async function close() {
     await this.writeStream.end();
     await this.closePromise;
-    await fs.rename(tempName, finalName, () => true); // console.log('Renamed', tempName,finalName));
+    await fs.rename(tempName, finalName, () => true);
+    writeCount--;
   }
 
   return {