@radicalimaging/static-wado-creator 1.7.3 → 1.7.6

package/dist/writer/HashDataWriter.js

@@ -0,0 +1,74 @@
+const hashFactory = require('node-object-hash');
+const { createHash } = require('crypto');
+
+const path = require('path');
+const { Tags } = require('@radicalimaging/static-wado-util');
+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',
+};
+
+const baseHasher = hashFactory.hasher();
+
+const hasher = {
+  hash: v => {
+    const type = v.constructor?.name;
+    if (type === 'Buffer') {
+      return createHash('sha256').update(v).digest('hex');
+    }
+    return baseHasher.hash(v);
+  },
+};
+
+/** 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 { 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) {
+      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/dist/writer/ImageFrameWriter.js

@@ -0,0 +1,59 @@
+const { uids } = require('@radicalimaging/static-wado-util');
+const WriteStream = require('./WriteStream');
+const WriteMultipart = require('./WriteMultipart');
+const ExpandUriPath = require('./ExpandUriPath');
+const { MultipartHeader, MultipartAttribute } = require('./MultipartHeader');
+
+const ImageFrameWriter = options => {
+  const { encapsulatedImage, singlePartImage } = options;
+  return async (id, index, imageFrame) => {
+    const { transferSyntaxUid } = id;
+    const type = uids[transferSyntaxUid] || uids.default;
+    const extension = type.extension;
+    let content;
+    if (imageFrame instanceof Uint8Array) {
+      content = imageFrame;
+    } else {
+      content = Buffer.from(imageFrame.buffer);
+    }
+
+    if (encapsulatedImage || !extension) {
+      const writeStream = WriteStream(id.imageFrameRootPath, `${1 + index}.mht`, {
+        gzip: type.gzip,
+        mkdir: true,
+      });
+      await WriteMultipart(
+        writeStream,
+        [
+          new MultipartHeader('Content-Type', type.contentType, [
+            new MultipartAttribute('transfer-syntax', transferSyntaxUid),
+          ]),
+        ],
+        content
+      );
+      await writeStream.close();
+      console.verbose(
+        'Wrote encapsulated image frame',
+        id.sopInstanceUid,
+        index + 1,
+        type.contentType
+      );
+    }
+    if (extension && singlePartImage) {
+      const writeStreamSingle = WriteStream(id.imageFrameRootPath, `${1 + index}${extension}`, {
+        gzip: type.gzip,
+        mkdir: true,
+      });
+      await writeStreamSingle.write(content);
+      await writeStreamSingle.close();
+      console.verbose('Wrote single part image frame', id.sopInstanceUid, index + 1, extension);
+    }
+    const includeSeries = true;
+    return ExpandUriPath(id, `instances/${id.sopInstanceUid}/frames`, {
+      includeSeries,
+      ...options,
+    });
+  };
+};
+
+module.exports = ImageFrameWriter;

package/dist/writer/MultipartAttribute.js

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

package/dist/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/dist/writer/RawDicomWriter.js

@@ -0,0 +1,44 @@
+const { Tags } = require('@radicalimaging/static-wado-util');
+const WriteStream = require('./WriteStream');
+const WriteMultipart = require('./WriteMultipart');
+const { MultipartHeader } = require('./MultipartHeader');
+
+const modalitiesToRawWrite = ['SEG', 'SR'];
+const sopClassesToRawWrite = ['1.2.840.10008.5.1.4.1.1.30'];
+
+const defaultSelector = instance => {
+  const modality = instance.metadata[Tags.Modality]?.Value?.[0];
+  const sopClass = instance.metadata[Tags.SOPClassUID]?.Value?.[0];
+  return (
+    modalitiesToRawWrite.indexOf(modality) !== -1 || sopClassesToRawWrite.indexOf(sopClass) !== -1
+  );
+};
+
+/** Writes out raw DICOM files, encapsulated in multipart and gzipped - currently just DICOM SR and SEG */
+const RawDicomWriter =
+  () =>
+  async (id, instance, content, options = { gzip: true }) => {
+    if (!instance) {
+      return undefined;
+    }
+    const selector = options.selector || defaultSelector;
+    if (!selector(instance)) {
+      return undefined;
+    }
+    const contentType = options.contentType || 'application/dicom';
+    const writeStream = WriteStream(id.sopInstanceRootPath, 'index.mht', {
+      gzip: options.gzip,
+      mkdir: true,
+    });
+    const { length } = content;
+    const buffer = content.slice(0, length);
+    await WriteMultipart(
+      writeStream,
+      [new MultipartHeader('Content-Type', contentType, [])],
+      buffer
+    );
+    await writeStream.close();
+  };
+RawDicomWriter.defaultSelector = defaultSelector;
+
+module.exports = RawDicomWriter;

package/dist/writer/ThumbnailWriter.js

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

package/dist/writer/VideoWriter.js

