@radicalimaging/static-wado-creator 1.7.4 → 1.7.6

package/dist/index.mjs

@@ -0,0 +1,18 @@
+import mkdicomwebConfig from './mkdicomwebConfig.js';
+import StaticWado from './StaticWado.js';
+import programIndex from './program/index.js';
+import createMain from './createMain.js';
+import deleteMain from './deleteMain.js';
+import adaptProgramOpts from './util/adaptProgramOpts.js';
+import { uids } from '@radicalimaging/static-wado-util';
+
+const { configureProgram } = programIndex;
+
+StaticWado.mkdicomwebConfig = mkdicomwebConfig;
+StaticWado.createMain = createMain;
+StaticWado.deleteMain = deleteMain;
+StaticWado.adaptProgramOpts = adaptProgramOpts;
+StaticWado.configureProgram = configureProgram;
+
+export default StaticWado;
+export { uids, StaticWado };

package/dist/indexMain.js

@@ -0,0 +1,10 @@
+const StaticWado = require('./StaticWado');
+const adaptProgramOpts = require('./util/adaptProgramOpts');
+
+module.exports = function createMain(options) {
+  const finalOptions = adaptProgramOpts(options, {
+    ...this,
+  });
+  const importer = new StaticWado(finalOptions);
+  return importer.reindex();
+};

package/dist/instanceMain.js

@@ -0,0 +1,16 @@
+const StaticWado = require('./StaticWado');
+const adaptProgramOpts = require('./util/adaptProgramOpts');
+
+module.exports = function createMain(options, program) {
+  const finalOptions = adaptProgramOpts(options, {
+    ...this,
+    isInstance: true,
+    // Deduplicated data is single instance deduplicated data
+    isDeduplicate: true,
+    isGroup: false,
+    isStudyData: false,
+    isSkipStudyScan: true,
+  });
+  const importer = new StaticWado(finalOptions);
+  return importer.executeCommand(program.args);
+};

package/dist/metadataMain.js

@@ -0,0 +1,15 @@
+const StaticWado = require('./StaticWado');
+const adaptProgramOpts = require('./util/adaptProgramOpts');
+
+module.exports = function createMain(options, program) {
+  const finalOptions = adaptProgramOpts(options, {
+    ...this,
+    isInstance: false,
+    isGroup: true,
+    isStudyData: true,
+    scanStudies: true,
+  });
+  const importer = new StaticWado(finalOptions);
+  // Either do a scan or on specified studies
+  return importer.executeCommand(program.args);
+};

package/dist/mkdicomwebConfig.js

