@radicalimaging/static-wado-creator 1.7.4 → 1.7.6

package/dist/operation/getVR.js

@@ -0,0 +1,24 @@
+const { dataDictionary } = require('@radicalimaging/static-wado-util');
+
+const nullVrTags = new Set();
+nullVrTags.add('FFFEE00D');
+
+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?.vr) {
+    return dataDictAttr.vr;
+  }
+  if (nullVrTags.has(tag)) {
+    return null;
+  }
+
+  console.log('Unknown VR', tag, attr, dataDictAttr);
+  return 'UN';
+};
+
+module.exports = getVR;

package/dist/operation/getValue.js

@@ -0,0 +1,216 @@
+const extractImageFrames = require('./extractImageFrames');
+
+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, options) => {
+  const ret = dataSet.string(attr.tag);
+  if (ret) {
+    return ret.split(/\\/).map(decodeUtf8, options);
+  }
+  return 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) => {
+  const ret = [];
+  for (let i = 0; i < attr.length / 2; i++) {
+    ret.push(dataSet.int16(attr.tag, i));
+  }
+  return ret;
+};
+
+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, options) => {
+  if (attr.length == 0) {
+    return [];
+  }
+
+  switch (vr) {
+    case 'AE':
+    case 'AS':
+      return getValueInlineString(dataSet, attr, options);
+    case 'AT':
+      return getValueInlineAttributeTag(dataSet, attr);
+    case 'DS':
+      return getValueInlineFloatString(dataSet, attr);
+    case 'CS':
+    case 'DA':
+    case 'DT':
+      return getValueInlineString(dataSet, attr, options);
+    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, options);
+    case 'OB':
+    case 'OF':
+    case 'OW':
+      return getValueInlineBinary(dataSet, attr);
+    case 'PN':
+      return getValuePatientName(dataSet, attr);
+    case 'SH':
+      return getValueInlineString(dataSet, attr, options);
+    case 'SL':
+      return getValueInlineSignedLong(dataSet, attr);
+    case 'SS':
+      return getValueInlineSignedShort(dataSet, attr);
+    case 'ST':
+    case 'TM':
+    case 'UI':
+      return getValueInlineString(dataSet, attr, options);
+    case 'UL':
+      return getValueInlineUnsignedLong(dataSet, attr);
+    case 'UN':
+      return getValueInlineBinary(dataSet, attr);
+    case 'US':
+      return getValueInlineUnsignedShort(dataSet, attr);
+    case 'UT':
+      return getValueInlineString(dataSet, attr, options);
+    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 RawEncapsulatedDocument = 'x00420011';
+
+const isValueInline = (attr, options) => {
+  if (isPrivate(attr)) {
+    return attr.length <= options.maximumInlinePrivateLength;
+  }
+  // For encapsulated documents, almost always have them be external
+  if (attr.tag === RawEncapsulatedDocument && attr.length > 4) {
+    return false;
+  }
+  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, options);
+  }
+  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/dist/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/dist/program/index.js

@@ -0,0 +1,14 @@
+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);
+  return staticWadoUtil.configureCommands(defaults);
+}
+
+exports.configureProgram = configureProgram;

package/dist/rejectMain.js

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

package/dist/serverMain.js

@@ -0,0 +1,21 @@
+const readline = require('node:readline');
+const { argv, argv0, exit, stdin: input, stdout: output } = require('node:process');
+
+const StaticWado = require('./StaticWado');
+const adaptProgramOpts = require('./util/adaptProgramOpts');
+
+module.exports = async function createMain(options, program) {
+  const rl = readline.createInterface({ input, output });
+  for await (const line of rl) {
+    if (!line) continue;
+    if (line.startsWith('exit')) {
+      exit(0);
+    }
+    argv.splice(2, argv.length - 2, ...line.split(' '));
+    console.verbose('exec mkdicomweb', JSON.stringify(argv));
+
+    // Configure program commander
+    await StaticWado.configureProgram(StaticWado.mkdicomwebConfig);
+    output.write('mkdicomweb server -->\n');
+  }
+};

package/dist/util/IdCreator.js

