@radicalimaging/static-wado-creator 0.6.4

package/lib/operation/adapter/asyncIterableToBuffer.js

@@ -0,0 +1,112 @@
+const { Stats } = require("@radicalimaging/static-wado-util");
+/* eslint "no-param-reassign": "off" */
+
+const handler = {
+  get(obj, key) {
+    const ikey = parseInt(key);
+    if (ikey == key) return obj.index_get(ikey);
+    const handlerFunc = handler[key];
+    if (handlerFunc && key != "get") return handlerFunc(obj, key);
+    if (!obj._keys[key]) {
+      console.log("New call to", key);
+      obj._keys[key] = true;
+    }
+    return obj[key];
+  },
+
+  length: (obj) => obj.combinedLength,
+};
+
+const StreamingFunctions = {
+  addChunks(chunks) {
+    if (!this.chunks) this.chunks = [];
+    chunks.forEach((chunk) => this.chunks.push(chunk));
+    this.combinedLength = 0;
+    let i = 0;
+    this.chunks.forEach((chunk) => {
+      chunk.start = this.combinedLength;
+      chunk.i = i;
+      i += 1;
+      this.combinedLength += chunk.length;
+    });
+    this.lastChunk = this.chunks[0];
+  },
+
+  index_get(ikey) {
+    const found = this.findChunk(ikey);
+    if (!found) throw Error(`index ${ikey} not found between 0..${this.combinedLength}`);
+    return found[ikey - found.start];
+  },
+
+  findChunk(ikey) {
+    let i = (this.lastChunk.start <= ikey && this.lastChunk.i) || 0;
+    while (i < this.chunks.length) {
+      const chunk = this.chunks[i];
+      if (ikey >= chunk.start && ikey < chunk.start + chunk.length) {
+        this.lastChunk = chunk;
+        return chunk;
+      }
+      i += 1;
+    }
+    return undefined;
+  },
+
+  slice(start, end) {
+    const buflen = end - start;
+    const ret = Buffer.alloc(buflen);
+    let i = 0;
+    while (i < buflen) {
+      const chunk = this.findChunk(start + i);
+      const chunkI = start + i - chunk.start;
+      const useLen = Math.min(buflen, chunk.length - chunkI);
+      chunk.copy(ret, i, chunkI, chunkI + useLen);
+      i += useLen;
+    }
+    return ret;
+  },
+
+  hexSlice(start, end) {
+    return this.slice(start, end).hexSlice();
+  },
+
+  /** The internal node copy function is a native that directly accesses internal class details, so over-ride it.
+   * TODO: Make this efficient by using the internal copy function when available rather than copy one at a time.
+   */
+  copy(target, targetStart = 0, srcStart = 0, srcEnd = 0) {
+    const { length } = target;
+    const srcLength = (srcEnd === undefined && Math.min(this.length, srcEnd)) || this.length;
+    const copied = 0;
+    while (targetStart < length && srcStart < srcLength) {
+      target[targetStart] = this[srcStart];
+      targetStart += 1;
+      srcStart += 1;
+    }
+    return copied;
+  },
+
+  _keys: { then: true, lastChunk: true, chunks: true },
+};
+
+Object.keys(StreamingFunctions).forEach((key) => {
+  StreamingFunctions._keys[key] = true;
+});
+
+const StreamingBuffer = (chunks) => {
+  const buf = Buffer.from("NotUsed");
+  Object.assign(buf, StreamingFunctions);
+  buf.addChunks(chunks);
+  return new Proxy(buf, handler);
+};
+
+const asyncIteratorToBuffer = async (readable) => {
+  if (ArrayBuffer.isView(readable)) return readable;
+  const chunks = [];
+  for await (const chunk of readable) {
+    chunks.push(chunk);
+    Stats.BufferStats.add("Read Async", `Read async buffer ${chunks.length}`, 1024);
+  }
+  Stats.BufferStats.reset();
+  return StreamingBuffer(chunks);
+};
+
+module.exports = asyncIteratorToBuffer;

package/lib/operation/adapter/decodeImage.js

