@radicalimaging/static-wado-creator 0.6.4

package/lib/operation/getValue.js

@@ -0,0 +1,193 @@
+const extractImageFrames = require("./extractImageFrames");
+
+const getValueInlineString = (dataSet, attr) => [dataSet.string(attr.tag)];
+
+const getStrings = (dataSet, attr) => {
+  const ret = dataSet.string(attr.tag);
+  return (ret && ret.split(/\\/)) || undefined;
+};
+
+const getValuePatientName = (dataSet, attr) => {
+  const strings = getStrings(dataSet, attr);
+  return (strings && strings.map((item) => ({ Alphabetic: item }))) || undefined;
+};
+
+/** Gets either InlineBinary or BulkDataURI, if already defined */
+const getValueInlineBinary = (dataSet, attr) => {
+  if (attr.BulkDataURI) return { BulkDataURI: attr.BulkDataURI };
+  const binaryValue = dataSet.byteArray.slice(attr.dataOffset, attr.dataOffset + attr.length);
+  return { InlineBinary: binaryValue.toString("base64") };
+};
+
+const getValueInlineSignedShort = (dataSet, attr) => {
+  if (attr.length > 2) {
+    return getValueInlineBinary(dataSet, attr);
+  }
+  return [dataSet.int16(attr.tag)];
+};
+
+const getValueInlineUnsignedShort = (dataSet, attr) => {
+  const ret = [];
+  for (let i = 0; i < attr.length / 2; i++) {
+    ret.push(dataSet.uint16(attr.tag, i));
+  }
+  return ret;
+};
+
+const getValueInlineSignedLong = (dataSet, attr) => {
+  if (attr.length > 4) {
+    return getValueInlineBinary(dataSet, attr);
+  }
+  return [dataSet.int32(attr.tag)];
+};
+
+const getValueInlineUnsignedLong = (dataSet, attr) => {
+  if (attr.length > 4) {
+    return getValueInlineBinary(dataSet, attr);
+  }
+  return [dataSet.uint32(attr.tag)];
+};
+
+const getValueInlineFloat = (dataSet, attr) => {
+  if (attr.length > 65536 * 4) {
+    return getValueInlineBinary(dataSet, attr);
+  }
+  const ret = [];
+  for (let i = 0; i < attr.length / 4; i++) {
+    ret.push(dataSet.float(attr.tag, i));
+  }
+  return ret;
+};
+
+const getValueInlineIntString = (dataSet, attr) => getStrings(dataSet, attr).map((val) => parseInt(val));
+
+const getValueInlineFloatString = (dataSet, attr) => getStrings(dataSet, attr).map((val) => parseFloat(val));
+
+const getValueInlineFloatDouble = (dataSet, attr) => {
+  if (attr.length > 8) {
+    return getValueInlineBinary(dataSet, attr);
+  }
+  return [dataSet.double(attr.tag)];
+};
+
+const getValueInlineAttributeTag = (dataSet, attr) => {
+  const group = dataSet.uint16(attr.tag, 0);
+  const groupHexStr = `0000${group.toString(16)}`.substr(-4);
+  const element = dataSet.uint16(attr.tag, 1);
+  const elementHexStr = `0000${element.toString(16)}`.substr(-4);
+  return groupHexStr + elementHexStr;
+};
+
+const getValueInline = (dataSet, attr, vr) => {
+  if (attr.length == 0) {
+    return [];
+  }
+
+  switch (vr) {
+    case "AE":
+    case "AS":
+      return getValueInlineString(dataSet, attr);
+    case "AT":
+      return getValueInlineAttributeTag(dataSet, attr);
+    case "DS":
+      return getValueInlineFloatString(dataSet, attr);
+    case "CS":
+    case "DA":
+    case "DT":
+      return getValueInlineString(dataSet, attr);
+    case "FL":
+      return getValueInlineFloat(dataSet, attr);
+    case "FD":
+      return getValueInlineFloatDouble(dataSet, attr);
+    case "IS":
+      return getValueInlineIntString(dataSet, attr);
+    case "LO":
+    case "LT":
+      return getValueInlineString(dataSet, attr);
+    case "OB":
+    case "OF":
+    case "OW":
+      return getValueInlineBinary(dataSet, attr);
+    case "PN":
+      return getValuePatientName(dataSet, attr);
+    case "SH":
+      return getValueInlineString(dataSet, attr);
+    case "SL":
+      return getValueInlineSignedLong(dataSet, attr);
+    case "SS":
+      return getValueInlineSignedShort(dataSet, attr);
+    case "ST":
+    case "TM":
+    case "UI":
+      return getValueInlineString(dataSet, attr);
+    case "UL":
+      return getValueInlineUnsignedLong(dataSet, attr);
+    case "UN":
+      return getValueInlineBinary(dataSet, attr);
+    case "US":
+      return getValueInlineUnsignedShort(dataSet, attr);
+    case "UT":
+      return getValueInlineString(dataSet, attr);
+    default:
+      return getValueInlineBinary(dataSet, attr);
+  }
+};
+
+const isPrivate = (attr) => {
+  const { tag } = attr;
+  const ch = tag.substr(4, 1);
+  const chHex = parseInt(ch, 16);
+  return chHex % 2 == 1;
+};
+
+const isValueInline = (attr, options) => {
+  if (isPrivate(attr)) {
+    return attr.length <= options.maximumInlinePrivateLength;
+  }
+  return !attr.length || attr.length <= options.maximumInlinePublicLength;
+};
+
+/**
+ * Get data value for the given attr.
+ * Attr can be a pixelData tag, sequence items, inline or bulkdata
+ *
+ * @param {*} dataSet
+ * @param {*} attr
+ * @param {*} vr
+ * @param {*} getDataSet
+ * @param {*} callback
+ * @param {*} options object containing program properties.
+ * @param {*} parentAttr attr's parent. If not present means attr is at root level.
+ * @returns
+ */
+const getValue = async (dataSet, attr, vr, getDataSet, callback, options, parentAttr) => {
+  // It will only process pixelData tag if on metadata root. Otherwise it will be skiped.
+  if (attr.tag === "x7fe00010" && !parentAttr) {
+    const BulkDataURI = await extractImageFrames(dataSet, attr, vr, callback, options);
+    return { BulkDataURI };
+  }
+  if (attr.tag === "xfffee00d") return undefined;
+  // Group length
+  if (attr.tag.length == 9 && attr.tag.substring(5, 9) === "0000") return undefined;
+  if (attr.items) {
+    // sequences
+    const result = [];
+    for (const item of attr.items) {
+      const subResult = await getDataSet(item.dataSet, callback, options, attr);
+      if (subResult.metadata) result.push(subResult.metadata);
+    }
+    return result;
+  }
+  if (attr.Value) {
+    return (Array.isArray(attr.Value) && attr.Value) || [attr.Value];
+  }
+  // non sequence item
+  if (isValueInline(attr, options)) {
+    return getValueInline(dataSet, attr, vr);
+  }
+  const binaryValue = dataSet.byteArray.slice(attr.dataOffset, attr.dataOffset + attr.length);
+  const mimeType = attr.tag == "x00420011" && dataSet.string("x00420012");
+  const BulkDataURI = await callback.bulkdata(binaryValue, { mimeType });
+  return { BulkDataURI, vr };
+};
+module.exports = getValue;