@@ -0,0 +1,42 @@
+const path = require('path');
+const { getStudyUIDPathAndSubPath } = require('@radicalimaging/static-wado-util');
+
+function IdCreator({
+  directoryName,
+  deduplicatedRoot,
+  deduplicatedInstancesRoot,
+  hashStudyUidPath,
+}) {
+  return (uids, filename) => {
+    const { studyInstanceUid, seriesInstanceUid, sopInstanceUid } = uids;
+
+    const { path: hashPath = '', subpath: hashSubpath = '' } = hashStudyUidPath
+      ? getStudyUIDPathAndSubPath(studyInstanceUid)
+      : {};
+
+    const studySubDir = hashStudyUidPath
+      ? path.join(hashPath, hashSubpath, studyInstanceUid)
+      : studyInstanceUid;
+
+    const studyPath = path.join(directoryName, 'studies', studySubDir);
+    const seriesRootPath = path.join(studyPath, 'series', seriesInstanceUid);
+    const sopInstanceRootPath = path.join(seriesRootPath, 'instances', sopInstanceUid);
+    const imageFrameRootPath = path.join(sopInstanceRootPath, 'frames');
+
+    const deduplicatedPath = path.join(deduplicatedRoot, studySubDir);
+    const deduplicatedInstancesPath = path.join(deduplicatedInstancesRoot, studySubDir);
+
+    return {
+      ...uids,
+      studyPath,
+      deduplicatedPath,
+      deduplicatedInstancesPath,
+      seriesRootPath,
+      sopInstanceRootPath,
+      imageFrameRootPath,
+      filename,
+    };
+  };
+}
+
+module.exports = IdCreator;

package/dist/util/adaptProgramOpts.js

@@ -0,0 +1,39 @@
+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 {
+    group: isGroup,
+    instances: isInstanceMetadata,
+    deduplicate: isDeduplicate,
+    study: isStudyData,
+    clean: isClean,
+    dir: rootDir,
+    delete: deleteInstances,
+    singlePartImage,
+    encapsulatedImage,
+  } = programOpts;
+
+  return assignDefined(
+    { ...defaults },
+    {
+      ...programOpts,
+      isStudyData,
+      isClean,
+      isInstanceMetadata,
+      isDeduplicate,
+      isGroup,
+      rootDir,
+      encapsulatedImage: encapsulatedImage ?? singlePartImage !== true,
+      singlePartImage: singlePartImage ?? encapsulatedImage === false,
+      delete: deleteInstances,
+    }
+  );
+};

package/dist/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/dist/util/resultsReport.ts

@@ -0,0 +1,87 @@
+import fs from 'fs';
+
+const results = [];
+let sopResponse = null;
+
+function ensureSOPResponse(data) {
+  if (!data.ReferencedSOPSequence && !data.FailedSOPSequence) {
+    return;
+  }
+  if (!sopResponse) {
+    sopResponse = {
+      ...data,
+      FailedSOPSequence: undefined,
+      ReferencedSOPSequence: undefined,
+    };
+    results.push(sopResponse);
+  }
+  if (data.ReferencedSOPSequence) {
+    sopResponse.ReferencedSOPSequence ||= [];
+    sopResponse.ReferencedSOPSequence.push(...data.ReferencedSOPSequence);
+  }
+  if (data.FailedSOPSequence) {
+    sopResponse.FailedSOPSequence ||= [];
+    sopResponse.FailedSOPSequence.push(...data.FailedSOPSequence);
+  }
+}
+export function Success(options) {
+  const { deleteInput = false } = options;
+
+  return (_action, data, file) => {
+    if (data.ReferencedSOPSequence) {
+      ensureSOPResponse(data);
+    } else {
+      results.push(data);
+    }
+    if (file && deleteInput) {
+      console.noQuiet('Deleting', file);
+      fs.unlinkSync(file);
+    } else if (file) {
+      console.verbose('Not deleting', file);
+    }
+  };
+}
+
+export function Failure(options) {
+  const { deleteFailed } = options;
+
+  return (_action, data, file) => {
+    if (data.FailedSOPSequence) {
+      ensureSOPResponse(data);
+    } else {
+      results.push(data);
+    }
+    if (file && deleteFailed) {
+      console.noQuiet('Deleting failure', file);
+      fs.unlinkSync(file);
+    } else if (file) {
+      console.verbose('Not deleting failure file', file);
+    }
+  };
+}
+
+export function clearResults() {
+  results.splice(0, results.length);
+  sopResponse = null;
+}
+
+export function WriteResults(options) {
+  const { multipart } = options;
+
+  return function () {
+    if (multipart) {
+      const str =
+        results.length === 1
+          ? JSON.stringify(results[0])
+          : `[\n${results.map(r => JSON.stringify(r, null, 2)).join(',\n')}\n]`;
+      console.log(
+        '\r\n--boundary-response\r\n' +
+          'content-type: application/json\r\n\r\n' +
+          str +
+          '\r\n--boundary-response--\r\n'
+      );
+    }
+
+    clearResults();
+  };
+}

