@radicalimaging/static-wado-creator 0.6.5 → 1.2.0

package/lib/operation/StudyData.js

@@ -1,10 +1,9 @@
 const path = require("path");
 const fs = require("fs");
 const hashFactory = require("node-object-hash");
-const { JSONReader } = require("@radicalimaging/static-wado-util");
-const Tags = require("../dictionary/Tags");
+const { JSONReader, JSONWriter } = require("@radicalimaging/static-wado-util");
+const { Tags } = require("@radicalimaging/static-wado-util");
 const TagLists = require("../model/TagLists");
-const JSONWriter = require("../writer/JSONWriter");
 
 const { getValue, setValue, getList, setList } = Tags;
 const hasher = hashFactory();
@@ -42,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;
@@ -55,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);
     }
   }
 
@@ -73,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++) {
@@ -108,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");
     }
   }
@@ -240,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) {
@@ -266,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 = {};
@@ -300,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);
@@ -335,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);
     }
 
@@ -389,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();

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 decodeImage = require("./adapter/decodeImage");
+const { Tags, execSpawn, Stats } = require("@radicalimaging/static-wado-util");
 const { shouldThumbUseTranscoded } = require("./adapter/transcodeImage");
-const { isVideo } = require("../writer/VideoWriter");
-const Tags = require("../dictionary/Tags");
 
 /**
  * Return the middle index of given list
@@ -17,21 +12,6 @@ const Tags = require("../dictionary/Tags");
 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

@@ -1,7 +1,9 @@
 const dicomCodec = require("@cornerstonejs/dicom-codec");
-const Tags = require("../../dictionary/Tags");
+const { Tags } = require("@radicalimaging/static-wado-util");
 const getImageInfo = require("./getImageInfo");
 
+dicomCodec.setConfig("verbose: false");
+
 const transcodeOp = {
   none: 0,
   decode: 1,
@@ -33,6 +35,14 @@ const transcodeDestinationMap = {
     transferSyntaxUid: "1.2.840.10008.1.2.4.91",
     transcodeOp: transcodeOp.encode,
   },
+  jhc: {
+    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 = {
@@ -48,13 +58,17 @@ 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: "jpeglossless",
+    alias: "jls",
   },
   "1.2.840.10008.1.2.4.70": {
     transcodeOp: transcodeOp.decode,
-    alias: "jpeglossless",
+    alias: "jls",
   },
   "1.2.840.10008.1.2.4.90": {
     transcodeOp: transcodeOp.decode,
@@ -64,6 +78,10 @@ const transcodeSourceMap = {
     transcodeOp: transcodeOp.decode,
     alias: "jp2",
   },
+  "3.2.840.10008.1.2.4.96": {
+    transcodeOp: transcodeOp.decode,
+    alias: "jhc",
+  },
   "1.2.840.10008.1.2.5": {
     transcodeOp: transcodeOp.decode,
     alias: "rle",
@@ -90,10 +108,8 @@ function getDestinationTranscoder(id) {
  * @param {*} transferSyntaxUid
  * @returns
  */
-function getTranscoder(transferSyntaxUid, { contentType, verbose }) {
-  if (verbose) {
-    console.log(`getTranscoder for ${transferSyntaxUid}`);
-  }
+function getTranscoder(transferSyntaxUid, { contentType: greyContentType, colorContentType }, samplesPerPixel) {
+  const contentType = samplesPerPixel===3 ? colorContentType : greyContentType;
   const sourceTranscoder = transcodeSourceMap[transferSyntaxUid];
   const destinationTranscoder = getDestinationTranscoder(contentType);
   if (!sourceTranscoder || !destinationTranscoder) {
@@ -112,18 +128,25 @@ function getTranscoder(transferSyntaxUid, { contentType, verbose }) {
  * @param {*} id object containing transferSyntaxUid
  * @param {*} options runner options
  */
-function shouldTranscodeImageFrame(id, options) {
-  if (!options.recompress) {
+function shouldTranscodeImageFrame(id, options, samplesPerPixel) {
+  const { recompress: recompressGrey, recompressColor } = options;
+  const recompress = samplesPerPixel === 3 ? recompressColor : recompressGrey;
+  if (!recompress) {
+    console.verbose("Not transcoding because recompress not set");
     return false;
   }
 
   function isValidTranscoder() {
     const { transferSyntaxUid } = id;
-    const transcoder = getTranscoder(transferSyntaxUid, options);
-    return transcoder && transcoder.transferSyntaxUid && options.recompress.includes(transcoder.alias);
+    const transcoder = getTranscoder(transferSyntaxUid, options, samplesPerPixel);
+    return transcoder && transcoder.transferSyntaxUid && (recompress.includes("true") || recompress.includes(transcoder.alias));
   }
 
-  return isValidTranscoder();
+  const ret = isValidTranscoder();
+  if (!ret) {
+    console.verbose("Not transcoding");
+  }
+  return ret;
 }
 
 /**
@@ -140,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;
@@ -169,7 +193,9 @@ async function transcodeImageFrame(id, targetIdSrc, imageFrame, dataSet, options
   let targetId = targetIdSrc;
   let result = {};
 
-  if (!shouldTranscodeImageFrame(id, options)) {
+  const samplesPerPixel = dataSet.uint16(Tags.RawSamplesPerPixel);
+  if (!shouldTranscodeImageFrame(id, options, samplesPerPixel)) {
+    console.verbose("Shouldn't transcode");
     return {
       id,
       imageFrame,
@@ -177,10 +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.verbose("Image is already in", targetId.transferSyntaxUid, "not transcoding");
     return {
       id,
       imageFrame,
@@ -188,9 +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 = "";
@@ -254,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;
 
@@ -279,16 +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);
+    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

@@ -1,6 +1,6 @@
+const { Tags } = require("@radicalimaging/static-wado-util");
 const getVR = require("./getVR");
 const getValue = require("./getValue");
-const Tags = require("../dictionary/Tags");
 
 /**
  * Get dataset.
@@ -13,8 +13,9 @@ const Tags = require("../dictionary/Tags");
  * @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/getVR.js

@@ -1,4 +1,4 @@
-const dataDictionary = require("../dictionary/dataDictionary");
+const { dataDictionary } = require("@radicalimaging/static-wado-util");
 
 const getVR = (attr) => {
   if (attr.vr) {

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");