@radicalimaging/static-wado-creator 1.7.3 → 1.7.6

package/dist/createThumbnail.js

@@ -0,0 +1,163 @@
+const { Tags, readBulkData, handleHomeRelative } = require('@radicalimaging/static-wado-util');
+const dcmjs = require('dcmjs');
+
+const StaticWado = require('./StaticWado');
+const adaptProgramOpts = require('./util/adaptProgramOpts');
+const WriteStream = require('./writer/WriteStream');
+
+const UncompressedLEIExplicit = '1.2.840.10008.1.2.1';
+const { DicomDict, DicomMetaDictionary } = dcmjs.data;
+
+const fileMetaInformationVersionArray = new Uint8Array(2);
+fileMetaInformationVersionArray[1] = 1;
+
+const readBulkDataValue = async (studyDir, instance, value, options) => {
+  const { BulkDataURI } = value;
+  value.vr = 'OB';
+  const seriesUid = Tags.getValue(instance, Tags.SeriesInstanceUID);
+  const numberOfFrames = Tags.getValue(instance, Tags.NumberOfFrames) || 1;
+  if (BulkDataURI.indexOf('/frames') !== -1) {
+    const seriesDir = `${studyDir}/series/${seriesUid}`;
+    if (options?.frame === false) {
+      return;
+    }
+    // Really only support a limited number of frames based on memory size
+    value.Value = [];
+    if (typeof options?.frame === 'number') {
+      console.noQuiet('Reading frame', options.frame);
+      const bulk = await readBulkData(seriesDir, BulkDataURI, options.frame);
+      if (!bulk) {
+        return;
+      }
+      value.Value[options.frame - 1] = bulk.binaryData;
+      value.transferSyntaxUid = bulk.transferSyntaxUid;
+      value.contentType = bulk.contentType;
+      return;
+    }
+    console.noQuiet('Reading frames', 1, '...', numberOfFrames);
+    for (let frame = 1; frame <= numberOfFrames; frame++) {
+      const bulk = await readBulkData(seriesDir, BulkDataURI, frame);
+      if (!bulk) break;
+      value.Value.push(bulk.binaryData);
+      value.transferSyntaxUid = bulk.transferSyntaxUid;
+      value.contentType = bulk.contentType;
+    }
+  } else {
+    const bulk = await readBulkData(studyDir, BulkDataURI);
+    value.Value = [new ArrayBuffer(bulk.binaryData)];
+    value.contentType = bulk.contentType;
+  }
+};
+
+const readBinaryData = async (dir, instance, options = { frame: true }) => {
+  for (const tag of Object.keys(instance)) {
+    const v = instance[tag];
+    if (v.BulkDataURI) {
+      await readBulkDataValue(dir, instance, v, options);
+      continue;
+    }
+    if (!v.vr) {
+      const value0 = v.Value?.[0];
+      if (typeof value0 === 'string') {
+        v.vr = 'LT';
+      } else {
+        console.log('Deleting', tag, v.Value, v);
+        delete instance[tag];
+      }
+      continue;
+    }
+    if (v.vr === 'SQ' && v.Values?.length) {
+      await Promise.all(v.Values.map(readBinaryData));
+      continue;
+    }
+  }
+};
+
+module.exports = async function createThumbnail(options, program) {
+  const finalOptions = adaptProgramOpts(options, {
+    ...this,
+    // Instance metadata is the instances/<sopUID>/metadata.gz files
+    isInstance: false,
+    // Deduplicated data is single instance deduplicated data
+    isDeduplicate: false,
+    // Group data is the group file directories
+    isGroup: false,
+    isStudyData: false,
+    isDeleteInstances: false,
+  });
+  const importer = new StaticWado(finalOptions);
+  const studyInstanceUid = program.args[0];
+  const dir = `${importer.options.rootDir}/studies/${studyInstanceUid}`;
+  console.noQuiet('Creating thumbnail for', studyInstanceUid, dir);
+  const study = await importer.callback.scanStudy(studyInstanceUid);
+  const outputPath = `./studies/${studyInstanceUid}`;
+  const { sopInstanceUid, seriesInstanceUid, seriesThumbnail, studyThumbnail } = options;
+  const sops = sopInstanceUid ? new Set() : null;
+  if (sopInstanceUid) {
+    for (const sop of sopInstanceUid.split(',').map(s => s.trim())) {
+      sops.add(sop);
+    }
+  }
+  const promises = [];
+
+  const writeThumbnail = async (id, buffer) => {
+    console.verbose('Write thumbnail', id, buffer);
+    await importer.callback.thumbWriter(id.sopInstanceRootPath, 'thumbnail', buffer);
+    if (seriesThumbnail) {
+      await importer.callback.thumbWriter(id.seriesRootPath, 'thumbnail', buffer);
+    }
+    if (studyThumbnail) {
+      await importer.callback.thumbWriter(id.studyPath, 'thumbnail', buffer);
+    }
+  };
+
+  // TODO - choose middle frame of multiframe and choose middle image of
+  // series for series thumbnail, and first series for study thumbnail
+  const codecOptions = { frame: 1 };
+
+  for (const sop of study.getSopUids()) {
+    if (sops && !sops.has(sop)) {
+      continue;
+    }
+    const instance = await study.recombine(sop);
+
+    if (
+      seriesInstanceUid &&
+      Tags.getValue(instance, Tags.SeriesInstanceUID) !== seriesInstanceUid
+    ) {
+      continue;
+    }
+
+    await readBinaryData(dir, instance, codecOptions);
+
+    const availableTransferSyntaxUID = Tags.getValue(instance, Tags.AvailableTransferSyntaxUID);
+    const pixelData = Tags.getValue(instance, Tags.PixelData);
+    if (!pixelData) {
+      console.warn('No pixel data found in instance');
+      continue;
+    }
+    const transferSyntaxUid =
+      instance[Tags.PixelData].transferSyntaxUid || availableTransferSyntaxUID;
+    const frame = Array.isArray(pixelData.Value) ? pixelData.Value[0] : pixelData;
+    console.verbose('Use transfer syntax uid:', transferSyntaxUid);
+    const id = importer.callback.uids({
+      studyInstanceUid,
+      seriesInstanceUid: Tags.getValue(instance, Tags.SeriesInstanceUID),
+      sopInstanceUid: sop,
+      transferSyntaxUid,
+    });
+
+    const promise = importer.callback.internalGenerateImage(
+      frame,
+      null,
+      instance,
+      id.transferSyntaxUid,
+      writeThumbnail.bind(null, id)
+    );
+    promises.push(promise);
+    if (seriesThumbnail) {
+      break;
+    }
+  }
+  await Promise.all(promises);
+};

package/dist/deleteMain.js

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

package/dist/groupMain.js

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

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;