package/dist/writer/CompleteStudyWriter.js

@@ -0,0 +1,129 @@
+const { JSONReader, JSONWriter, Stats } = require('@radicalimaging/static-wado-util');
+const { Tags } = require('@radicalimaging/static-wado-util');
+const StudyData = require('../operation/StudyData');
+
+/**
+ * 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.noQuiet('Wrote updated deduplicated data for study', studyData.studyInstanceUid);
+      } else {
+        console.noQuiet(
+          'Not writing new deduplicated data because it is clean:',
+          studyData.studyInstanceUid
+        );
+        const message = {
+          text: 'Metadata clean, not updating',
+          status: 0,
+          studyInstanceUid: studyData.studyInstanceUid,
+        };
+        this.success('metadataClean', message);
+      }
+      await studyData.deleteInstancesReferenced();
+    }
+
+    if (!options.isStudyData) {
+      if (options.notifications) this.notificationService.notifyStudy(studyData.studyInstanceUid);
+      delete this.studyData;
+      Stats.StudyStats.summarize();
+      return;
+    }
+
+    const isDirtyMetadata = await studyData.dirtyMetadata();
+    if (!isDirtyMetadata && !options.force) {
+      console.log('Study metadata', studyData.studyInstanceUid, 'is clean.');
+      delete this.studyData;
+      Stats.StudyStats.summarize(
+        `Study metadata ${studyData.studyInstanceUid} has clean metadata, not writing`
+      );
+      return;
+    }
+    console.noQuiet('Writing study metadata', studyData.studyInstanceUid);
+
+    const studyQuery = await studyData.writeMetadata();
+
+    if (options.index === false) {
+      if (options.notifications) this.notificationService.notifyStudy(studyData.studyInstanceUid);
+      const message = {
+        action: 'metadata',
+        status: 0,
+        studyInstanceUid: studyData.studyInstanceUid,
+      };
+      this.success('completeStudyWriter', message);
+      delete this.studyData;
+      Stats.StudyStats.summarize(
+        `Wrote study metadata/query files for ${studyData.studyInstanceUid} (index skipped)`
+      );
+      return;
+    }
+
+    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);
+    if (options.notifications) this.notificationService.notifyStudy(studyData.studyInstanceUid);
+    const message = {
+      action: 'metadata',
+      status: 0,
+      studyInstanceUid: studyData.studyInstanceUid,
+    };
+    this.success('completeStudyWriter', message);
+    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));
+    if (!options.isSkipStudyScan) {
+      console.verbose('Initiate StudyData');
+      await callback.studyData.init(options);
+    }
+    return callback.studyData;
+  };
+
+  return ret;
+};
+
+module.exports = CompleteStudyWriter;

package/dist/writer/DeduplicateWriter.js

@@ -0,0 +1,33 @@
+const hashFactory = require('node-object-hash');
+
+const hasher = hashFactory.hasher();
+const { JSONWriter, Tags, TagLists } = require('@radicalimaging/static-wado-util');
+
+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) {
+      if (options.verbose) console.log('Writing single instance', id.studyInstanceUid);
+      await perInstanceWriter(id, data);
+    } else if (options.verbose) {
+      console.log('Not writing single instance deduplicated');
+    }
+    studyData.addDeduplicated(data, id.filename);
+  };
+
+module.exports = DeduplicateWriter;

package/dist/writer/ExpandUriPath.js

@@ -0,0 +1,16 @@
+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;