package/lib/program/index.js

@@ -0,0 +1,15 @@
+const staticWadoUtil = require("@radicalimaging/static-wado-util");
+
+/**
+ * Configure static-wado-creator commander program.
+ *
+ * @param {*} defaults Configuration caller level
+ * @returns Program object
+ */
+async function configureProgram(defaults) {
+  const configurationFile = await staticWadoUtil.loadConfiguration(defaults, process.argv);
+  console.log("Loaded configuration from", configurationFile);
+  staticWadoUtil.configureCommands(defaults);
+}
+
+exports.configureProgram = configureProgram;

package/lib/rejectMain.js

@@ -0,0 +1,12 @@
+const StaticWado = require("./StaticWado");
+const adaptProgramOpts = require("./util/adaptProgramOpts");
+
+module.exports = function rejectMain(options, program) {
+  const finalOptions = adaptProgramOpts(options, {
+    ...this,
+    isGroup: true,
+    isStudyData: true,
+  });
+  const importer = new StaticWado(finalOptions);
+  return importer.reject(program.args);
+};

package/lib/util/IdCreator.js

@@ -0,0 +1,25 @@
+const path = require("path");
+
+function IdCreator({ directoryName, deduplicatedRoot, deduplicatedInstancesRoot }) {
+  return (uids, filename) => {
+    const studyPath = path.join(directoryName, "studies", uids.studyInstanceUid);
+    const seriesRootPath = path.join(studyPath, "series", uids.seriesInstanceUid);
+    const sopInstanceRootPath = path.join(studyPath, "series", uids.seriesInstanceUid, "instances", uids.sopInstanceUid);
+    const deduplicatedPath = path.join(deduplicatedRoot, uids.studyInstanceUid);
+    const deduplicatedInstancesPath = path.join(deduplicatedInstancesRoot, uids.studyInstanceUid);
+    const imageFrameRootPath = path.join(sopInstanceRootPath, "frames");
+
+    return {
+      ...uids,
+      studyPath,
+      deduplicatedPath,
+      deduplicatedInstancesPath,
+      seriesRootPath,
+      sopInstanceRootPath,
+      imageFrameRootPath,
+      filename,
+    };
+  };
+}
+
+module.exports = IdCreator;