@@ -0,0 +1,9 @@
+const dicomCodec = require("@cornerstonejs/dicom-codec");
+const getImageInfo = require("./getImageInfo");
+
+async function decodeImage(imageFrame, dataset, transferSyntaxUid) {
+  const imageInfo = getImageInfo(dataset);
+  return dicomCodec.decode(imageFrame, imageInfo, transferSyntaxUid);
+}
+
+module.exports = decodeImage;

package/lib/operation/adapter/getImageInfo.js

@@ -0,0 +1,21 @@
+/**
+ * Minimum image info data to be used on transcode process by dicom-codec api.
+ */
+function getImageInfo(dataSet) {
+  const rows = dataSet.uint16("x00280010");
+  const columns = dataSet.uint16("x00280011");
+  const bitsAllocated = dataSet.uint16("x00280100");
+  const samplesPerPixel = dataSet.uint16("x00280002");
+  const pixelRepresentation = dataSet.uint16("x00280103") || 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,
+  };
+}
+
+module.exports = getImageInfo;

package/lib/operation/adapter/transcodeImage.js

@@ -0,0 +1,303 @@
+const dicomCodec = require("@cornerstonejs/dicom-codec");
+const Tags = require("../../dictionary/Tags");
+const getImageInfo = require("./getImageInfo");
+
+const transcodeOp = {
+  none: 0,
+  decode: 1,
+  encode: 2,
+  transcode: 3, // decode and then encode
+};
+
+/**
+ * Static mapping for transcoding decoder destination names/uids - currently only lei, jls and jls-lossy appear to work.
+ */
+const transcodeDestinationMap = {
+  lei: {
+    transferSyntaxUid: "1.2.840.10008.1.2.1",
+    transcodeOp: transcodeOp.none
+  },
+  jls: {
+    transferSyntaxUid: "1.2.840.10008.1.2.4.80",
+    transcodeOp: transcodeOp.encode,
+  },
+  "jls-lossy": {
+    transferSyntaxUid: "1.2.840.10008.1.2.4.81",
+    transcodeOp: transcodeOp.encode,
+  },
+  jp2: {
+    transferSyntaxUid: "1.2.840.10008.1.2.4.90",
+    transcodeOp: transcodeOp.encode,
+  },
+  "jp2-lossy": {
+    transferSyntaxUid: "1.2.840.10008.1.2.4.91",
+    transcodeOp: transcodeOp.encode,
+  },
+};
+
+const transcodeSourceMap = {
+  "1.2.840.10008.1.2": {
+    transcodeOp: transcodeOp.decode,
+    alias: "uncompressed",
+  },
+  "1.2.840.10008.1.2.1": {
+    transcodeOp: transcodeOp.none,
+    alias: "uncompressed",
+  },
+  "1.2.840.10008.1.2.2": {
+    transcodeOp: transcodeOp.decode,
+    alias: "uncompressed",
+  },
+  "1.2.840.10008.1.2.4.57": {
+    transcodeOp: transcodeOp.decode,
+    alias: "jpeglossless",
+  },
+  "1.2.840.10008.1.2.4.70": {
+    transcodeOp: transcodeOp.decode,
+    alias: "jpeglossless",
+  },
+  "1.2.840.10008.1.2.4.90": {
+    transcodeOp: transcodeOp.decode,
+    alias: "jp2",
+  },
+  "1.2.840.10008.1.2.4.91": {
+    transcodeOp: transcodeOp.decode,
+    alias: "jp2",
+  },
+  "1.2.840.10008.1.2.5": {
+    transcodeOp: transcodeOp.decode,
+    alias: "rle",
+  },
+};
+
+/**
+ * Get an existing destination transcoder from destination map. 
+ *
+ * @param {*} id Destination type to compress to 
+ * @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;
+}
+
+/**
+ * Return a merged source and destination transcoder for the given transferSyntaxUid. Otherwise it returns undefined.
+ *
+ * @param {*} transferSyntaxUid
+ * @returns
+ */
+function getTranscoder(transferSyntaxUid, { contentType, verbose }) {
+  if (verbose) {
+    console.log(`getTranscoder for ${transferSyntaxUid}`);
+  }
+  const sourceTranscoder = transcodeSourceMap[transferSyntaxUid];
+  const destinationTranscoder = getDestinationTranscoder(contentType);
+  if (!sourceTranscoder || !destinationTranscoder) {
+    return undefined;
+  }
+  
+  return {
+    transferSyntaxUid: destinationTranscoder.transferSyntaxUid,
+    transcodeOp: sourceTranscoder.transcodeOp | destinationTranscoder.transcodeOp, // eslint-disable-line no-bitwise
+    alias: sourceTranscoder.alias,
+  };
+}
+
+
+/**
+ * Tell whether given id contain transferSyntaxUid which can be transcoded or not.
+ * @param {*} id object containing transferSyntaxUid
+ * @param {*} options runner options
+ */
+function shouldTranscodeImageFrame(id, options) {
+  if (!options.recompress) {
+    return false;
+  }
+
+  function isValidTranscoder() {
+    const { transferSyntaxUid } = id;
+    const transcoder = getTranscoder(transferSyntaxUid, options);
+    return transcoder && transcoder.transferSyntaxUid && options.recompress.includes(transcoder.alias);
+  }
+
+  return isValidTranscoder();
+}
+
+/**
+ * It tells if we should use transcoded image to generate thumb or not.
+ *
+ * @param {*} id
+ * @param {*} options
+ * @returns True if transcoder.alias is present on intersection of recompressThumb and recompress options.
+ */
+function shouldThumbUseTranscoded(id, options) {
+  if (!options.recompressThumb) {
+    return false;
+  }
+
+  function isValidTranscoder() {
+    const { transferSyntaxUid } = id;
+    const transcoder = getTranscoder(transferSyntaxUid, options);
+    const result = transcoder && transcoder.transferSyntaxUid && options.recompress.includes(transcoder.alias) && options.recompressThumb.includes(transcoder.alias);
+
+    return result;
+  }
+
+  return isValidTranscoder();
+}
+
+function transcodeLog(options, msg, error = "") {
+  if (options.verbose) {
+    console.log(`\x1b[34m${msg}\x1b[0m`, error);
+  }
+}
+
+/**
+ * Transcode imageFrame. It uses transcodeMap to define the target encoding based on source encoding.
+ *
+ * @param {*} id object containing transferSyntaxUid
+ * @param {*} targetId target object containing transferSyntaxUid
+ * @param {*} imageFrame data to be transcoded
+ * @param {*} dataSet related image frame dataset
+ * @param {*} options runner options
+ * @returns object result for transcoding operation with id and image frame.
+ */
+async function transcodeImageFrame(id, targetIdSrc, imageFrame, dataSet, options = {}) {
+  let targetId = targetIdSrc;
+  let result = {};
+
+  if (!shouldTranscodeImageFrame(id, options)) {
+    return {
+      id,
+      imageFrame,
+      done: false,
+    };
+  }
+
+  const transcoder = getTranscoder(id.transferSyntaxUid, options);
+
+  // last chance to prevent transcoding
+  if (targetId.transferSyntaxUid !== transcoder.transferSyntaxUid) {
+    return {
+      id,
+      imageFrame,
+      done: false,
+    };
+  }
+
+  if (options.verbose) {
+    console.log("Transcoding to", transcoder.transferSyntaxUid);
+  }
+  const imageInfo = getImageInfo(dataSet);
+  let done = false;
+  let processResultMsg = "";
+
+  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`);
+
+        result = await dicomCodec.transcode(imageFrame, imageInfo, id.transferSyntaxUid, targetId.transferSyntaxUid);
+
+        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);
+
+        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);
+
+        processResultMsg = `Decoding finished`;
+        break;
+      default:
+        processResultMsg = "";
+    }
+
+    done = !!result.imageFrame;
+  } catch (e) {
+    transcodeLog(options, "Failed to transcode image", e);
+  }
+
+  // recover transfer syntax
+  if (!done) {
+    targetId = id;
+  }
+
+  // log final message only if resultMsg is present
+  if (processResultMsg) {
+    processResultMsg += done ? " successfully" : " unsuccessfully";
+    transcodeLog(options, processResultMsg);
+  }
+
+  const _imageFrame = result.imageFrame ?? imageFrame;
+
+  return {
+    id: targetId,
+    imageFrame: _imageFrame,
+    done,
+  };
+}
+
+/**
+ * Returns transcoded id object based on the given id's transferSyntaxUid. If transcoding should not occur it will return original id value.
+ * It does not mutate id param.
+ *
+ * @param {*} id Object that contains (but not only) data transferSyntaxUid.
+ * @param {*} options runner options.
+ * @returns Transcoded id object
+ */
+function transcodeId(id, options) {
+  if (!shouldTranscodeImageFrame(id, options)) {
+    return id;
+  }
+
+  const targetId = { ...id };
+  const { transferSyntaxUid } = getTranscoder(id.transferSyntaxUid, options);
+
+  targetId.transferSyntaxUid = transferSyntaxUid;
+
+  return targetId;
+}
+
+/**
+ * Returns transcoded metadata based on the given id's transferSyntaxUid.
+ * Basically it changes the metadata AvailableTransferSyntaxUID tag's value to be transcodedId.transferSyntaxUid
+ * If transcoding should not occur it will return original metadata value.
+ *
+ * It does not mutate metadata param.
+ * @param {*} metadata Metadata object.
+ * @param {*} id Object that contains (but not only) data transferSyntaxUid.
+ * @param {*} options runner options.
+ * @returns Transcoded metadata.
+ */
+function transcodeMetadata(metadata, id, options) {
+  if (!shouldTranscodeImageFrame(id, options)) {
+    return metadata;
+  }
+
+  const transcodedId = transcodeId(id, options);
+
+  const result = { ...metadata };
+
+  if (result[Tags.AvailableTransferSyntaxUID]) {
+    Tags.setValue(result,Tags.AvailableTransferSyntaxUID, transcodedId.transferSyntaxUid);
+  }
+
+  return result;
+}
+
+exports.shouldTranscodeImageFrame = shouldTranscodeImageFrame;
+exports.shouldThumbUseTranscoded = shouldThumbUseTranscoded;
+exports.transcodeId = transcodeId;
+exports.getDestinationTranscoder = getDestinationTranscoder;
+exports.transcodeImageFrame = transcodeImageFrame;
+exports.transcodeMetadata = transcodeMetadata;

package/lib/operation/extractImageFrames.js

@@ -0,0 +1,41 @@
+const getNumberOfFrames = require("./getNumberOfFrames");
+const getUncompressedImageFrame = require("./getUncompressedImageFrame");
+const getEncapsulatedImageFrame = require("./getEncapsulatedImageFrame");
+const { isVideo } = require("../writer/VideoWriter");
+
+const areFramesAreFragmented = (attr, numberOfFrames) => attr.encapsulatedPixelData && numberOfFrames != attr.fragments.length;
+
+const getFrameSize = (dataSet) => {
+  const rows = dataSet.uint16("x00280010");
+  const columns = dataSet.uint16("x00280011");
+  const samplesPerPixel = dataSet.uint16("x00280002");
+  const bitsAllocated = dataSet.uint16("x00280100");
+  return (rows * columns * samplesPerPixel * bitsAllocated) / 8;
+};
+
+const extractImageFrames = async (dataSet, attr, vr, callback) => {
+  const numberOfFrames = getNumberOfFrames(dataSet);
+  const framesAreFragmented = areFramesAreFragmented(attr, numberOfFrames);
+  const uncompressedFrameSize = getFrameSize(dataSet);
+
+  const videoType = isVideo(dataSet);
+  if (videoType) {
+    // The top level function is asynchronous, so this one doesn't need an additional await
+    return callback.videoWriter(dataSet);
+  }
+
+  let BulkDataURI;
+
+  for (let frameIndex = 0; frameIndex < numberOfFrames; frameIndex++) {
+    if (attr.encapsulatedPixelData) {
+      const compressedFrame = getEncapsulatedImageFrame(dataSet, attr, frameIndex, framesAreFragmented);
+      BulkDataURI = await callback.imageFrame(compressedFrame, { dataSet });
+    } else {
+      const uncompressedFrame = getUncompressedImageFrame(dataSet, attr, frameIndex, uncompressedFrameSize);
+      BulkDataURI = await callback.imageFrame(uncompressedFrame, { dataSet });
+    }
+  }
+  return BulkDataURI;
+};
+
+module.exports = extractImageFrames;

package/lib/operation/getDataSet.js

@@ -0,0 +1,60 @@
+const getVR = require("./getVR");
+const getValue = require("./getValue");
+const Tags = require("../dictionary/Tags");
+
+/**
+ * Get dataset.
+ *
+ * ParentAttr is used to control root/non-root attr scenarios (such as pixel data).
+ *
+ * @param {*} dataSet
+ * @param {*} callback
+ * @param {*} options
+ * @param {*} parentAttr Parent reference for sequence element tags.
+ * @returns
+ */
+async function getDataSet(dataSet, callback, options, parentAttr = undefined) {
+  const metadata = {};
+
+  // 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) {
+      continue;
+    }
+    const attr = dataSet.elements[tag];
+    /* eslint-disable-next-line no-use-before-define */
+    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];
+    delete metadata[Tags.TransferSyntaxUID];
+  }
+  return { metadata };
+}
+
+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 key = tag.substring(1).toUpperCase();
+  if (value === undefined || value === null || value.length === 0) {
+    if (!vr) return;
+    metadata[key] = {
+      vr,
+    };
+  } else if (value.InlineBinary || value.BulkDataURI) {
+    metadata[key] = {
+      vr,
+      ...value,
+    };
+  } else {
+    metadata[key] = {
+      vr,
+      Value: value,
+    };
+  }
+}
+
+module.exports = getDataSet;

package/lib/operation/getEncapsulatedImageFrame.js

@@ -0,0 +1,23 @@
+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) {
+    // Basic Offset Table is not empty
+    return dicomParser.readEncapsulatedImageFrame(dataSet, dataSet.elements.x7fe00010, frameIndex);
+  }
+
+  // Empty basic offset table
+  if (framesAreFragmented) {
+    const basicOffsetTable = dicomParser.createJPEGBasicOffsetTable(dataSet, dataSet.elements.x7fe00010);
+
+    return dicomParser.readEncapsulatedImageFrame(dataSet, dataSet.elements.x7fe00010, frameIndex, basicOffsetTable);
+  }
+
+  return dicomParser.readEncapsulatedPixelDataFromFragments(dataSet, dataSet.elements.x7fe00010, frameIndex);
+};
+
+module.exports = getEncapsulatedImageFrame;

package/lib/operation/getNumberOfFrames.js

@@ -0,0 +1,13 @@
+const getNumberOfFrames = (dataSet) => {
+  if (dataSet.elements.x00280008) {
+    const numberOfFramesString = dataSet.string("x00280008");
+    if (numberOfFramesString.length === 0) {
+      return 1;
+    }
+    const numberOfFrames = parseInt(numberOfFramesString);
+    return numberOfFrames;
+  }
+  return 1;
+};
+
+module.exports = getNumberOfFrames;

package/lib/operation/getUncompressedImageFrame.js

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

package/lib/operation/getVR.js

@@ -0,0 +1,16 @@
+const dataDictionary = require("../dictionary/dataDictionary");
+
+const getVR = (attr) => {
+  if (attr.vr) {
+    return attr.vr;
+  }
+  // lookup the vr using the data dictionary
+  const tag = attr.tag.substring(1).toUpperCase();
+  const dataDictAttr = dataDictionary[tag];
+  if (dataDictAttr) {
+    return dataDictAttr.vr;
+  }
+  return undefined;
+};
+
+module.exports = getVR;