@radicalimaging/static-wado-creator 1.1.0 → 1.2.1

package/bin/mkdicomweb.js

@@ -5,5 +5,5 @@ const { configureProgram } = require("../lib/program");
 
 // Configure program commander
 configureProgram(mkdicomwebConfig).then(() => {
-  console.log("done");
+  console.verbose("done");
 });

package/lib/RejectInstance.js

@@ -1,16 +1,23 @@
-const dataExtractor = /^(.*studies)?[\\/]?([^/\\]+)[\\/](series[\\/])?([^/\\]+)([\\/]instances[\\/]([^/\\]*))?$/;
+const dataExtractor = /^(.*studies)?[\\/]?([0-9.a-zA-Z]+)[\\/](series[\\/])?([0-9.a-zA-Z]+)([\\/]instances[\\/]([0-9.a-zA-Z]*))?$/;
 
-module.exports = (options) =>
-  async function (rejectPath, reason) {
-    console.log("Reject instance", rejectPath, reason);
-    const extracted = rejectPath.match(dataExtractor);
-    if (!extracted) {
-      console.log("Unable to reject", rejectPath, "because it isn't in the format studies/<studyUID>/series/<seriesUID>");
-      return;
+module.exports = () =>
+  async function rejectInstanceWithOptions(args) {
+    let studyInstanceUid = args[0];
+    let seriesInstanceUid;
+    let sopInstanceUid;
+    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);
+    } else {
+      console.log("Not extracting from URL", studyInstanceUid, seriesInstanceUid, reason);
+      seriesInstanceUid = args[1];
     }
-    const [, , studyInstanceUid, , seriesInstanceUid, , sopInstanceUid] = extracted;
-    const studyData = await this.scanStudy("studies", studyInstanceUid);
-    if (options.verbose) console.log("Trying to reject", seriesInstanceUid, "because", reason);
+    const studyData = await this.scanStudy(studyInstanceUid);
+    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,9 +1,10 @@
 const dicomCodec = require("@cornerstonejs/dicom-codec");
-const { Stats, handleHomeRelative } = require("@radicalimaging/static-wado-util");
+const staticCS = require("@radicalimaging/static-cs-lite");
+const { Stats, handleHomeRelative, dirScanner, JSONReader, JSONWriter, asyncIterableToBuffer, Tags } = require("@radicalimaging/static-wado-util");
 const dicomParser = require("dicom-parser");
 const fs = require("fs");
 const path = require("path");
-const { dirScanner, JSONReader, JSONWriter, asyncIterableToBuffer } = require("@radicalimaging/static-wado-util");
+const { NotificationService } = require("@radicalimaging/static-wado-util");
 const getDataSet = require("./operation/getDataSet");
 const InstanceDeduplicate = require("./operation/InstanceDeduplicate");
 const DeduplicateWriter = require("./writer/DeduplicateWriter");
@@ -15,15 +16,33 @@ const HashDataWriter = require("./writer/HashDataWriter");
 const VideoWriter = require("./writer/VideoWriter");
 const { transcodeImageFrame, 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");
 
 function setStudyData(studyData) {
   this.studyData = studyData;
 }
 
+function internalGenerateImage(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}`);
+    });
+}
+
 class StaticWado {
   constructor(configuration) {
     const { rootDir = "~/dicomweb", pathDeduplicated = "deduplicated", pathInstances = "instances", verbose } = configuration;
@@ -36,7 +55,8 @@ class StaticWado {
       directoryName,
       deduplicatedRoot: path.join(directoryName, pathDeduplicated),
       deduplicatedInstancesRoot: path.join(directoryName, pathInstances),
-      TransferSyntaxUID: "1.2.840.10008.1.2",
+      // TODO - make this configurable and auto-detect by updating the parseDicom library
+      TransferSyntaxUID: "1.2.840.10008.1.2.1",
     };
     this.callback = {
       uids: IdCreator(this.options),
@@ -52,6 +72,8 @@ class StaticWado {
       delete: DeleteStudy(this.options),
       setStudyData,
       rawDicomWriter: RawDicomWriter(this.options),
+      notificationService: new NotificationService(this.options.notificationDir),
+      internalGenerateImage
     };
   }
 
@@ -61,10 +83,8 @@ class StaticWado {
    *
    * @param {string} args listing the instances to remove (may remove entire series)
    */
-  async reject(args) {
-    args.forEach((removal) => {
-      this.callback.reject(removal);
-    });
+  async reject(studyUID, seriesUID, reason) {
+    this.callback.reject(studyUID, seriesUID, reason);
   }
 
   /**
@@ -94,7 +114,7 @@ class StaticWado {
           await this.importBinaryDicom(dicomp10stream, { ...params, file });
           Stats.StudyStats.add("DICOM P10", "Parse DICOM P10 file");
         } catch (e) {
-          console.error("Couldn't process", file, e);
+          console.error("Couldn't process", file);
         }
       },
     });
@@ -103,14 +123,13 @@ class StaticWado {
   /**
    * Processes a study directory, matching up study instance UIDs.  Either processes the
    * deduplicated group directory or the instances directory, or the notifications directory.
-   * @param {*} params
+   * @param {*} options
    */
-  async processStudyDir(studyUids, params) {
-    return dirScanner(params[params.scanStudies], {
-      ...params,
-      recursive: false,
-      callback: (dir, name) => this.callback.scanStudy(dir, name),
-    });
+  async processStudyDir(studyUids /* , options */) {
+    for (const studyUid of studyUids) {
+      const study = await this.callback.scanStudy(studyUid);
+      console.log("Processed study", study.studyInstanceUid);
+    }
   }
 
   async importBinaryDicom(dicomp10stream, params) {
@@ -123,7 +142,7 @@ class StaticWado {
     const studyInstanceUid = dataSet.string("x0020000d");
 
     if (!studyInstanceUid) {
-      console.log(`Can't import file ${params.file}`);
+      console.log("No study UID, can't import file", params.file, dataSet.elements);
       return undefined;
     }
 
@@ -138,7 +157,7 @@ class StaticWado {
       params.file
     );
 
-    const targetId = transcodeId(id, this.options);
+    const targetId = transcodeId(id, this.options, dataSet.uint16(Tags.RawSamplesPerPixel));
 
     let bulkDataIndex = 0;
     let imageFrameIndex = 0;
@@ -178,7 +197,7 @@ class StaticWado {
     await this.callback.rawDicomWriter?.(id, result, buffer);
 
     const transcodedMeta = transcodeMetadata(result.metadata, id, this.options);
-    thumbnailService.generateThumbnails(id, dataSet, transcodedMeta, this.callback);
+    await thumbnailService.generateThumbnails(id, dataSet, transcodedMeta, this.callback);
 
     await this.callback.metadata(targetId, transcodedMeta);
 
@@ -186,6 +205,14 @@ class StaticWado {
     return {};
   }
 
+  static async getDataSet(dataSet, generator, params) {
+    return await getDataSet(dataSet, generator, params);
+  }
+
+  static internalGenerateImage(originalImageFrame, dataSet, metadata, transferSyntaxUid, doneCallback) {
+      return internalGenerateImage(originalImageFrame, dataSet, metadata, transferSyntaxUid, doneCallback)
+  }
+
   /**
    * The mkdicomweb command first runs mkdicomwebinstances, writing out the deduplicated data, and then runs the
    * mkdicomwebstudy command, creating the deduplicated data set.  This version, however, keeps the deduplicated
@@ -193,16 +220,18 @@ class StaticWado {
    */
   async executeCommand(input) {
     if (this.options.scanStudies) {
+      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.log("Scanning files", input);
       await this.processFiles(input, this.options);
     }
     await this.close();
   }
 
   async close() {
-    await this.callback.completeStudy();
+    await this.callback.completeStudy(this.callback);
     Stats.OverallStats.summarize("Completed Study Processing");
   }
 

package/lib/createMain.js

@@ -4,10 +4,14 @@ const adaptProgramOpts = require("./util/adaptProgramOpts");
 module.exports = function createMain(options, program) {
   const finalOptions = adaptProgramOpts(options, {
     ...this,
-    isInstance: false,
+    // Instance metadata is the instances/<sopUID>/metadata.gz files
+    isInstance: true,
+    // Deduplicated data is single instance deduplicated data
+    isDeduplicate: false,
+    // Group data is the group file directories
     isGroup: true,
-    isDeduplicate: true,
     isStudyData: true,
+    isDeleteInstances: true,
   });
   const importer = new StaticWado(finalOptions);
   return importer.executeCommand(program.args);

package/lib/groupMain.js

@@ -5,8 +5,11 @@ module.exports = function createMain(options, program) {
   const finalOptions = adaptProgramOpts(options, {
     ...this,
     isInstance: false,
+    isDeduplicate: true,
     isGroup: true,
     isStudyData: false,
+    scanStudies: true,
+    isDeleteInstances: true,
   });
   const importer = new StaticWado(finalOptions);
   // Either do a scan or on specified studies

package/lib/instanceMain.js

@@ -5,6 +5,8 @@ module.exports = function createMain(options, program) {
   const finalOptions = adaptProgramOpts(options, {
     ...this,
     isInstance: true,
+    // Deduplicated data is single instance deduplicated data
+    isDeduplicate: true,
     isGroup: false,
     isStudyData: false,
   });

package/lib/metadataMain.js

@@ -5,8 +5,9 @@ module.exports = function createMain(options, program) {
   const finalOptions = adaptProgramOpts(options, {
     ...this,
     isInstance: false,
-    isGroup: false,
-    isStudyData: false,
+    isGroup: true,
+    isStudyData: true,
+    scanStudies: true,
   });
   const importer = new StaticWado(finalOptions);
   // Either do a scan or on specified studies

package/lib/mkdicomwebConfig.js

@@ -30,6 +30,15 @@ const { mkdicomwebConfig } = ConfigPoint.register({
         description: "List of deployments from configuration to deploy to. Separated by space.",
         defaultValue: undefined,
       },
+      {
+        key: "--no-notifications",
+        description: "Turns off notifications",
+      },
+      {
+        key: "--delete",
+        description: "Delete the imported instances",
+        defaultValue: false,
+      },
       {
         key: "-v, --verbose",
         description: "Write verbose output",
@@ -37,14 +46,26 @@ const { mkdicomwebConfig } = ConfigPoint.register({
       },
       {
         key: "-t, --content-type <type>",
-        description: 'Destination type to compress to (choices: "jls", "lei", "jls-lossy", "jhc", "jxl" or DICOM Transfer Syntax UID - default: "jls")',
-        defaultValue: "jhc",
+        description: 'Destination type to compress to (choices: "jpeg", "jls", "lei", "jls-lossy", "jhc", "jxl" or DICOM Transfer Syntax UID - default: "jls")',
+        defaultValue: "jls",
         customParser: compressionOptionParser,
       },
       {
-        key: "-e, --no-encapsulated-image-frame",
+        key: "--encapsulated-image",
+        description: "Avoid encapsulating the image frame.  Writes with the extension and without multipart",
+      },
+      {
+        key: "-e, --no-encapsulated-image",
         description: "Avoid encapsulating the image frame.  Writes with the extension and without multipart",
       },
+      {
+        key: "--single-part-image",
+        description: "Writes single part image data",
+      },
+      {
+        key: "--no-single-part-image",
+        description: "Writes single part image data",
+      },
       {
         key: "-m, --maximum-inline-public-length <value>",
         description: "Maximum length of public binary data",
@@ -59,7 +80,13 @@ const { mkdicomwebConfig } = ConfigPoint.register({
         key: "-r, --recompress <listvalue...>",
         description: "List of types to recompress separated by space",
         defaultValue: ["uncompressed", "jp2", "jls", "jll"],
-        choices: ["uncompressed", "jp2", "jpeglossless", "rle", "jph", "jls", "true", "none"],
+        choices: ["uncompressed", "jp2", "jpeg", "jpeglossless", "rle", "jph", "jls", "true", "none"],
+      },
+      {
+        key: "--recompress-color <listvalue...>",
+        description: "List of types to recompress for color images, separated by space",
+        defaultValue: ["uncompressed"],
+        choices: ["uncompressed", "jpeg", "jp2", "jpeglossless", "rle", "jph", "jls", "true", "none"],
       },
       {
         key: "--recompress-thumb <listvalue...>",
@@ -78,9 +105,9 @@ const { mkdicomwebConfig } = ConfigPoint.register({
         defaultValue: false,
       },
       {
-        key: "-T, --colour-content-type <value>",
+        key: "-T, --color-content-type <value>",
         description: "Colour content type",
-        defaultValue: null,
+        defaultValue: "jpeg",
       },
       {
         key: "--path-deduplicated <path>",
@@ -145,7 +172,7 @@ const { mkdicomwebConfig } = ConfigPoint.register({
         command: "metadata",
         arguments: ["input"],
         main: metadataMain,
-        helpDescription: "Write the metadata object (series and study details) from the deduplicated data.",
+        helpDescription: "Write the metadata object (series and study details) from the grouped deduplicated data.",
       },
       {
         command: "delete",
@@ -153,9 +180,9 @@ const { mkdicomwebConfig } = ConfigPoint.register({
         helpDescription: "Delete the given study, series or instance (not yet implemented)",
       },
       {
-        command: "reject",
+        command: "reject <studyUID...>",
         main: rejectMain,
-        helpDescription: "Reject the specified series, specified as studies/<studyUID>/series/<seriesUID>",
+        helpDescription: "Reject the specified series",
       },
     ],
   },

package/lib/operation/InstanceDeduplicate.js

@@ -77,8 +77,8 @@ const InstanceDeduplicate = (options) =>
   async function run(id, sourceImageFrame) {
     // Notify the existing listeners, if any
     const imageFrame = canonicalize(sourceImageFrame);
-    if (options.isInstanceMetadata) {
-      // console.log("Writing instance metadata");
+    if (options.isInstance) {
+      if (options.verbose) console.log("Writing instance metadata");
       await JSONWriter(id.sopInstanceRootPath, "metadata", imageFrame);
     }
     if (!options.isDeduplicate && !options.isGroup) {

package/lib/operation/ScanStudy.js

@@ -3,11 +3,12 @@ const path = require("path");
 function ScanStudy(options) {
   const { directoryName, deduplicatedRoot, deduplicatedInstancesRoot } = options;
 
-  return function run(dir, studyInstanceUid) {
+  return function scanStudy(studyInstanceUid) {
+    console.verbose("scanStudy", studyInstanceUid);
     const studyPath = path.join(directoryName, "studies", studyInstanceUid);
-    const deduplicatedPath = path.join(deduplicatedRoot, studyInstanceUid);
     const deduplicatedInstancesPath = path.join(deduplicatedInstancesRoot, studyInstanceUid);
-    console.log("Scanning", dir, studyInstanceUid);
+    const deduplicatedPath = path.join(deduplicatedRoot, studyInstanceUid);
+    console.verbose("Importing", studyInstanceUid, studyPath, deduplicatedInstancesPath, deduplicatedPath);
     return this.completeStudy.getCurrentStudyData(this, {
       studyPath,
       deduplicatedPath,

package/lib/operation/StudyData.js

@@ -41,6 +41,7 @@ class StudyData {
     // The deduplicated hashes are just the hashes for individual items
     this.deduplicatedHashes = {};
     this.sopInstances = {};
+    this.instanceFiles = 0;
 
     // Used to track if new instances have been added.
     this.newInstancesAdded = 0;
@@ -54,11 +55,22 @@ class StudyData {
     if (clean) {
       // Wipe out the study directory entirely, as well as the deduplicatedRoot and instancesRoot
     }
+    this.groupFiles = 0;
+    const studyDeduplicated = await JSONReader(this.studyPath, "deduplicated/index.json.gz", []);
+    const info = studyDeduplicated[0];
+    if (info) {
+      const hash = getValue(info, Tags.DeduppedHash);
+      console.log("Reading studies/<studyUID>/deduplicated/index.json.gz");
+      this.readDeduplicatedData("index.json.gz", studyDeduplicated, hash);
+    } else {
+      console.log("No deduplicated/index.json to read in", this.studyPath, "/deduplicated/index.json.gz");
+    }
     if (this.deduplicatedPath) {
-      await this.readDeduplicated(this.deduplicatedPath);
+      this.groupFiles = await this.readDeduplicated(this.deduplicatedPath);
+      console.verbose("Read groupFiles:", this.groupFiles);
     }
     if (this.deduplicatedInstancesPath) {
-      await this.readDeduplicated(this.deduplicatedInstancesPath);
+      this.instanceFiles = await this.readDeduplicated(this.deduplicatedInstancesPath);
     }
   }
 
@@ -72,33 +84,36 @@ class StudyData {
    * a separate type of check.
    */
   get dirty() {
-    return this.newInstancesAdded > 0 || this.existingFiles.length > 1;
+    return this.newInstancesAdded > 0 || this.existingFiles.length > 1 || this.instanceFiles > 0;
   }
 
   async dirtyMetadata() {
     if (this.dirty) {
-      // console.log("Study data is dirty - need to write updated file");
+      console.verbose("dirtyMetadata::Group data is dirty");
       return true;
     }
+    if (this.groupFiles > 0) {
+      console.verbose("dirtyMetadata::Study level deduplicated doesn't match group files");
+    }
     try {
-      const deduplicatedTopFile = await JSONReader(this.studyPath, "deduplicated.gz", null);
-      if (!deduplicatedTopFile) {
+      const studyFile = await JSONReader(this.studyPath, "index.json.gz", null);
+      if (!studyFile) {
+        console.verbose("dirtyMetadata::studyIndex");
         return true;
       }
-      const info = deduplicatedTopFile[0];
-      if (!info || getValue(info, Tags.DeduppedHash) || getValue(info, Tags.DeduppedType) != "info") {
-        return true;
+      const hashValue = getValue(studyFile, Tags.DeduppedHash);
+      if (this.existingFiles[0].indexOf(hashValue) == -1) {
+        return false;
       }
-      const hashValue = getValue(info, Tags.DeduppedHash);
-      return this.existingFiles[0].indexOf(hashValue) == -1;
+      console.verbose("dirtyMetadata::Dedupped hash missing");
+      return true;
     } catch (e) {
-      console.log("Assume study metadata is dirty", e);
+      console.verbose("dirtyMetadata::Exception, assume study metadata is dirty", e);
       return true;
     }
   }
 
-  async reject(seriesInstanceUid, sopInstanceUid, reason) {
-    console.log("Rejecting series instance UID", seriesInstanceUid, "because", reason);
+  async reject(seriesInstanceUid, sopInstanceUid /* , reason */) {
     // TODO - actually add a reject note...
     this.newInstancesAdded += 1;
     for (let i = 0; i < this.deduplicated.length; i++) {
@@ -107,7 +122,7 @@ class StudyData {
       if (reSeriesUid !== seriesInstanceUid) continue;
       const reSop = getValue(recombined, Tags.SOPInstanceUID);
       if (!reSop) continue;
-      if (reSop !== sopInstanceUid) continue;
+      if (sopInstanceUid && reSop !== sopInstanceUid) continue;
       setValue(this.deduplicated[i], Tags.DeduppedType, "deleted");
     }
   }
@@ -239,25 +254,28 @@ class StudyData {
    * @param {*} deduplicatedDirectory
    */
   async readDeduplicated(deduplicatedDirectory) {
+    let readCount = 0;
     try {
       const files = await this.listJsonFiles(deduplicatedDirectory);
       if (!files || !files.length) {
-        console.log("No deduplicated for", deduplicatedDirectory);
-        return;
+        console.verbose("No deduplicated for", deduplicatedDirectory);
+        return 0;
       }
-      console.log("There are", files.length, "files to check");
+      console.verbose("There are", files.length, "files to check");
       for (let i = 0; i < files.length; i++) {
         const stat = files[i];
         const { hash } = stat;
         if (this.readHashes[hash]) {
           continue;
         }
+        readCount += 1;
         await this.readDeduplicatedFile(deduplicatedDirectory, stat);
       }
-      console.log("Done checking", deduplicatedDirectory);
+      console.verbose("Done checking", deduplicatedDirectory);
     } catch (e) {
       // No-op console.log(e);
     }
+    return readCount;
   }
 
   async readDeduplicatedFile(dir, stat) {
@@ -265,32 +283,36 @@ class StudyData {
     try {
       if (this.verbose) console.log("Reading deduplicated file", name);
       const data = await JSONReader(dir, name);
-      this.readHashes[hash] = name;
-      this.existingFiles.push(name);
-      const listData = (Array.isArray(data) && data) || [data];
-      listData.forEach((item) => {
-        const type = getValue(item, Tags.DeduppedType);
-        if (type == Tags.InstanceType) {
-          this.internalAddDeduplicated(item, name);
-        } else if (type == "info") {
-          const refs = getList(item, Tags.DeduppedRef);
-          if (refs) {
-            refs.forEach((hashValue) => {
-              this.readHashes[hashValue] = `${hashValue}.gz`;
-            });
-          }
-        } else {
-          const hashValue = getValue(item, Tags.DeduppedHash);
-          if (hashValue) {
-            this.extractData[hashValue] = item;
-          }
-        }
-      });
+      this.readDeduplicatedData(name, data, hash);
     } catch (e) {
       console.error("Unable to read", dir, name);
     }
   }
 
+  readDeduplicatedData(name, data, hash) {
+    this.readHashes[hash] = name;
+    this.existingFiles.push(name);
+    const listData = (Array.isArray(data) && data) || [data];
+    listData.forEach((item) => {
+      const type = getValue(item, Tags.DeduppedType);
+      if (type === Tags.InstanceType || type === Tags.DeletedType) {
+        this.internalAddDeduplicated(item, name);
+      } else if (type == "info") {
+        const refs = getList(item, Tags.DeduppedRef);
+        if (refs) {
+          refs.forEach((hashValue) => {
+            this.readHashes[hashValue] = `${hashValue}.gz`;
+          });
+        }
+      } else {
+        const hashValue = getValue(item, Tags.DeduppedHash);
+        if (hashValue) {
+          this.extractData[hashValue] = item;
+        }
+      }
+    });
+  }
+
   async writeMetadata() {
     const anInstance = await this.recombine(0);
     const series = {};
@@ -299,7 +321,7 @@ class StudyData {
       const seriesInstance = await this.recombine(i);
       const type = getValue(seriesInstance, Tags.DeduppedType);
       if (type == "deleted") {
-        console.log("Skipping", type);
+        console.log("Skipping deleted instance", type, getValue(seriesInstance, Tags.SeriesInstanceUID));
         continue;
       }
       const seriesInstanceUid = getSeriesInstanceUid(seriesInstance);
@@ -334,14 +356,15 @@ class StudyData {
       };
       numberOfInstances += instances.length;
       numberOfSeries += 1;
-      seriesList.push(seriesQuery);
       const modality = getValue(seriesQuery, Tags.Modality);
+      seriesList.push(seriesQuery);
       if (modalitiesInStudy.indexOf(modality) == -1) modalitiesInStudy.push(modality);
       await JSONWriter(seriesPath, "metadata", instances, {
         gzip: true,
         index: false,
       });
-      await JSONWriter(seriesPath, "series", [seriesQuery]);
+      // Write out a series singleton that has just the series response for a single series.
+      await JSONWriter(seriesPath, "series-singleton.json", [seriesQuery], {gzip:true, index:false});
       await JSONWriter(seriesPath, "instances", instancesQuery);
     }
 
@@ -388,6 +411,32 @@ class StudyData {
     return (gzIndex > 0 && name.substring(0, gzIndex)) || name;
   }
 
+  async deleteInstancesReferenced() {
+    const deduplicatedDirectory = this.deduplicatedInstancesPath;
+    if (!fs.existsSync(deduplicatedDirectory)) return;
+    console.log("Deleting instances referenced in", this.studyInstanceUid, this.deduplicatedInstancesPath);
+    const files = await this.listJsonFiles(deduplicatedDirectory);
+    console.log("Deleting", files.length, "files");
+    let deleteCount = 0;
+    for (let i = 0; i < files.length; i++) {
+      const stat = files[i];
+      const { hash } = stat;
+      if (this.readHashes[hash]) {
+        console.log("Deleting", deduplicatedDirectory, stat.name);
+        try {
+          fs.unlinkSync(path.join(deduplicatedDirectory, stat.name));
+          deleteCount += 1;
+        } catch (e) {
+          console.log("Delete failed", e);
+        }
+      }
+    }
+    if (deleteCount === files.length) {
+      console.log("Deleting instances directory", deduplicatedDirectory);
+      fs.rmdirSync(deduplicatedDirectory);
+    }
+  }
+
   /** Writes the deduplicated group */
   async writeDeduplicatedGroup() {
     const data = this.createInfo();