@radicalimaging/static-wado-creator 1.3.2 → 1.6.10

package/lib/operation/StudyData.js

@@ -8,7 +8,8 @@ const TagLists = require("../model/TagLists");
 const { getValue, setValue, getList, setList } = Tags;
 const hasher = hashFactory.hasher();
 
-const getSeriesInstanceUid = (seriesInstance) => getValue(seriesInstance, Tags.SeriesInstanceUID);
+const getSeriesInstanceUid = (seriesInstance) =>
+  getValue(seriesInstance, Tags.SeriesInstanceUID);
 
 /**
  * StudyData contains information about the grouped study data.  It is used to create
@@ -21,12 +22,21 @@ const getSeriesInstanceUid = (seriesInstance) => getValue(seriesInstance, Tags.S
  * level data multiple times when it already exists.
  */
 class StudyData {
-  constructor({ studyInstanceUid, studyPath, deduplicatedPath, deduplicatedInstancesPath }, { isGroup, clean }) {
+  constructor(
+    {
+      studyInstanceUid,
+      studyPath,
+      deduplicatedPath,
+      deduplicatedInstancesPath,
+    },
+    { isGroup, clean, hashStudyUidPath },
+  ) {
     this.studyInstanceUid = studyInstanceUid;
     this.studyPath = studyPath;
     this.isGroup = isGroup;
     this.deduplicatedPath = deduplicatedPath;
     this.deduplicatedInstancesPath = deduplicatedInstancesPath;
+    this.hashStudyUidPath = hashStudyUidPath;
     this.clean = clean;
     this.clear();
   }
@@ -55,22 +65,49 @@ class StudyData {
     if (clean) {
       // Wipe out the study directory entirely, as well as the deduplicatedRoot and instancesRoot
     }
+
+    console.verbose("studyInstanceUid", this.studyInstanceUid);
+    console.verbose("studyPath", this.studyPath);
+    console.verbose("deduplicatedPath", this.deduplicatedPath);
+    console.verbose(
+      "deduplicatedInstancesPath",
+      this.deduplicatedInstancesPath,
+    );
+
     this.groupFiles = 0;
-    const studyDeduplicated = await JSONReader(this.studyPath, "deduplicated/index.json.gz", []);
+    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");
+      if (this.hashStudyUidPath) {
+        console.verbose(
+          "Reading studies/<studyUIDPath>/<studyUIDSubpath>/<studyUID>/deduplicated/index.json.gz",
+        );
+      } else {
+        console.verbose(
+          "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");
+      console.log(
+        "No deduplicated/index.json to read in",
+        this.studyPath,
+        "/deduplicated/index.json.gz",
+      );
     }
     if (this.deduplicatedPath) {
       this.groupFiles = await this.readDeduplicated(this.deduplicatedPath);
       console.verbose("Read groupFiles:", this.groupFiles);
     }
     if (this.deduplicatedInstancesPath) {
-      this.instanceFiles = await this.readDeduplicated(this.deduplicatedInstancesPath);
+      this.instanceFiles = await this.readDeduplicated(
+        this.deduplicatedInstancesPath,
+      );
     }
   }
 
@@ -84,7 +121,11 @@ class StudyData {
    * a separate type of check.
    */
   get dirty() {
-    return this.newInstancesAdded > 0 || this.existingFiles.length > 1 || this.instanceFiles > 0;
+    return (
+      this.newInstancesAdded > 0 ||
+      this.existingFiles.length > 1 ||
+      this.instanceFiles > 0
+    );
   }
 
   async dirtyMetadata() {
@@ -93,7 +134,9 @@ class StudyData {
       return true;
     }
     if (this.groupFiles > 0) {
-      console.verbose("dirtyMetadata::Study level deduplicated doesn't match group files");
+      console.verbose(
+        "dirtyMetadata::Study level deduplicated doesn't match group files",
+      );
     }
     try {
       const studyFile = await JSONReader(this.studyPath, "index.json.gz", null);
@@ -108,7 +151,10 @@ class StudyData {
       console.verbose("dirtyMetadata::Dedupped hash missing");
       return true;
     } catch (e) {
-      console.verbose("dirtyMetadata::Exception, assume study metadata is dirty", e);
+      console.verbose(
+        "dirtyMetadata::Exception, assume study metadata is dirty",
+        e,
+      );
       return true;
     }
   }
@@ -129,7 +175,10 @@ class StudyData {
 
   async delete() {
     await fs.rmSync(this.studyPath, { recursive: true, force: true });
-    await fs.rmSync(this.deduplicatedInstancesPath, { recursive: true, force: true });
+    await fs.rmSync(this.deduplicatedInstancesPath, {
+      recursive: true,
+      force: true,
+    });
     await fs.rmSync(this.deduplicatedPath, { recursive: true, force: true });
     this.clear();
   }
@@ -159,10 +208,15 @@ class StudyData {
    * Create a full study instance data for instance at index
    */
   async recombine(indexOrSop) {
-    const index = typeof indexOrSop === "string" ? this.sopInstances[indexOrSop] : indexOrSop;
+    const index =
+      typeof indexOrSop === "string"
+        ? this.sopInstances[indexOrSop]
+        : indexOrSop;
     const deduplicated = this.deduplicated[index];
     if (index < 0 || index >= this.deduplicated.length) {
-      throw new Error(`Can't read index ${index}, out of bounds [0..${this.deduplicated.length})`);
+      throw new Error(
+        `Can't read index ${index}, out of bounds [0..${this.deduplicated.length})`,
+      );
     }
     const refs = getList(deduplicated, Tags.DeduppedRef);
     if (!refs) {
@@ -179,7 +233,12 @@ class StudyData {
 
   async addExtracted(callback, hashKey, item) {
     if (this.extractData[hashKey]) {
-      if (this.verbose) console.log("Already have extracted", hashKey, getValue(item, Tags.DeduppedType));
+      if (this.verbose)
+        console.log(
+          "Already have extracted",
+          hashKey,
+          getValue(item, Tags.DeduppedType),
+        );
       return;
     }
     await callback.bulkdata(this, hashKey, item);
@@ -215,7 +274,7 @@ class StudyData {
     this.deduplicatedHashes[hashValue] = data;
     this.readHashes[hashValue] = filename;
     if (sopIndex !== undefined) {
-      console.log("Replacing SOP", sopValue, "at index", sopIndex);
+      console.noQuiet("Replacing SOP", sopValue, "at index", sopIndex);
       this.deduplicated[sopIndex] = data;
     } else {
       this.sopInstances[sopValue] = this.deduplicated.length;
@@ -282,7 +341,7 @@ class StudyData {
   async readDeduplicatedFile(dir, stat) {
     const { hash, name } = stat;
     try {
-      if (this.verbose) console.log("Reading deduplicated file", name);
+      console.verbose("Reading deduplicated file", name);
       const data = await JSONReader(dir, name);
       this.readDeduplicatedData(name, data, hash);
     } catch (e) {
@@ -322,17 +381,33 @@ class StudyData {
       const seriesInstance = await this.recombine(i);
       const type = getValue(seriesInstance, Tags.DeduppedType);
       if (type == "deleted") {
-        console.log("Skipping deleted instance", type, getValue(seriesInstance, Tags.SeriesInstanceUID));
+        console.log(
+          "Skipping deleted instance",
+          type,
+          getValue(seriesInstance, Tags.SeriesInstanceUID),
+        );
         continue;
       }
       const seriesInstanceUid = getSeriesInstanceUid(seriesInstance);
       if (!seriesInstanceUid) {
-        console.log("Cant get seriesUid from", Tags.SeriesInstanceUID, seriesInstance);
+        console.log(
+          "Cant get seriesUid from",
+          Tags.SeriesInstanceUID,
+          seriesInstance,
+        );
         continue;
       }
       if (!series[seriesInstanceUid]) {
-        const seriesQuery = TagLists.extract(seriesInstance, "series", TagLists.SeriesQuery);
-        const seriesPath = path.join(this.studyPath, "series", seriesInstanceUid);
+        const seriesQuery = TagLists.extract(
+          seriesInstance,
+          "series",
+          TagLists.SeriesQuery,
+        );
+        const seriesPath = path.join(
+          this.studyPath,
+          "series",
+          seriesInstanceUid,
+        );
         series[seriesInstanceUid] = {
           seriesPath,
           seriesQuery,
@@ -341,16 +416,20 @@ class StudyData {
         };
       }
       series[seriesInstanceUid].instances.push(seriesInstance);
-      series[seriesInstanceUid].instancesQuery.push(TagLists.extract(seriesInstance, "instance", TagLists.InstanceQuery));
+      series[seriesInstanceUid].instancesQuery.push(
+        TagLists.extract(seriesInstance, "instance", TagLists.InstanceQuery),
+      );
     }
 
     const seriesList = [];
     const modalitiesInStudy = [];
     let numberOfInstances = 0;
     let numberOfSeries = 0;
+
     for (const seriesUid of Object.keys(series)) {
       const singleSeries = series[seriesUid];
-      const { seriesQuery, seriesPath, instances, instancesQuery } = singleSeries;
+      const { seriesQuery, seriesPath, instances, instancesQuery } =
+        singleSeries;
       seriesQuery[Tags.NumberOfSeriesRelatedInstances] = {
         vr: "IS",
         Value: [instances.length],
@@ -359,20 +438,39 @@ class StudyData {
       numberOfSeries += 1;
       const modality = getValue(seriesQuery, Tags.Modality);
       seriesList.push(seriesQuery);
-      if (modalitiesInStudy.indexOf(modality) == -1) modalitiesInStudy.push(modality);
+      if (modalitiesInStudy.indexOf(modality) == -1)
+        modalitiesInStudy.push(modality);
       await JSONWriter(seriesPath, "metadata", instances, {
         gzip: true,
         index: false,
       });
       // 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, "series-singleton.json", [seriesQuery], {
+        gzip: true,
+        index: false,
+      });
       await JSONWriter(seriesPath, "instances", instancesQuery);
+      console.noQuiet(
+        "Wrote instances",
+        seriesUid,
+        "with",
+        instancesQuery.length,
+      );
     }
 
     await JSONWriter(this.studyPath, "series", seriesList);
-    console.log("Wrote series with", seriesList.length);
+    console.noQuiet(
+      "Wrote series",
+      this.studyInstanceUid,
+      "with",
+      seriesList.length,
+    );
 
-    const studyQuery = TagLists.extract(anInstance, "study", TagLists.PatientStudyQuery);
+    const studyQuery = TagLists.extract(
+      anInstance,
+      "study",
+      TagLists.PatientStudyQuery,
+    );
     studyQuery[Tags.ModalitiesInStudy] = { Value: modalitiesInStudy, vr: "CS" };
     studyQuery[Tags.NumberOfStudyRelatedInstances] = {
       Value: [numberOfInstances],
@@ -389,8 +487,18 @@ class StudyData {
     });
 
     const infoItem = this.createInfo();
-    console.log("Writing deduplicated study data with", Object.values(this.extractData).length, "extract items and", this.deduplicated.length, "instance items");
-    await JSONWriter(this.studyPath, "deduplicated", [infoItem, ...Object.values(this.extractData), ...this.deduplicated]);
+    console.noQuiet(
+      "Writing deduplicated study data with",
+      Object.values(this.extractData).length,
+      "extract items and",
+      this.deduplicated.length,
+      "instance items",
+    );
+    await JSONWriter(this.studyPath, "deduplicated", [
+      infoItem,
+      ...Object.values(this.extractData),
+      ...this.deduplicated,
+    ]);
 
     return studyQuery;
   }
@@ -406,7 +514,6 @@ class StudyData {
     return data;
   }
 
-  /* eslint-disable-next-line class-methods-use-this */
   removeGz(name) {
     const gzIndex = name.indexOf(".gz");
     return (gzIndex > 0 && name.substring(0, gzIndex)) || name;
@@ -415,15 +522,19 @@ class StudyData {
   async deleteInstancesReferenced() {
     const deduplicatedDirectory = this.deduplicatedInstancesPath;
     if (!fs.existsSync(deduplicatedDirectory)) return;
-    console.log("Deleting instances referenced in", this.studyInstanceUid, this.deduplicatedInstancesPath);
+    console.log(
+      "Deleting instances referenced in",
+      this.studyInstanceUid,
+      this.deduplicatedInstancesPath,
+    );
     const files = await this.listJsonFiles(deduplicatedDirectory);
-    console.log("Deleting", files.length, "files");
+    console.noQuiet("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);
+        console.noQuiet("Deleting", deduplicatedDirectory, stat.name);
         try {
           fs.unlinkSync(path.join(deduplicatedDirectory, stat.name));
           deleteCount += 1;
@@ -433,7 +544,7 @@ class StudyData {
       }
     }
     if (deleteCount === files.length) {
-      console.log("Deleting instances directory", deduplicatedDirectory);
+      console.noQuiet("Deleting instances directory", deduplicatedDirectory);
       fs.rmdirSync(deduplicatedDirectory);
     }
   }
@@ -442,25 +553,34 @@ class StudyData {
   async writeDeduplicatedGroup() {
     const data = this.createInfo();
     const hashValue = getValue(data, Tags.DeduppedHash);
-    console.log(
+    console.noQuiet(
       "Writing deduplicated hash data set data with",
       Object.values(this.extractData).length,
       "extract items and",
       this.deduplicated.length,
-      "instance items"
+      "instance items",
     );
     setList(
       data,
       Tags.DeduppedRef,
-      Object.keys(this.readHashes).filter(() => this.deduplicatedHashes[hashValue] == undefined)
+      Object.keys(this.readHashes).filter(
+        () => this.deduplicatedHashes[hashValue] == undefined,
+      ),
     );
-    const deduplicatedList = [data, ...Object.values(this.extractData), ...this.deduplicated];
+    const deduplicatedList = [
+      data,
+      ...Object.values(this.extractData),
+      ...this.deduplicated,
+    ];
     // const naturalList = deduplicatedList.map(Tags.naturalizeDataset);
     // // console.log("naturalList=", JSON.stringify(naturalList,null,2));
     // console.log("Going to write study data", naturalList.length);
     // await JSONWriter(this.deduplicatedPath, hashValue, naturalList, { gzip: true, index: false });
-    await JSONWriter(this.deduplicatedPath, hashValue, deduplicatedList, { gzip: true, index: false });
-    console.log("Wrote naturalized dataset");
+    await JSONWriter(this.deduplicatedPath, hashValue, deduplicatedList, {
+      gzip: true,
+      index: false,
+    });
+    console.noQuiet("Wrote naturalized dataset");
   }
 
   getSopUids() {

package/lib/operation/ThumbnailService.js

@@ -56,8 +56,12 @@ class ThumbnailService {
    * @param {Object} programOpts
    */
   queueThumbnail(thumbObjWrapper, programOpts) {
-    const { id, imageFrame, transcodedId, transcodedImageFrame, frameIndex } = thumbObjWrapper;
-    const getThumbContent = (originalContent, trancodedContent) => (shouldThumbUseTranscoded(id, programOpts) ? trancodedContent : originalContent);
+    const { id, imageFrame, transcodedId, transcodedImageFrame, frameIndex } =
+      thumbObjWrapper;
+    const getThumbContent = (originalContent, trancodedContent) =>
+      shouldThumbUseTranscoded(id, programOpts)
+        ? trancodedContent
+        : originalContent;
 
     const thumbObj = {
       imageFrame: getThumbContent(imageFrame, transcodedImageFrame),
@@ -77,7 +81,9 @@ class ThumbnailService {
   }
 
   ffmpeg(input, output) {
-    execSpawn(`ffmpeg -i "${input}" -vf  "thumbnail,scale=640:360" -frames:v 1 -f singlejpeg "${output}"`);
+    execSpawn(
+      `ffmpeg -i "${input}" -y -f image2 -frames:v 1 -update true "${output}"`,
+    );
   }
 
   dcm2jpg(input, output, options) {
@@ -110,47 +116,70 @@ class ThumbnailService {
   async generateThumbnails(itemId, dataSet, metadata, callback, options) {
     const { imageFrame, id } = this.favoriteThumbnailObj;
 
-    if (!options.thumb) {
-      return null;
-    }
-
     // There are various reasons no thumbnails might be generated, so just return
     if (!id) {
       const pixelData = metadata[Tags.PixelData];
       if (pixelData) {
         const { BulkDataURI } = pixelData;
         if (BulkDataURI?.indexOf("mp4")) {
-          fs.mkdirSync(`${itemId.sopInstanceRootPath}/rendered`, { recursive: true });
-          const mp4Path = path.join(itemId.sopInstanceRootPath, "rendered/index.mp4");
-          // Generate as rendered, as more back ends support that.
-          const thumbPath = path.join(itemId.sopInstanceRootPath, "rendered/1.jpg");
-          console.log("MP4 - converting video format", mp4Path);
+          fs.mkdirSync(`${itemId.sopInstanceRootPath}/rendered`, {
+            recursive: true,
+          });
+          const mp4Path = path.join(
+            itemId.sopInstanceRootPath,
+            "rendered/index.mp4",
+          );
+          const thumbPath = path.join(itemId.sopInstanceRootPath, "thumbnail");
+          console.verbose("MP4 - converting video format", mp4Path);
           this.ffmpeg(mp4Path, thumbPath);
           return thumbPath;
         }
       } else {
-        console.log("Series is of other type...", metadata[Tags.Modality]);
+        console.verbose("Series is of other type...", metadata[Tags.Modality]);
       }
       return null;
     }
-    if (options.dcm2jpg) {
-      return this.dcm2jpg(id.filename, id.imageFrameRootPath.replace(/frames/, "thumbnail"), {});
+
+    if (!options.thumb) {
+      return null;
     }
 
-    await callback.internalGenerateImage(imageFrame, dataSet, metadata, id.transferSyntaxUid, async (thumbBuffer) => {
-      try {
-        if (thumbBuffer) {
-          await callback.thumbWriter(id.sopInstanceRootPath, this.thumbFileName, thumbBuffer);
+    if (options.dcm2jpg) {
+      return this.dcm2jpg(
+        id.filename,
+        id.imageFrameRootPath.replace(/frames/, "thumbnail"),
+        {},
+      );
+    }
 
-          this.copySyncThumbnail(id.sopInstanceRootPath, id.seriesRootPath);
-          this.copySyncThumbnail(id.seriesRootPath, id.studyPath);
-          Stats.StudyStats.add("Thumbnail Write", `Write thumbnail ${this.thumbFileName}`, 100);
+    await 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,
+            );
+          }
+          return this.thumbFileName;
+        } catch (e) {
+          console.log("Couldn't generate thumbnail", this.thumbFileName, e);
         }
-        return this.thumbFileName;
-      } catch (e) {
-        console.log("Couldn't generate thumbnail", this.thumbFileName, e);
-      }
-    });
+      },
+    );
   }
 
   /**
@@ -164,13 +193,15 @@ class ThumbnailService {
    */
   async copySyncThumbnail(sourceFolderPath, targetFolderPath) {
     const parentPathLevel = path.join(sourceFolderPath, "../");
-    const thumbFilesPath = glob.sync(`${parentPathLevel}*/${this.thumbFileName}`);
+    const thumbFilesPath = glob.sync(
+      `${parentPathLevel}*/${this.thumbFileName}`,
+    );
 
     const thumbIndex = getThumbIndex(thumbFilesPath.length);
     const thumbFilePath = thumbFilesPath[thumbIndex];
 
     if (!fs.existsSync(thumbFilePath)) {
-      console.log("Thumbnail to copy does not exists");
+      console.verbose("Thumbnail to copy does not exists");
       return;
     }
 
@@ -179,9 +210,12 @@ class ThumbnailService {
         throw new Error(`Target path: ${targetFolderPath} is not a directory`);
       }
 
-      fs.copyFileSync(thumbFilePath, `${targetFolderPath}/${this.thumbFileName}`);
+      fs.copyFileSync(
+        thumbFilePath,
+        `${targetFolderPath}/${this.thumbFileName}`,
+      );
     } catch (e) {
-      console.log("The file could not be copied", e);
+      console.verbose("The file could not be copied", e);
     }
   }
 }

package/lib/operation/adapter/decodeImage.js

@@ -1,8 +1,11 @@
 const dicomCodec = require("@cornerstonejs/dicom-codec");
 const getImageInfo = require("./getImageInfo");
 
-async function decodeImage(imageFrame, dataset, transferSyntaxUid) {
-  const imageInfo = getImageInfo(dataset);
+function decodeImage(imageFrame, dataset, instance, transferSyntaxUid) {
+  const imageInfo = getImageInfo(dataset, instance);
+  if (imageFrame && !imageFrame.length) {
+    imageFrame = new Uint8Array(imageFrame);
+  }
   return dicomCodec.decode(imageFrame, imageInfo, transferSyntaxUid);
 }
 

package/lib/operation/adapter/getImageInfo.js

@@ -1,7 +1,25 @@
+const { Tags } = require("@radicalimaging/static-wado-util");
 /**
  * Minimum image info data to be used on transcode process by dicom-codec api.
  */
-function getImageInfo(dataSet) {
+function getImageInfo(dataSet, instance) {
+  if (instance) {
+    const rows = Tags.getValue(instance, Tags.Rows);
+    const columns = Tags.getValue(instance, Tags.Columns);
+    const bitsAllocated = Tags.getValue(instance, Tags.BitsAllocated);
+    const samplesPerPixel = Tags.getValue(instance, Tags.SamplesPerPixel);
+    const pixelRepresentation =
+      Tags.getValue(instance, Tags.PixelRepresentation) || 0; // not yet being used.
+
+    return {
+      bitsAllocated,
+      samplesPerPixel,
+      rows, // Number with the image rows/height
+      columns, // Number with the image columns/width,
+      signed: pixelRepresentation === 1,
+      pixelRepresentation,
+    };
+  }
   const rows = dataSet.uint16("x00280010");
   const columns = dataSet.uint16("x00280011");
   const bitsAllocated = dataSet.uint16("x00280100");