@radicalimaging/static-wado-creator 1.5.0 → 1.6.11

package/lib/operation/ScanStudy.js

@@ -1,14 +1,40 @@
-const path = require("path");
+const { getStudyUIDPathAndSubPath } = require('@radicalimaging/static-wado-util');
+
+const path = require('path');
 
 function ScanStudy(options) {
-  const { directoryName, deduplicatedRoot, deduplicatedInstancesRoot } = options;
+  const { directoryName, deduplicatedRoot, deduplicatedInstancesRoot, hashStudyUidPath } = options;
 
   return function scanStudy(studyInstanceUid) {
-    console.verbose("scanStudy", studyInstanceUid);
-    const studyPath = path.join(directoryName, "studies", studyInstanceUid);
-    const deduplicatedInstancesPath = path.join(deduplicatedInstancesRoot, studyInstanceUid);
-    const deduplicatedPath = path.join(deduplicatedRoot, studyInstanceUid);
-    console.verbose("Importing", studyInstanceUid, studyPath, deduplicatedInstancesPath, deduplicatedPath);
+    const { path: hashPath = '', subpath: hashSubpath = '' } = hashStudyUidPath
+      ? getStudyUIDPathAndSubPath(studyInstanceUid)
+      : {};
+
+    console.verbose('scanStudy', studyInstanceUid);
+
+    if (hashPath && hashSubpath) {
+      console.verbose('hashPath', hashPath);
+      console.verbose('hashSubpath', hashSubpath);
+    }
+
+    const studySubDir = hashStudyUidPath
+      ? path.join(hashPath, hashSubpath, studyInstanceUid)
+      : studyInstanceUid;
+
+    const studyPath = path.join(directoryName, 'studies', studySubDir);
+    const deduplicatedInstancesPath = path.join(
+      deduplicatedInstancesRoot,
+      // studyInstanceUid,
+      studySubDir
+    );
+    const deduplicatedPath = path.join(deduplicatedRoot, studySubDir);
+    console.verbose(
+      'Importing',
+      studyInstanceUid,
+      studyPath,
+      deduplicatedInstancesPath,
+      deduplicatedPath
+    );
     return this.completeStudy.getCurrentStudyData(this, {
       studyPath,
       deduplicatedPath,

package/lib/operation/StudyData.js

@@ -1,14 +1,14 @@
-const path = require("path");
-const fs = require("fs");
-const hashFactory = require("node-object-hash");
-const { JSONReader, JSONWriter } = require("@radicalimaging/static-wado-util");
-const { Tags } = require("@radicalimaging/static-wado-util");
-const TagLists = require("../model/TagLists");
+const path = require('path');
+const fs = require('fs');
+const hashFactory = require('node-object-hash');
+const { JSONReader, JSONWriter } = require('@radicalimaging/static-wado-util');
+const { Tags } = require('@radicalimaging/static-wado-util');
+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 +21,16 @@ 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,19 +59,35 @@ 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");
-      this.readDeduplicatedData("index.json.gz", studyDeduplicated, hash);
+      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);
+      console.verbose('Read groupFiles:', this.groupFiles);
     }
     if (this.deduplicatedInstancesPath) {
       this.instanceFiles = await this.readDeduplicated(this.deduplicatedInstancesPath);
@@ -89,26 +109,26 @@ class StudyData {
 
   async dirtyMetadata() {
     if (this.dirty) {
-      console.verbose("dirtyMetadata::Group data is dirty");
+      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 studyFile = await JSONReader(this.studyPath, "index.json.gz", null);
+      const studyFile = await JSONReader(this.studyPath, 'index.json.gz', null);
       if (!studyFile) {
-        console.verbose("dirtyMetadata::studyIndex");
+        console.verbose('dirtyMetadata::studyIndex');
         return true;
       }
       const hashValue = getValue(studyFile, Tags.DeduppedHash);
       if (this.existingFiles[0].indexOf(hashValue) == -1) {
         return false;
       }
-      console.verbose("dirtyMetadata::Dedupped hash missing");
+      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;
     }
   }
@@ -123,13 +143,16 @@ class StudyData {
       const reSop = getValue(recombined, Tags.SOPInstanceUID);
       if (!reSop) continue;
       if (sopInstanceUid && reSop !== sopInstanceUid) continue;
-      setValue(this.deduplicated[i], Tags.DeduppedType, "deleted");
+      setValue(this.deduplicated[i], Tags.DeduppedType, 'deleted');
     }
   }
 
   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();
   }
@@ -139,7 +162,7 @@ class StudyData {
     if (!item) {
       item = await JSONReader.readHashData(this.studyPath, hashKey);
       if (!item) {
-        console.error("Unable to read hashdata", hashKey);
+        console.error('Unable to read hashdata', hashKey);
         return item;
       }
       this.extractData[hashKey] = item;
@@ -149,7 +172,7 @@ class StudyData {
 
   assignUndefined(ret, item) {
     if (!item) return;
-    Object.keys(item).forEach((key) => {
+    Object.keys(item).forEach(key => {
       if (ret[key]) return;
       ret[key] = item[key];
     });
@@ -159,14 +182,14 @@ 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})`);
     }
     const refs = getList(deduplicated, Tags.DeduppedRef);
     if (!refs) {
-      console.log("No refs for", deduplicated);
+      console.log('No refs for', deduplicated);
       return deduplicated;
     }
     const ret = { ...deduplicated };
@@ -179,7 +202,8 @@ 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);
@@ -200,7 +224,7 @@ class StudyData {
   }
 
   /** Add the instance if not already present */
-  internalAddDeduplicated(data, filename = "internal") {
+  internalAddDeduplicated(data, filename = 'internal') {
     const hashValue = TagLists.addHash(data, Tags.InstanceType);
     if (!hashValue || this.deduplicatedHashes[hashValue]) {
       // console.log('Not adding', hashValue, 'because the hash exists');
@@ -209,13 +233,13 @@ class StudyData {
     const sopValue = getValue(data, Tags.SOPInstanceUID);
     const sopIndex = this.sopInstances[sopValue];
     if (!sopValue) {
-      console.warn("No sop value in", filename, "reading", data);
+      console.warn('No sop value in', filename, 'reading', data);
       return false;
     }
     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;
@@ -228,9 +252,9 @@ class StudyData {
   async listJsonFiles(dir) {
     const names = await fs.promises.readdir(dir);
     if (!names || names.length == 0) return [];
-    const gzNames = names.filter((name) => name.indexOf(".gz") > 0);
+    const gzNames = names.filter(name => name.indexOf('.gz') > 0);
     const statInfo = gzNames
-      .map((name) => {
+      .map(name => {
         const stat = fs.statSync(path.join(dir, name));
         return {
           ...stat,
@@ -259,10 +283,10 @@ class StudyData {
     try {
       const files = await this.listJsonFiles(deduplicatedDirectory);
       if (!files || !files.length) {
-        console.verbose("No deduplicated for", deduplicatedDirectory);
+        console.verbose('No deduplicated for', deduplicatedDirectory);
         return 0;
       }
-      console.verbose("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;
@@ -272,7 +296,7 @@ class StudyData {
         readCount += 1;
         await this.readDeduplicatedFile(deduplicatedDirectory, stat);
       }
-      console.verbose("Done checking", deduplicatedDirectory);
+      console.verbose('Done checking', deduplicatedDirectory);
     } catch (e) {
       // No-op console.log(e);
     }
@@ -282,11 +306,11 @@ 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) {
-      console.error("Unable to read", dir, name);
+      console.error('Unable to read', dir, name);
     }
   }
 
@@ -294,14 +318,14 @@ class StudyData {
     this.readHashes[hash] = name;
     this.existingFiles.push(name);
     const listData = (Array.isArray(data) && data) || [data];
-    listData.forEach((item) => {
+    listData.forEach(item => {
       const type = getValue(item, Tags.DeduppedType);
       if (type === Tags.InstanceType || type === Tags.DeletedType) {
         this.internalAddDeduplicated(item, name);
-      } else if (type == "info") {
+      } else if (type == 'info') {
         const refs = getList(item, Tags.DeduppedRef);
         if (refs) {
-          refs.forEach((hashValue) => {
+          refs.forEach(hashValue => {
             this.readHashes[hashValue] = `${hashValue}.gz`;
           });
         }
@@ -321,18 +345,22 @@ class StudyData {
     for (let i = 0; i < this.numberOfInstances; i++) {
       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));
+      if (type == 'deleted') {
+        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,18 +369,21 @@ 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;
       seriesQuery[Tags.NumberOfSeriesRelatedInstances] = {
-        vr: "IS",
+        vr: 'IS',
         Value: [instances.length],
       };
       numberOfInstances += instances.length;
@@ -360,37 +391,51 @@ class StudyData {
       const modality = getValue(seriesQuery, Tags.Modality);
       seriesList.push(seriesQuery);
       if (modalitiesInStudy.indexOf(modality) == -1) modalitiesInStudy.push(modality);
-      await JSONWriter(seriesPath, "metadata", instances, {
+      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, "instances", instancesQuery);
+      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);
+    await JSONWriter(this.studyPath, 'series', seriesList);
+    console.noQuiet('Wrote series', this.studyInstanceUid, 'with', seriesList.length);
 
-    const studyQuery = TagLists.extract(anInstance, "study", TagLists.PatientStudyQuery);
-    studyQuery[Tags.ModalitiesInStudy] = { Value: modalitiesInStudy, vr: "CS" };
+    const studyQuery = TagLists.extract(anInstance, 'study', TagLists.PatientStudyQuery);
+    studyQuery[Tags.ModalitiesInStudy] = { Value: modalitiesInStudy, vr: 'CS' };
     studyQuery[Tags.NumberOfStudyRelatedInstances] = {
       Value: [numberOfInstances],
-      vr: "IS",
+      vr: 'IS',
     };
     studyQuery[Tags.NumberOfStudyRelatedSeries] = {
       Value: [numberOfSeries],
-      vr: "IS",
+      vr: 'IS',
     };
     // Write the index.json directly in the studyPath directory.
-    await JSONWriter(this.studyPath, "index.json", [studyQuery], {
+    await JSONWriter(this.studyPath, 'index.json', [studyQuery], {
       gzip: true,
       index: false,
     });
 
     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;
   }
@@ -402,38 +447,41 @@ class StudyData {
     const data = {};
     const hashValue = hasher.hash(this.deduplicated);
     setValue(data, Tags.DeduppedHash, hashValue);
-    setValue(data, Tags.DeduppedType, "info");
+    setValue(data, Tags.DeduppedType, 'info');
     return data;
   }
 
-  /* eslint-disable-next-line class-methods-use-this */
   removeGz(name) {
-    const gzIndex = name.indexOf(".gz");
+    const gzIndex = name.indexOf('.gz');
     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);
+    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;
         } catch (e) {
-          console.log("Delete failed", e);
+          console.log('Delete failed', e);
         }
       }
     }
     if (deleteCount === files.length) {
-      console.log("Deleting instances directory", deduplicatedDirectory);
+      console.noQuiet('Deleting instances directory', deduplicatedDirectory);
       fs.rmdirSync(deduplicatedDirectory);
     }
   }
@@ -442,12 +490,12 @@ class StudyData {
   async writeDeduplicatedGroup() {
     const data = this.createInfo();
     const hashValue = getValue(data, Tags.DeduppedHash);
-    console.log(
-      "Writing deduplicated hash data set data with",
+    console.noQuiet(
+      'Writing deduplicated hash data set data with',
       Object.values(this.extractData).length,
-      "extract items and",
+      'extract items and',
       this.deduplicated.length,
-      "instance items"
+      'instance items'
     );
     setList(
       data,
@@ -459,8 +507,11 @@ class StudyData {
     // // 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

@@ -1,8 +1,8 @@
-const path = require("path");
-const glob = require("glob");
-const fs = require("fs");
-const { Tags, execSpawn, Stats } = require("@radicalimaging/static-wado-util");
-const { shouldThumbUseTranscoded } = require("./adapter/transcodeImage");
+const path = require('path');
+const glob = require('glob');
+const fs = require('fs');
+const { Tags, execSpawn, Stats } = require('@radicalimaging/static-wado-util');
+const { shouldThumbUseTranscoded } = require('./adapter/transcodeImage');
 
 /**
  * Return the middle index of given list
@@ -46,7 +46,7 @@ class ThumbnailService {
   constructor() {
     this.framesThumbnailObj = [];
     this.favoriteThumbnailObj = {};
-    this.thumbFileName = "thumbnail";
+    this.thumbFileName = 'thumbnail';
   }
 
   /**
@@ -57,7 +57,8 @@ class ThumbnailService {
    */
   queueThumbnail(thumbObjWrapper, programOpts) {
     const { id, imageFrame, transcodedId, transcodedImageFrame, frameIndex } = thumbObjWrapper;
-    const getThumbContent = (originalContent, trancodedContent) => (shouldThumbUseTranscoded(id, programOpts) ? trancodedContent : originalContent);
+    const getThumbContent = (originalContent, trancodedContent) =>
+      shouldThumbUseTranscoded(id, programOpts) ? trancodedContent : originalContent;
 
     const thumbObj = {
       imageFrame: getThumbContent(imageFrame, transcodedImageFrame),
@@ -77,15 +78,15 @@ 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) {
-    const script = ["dcm2jpg", `"${input}" "${output}"`];
+    const script = ['dcm2jpg', `"${input}" "${output}"`];
     if (options?.format) {
-      script.push("-F", options.format);
+      script.push('-F', options.format);
     }
-    execSpawn(script.join(" "));
+    execSpawn(script.join(' '));
   }
 
   /** Generates a rendered copy of this, assuming --rendered is set.
@@ -96,8 +97,8 @@ class ThumbnailService {
       return null;
     }
     const { id } = this.favoriteThumbnailObj;
-    const rendered = id.imageFrameRootPath.replace(/frames/, "rendered");
-    return this.dcm2jpg(id.filename, rendered, { format: "png" });
+    const rendered = id.imageFrameRootPath.replace(/frames/, 'rendered');
+    return this.dcm2jpg(id.filename, rendered, { format: 'png' });
   }
 
   /**
@@ -115,17 +116,18 @@ class ThumbnailService {
       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);
+        if (BulkDataURI?.indexOf('mp4')) {
+          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;
     }
@@ -135,23 +137,29 @@ class ThumbnailService {
     }
 
     if (options.dcm2jpg) {
-      return this.dcm2jpg(id.filename, id.imageFrameRootPath.replace(/frames/, "thumbnail"), {});
+      return this.dcm2jpg(id.filename, id.imageFrameRootPath.replace(/frames/, 'thumbnail'), {});
     }
 
-    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);
+    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,14 +172,14 @@ class ThumbnailService {
    * @returns
    */
   async copySyncThumbnail(sourceFolderPath, targetFolderPath) {
-    const parentPathLevel = path.join(sourceFolderPath, "../");
+    const parentPathLevel = path.join(sourceFolderPath, '../');
     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;
     }
 
@@ -182,7 +190,7 @@ class ThumbnailService {
 
       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);
     }
   }
 }