package/lib/util/adaptProgramOpts.js

@@ -0,0 +1,58 @@
+const assignDefined = (dest, src) => {
+  Object.keys(src).forEach((key) => {
+    const val = src[key];
+    if (val !== undefined) {
+      dest[key] = val;
+    }
+  });
+  return dest;
+};
+
+module.exports = function adaptProgramOpts(programOpts, defaults) {
+  const {
+    maximumInlinePublicLength,
+    maximumInlinePrivateLength,
+    group: isGroup,
+    instances: isInstanceMetadata,
+    deduplicate: isDeduplicate,
+    study: isStudyData,
+    clean: isClean,
+    recompress,
+    recompressThumb,
+    contentType,
+    colourContentType,
+    dir: rootDir,
+    pathDeduplicated,
+    pathInstances,
+    removeDeduplicatedInstances,
+    storeMultipartBulkData,
+    prependBulkDataUri,
+    expandBulkDataUri,
+    verbose,
+  } = programOpts;
+
+  return assignDefined(
+    { ...defaults },
+    {
+      maximumInlinePublicLength,
+      maximumInlinePrivateLength,
+      isGroup,
+      isInstanceMetadata,
+      isDeduplicate,
+      isStudyData,
+      isClean,
+      recompress,
+      recompressThumb,
+      contentType,
+      colourContentType,
+      rootDir,
+      pathDeduplicated,
+      pathInstances,
+      removeDeduplicatedInstances,
+      storeMultipartBulkData,
+      prependBulkDataUri,
+      expandBulkDataUri,
+      verbose,
+    }
+  );
+};

package/lib/util/compressionOptionParser.js

@@ -0,0 +1,13 @@
+const { program } = require("@radicalimaging/static-wado-util");
+const { getDestinationTranscoder } = require("../operation/adapter/transcodeImage");
+
+module.exports = function compressionOptionParser(value) { 
+  const destination = getDestinationTranscoder(value);
+  if (destination) {
+    console.log("Found destination transferSyntax ", destination.transferSyntaxUid, "for ", value);
+  } else {
+    console.log("No transcoder destination for ", value);
+    throw new program.InvalidArgumentError(`No transcoder destination for ${value}`);
+  } 
+  return destination.transferSyntaxUid;
+}

package/lib/writer/CompleteStudyWriter.js