@@ -0,0 +1,342 @@
+const ConfigPoint = require('config-point');
+const { staticWadoConfig } = require('@radicalimaging/static-wado-util');
+const createMain = require('./createMain');
+const createPart10 = require('./createPart10');
+const createThumbnail = require('./createThumbnail');
+const deleteMain = require('./deleteMain');
+const rejectMain = require('./rejectMain');
+const serverMain = require('./serverMain');
+const instanceMain = require('./instanceMain');
+const indexMain = require('./indexMain');
+const groupMain = require('./groupMain');
+const metadataMain = require('./metadataMain');
+const compressionOptionParser = require('./util/compressionOptionParser');
+
+/**
+ * Defines the basic configuration values for the dicomwebserver component.  See the README for more details.
+ * TODO - fix the default values so they come from the configuration file.  In the meantime, leave the defaults blank.
+ */
+const { mkdicomwebConfig } = ConfigPoint.register({
+  mkdicomwebConfig: {
+    // This declare the inheritted configuration, don't assume this is directly accessible
+    configBase: staticWadoConfig,
+    isStudyData: true,
+    isGroup: true,
+    options: [
+      {
+        key: '-c <configFile.json5>',
+        description: 'Use an alternate configuration file',
+        defaultValue: '~/static-wado.json5',
+      },
+      {
+        key: '--clean',
+        description: 'Clean the outputs before generating/starting to write new values.',
+        defaultValue: false,
+      },
+      {
+        key: '-d, --deployments <listvalue...>',
+        description: 'List of deployments from configuration to deploy to. Separated by space.',
+        defaultValue: undefined,
+      },
+      {
+        key: '--no-notifications',
+        description: 'Turns off notifications',
+      },
+      {
+        key: '--delete',
+        description: 'Delete the imported instances',
+        defaultValue: false,
+      },
+      {
+        key: '--lossy',
+        description: 'Generate lossy instances instead of lossless',
+        defaultValue: false,
+      },
+      {
+        key: '--alternate <type>',
+        description:
+          'Generates an alternate representaton of the image generally in the /lossy sub-directory',
+        choices: ['jhc', 'jls', 'jhcLossless', 'jlsLossless'],
+      },
+      {
+        key: '--alternate-thumbnail',
+        description: 'Generates a thumbnail for the alternate representation',
+      },
+      {
+        key: '--alternate-name <dir>',
+        description: 'Uses a given sub directory name',
+        defaultValue: 'lossy',
+      },
+      {
+        key: '-v, --verbose',
+        description: 'Write verbose output',
+        defaultValue: false,
+      },
+      {
+        key: '--show-progress',
+        description: 'Show progress during DICOM file processing',
+      },
+      {
+        key: '-t, --content-type <type>',
+        description:
+          'Destination type to compress to (choices: "jpeg", "jls", "lei", "jls-lossy", "jhc", "jxl" or DICOM Transfer Syntax UID - default: "jls")',
+        defaultValue: 'jls',
+        customParser: compressionOptionParser,
+      },
+      {
+        key: '--encapsulated-image',
+        description:
+          'Avoid encapsulating the image frame.  Writes with the extension and without multipart',
+      },
+      {
+        key: '-e, --no-encapsulated-image',
+        description:
+          'Avoid encapsulating the image frame.  Writes with the extension and without multipart',
+      },
+      {
+        key: '--single-part-image',
+        description: 'Writes single part image data',
+      },
+      {
+        key: '--no-single-part-image',
+        description: 'Writes single part image data',
+      },
+      {
+        key: '-m, --maximum-inline-public-length <value>',
+        description: 'Maximum length of public binary data',
+        defaultValue: 128 * 1024 + 2,
+      },
+      {
+        key: '-M, --maximum-inline-private-length <value>',
+        description: 'Maximum length of private binary data',
+        defaultValue: 64,
+      },
+      {
+        key: '-r, --recompress <listvalue...>',
+        description: 'List of types to recompress separated by space',
+        defaultValue: ['uncompressed', 'jp2', 'jls', 'jll'],
+        choices: [
+          'uncompressed',
+          'jp2',
+          'jpeg',
+          'jpeglossless',
+          'rle',
+          'jph',
+          'jls',
+          'true',
+          'none',
+        ],
+      },
+      {
+        key: '--recompress-color <listvalue...>',
+        description: 'List of types to recompress for color images, separated by space',
+        defaultValue: ['uncompressed'],
+        choices: [
+          'uncompressed',
+          'jpeg',
+          'jp2',
+          'jpeglossless',
+          'rle',
+          'jph',
+          'jls',
+          'true',
+          'none',
+        ],
+      },
+      {
+        key: '-f, --force',
+        description: 'Force the update even if the SOP exists',
+        defaultValue: false,
+      },
+      {
+        key: '--delete-input',
+        description: 'Deletes successful input files',
+        defaultValue: false,
+      },
+      {
+        key: '--delete-failed',
+        description: 'Deletes unsuccessful input files',
+        defaultValue: false,
+      },
+      {
+        key: '--recompress-thumb <listvalue...>',
+        description: 'List of types to recompress thumb separated by space',
+        defaultValue: ['uncompressed', 'jp2'],
+        choices: ['uncompressed', 'jp2', 'jpeglossless', 'rle', 'none'],
+      },
+      {
+        key: '--no-recompress',
+        description: 'Force no recompression',
+        defaultValue: false,
+      },
+      {
+        key: '--no-recompress-thumb',
+        description: 'Force no recompression thumbnail',
+        defaultValue: false,
+      },
+      {
+        key: '--no-thumb',
+        description: 'Skip generating thumbnails using CS3D internal render',
+        defaultValue: true,
+      },
+      {
+        key: '--dcm2jpg',
+        description: 'Use dcm2jpg for thumbnail image generation',
+        defaultValue: false,
+      },
+      {
+        key: '--rendered',
+        description: 'Use dcm2jpg to generate a rendered PNG image',
+        defaultValue: false,
+      },
+      {
+        key: '-T, --color-content-type <value>',
+        description: 'Colour content type',
+        defaultValue: 'jpeg',
+      },
+      {
+        key: '--path-deduplicated <path>',
+        description: 'Set the deduplicate data directory path (relative to dir)',
+        defaultValue: 'deduplicated',
+      },
+      {
+        key: '--path-instances <path>',
+        description: 'Set the instances directory path (relative to dir)',
+        defaultValue: 'instances',
+      },
+      {
+        key: '--store-multipart-bulk-data',
+        description: 'Use multipart encoding for non image frame bulkdata',
+        defaultValue: false,
+      },
+      {
+        key: '--prepend-bulk-data-uri <value>',
+        description:
+          'Prepend bulkdata uri (ex. to use absolute Uri like http://host:3000/dicomweb)',
+        defaultValue: '',
+      },
+      {
+        key: '--expand-bulk-data-uri',
+        description:
+          'expand bulkdata relative uri to use full relative path (should also be set when using --prepend-bulk-data-uri)',
+        defaultValue: false,
+      },
+      {
+        key: '--quiet',
+        description: 'Run quietly, minimizing extraneous output',
+        defaultValue: false,
+      },
+      {
+        key: '--multipart',
+        description: 'Add a multipart result output',
+        defaultValue: false,
+      },
+      {
+        key: '--no-verify',
+        description: 'Verify',
+        defaultValue: true,
+      },
+      {
+        key: '-o, --dir <value>',
+        description: 'Set output directory',
+        defaultValue: {
+          configOperation: 'reference',
+          source: 'staticWadoConfig',
+          reference: 'rootDir',
+        },
+      },
+      {
+        key: '--sop-instance-uid <value>',
+        description: 'Choose sop instances to run against (only for instance runs)',
+      },
+      {
+        key: '--series-instance-uid <value>',
+        description: 'Choose series instances to run against (only for instance runs)',
+      },
+
+      {
+        key: '--hash-study-uid-path',
+        description: 'Enable hashing of studyUID folder structure',
+        defaultValue: false,
+      },
+      {
+        key: '--no-index',
+        description:
+          'Skip updating the shared studies index file in dicomweb/studies/index.json.gz',
+        defaultValue: true,
+      },
+    ],
+    programs: [
+      {
+        command: 'create',
+        isDefault: true,
+        arguments: ['input'],
+        main: createMain,
+        helpDescription:
+          'Make DICOMweb query and metadata from binary Part 10 DICOM files.  Does a full read\n' +
+          'of deduplicated files each time a study instance UID is found, and only updates\n' +
+          'those studies having at least one ',
+      },
+      {
+        command: 'server',
+        main: serverMain,
+        helpDescription: 'Run server deploy instances single threaded/separated exec process',
+      },
+      {
+        command: 'part10',
+        arguments: ['studyUID'],
+        main: createPart10,
+        helpDescription: 'Store the specified study as part 10 data',
+      },
+      {
+        command: 'index',
+        main: indexMain,
+        helpDescription: 'Recreate the index for the DICOMweb data.',
+      },
+      {
+        command: 'thumbnail',
+        main: createThumbnail,
+        helpDescription: 'Create a thumbnail for the specified image',
+        options: [
+          {
+            key: '--series-thumbnail',
+            description: 'Generate a series thumbnail instead of instance',
+          },
+        ],
+      },
+      {
+        command: 'instance',
+        arguments: ['input'],
+        main: instanceMain,
+        helpDescription:
+          "Make instance level DICOMweb metadata and bulkdata, but don't group or write series metadata",
+      },
+      {
+        command: 'group',
+        arguments: ['input'],
+        main: groupMain,
+        helpDescription:
+          'Group instance level metadata into deduplicated data.\nDeletes instance level deduplicated information once it is confirmed written.',
+      },
+      {
+        command: 'metadata',
+        arguments: ['input'],
+        main: metadataMain,
+        helpDescription:
+          'Write the metadata object (series and study details) from the grouped deduplicated data.',
+      },
+      {
+        command: 'delete',
+        main: deleteMain,
+        helpDescription: 'Delete the given study, series or instance (not yet implemented)',
+      },
+      {
+        command: 'reject <studyUID...>',
+        main: rejectMain,
+        helpDescription: 'Reject the specified series',
+      },
+    ],
+  },
+});
+
+module.exports = mkdicomwebConfig;