@@ -0,0 +1,53 @@
+/** Write raw video file */
+const { Tags } = require('@radicalimaging/static-wado-util');
+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 = `index.${extension}`;
+    const writeStream = WriteStream(`${id.sopInstanceRootPath}/rendered`, 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}/rendered?length=${length}&offset=0&accept=video/mp4`;
+  };
+
+module.exports = VideoWriter;
+VideoWriter.isVideo = isVideo;

package/dist/writer/WriteMultipart.js

@@ -0,0 +1,22 @@
+const { v4: uuid } = require('uuid');
+
+const WriteMultipart = async (writeStream, headers, content) => {
+  const boundaryId = uuid();
+  await writeStream.write(`--BOUNDARY_${boundaryId}\r\n`);
+  for (let i = 0; i < headers.length; i++) {
+    const header = headers[i];
+    await writeStream.write(`${header.headerName}: ${header.headerValue}`);
+    if (header.attributes) {
+      for (let j = 0; j < header.attributes.length; j++) {
+        const attribute = header.attributes[j];
+        await writeStream.write(`;${attribute.attributeName}=${attribute.attributeValue}`);
+      }
+    }
+    await writeStream.write('\r\n');
+  }
+  await writeStream.write('\r\n');
+  await writeStream.write(content);
+  await writeStream.write(`\r\n--BOUNDARY_${boundaryId}--`);
+};
+
+module.exports = WriteMultipart;

package/dist/writer/WriteStream.js

@@ -0,0 +1,64 @@
+const fs = require('fs');
+const zlib = require('zlib');
+const path = require('path');
+
+let writeCount = 0;
+
+/** Create an optionally gzipped stream,
+ * where the write operations are performed in order executed,
+ * and don't require synchronization, only the 'close' operation
+ * requires syncing.
+ */
+const WriteStream = (dir, nameSrc, options = {}) => {
+  const isGzip = nameSrc.indexOf('.gz') != -1 || options.gzip;
+  const name = (isGzip && nameSrc.indexOf('.gz') === -1 && `${nameSrc}.gz`) || nameSrc;
+  if (options.mkdir && !fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  const tempName = path.join(dir, `tempFile-${Math.round(Math.random() * 1000000000)}`);
+  const finalName = path.join(dir, name);
+  writeCount++;
+  if (writeCount > 10) {
+    console.log('Write count', tempName, finalName, writeCount);
+    if (writeCount > 100) {
+      console.error('Too many open writes', new Error());
+      throw new Error(`Write count too high ${writeCount} destination ${finalName}`);
+    }
+  }
+  const rawStream = fs.createWriteStream(tempName);
+  const closePromise = new Promise(resolve => {
+    rawStream.on('close', () => {
+      resolve('closed');
+    });
+  });
+
+  let writeStream = rawStream;
+  if (isGzip) {
+    writeStream = zlib.createGzip();
+    writeStream.pipe(rawStream);
+    writeStream.on('close', () => {
+      rawStream.close();
+    });
+  }
+
+  async function close() {
+    await this.writeStream.end();
+    await this.closePromise;
+    await fs.rename(tempName, finalName, () => true);
+    writeCount--;
+  }
+
+  return {
+    writeStream,
+    closePromise,
+
+    write(data) {
+      return this.writeStream.write(data);
+    },
+
+    close,
+  };
+};
+
+module.exports = WriteStream;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radicalimaging/static-wado-creator",
-  "version": "1.7.3",
+  "version": "1.7.6",
   "description": "Library to convert DICOMP10 to DICOMweb format. Original upstream: https://github.com/chafey/dicomp10-to-dicomweb-js",
   "publishConfig": {
     "access": "public"
@@ -31,16 +31,21 @@
   "homepage": "https://github.com/radicalimaging/static-dicomweb#readme",
   "license": "ISC",
   "main": "lib/index.mjs",
-  "module": "dist/index.js",
+  "module": "lib/index.mjs",
+  "exports": {
+    ".": {
+      "default": "./lib/index.mjs",
+      "esm": "./lib/index.mjs"
+    }
+  },
   "directories": {
     "lib": "lib",
-    "dist": "dist",
     "bin": "bin"
   },
   "files": [
     "bin",
-    "dist",
-    "lib"
+    "lib",
+    "dist"
   ],
   "bin": {
     "mkdicomweb": "bin/mkdicomweb.mjs"
@@ -48,7 +53,7 @@
   "scripts": {
     "test": "jest --config ./jest.config.js",
     "build": "bun run build:esm",
-    "build:esm": "bun build lib/index.mjs --target node --outdir dist",
+    "build:esm": "bun -e \"import { mkdirSync, cpSync } from 'node:fs'; mkdirSync('dist', { recursive: true }); cpSync('lib', 'dist', { recursive: true });\"",
     "clean": "rimraf dist",
     "link:exec": "bun link",
     "lint": "npx eslint --color \"**/*.{js,mjs,cjs}\"",