@radicalimaging/static-wado-creator 1.5.0 → 1.6.10

package/lib/operation/adapter/transcodeImage.js

@@ -11,6 +11,26 @@ const transcodeOp = {
   transcode: 3, // decode and then encode
 };
 
+const jpegBeforeEncode = (options, encoder) => {
+  const quality = options.quality ?? 99;
+  // First value is to encode as reversible lossless colour
+  return (encoder) => {
+    console.log("Calling setQuality", quality, !!encoder.setQuality);
+    encoder.setQuality(quality);
+  };
+};
+
+const jlsBeforeEncode = (options) => {
+  const delta = (options.delta ?? lossy) ? 3 : 0;
+  return (encoder) => encoder.setNearLossless(delta);
+};
+
+const htj2kBeforeEncode = (options) => {
+  const { lossy } = options;
+  const quality = lossy === true ? 0.002 : -1;
+  return (encoder) => encoder.setQuality(!lossy, quality);
+};
+
 /**
  * Static mapping for transcoding decoder destination names/uids - currently only lei, jls and jls-lossy appear to work.
  */
@@ -22,10 +42,12 @@ const transcodeDestinationMap = {
   jls: {
     transferSyntaxUid: "1.2.840.10008.1.2.4.80",
     transcodeOp: transcodeOp.encode,
+    beforeEncode: jlsBeforeEncode.bind(null, { lossy: false }),
   },
   "jls-lossy": {
     transferSyntaxUid: "1.2.840.10008.1.2.4.81",
     transcodeOp: transcodeOp.encode,
+    beforeEncode: jlsBeforeEncode.bind(null, { lossy: true, delta: 3 }),
   },
   jp2: {
     transferSyntaxUid: "1.2.840.10008.1.2.4.90",
@@ -36,12 +58,19 @@ const transcodeDestinationMap = {
     transcodeOp: transcodeOp.encode,
   },
   jhc: {
+    transferSyntaxUid: "1.2.840.10008.1.2.4.201",
+    transcodeOp: transcodeOp.encode,
+    beforeEncode: htj2kBeforeEncode({}),
+  },
+  "jhc-lossy": {
     transferSyntaxUid: "1.2.840.10008.1.2.4.202",
     transcodeOp: transcodeOp.encode,
+    beforeEncode: htj2kBeforeEncode({ lossy: true }),
   },
   jpeg: {
     transferSyntaxUid: "1.2.840.10008.1.2.4.50",
     transcodeOp: transcodeOp.encode,
+    // beforeEncode: jpegBeforeEncode({}),
   },
 };
 
@@ -103,11 +132,12 @@ const transcodeSourceMap = {
  * @returns A partial transcoder definition. Otherwise it returns undefined.
  */
 function getDestinationTranscoder(id) {
-  const destinationTranscoderEntry = Object.entries(transcodeDestinationMap).find(([key, value]) => key === id || value.transferSyntaxUid === id);
-  if (destinationTranscoderEntry) {
-    return destinationTranscoderEntry[1];
-  }
-  return undefined;
+  const destinationTranscoderEntry =
+    transcodeDestinationMap[id] ||
+    Object.values(transcodeDestinationMap).find(
+      (value) => value.transferSyntaxUid === id,
+    );
+  return destinationTranscoderEntry;
 }
 
 /**
@@ -116,8 +146,13 @@ function getDestinationTranscoder(id) {
  * @param {*} transferSyntaxUid
  * @returns
  */
-function getTranscoder(transferSyntaxUid, { contentType: greyContentType, colorContentType }, samplesPerPixel) {
-  const contentType = samplesPerPixel === 3 ? colorContentType : greyContentType;
+function getTranscoder(
+  transferSyntaxUid,
+  { contentType: greyContentType, colorContentType },
+  samplesPerPixel,
+) {
+  const contentType =
+    samplesPerPixel === 3 ? colorContentType : greyContentType;
   const sourceTranscoder = transcodeSourceMap[transferSyntaxUid];
   const destinationTranscoder = getDestinationTranscoder(contentType);
   if (!sourceTranscoder || !destinationTranscoder) {
@@ -126,8 +161,10 @@ function getTranscoder(transferSyntaxUid, { contentType: greyContentType, colorC
 
   return {
     transferSyntaxUid: destinationTranscoder.transferSyntaxUid,
-    transcodeOp: sourceTranscoder.transcodeOp | destinationTranscoder.transcodeOp, // eslint-disable-line no-bitwise
+    transcodeOp:
+      sourceTranscoder.transcodeOp | destinationTranscoder.transcodeOp,
     alias: sourceTranscoder.alias,
+    beforeEncode: destinationTranscoder.beforeEncode,
   };
 }
 
@@ -148,12 +185,22 @@ function shouldTranscodeImageFrame(id, options, samplesPerPixel) {
   const transcoder = getTranscoder(transferSyntaxUid, options, samplesPerPixel);
   const validTranscoder = transcoder && transcoder.transferSyntaxUid;
   if (!validTranscoder) {
-    console.verbose("Not transcoding because no decoder found for", transferSyntaxUid, samplesPerPixel);
+    console.verbose(
+      "Not transcoding because no decoder found for",
+      transferSyntaxUid,
+      samplesPerPixel,
+    );
     return false;
   }
-  const validRecompress = recompress.includes("true") || recompress.includes(transcoder.alias);
+  const validRecompress =
+    recompress.includes("true") || recompress.includes(transcoder.alias);
   if (!validRecompress) {
-    console.verbose("Not transcoding because recompress", recompress, "does not include", transcoder.alias);
+    console.verbose(
+      "Not transcoding because recompress",
+      recompress,
+      "does not include",
+      transcoder.alias,
+    );
     return false;
   }
 
@@ -176,7 +223,11 @@ function shouldThumbUseTranscoded(id, options) {
     const { transferSyntaxUid } = id;
     // 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);
+    const result =
+      transcoder &&
+      transcoder.transferSyntaxUid &&
+      options.recompress.includes(transcoder.alias) &&
+      options.recompressThumb.includes(transcoder.alias);
 
     return result;
   }
@@ -190,17 +241,9 @@ function transcodeLog(options, msg, error = "") {
   }
 }
 
-const beforeEncode = (options, encoder) => {
-  const lossy = !!options.lossy;
-  const quality = lossy ? 0.002 : -1;
-  const delta = lossy ? 3 : 0;
-  // First value is to encode as reversible lossless colour
-  encoder.setQuality?.(!lossy, quality);
-  encoder.setNearLossless?.(delta);
-};
-
 function scale(imageFrame, imageInfo) {
-  const { rows, columns, bitsPerPixel, pixelRepresentation, samplesPerPixel } = imageInfo;
+  const { rows, columns, bitsPerPixel, pixelRepresentation, samplesPerPixel } =
+    imageInfo;
   let ArrayConstructor = Float32Array;
   if (bitsPerPixel === 8) {
     ArrayConstructor = pixelRepresentation ? Int8Array : Uint8Array;
@@ -218,7 +261,9 @@ function scale(imageFrame, imageInfo) {
     columns: Math.round(columns / 4),
     samplesPerPixel,
   };
-  dest.pixelData = new ArrayConstructor(dest.rows * dest.columns * samplesPerPixel);
+  dest.pixelData = new ArrayConstructor(
+    dest.rows * dest.columns * samplesPerPixel,
+  );
   replicate(src, dest);
 
   return {
@@ -243,12 +288,16 @@ function scale(imageFrame, imageInfo) {
 async function generateLossyImage(id, decoded, options) {
   if (!options.alternate) return;
   if (!decoded?.imageFrame) return;
+  console.verbose("Writing alternate thumbnail");
 
   try {
     let { imageFrame, imageInfo } = decoded;
     const lossyId = {
       ...id,
-      imageFrameRootPath: id.imageFrameRootPath.replace("frames", options.alternateName),
+      imageFrameRootPath: id.imageFrameRootPath.replace(
+        "frames",
+        options.alternateName,
+      ),
       transferSyntaxUid: transcodeDestinationMap.jhc.transferSyntaxUid,
     };
 
@@ -264,7 +313,8 @@ async function generateLossyImage(id, decoded, options) {
     }
 
     if (options.alternate === "jls") {
-      lossyId.transferSyntaxUid = transcodeDestinationMap["jls-lossy"].transferSyntaxUid;
+      lossyId.transferSyntaxUid =
+        transcodeDestinationMap["jls-lossy"].transferSyntaxUid;
     } else if (options.alternate === "jlsLossless") {
       lossyId.transferSyntaxUid = transcodeDestinationMap.jls.transferSyntaxUid;
       lossy = false;
@@ -273,13 +323,22 @@ async function generateLossyImage(id, decoded, options) {
     }
 
     const encodeOptions = {
-      beforeEncode: beforeEncode.bind(null, {
-        lossy,
-      }),
+      beforeEncode: transcodeDestinationMap[options.alternate]?.beforeEncode,
     };
-    const lossyEncoding = await dicomCodec.encode(imageFrame, imageInfo, lossyId.transferSyntaxUid, encodeOptions);
-    console.log("Encoded alternate", lossyId.transferSyntaxUid, "of size", lossyEncoding.imageFrame.length);
-    // eslint-disable-next-line consistent-return
+
+    const lossyEncoding = await dicomCodec.encode(
+      imageFrame,
+      imageInfo,
+      lossyId.transferSyntaxUid,
+      encodeOptions,
+    );
+    console.verbose(
+      "Encoded alternate",
+      lossyId.transferSyntaxUid,
+      "of size",
+      lossyEncoding.imageFrame.length,
+    );
+
     return { id: lossyId, imageFrame: lossyEncoding.imageFrame };
   } catch (e) {
     console.warn("Unable to create alternate:", e);
@@ -300,13 +359,23 @@ function isPalette(dataSet) {
  * @param {*} options runner options
  * @returns object result for transcoding operation with id and image frame.
  */
-async function transcodeImageFrame(id, targetIdSrc, imageFrame, dataSet, options = {}) {
+async function transcodeImageFrame(
+  id,
+  targetIdSrc,
+  imageFrame,
+  dataSet,
+  options = {},
+) {
   let targetId = targetIdSrc;
   let result = {};
 
   const samplesPerPixel = dataSet.uint16(Tags.RawSamplesPerPixel);
   const planarConfiguration = dataSet.uint16("x00280006");
-  if (!shouldTranscodeImageFrame(id, options, samplesPerPixel) || planarConfiguration === 1 || isPalette(dataSet)) {
+  if (
+    !shouldTranscodeImageFrame(id, options, samplesPerPixel) ||
+    planarConfiguration === 1 ||
+    isPalette(dataSet)
+  ) {
     console.verbose("Shouldn't transcode");
     return {
       id,
@@ -315,11 +384,22 @@ async function transcodeImageFrame(id, targetIdSrc, imageFrame, dataSet, options
     };
   }
 
-  const transcoder = getTranscoder(id.transferSyntaxUid, options, samplesPerPixel);
+  const transcoder = getTranscoder(
+    id.transferSyntaxUid,
+    options,
+    samplesPerPixel,
+  );
 
   // Don't transcode if not required
-  if (targetId.transferSyntaxUid !== transcoder.transferSyntaxUid && !options.forceTranscode) {
-    console.verbose("Image is already in", targetId.transferSyntaxUid, "not transcoding");
+  if (
+    targetId.transferSyntaxUid !== transcoder.transferSyntaxUid &&
+    !options.forceTranscode
+  ) {
+    console.verbose(
+      "Image is already in",
+      targetId.transferSyntaxUid,
+      "not transcoding",
+    );
     return {
       id,
       imageFrame,
@@ -333,33 +413,63 @@ async function transcodeImageFrame(id, targetIdSrc, imageFrame, dataSet, options
   let done = false;
   let processResultMsg = "";
   const encodeOptions = {
-    beforeEncode: beforeEncode.bind(null, {
-      lossy: options.lossy,
-    }),
+    beforeEncode: transcoder.beforeEncode,
   };
   let decoded;
 
   try {
     switch (transcoder.transcodeOp) {
       case transcodeOp.transcode:
-        transcodeLog(options, `Full transcoding image from \x1b[43m${id.transferSyntaxUid}\x1b[0m to \x1b[43m${targetId.transferSyntaxUid}\x1b[0m`);
-
-        decoded = await dicomCodec.decode(imageFrame, imageInfo, id.transferSyntaxUid);
-        result = await dicomCodec.encode(decoded.imageFrame, decoded.imageInfo, targetId.transferSyntaxUid, encodeOptions);
-
-        console.log("transcoded image to", targetId.transferSyntaxUid, "of size", result.imageFrame.length);
+        transcodeLog(
+          options,
+          `Full transcoding image from \x1b[43m${id.transferSyntaxUid}\x1b[0m to \x1b[43m${targetId.transferSyntaxUid}\x1b[0m`,
+        );
+
+        decoded = await dicomCodec.decode(
+          imageFrame,
+          imageInfo,
+          id.transferSyntaxUid,
+        );
+        result = await dicomCodec.encode(
+          decoded.imageFrame,
+          decoded.imageInfo,
+          targetId.transferSyntaxUid,
+          encodeOptions,
+        );
+
+        console.verbose(
+          "transcoded image to",
+          targetId.transferSyntaxUid,
+          "of size",
+          result.imageFrame.length,
+        );
         processResultMsg = `Transcoding finished`;
         break;
       case transcodeOp.encode:
-        transcodeLog(options, `Encoding image to \x1b[43m${targetId.transferSyntaxUid}\x1b[0m`);
-
-        result = await dicomCodec.encode(imageFrame, imageInfo, targetId.transferSyntaxUid, encodeOptions);
+        transcodeLog(
+          options,
+          `Encoding image to \x1b[43m${targetId.transferSyntaxUid}\x1b[0m`,
+        );
+
+        result = await dicomCodec.encode(
+          imageFrame,
+          imageInfo,
+          targetId.transferSyntaxUid,
+          encodeOptions,
+        );
 
         processResultMsg = `Encoding finished`;
         break;
       case transcodeOp.decode:
-        transcodeLog(options, `Decoding image from \x1b[43m${id.transferSyntaxUid}\x1b[0m`);
-        result = await dicomCodec.decode(imageFrame, imageInfo, id.transferSyntaxUid);
+        transcodeLog(
+          options,
+          `Decoding image from \x1b[43m${id.transferSyntaxUid}\x1b[0m`,
+        );
+        result = await dicomCodec.decode(
+          imageFrame,
+          imageInfo,
+          id.transferSyntaxUid,
+        );
 
         processResultMsg = `Decoding finished`;
         break;
@@ -407,7 +517,11 @@ function transcodeId(id, options, samplesPerPixel) {
   }
 
   const targetId = { ...id };
-  const { transferSyntaxUid } = getTranscoder(id.transferSyntaxUid, options, samplesPerPixel);
+  const { transferSyntaxUid } = getTranscoder(
+    id.transferSyntaxUid,
+    options,
+    samplesPerPixel,
+  );
 
   targetId.transferSyntaxUid = transferSyntaxUid;
 
@@ -436,7 +550,11 @@ function transcodeMetadata(metadata, id, options) {
   const result = { ...metadata };
 
   if (result[Tags.AvailableTransferSyntaxUID]) {
-    Tags.setValue(result, Tags.AvailableTransferSyntaxUID, transcodedId.transferSyntaxUid);
+    Tags.setValue(
+      result,
+      Tags.AvailableTransferSyntaxUID,
+      transcodedId.transferSyntaxUid,
+    );
     console.verbose("Apply available tsuid", transcodeId.transferSyntaxUid);
   }
 

package/lib/operation/extractImageFrames.js

@@ -5,7 +5,8 @@ const getUncompressedImageFrame = require("./getUncompressedImageFrame");
 const getEncapsulatedImageFrame = require("./getEncapsulatedImageFrame");
 const { isVideo } = require("../writer/VideoWriter");
 
-const areFramesAreFragmented = (attr, numberOfFrames) => attr.encapsulatedPixelData && numberOfFrames != attr.fragments.length;
+const areFramesAreFragmented = (attr, numberOfFrames) =>
+  attr.encapsulatedPixelData && numberOfFrames != attr.fragments.length;
 
 const getFrameSize = (dataSet) => {
   const rows = dataSet.uint16("x00280010");
@@ -30,11 +31,25 @@ const extractImageFrames = async (dataSet, attr, vr, callback) => {
 
   for (let frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
     if (attr.encapsulatedPixelData) {
-      const compressedFrame = getEncapsulatedImageFrame(dataSet, attr, frameIndex, framesAreFragmented);
+      const compressedFrame = getEncapsulatedImageFrame(
+        dataSet,
+        attr,
+        frameIndex,
+        framesAreFragmented,
+      );
       BulkDataURI = await callback.imageFrame(compressedFrame, { dataSet });
-      Stats.OverallStats.add("Image Write", `Write image frame ${frameIndex + 1}`, 5000);
+      Stats.OverallStats.add(
+        "Image Write",
+        `Write image frame ${frameIndex + 1}`,
+        5000,
+      );
     } else {
-      const uncompressedFrame = getUncompressedImageFrame(dataSet, attr, frameIndex, uncompressedFrameSize);
+      const uncompressedFrame = getUncompressedImageFrame(
+        dataSet,
+        attr,
+        frameIndex,
+        uncompressedFrameSize,
+      );
       BulkDataURI = await callback.imageFrame(uncompressedFrame, { dataSet });
     }
   }

package/lib/operation/getDataSet.js

@@ -13,14 +13,23 @@ const getValue = require("./getValue");
  * @param {*} parentAttr Parent reference for sequence element tags.
  * @returns
  */
-async function getDataSet(dataSet, callback, optionsOrig, 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) {
     // Raw versions have the x in front of them
-    if (tag != Tags.RawTransferSyntaxUID && tag >= Tags.RawMinTag && tag < Tags.RawFirstBodyTag) {
+    if (
+      tag != Tags.RawTransferSyntaxUID &&
+      tag >= Tags.RawMinTag &&
+      tag < Tags.RawFirstBodyTag
+    ) {
       continue;
     }
     if (tag === Tags.RawSpecificCharacterSet) {
@@ -28,21 +37,46 @@ async function getDataSet(dataSet, callback, optionsOrig, parentAttr = undefined
       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);
+
+    await attributeToJS(
+      metadata,
+      tag,
+      dataSet,
+      attr,
+      callback,
+      options,
+      parentAttr,
+    );
   }
   if (metadata[Tags.TransferSyntaxUID]) {
     // console.log(`Found tsuid ${JSON.stringify(metadata[Tags.TransferSyntaxUID])} assigning to ${Tags.AvailableTransferSyntaxUID}`)
-    metadata[Tags.AvailableTransferSyntaxUID] = metadata[Tags.TransferSyntaxUID];
+    metadata[Tags.AvailableTransferSyntaxUID] =
+      metadata[Tags.TransferSyntaxUID];
     delete metadata[Tags.TransferSyntaxUID];
   }
   return { metadata };
 }
 
-async function attributeToJS(metadataSrc, tag, dataSet, attr, callback, options, parentAttr) {
+async function attributeToJS(
+  metadataSrc,
+  tag,
+  dataSet,
+  attr,
+  callback,
+  options,
+  parentAttr,
+) {
   const metadata = metadataSrc;
   const vr = getVR(attr);
-  const value = await getValue(dataSet, attr, vr, getDataSet, callback, options, parentAttr);
+  const value = await getValue(
+    dataSet,
+    attr,
+    vr,
+    getDataSet,
+    callback,
+    options,
+    parentAttr,
+  );
   const key = tag.substring(1).toUpperCase();
   if (value === undefined || value === null || value.length === 0) {
     if (!vr) return;

package/lib/operation/getEncapsulatedImageFrame.js

@@ -4,20 +4,44 @@ const dicomParser = require("dicom-parser");
  * Function to deal with extracting an image frame from an encapsulated data set.
  */
 
-const getEncapsulatedImageFrame = (dataSet, attr, frameIndex, framesAreFragmented) => {
-  if (dataSet.elements.x7fe00010 && dataSet.elements.x7fe00010.basicOffsetTable.length) {
+const getEncapsulatedImageFrame = (
+  dataSet,
+  attr,
+  frameIndex,
+  framesAreFragmented,
+) => {
+  if (
+    dataSet.elements.x7fe00010 &&
+    dataSet.elements.x7fe00010.basicOffsetTable.length
+  ) {
     // Basic Offset Table is not empty
-    return dicomParser.readEncapsulatedImageFrame(dataSet, dataSet.elements.x7fe00010, frameIndex);
+    return dicomParser.readEncapsulatedImageFrame(
+      dataSet,
+      dataSet.elements.x7fe00010,
+      frameIndex,
+    );
   }
 
   // Empty basic offset table
   if (framesAreFragmented) {
-    const basicOffsetTable = dicomParser.createJPEGBasicOffsetTable(dataSet, dataSet.elements.x7fe00010);
+    const basicOffsetTable = dicomParser.createJPEGBasicOffsetTable(
+      dataSet,
+      dataSet.elements.x7fe00010,
+    );
 
-    return dicomParser.readEncapsulatedImageFrame(dataSet, dataSet.elements.x7fe00010, frameIndex, basicOffsetTable);
+    return dicomParser.readEncapsulatedImageFrame(
+      dataSet,
+      dataSet.elements.x7fe00010,
+      frameIndex,
+      basicOffsetTable,
+    );
   }
 
-  return dicomParser.readEncapsulatedPixelDataFromFragments(dataSet, dataSet.elements.x7fe00010, frameIndex);
+  return dicomParser.readEncapsulatedPixelDataFromFragments(
+    dataSet,
+    dataSet.elements.x7fe00010,
+    frameIndex,
+  );
 };
 
 module.exports = getEncapsulatedImageFrame;

package/lib/operation/getUncompressedImageFrame.js

@@ -1,6 +1,14 @@
-function getUncompressedImageFrame(dataSet, attr, frame, uncompressedFrameSize) {
+function getUncompressedImageFrame(
+  dataSet,
+  attr,
+  frame,
+  uncompressedFrameSize,
+) {
   const start = attr.dataOffset + frame * uncompressedFrameSize;
-  const binaryValue = dataSet.byteArray.slice(start, start + uncompressedFrameSize);
+  const binaryValue = dataSet.byteArray.slice(
+    start,
+    start + uncompressedFrameSize,
+  );
   return binaryValue;
 }
 

package/lib/operation/getVR.js

@@ -1,5 +1,8 @@
 const { dataDictionary } = require("@radicalimaging/static-wado-util");
 
+const nullVrTags = new Set();
+nullVrTags.add("FFFEE00D");
+
 const getVR = (attr) => {
   if (attr.vr) {
     return attr.vr;
@@ -7,10 +10,15 @@ const getVR = (attr) => {
   // lookup the vr using the data dictionary
   const tag = attr.tag.substring(1).toUpperCase();
   const dataDictAttr = dataDictionary[tag];
-  if (dataDictAttr) {
+  if (dataDictAttr?.vr) {
     return dataDictAttr.vr;
   }
-  return undefined;
+  if (nullVrTags.has(tag)) {
+    return null;
+  }
+
+  console.log("Unknown VR", tag, attr, dataDictAttr);
+  return "UN";
 };
 
 module.exports = getVR;

package/lib/operation/getValue.js

@@ -32,7 +32,7 @@ const getValueInlineBinary = (dataSet, attr) => {
   if (attr.BulkDataURI) return { BulkDataURI: attr.BulkDataURI };
   const binaryValue = dataSet.byteArray.slice(
     attr.dataOffset,
-    attr.dataOffset + attr.length
+    attr.dataOffset + attr.length,
   );
   return { InlineBinary: binaryValue.toString("base64") };
 };
@@ -194,7 +194,7 @@ const getValue = async (
   getDataSet,
   callback,
   options,
-  parentAttr
+  parentAttr,
 ) => {
   // It will only process pixelData tag if on metadata root. Otherwise it will be skiped.
   if (attr.tag === "x7fe00010" && !parentAttr) {
@@ -203,7 +203,7 @@ const getValue = async (
       attr,
       vr,
       callback,
-      options
+      options,
     );
     return { BulkDataURI };
   }
@@ -229,7 +229,7 @@ const getValue = async (
   }
   const binaryValue = dataSet.byteArray.slice(
     attr.dataOffset,
-    attr.dataOffset + attr.length
+    attr.dataOffset + attr.length,
   );
   const mimeType = attr.tag == "x00420011" && dataSet.string("x00420012");
 

package/lib/operation/validateMetadata.js

@@ -0,0 +1,40 @@
+const { Tags } = require("@radicalimaging/static-wado-util");
+
+function validateMetadata(options) {
+  const serviceUrl = "";
+  const { verify, multipart: stowResponse } = options;
+
+  return function (id, result) {
+    const getValue = Tags.getValue.bind(null, result.metadata);
+    if (verify) {
+      console.verbose("Validating metadata", id);
+      if (id.studyInstanceUid.length > 64) {
+        throw new Error(`StudyInstanceUID too long: ${id.studyInstanceUid}`);
+      }
+      if (id.seriesInstanceUid.length > 64) {
+        throw new Error(`SeriesInstanceUID too long: ${id.studyInstanceUid}`);
+      }
+    }
+    if (stowResponse) {
+      const RetrieveURL = `${serviceUrl}${id.studyInstanceUid}/series/${id.seriesInstanceUid}/instances/${id.sopInstanceUid}`;
+
+      // TODO - add check here from plugin to add remote query checks, eg kheops or similar
+      const { filename } = id;
+      const successMessage = {
+        ReferencedSOPSequence: [
+          {
+            StudyInstanceUID: id.studyInstanceUid,
+            SeriesInstanceUID: id.seriesInstanceUid,
+            ReferencedSOPClassUID: getValue(Tags.SOPClassUID),
+            ReferencedSOPInstanceUID: id.sopInstanceUid,
+            RetrieveURL,
+            StorageURL: filename,
+          },
+        ],
+      };
+      this.success("instanceStored", successMessage, filename);
+    }
+  };
+}
+
+module.exports = validateMetadata;

package/lib/program/index.js

@@ -7,9 +7,11 @@ const staticWadoUtil = require("@radicalimaging/static-wado-util");
  * @returns Program object
  */
 async function configureProgram(defaults) {
-  const configurationFile = await staticWadoUtil.loadConfiguration(defaults, process.argv);
-  console.log("Loaded configuration from", configurationFile);
-  staticWadoUtil.configureCommands(defaults);
+  const configurationFile = await staticWadoUtil.loadConfiguration(
+    defaults,
+    process.argv,
+  );
+  return staticWadoUtil.configureCommands(defaults);
 }
 
 exports.configureProgram = configureProgram;