package/dist/operation/InstanceDeduplicate.js

@@ -0,0 +1,103 @@
+// TODO review returning type of some methods
+const { JSONWriter, Tags, TagLists } = require('@radicalimaging/static-wado-util');
+
+const { getValue, setValue } = Tags;
+
+const extractors = {
+  patient: TagLists.PatientQuery,
+  study: TagLists.StudyQuery,
+  series: TagLists.SeriesExtract,
+  image: TagLists.ImageExtract,
+};
+
+/**
+ * This is an instance listener - the way this one works is that it listens for instance metadata.
+ * Every time an instance metadata event is fired, it deduplicates a bunch of data, firing deduplicate events,
+ * and then collects the deduplicate data into a list.
+ * Whenever the study UID changes, a new event is fired to indicate the deduplicated data is ready.
+ */
+async function deduplicateSingleInstance(id, imageFrame, { force }) {
+  if (!imageFrame) return {};
+  const studyData = await this.completeStudy.getCurrentStudyData(this, id);
+  const seriesUID = getValue(imageFrame, Tags.SeriesInstanceUID);
+  const sopUID = getValue(imageFrame, Tags.SOPInstanceUID);
+  if (!sopUID) {
+    console.warn('No sop instance UID in', imageFrame);
+    return {};
+  }
+  if (!force && studyData.sopExists(sopUID)) {
+    if (this.verbose) console.log('SOP Instance UID', sopUID, 'already exists, skipping');
+    // TODO - allow replace as an option
+    // Null value means skip writing this instance
+    return null;
+  }
+
+  if (this.verbose) console.log('SOP Instance UID', sopUID, 'being added');
+  const deduplicated = { ...imageFrame };
+
+  if (!this.extractors) this.extractors = extractors;
+  for (const key of Object.keys(this.extractors)) {
+    const extracted = TagLists.extract(
+      deduplicated,
+      key,
+      this.extractors[key],
+      TagLists.RemoveExtract
+    );
+    const hashKey = getValue(extracted, Tags.DeduppedHash);
+    await studyData.addExtracted(this, hashKey, extracted);
+  }
+
+  // Restore the series and SOP UIDs
+  setValue(deduplicated, Tags.SeriesInstanceUID, seriesUID);
+  setValue(deduplicated, Tags.SOPInstanceUID, sopUID);
+  TagLists.addHash(deduplicated, Tags.InstanceType);
+
+  return deduplicated;
+}
+
+/** Canonicalize the JSON data, making Values always arrays, remote "undefined" from the tags etc */
+const canonicalize = json => {
+  if (!json) return undefined;
+  if (Array.isArray(json)) {
+    return json.map(canonicalize);
+  }
+  Object.keys(json).forEach(tag => {
+    if (!tag || tag === 'undefined') {
+      // console.error('Got an undefined tag:', tag, typeof(tag));
+      // TODO check returning value
+      return;
+    }
+    const val = json[tag];
+    const { Value } = val || {};
+    if (Value && !Array.isArray(Value)) {
+      val.Value = [Value];
+    }
+  });
+  return json;
+};
+
+const InstanceDeduplicate = options =>
+  async function run(id, sourceImageFrame) {
+    // Notify the existing listeners, if any
+    const imageFrame = canonicalize(sourceImageFrame);
+    if (options.isInstance) {
+      await JSONWriter(id.sopInstanceRootPath, 'metadata', imageFrame);
+      console.verbose('Wrote instance metadata', id.sopInstanceRootPath, 'metadata');
+    }
+    if (!options.isDeduplicate && !options.isGroup) {
+      return;
+    }
+
+    if (!this.deduplicateSingleInstance) {
+      this.deduplicateSingleInstance = deduplicateSingleInstance;
+      this.verbose = options.verbose;
+    }
+
+    const deduppedInstance = await this.deduplicateSingleInstance(id, imageFrame, options);
+    if (deduppedInstance) {
+      // this refers to callee
+      await this.deduplicated(id, deduppedInstance);
+    }
+  };
+
+module.exports = InstanceDeduplicate;