@@ -0,0 +1,88 @@
+const { Stats } = require("@radicalimaging/static-wado-util");
+const { JSONReader } = require("@radicalimaging/static-wado-util");
+const JSONWriter = require("./JSONWriter");
+const StudyData = require("../operation/StudyData");
+const Tags = require("../dictionary/Tags");
+
+/**
+ * CompleteStudyWriter takes the deduplicated data values, all loaded into the study parameter,
+ * and writes it out as various dataset types.  The options parameters define what types it gets
+ * written out as.
+ * The studyData object is then removed, so that a new one can be created if required.
+ */
+const CompleteStudyWriter = (options) => {
+  async function ret() {
+    const { studyData } = this;
+    if (!studyData) return;
+
+    if (!studyData.numberOfInstances) {
+      console.log("studyData.deduplicated is empty");
+      delete this.studyData;
+      return;
+    }
+
+    if (options.isGroup) {
+      if (studyData.dirty) {
+        await studyData.writeDeduplicatedGroup();
+        console.log("Wrote updated deduplicated data for study", studyData.studyInstanceUid);
+      } else {
+        console.log("Not writing new deduplicated data because it is clean:", studyData.studyInstanceUid);
+      }
+    }
+
+    if (!options.isStudyData) {
+      delete this.studyData;
+      Stats.StudyStats.summarize();
+      return;
+    }
+
+    const isDirtyMetadata = await studyData.dirtyMetadata();
+    if (!isDirtyMetadata) {
+      console.log("Study metadata", studyData.studyInstanceUid, "has clean metadata, not writing");
+      delete this.studyData;
+      Stats.StudyStats.summarize(`Study metadata ${studyData.studyInstanceUid} has clean metadata, not writing`);
+      return;
+    }
+
+    const studyQuery = await studyData.writeMetadata();
+
+    const allStudies = await JSONReader(options.directoryName, "studies/index.json.gz", []);
+    const studyUID = Tags.getValue(studyQuery,Tags.StudyInstanceUID);
+    if (!studyUID) {
+      console.error("studyQuery=", studyQuery);
+      throw new Error("Study query has null studyUID");
+    }
+    const studyIndex = allStudies.findIndex((item) => Tags.getValue(item,Tags.StudyInstanceUID) == studyUID);
+    if (studyIndex == -1) {
+      allStudies.push(studyQuery);
+    } else {
+      allStudies[studyIndex] = studyQuery;
+    }
+    await JSONWriter(options.directoryName, "studies", allStudies);
+    delete this.studyData;
+    Stats.StudyStats.summarize(`Wrote study metadata/query files for ${studyData.studyInstanceUid}`);
+  }
+
+  /**
+   * Gets a current study data object, or completes the old one and generates a new one.
+   * async call as it may need to store the current study data value.
+   */
+  ret.getCurrentStudyData = async (callback, id) => {
+    const { studyData } = callback;
+    const { studyInstanceUid } = id;
+
+    if (studyData) {
+      if (studyData.studyInstanceUid == studyInstanceUid) {
+        return studyData;
+      }
+      await callback.completeStudy(studyData);
+    }
+    callback.setStudyData(new StudyData(id, options));
+    await callback.studyData.init(options);
+    return callback.studyData;
+  };
+
+  return ret;
+};
+
+module.exports = CompleteStudyWriter;

package/lib/writer/DeduplicateWriter.js

@@ -0,0 +1,32 @@
+const hashFactory = require("node-object-hash");
+
+const hasher = hashFactory();
+const JSONWriter = require("./JSONWriter");
+const Tags = require("../dictionary/Tags");
+const TagLists = require("../model/TagLists");
+
+async function writeDeduplicatedFile(dir, data, hashValueSrc) {
+  const hashValue = hashValueSrc || hasher.hash(data);
+  // Write it direct in the deduplicated directory, not as a sub-directory or index file
+  await JSONWriter(dir, hashValue, data, { gzip: true, index: false });
+  return hashValue;
+}
+
+const perInstanceWriter = async (id, data) => {
+  const { deduplicatedInstancesPath } = id;
+  const hashValue = TagLists.addHash(data, Tags.InstanceType);
+  return writeDeduplicatedFile(deduplicatedInstancesPath, [data], hashValue);
+};
+
+/** Writes out JSON files to the given file name.  Automatically GZips them, and adds the extension */
+const DeduplicateWriter = (options) =>
+  async function DeduplicateWriterInstance(id, data) {
+    const studyData = await this.completeStudy.getCurrentStudyData(this, id);
+
+    if (options.isDeduplicate) {
+      await perInstanceWriter(id, data);
+    }
+    studyData.addDeduplicated(data, id.filename);
+  };
+
+module.exports = DeduplicateWriter;

package/lib/writer/ExpandUriPath.js

@@ -0,0 +1,15 @@
+const ExpandUriPath = (id, path, options) => {
+  const { prependBulkDataUri, expandBulkDataUri, includeSeries } = options;
+  let expandedRelative = "";
+  if (expandBulkDataUri) {
+    let expandedRelativeSeries = "";
+    if (includeSeries) {
+      expandedRelativeSeries = `series/${id.seriesInstanceUid}/`;
+    }
+    expandedRelative = `studies/${id.studyInstanceUid}/${expandedRelativeSeries}`;
+  }
+  if (options.verbose) console.log(`Expanded path returned: ${prependBulkDataUri}${expandedRelative}${path}`);
+  return `${prependBulkDataUri}${expandedRelative}${path}`;
+};
+
+module.exports = ExpandUriPath;

package/lib/writer/HashDataWriter.js

@@ -0,0 +1,59 @@
+const hashFactory = require("node-object-hash");
+
+const hasher = hashFactory();
+const path = require("path");
+const Tags = require("../dictionary/Tags");
+const WriteStream = require("./WriteStream");
+const WriteMultipart = require("./WriteMultipart");
+const ExpandUriPath = require("./ExpandUriPath");
+const { MultipartHeader } = require("./MultipartHeader");
+
+// Extensions for encapsulated content.  Do NOT add any executable content extensions here.
+const extensions = {
+  "application/pdf": ".pdf",
+  "text/json": ".json",
+  "application/xml+cda": ".cda.xml",
+};
+
+/** Writes out JSON files to the given file name.  Automatically GZips them, and adds the extension */
+const HashDataWriter =
+  (options) =>
+  async (id, key, data, additionalOptions = {}) => {
+    const isRaw = ArrayBuffer.isView(data);
+    const { storeMultipartBulkData } = options;
+    const { mimeType } = additionalOptions;
+    // If the file has an extension, it should be directly accessible as that file type.
+    const gzip = !isRaw || (data.length > 1024 && !mimeType);
+    const { dirName, fileName } = HashDataWriter.createHashPath(data, options);
+    const absolutePath = path.join(id.studyPath, dirName);
+    const rawData = isRaw ? data : JSON.stringify(data, null, 1);
+    const writeStream = WriteStream(absolutePath, fileName, {
+      mkdir: true,
+      gzip,
+    });
+    if (isRaw && storeMultipartBulkData) {
+      await WriteMultipart(writeStream, [new MultipartHeader("Content-Type", "application/octet-stream")], rawData);
+    } else {
+      await writeStream.write(rawData);
+    }
+    await writeStream.close();
+    return ExpandUriPath(id, `${dirName}/${fileName}`, options);
+  };
+
+/**
+ * Returns a hash path relative to the objectUID directory.
+ */
+HashDataWriter.createHashPath = (data, options = {}) => {
+  const { mimeType } = options;
+  const isRaw = ArrayBuffer.isView(data);
+  const extension = isRaw ? (mimeType && extensions[mimeType]) || "" : ".json";
+  const hashValue = Tags.getValue(data,Tags.DeduppedHash) || hasher.hash(data);
+
+  return {
+    // Use string concat as this value is used for the BulkDataURI which needs forward slashes
+    dirName: `bulkdata/${hashValue.substring(0, 3)}/${hashValue.substring(3, 5)}`,
+    fileName: hashValue.substring(5) + extension,
+  };
+};
+
+module.exports = HashDataWriter;

package/lib/writer/ImageFrameWriter.js

@@ -0,0 +1,31 @@
+const uids = require("../model/uids");
+const WriteStream = require("./WriteStream");
+const WriteMultipart = require("./WriteMultipart");
+const ExpandUriPath = require("./ExpandUriPath");
+const { MultipartHeader, MultipartAttribute } = require("./MultipartHeader");
+
+const ImageFrameWriter = (options) => {
+  const { verbose } = options;
+
+  return async (id, index, imageFrame) => {
+    const { transferSyntaxUid } = id;
+    const type = uids[transferSyntaxUid] || uids.default;
+    const writeStream = WriteStream(id.imageFrameRootPath, `${1 + index}`, {
+      gzip: type.gzip,
+      mkdir: true,
+    });
+    let content;
+    if (imageFrame instanceof Uint8Array) {
+      content = imageFrame;
+    } else {
+      content = Buffer.from(imageFrame.buffer);
+    }
+    await WriteMultipart(writeStream, [new MultipartHeader("Content-Type", type.contentType, [new MultipartAttribute("transfer-syntax", transferSyntaxUid)])], content);
+    await writeStream.close();
+    if (verbose) console.log("Wrote image frame", id.sopInstanceUid, index + 1);
+    const includeSeries = true;
+    return ExpandUriPath(id, `instances/${id.sopInstanceUid}/frames`, { includeSeries, ...options });
+  };
+};
+
+module.exports = ImageFrameWriter;

package/lib/writer/JSONWriter.js