package/dist/operation/ScanStudy.js

@@ -0,0 +1,47 @@
+const { getStudyUIDPathAndSubPath } = require('@radicalimaging/static-wado-util');
+
+const path = require('path');
+
+function ScanStudy(options) {
+  const { directoryName, deduplicatedRoot, deduplicatedInstancesRoot, hashStudyUidPath } = options;
+
+  return function scanStudy(studyInstanceUid) {
+    const { path: hashPath = '', subpath: hashSubpath = '' } = hashStudyUidPath
+      ? getStudyUIDPathAndSubPath(studyInstanceUid)
+      : {};
+
+    console.verbose('scanStudy', studyInstanceUid);
+
+    if (hashPath && hashSubpath) {
+      console.verbose('hashPath', hashPath);
+      console.verbose('hashSubpath', hashSubpath);
+    }
+
+    const studySubDir = hashStudyUidPath
+      ? path.join(hashPath, hashSubpath, studyInstanceUid)
+      : studyInstanceUid;
+
+    const studyPath = path.join(directoryName, 'studies', studySubDir);
+    const deduplicatedInstancesPath = path.join(
+      deduplicatedInstancesRoot,
+      // studyInstanceUid,
+      studySubDir
+    );
+    const deduplicatedPath = path.join(deduplicatedRoot, studySubDir);
+    console.verbose(
+      'Importing',
+      studyInstanceUid,
+      studyPath,
+      deduplicatedInstancesPath,
+      deduplicatedPath
+    );
+    return this.completeStudy.getCurrentStudyData(this, {
+      studyPath,
+      deduplicatedPath,
+      deduplicatedInstancesPath,
+      studyInstanceUid,
+    });
+  };
+}
+
+module.exports = ScanStudy;