@@ -0,0 +1,18 @@
+const { Stats } = require("@radicalimaging/static-wado-util");
+const path = require("path");
+const WriteStream = require("./WriteStream");
+
+/** Writes out JSON files to the given file name.  Automatically GZips them, and adds the extension */
+const JSONWriter = async (dir, name, data, options = { gzip: true, brotli: false, index: true }) => {
+  const fileName = options.index ? "index.json.gz" : name + ((options.gzip && ".gz") || (options.brotli && ".br") || "");
+  const dirName = options.index ? path.join(dir, name) : dir;
+  const writeStream = WriteStream(dirName, fileName, {
+    ...options,
+    mkdir: true,
+  });
+  await writeStream.write(JSON.stringify(data));
+  await writeStream.close();
+  Stats.StudyStats.add("Write JSON", `Write JSON file ${name}`, 1000);
+};
+
+module.exports = JSONWriter;

package/lib/writer/MultipartAttribute.js

@@ -0,0 +1,8 @@
+class MultipartAttribute {
+  constructor(attributeName, attributeValue) {
+    this.attributeName = attributeName;
+    this.attributeValue = attributeValue;
+  }
+}
+
+module.exports = MultipartAttribute;

package/lib/writer/MultipartHeader.js

@@ -0,0 +1,14 @@
+const MultipartAttribute = require("./MultipartAttribute");
+
+class MultipartHeader {
+  constructor(headerName, headerValue, attributes = []) {
+    this.headerName = headerName;
+    this.headerValue = headerValue;
+    this.attributes = attributes;
+  }
+}
+
+module.exports = {
+  MultipartAttribute,
+  MultipartHeader,
+};

package/lib/writer/ThumbnailWriter.js

@@ -0,0 +1,21 @@
+const WriteStream = require("./WriteStream");
+
+const ThumbnailWriter = (options) => {
+  const { verbose } = options;
+
+  return async (filePath, fileName, thumbBuffer) => {
+    const writeStream = WriteStream(filePath, fileName, {
+      mkdir: true,
+    });
+
+    await writeStream.write(thumbBuffer);
+
+    await writeStream.close();
+
+    if (verbose) {
+      console.log("Wrote thumbnail frame", filePath, fileName);
+    }
+  };
+};
+
+module.exports = ThumbnailWriter;

package/lib/writer/VideoWriter.js

@@ -0,0 +1,52 @@
+/** Write raw video file */
+const Tags = require("../dictionary/Tags");
+const WriteStream = require("./WriteStream");
+
+const MPEG2 = "mpg";
+const H264 = "mp4";
+const H265 = "h265";
+
+const VIDEO_TYPES = {
+  "1.2.840.10008.1.2.4.100": MPEG2,
+  "1.2.840.10008.1.2.4.101": MPEG2,
+  "1.2.840.10008.1.2.4.102": H264,
+  "1.2.840.10008.1.2.4.103": H264,
+  "1.2.840.10008.1.2.4.104": H264,
+  "1.2.840.10008.1.2.4.105": H264,
+  "1.2.840.10008.1.2.4.106": H264,
+  "1.2.840.10008.1.2.4.107": H265,
+  "1.2.840.10008.1.2.4.108": H265,
+  // TODO - add the new multi-segment MPEG2 and H264 variants
+};
+
+const isVideo = (value) => VIDEO_TYPES[value && value.string ? value.string(Tags.RawTransferSyntaxUID) : value];
+
+const VideoWriter = () =>
+  async function run(id, dataSet) {
+    console.log(`Writing video  ${id.sopInstanceUid}`);
+    const extension = VIDEO_TYPES[dataSet.string(Tags.RawTransferSyntaxUID)];
+    const filename = `pixeldata.${extension}`;
+    const writeStream = WriteStream(id.sopInstanceRootPath, filename, {
+      mkdir: true,
+    });
+    let length = 0;
+    const { fragments } = dataSet.elements.x7fe00010;
+
+    if (!fragments) {
+      console.warn("No video data");
+      return "";
+    }
+    // The zero position fragment isn't available, even though present in the original data
+    for (let i = 0; i < fragments.length; i++) {
+      const fragment = fragments[i];
+      const blob = dataSet.byteArray.slice(fragment.position, fragment.position + fragment.length);
+      length += blob.length;
+      await writeStream.write(blob);
+    }
+    await writeStream.close();
+    console.log(`Done video ${id.sopInstanceRootPath}\\${filename} of length ${length}`);
+    return `series/${id.seriesInstanceUid}/instances/${id.sopInstanceUid}/pixeldata.${extension}?length=${length}&offset=0`;
+  };
+
+module.exports = VideoWriter;
+VideoWriter.isVideo = isVideo;