@radicalimaging/static-wado-creator 0.6.4

package/lib/groupMain.js

@@ -0,0 +1,14 @@
+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: false,
+  });
+  const importer = new StaticWado(finalOptions);
+  // Either do a scan or on specified studies
+  return importer.executeCommand(program.args);
+};

package/lib/index.js

@@ -0,0 +1,8 @@
+const mkdicomwebConfig = require("./mkdicomwebConfig");
+const StaticWado = require("./StaticWado");
+
+StaticWado.mkdicomwebConfig = mkdicomwebConfig;
+StaticWado.createMain = require("./createMain");
+StaticWado.deleteMain = require("./deleteMain");
+
+module.exports = StaticWado;

package/lib/instanceMain.js

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

package/lib/metadataMain.js

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

package/lib/mkdicomwebConfig.js

@@ -0,0 +1,149 @@
+const ConfigPoint = require("config-point");
+const { staticWadoConfig } = require("@radicalimaging/static-wado-util");
+const createMain = require("./createMain");
+const deleteMain = require("./deleteMain");
+const rejectMain = require("./rejectMain");
+const instanceMain = require("./instanceMain");
+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, --clean",
+        description: "Clean the outputs before generating/starting to write new values.",
+        defaultValue: false,
+      },
+      {
+        key: "-v, --verbose",
+        description: "Write verbose output",
+        defaultValue: false,
+      },
+      {
+        key: "-t, --content-type <type>",
+        description: 'Destination type to compress to (choices: "jls", "lei", "jls-lossy" or DICOM Transfer Syntax UID - default: "jls")',
+        defaultValue: "jls",
+        customParser: compressionOptionParser,
+      },
+      {
+        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"],
+        choices: ["uncompressed", "jp2", "jpeglossless", "rle", "none"],
+      },
+      {
+        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: "-T, --colour-content-type <value>",
+        description: "Colour content type",
+        defaultValue: null,
+      },
+      {
+        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: "-o, --dir <value>",
+        description: "Set output directory",
+        defaultValue: { configOperation: "reference", source: "staticWadoConfig", reference: "rootDir" },
+      },
+    ],
+    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 of\n" +
+          "deduplicated files each time a study instance UID is found, and only updates those studies\n" +
+          "having at least one ",
+      },
+      {
+        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 deduplicated data.",
+      },
+      {
+        command: "delete",
+        main: deleteMain,
+        helpDescription: "Delete the given study, series or instance (not yet implemented)",
+      },
+      {
+        command: "reject",
+        main: rejectMain,
+        helpDescription: "Reject the specified series, specified as studies/<studyUID>/series/<seriesUID>",
+      },
+    ],
+  },
+});
+
+module.exports = mkdicomwebConfig;

package/lib/model/TagLists.js

@@ -0,0 +1,151 @@
+const hashFactory = require("node-object-hash");
+const Tags = require("../dictionary/Tags");
+
+/* eslint "no-param-reassign": "off" */
+
+const hasher = hashFactory();
+
+const { PatientID, PatientName, IssuerOfPatientID } = Tags;
+const { StudyDescription, AccessionNumber, StudyInstanceUID, StudyDate, StudyTime } = Tags;
+const { SeriesDescription, SeriesNumber, SeriesInstanceUID, SeriesDate, SeriesTime } = Tags;
+
+const { DeduppedHash, DeduppedRef, DeduppedType, } = Tags;
+
+const { pushList, getList, setValue, getValue } = Tags;
+
+const PatientQuery = [
+  PatientID,
+  Tags.OtherPatientIDsSequence,
+  PatientName,
+  IssuerOfPatientID,
+  Tags.PatientBirthDate,
+  Tags.PatientBirthTime,
+  Tags.PatientSex,
+  Tags.PatientIdentityRemoved,
+  Tags.DeidentificationMethodCodeSequence,
+];
+const StudyQuery = [StudyDescription, AccessionNumber, StudyInstanceUID, StudyDate, StudyTime, Tags.StudyStatusID, Tags.StudyPriorityID, Tags.StudyID];
+
+const PatientStudyQuery = [...PatientQuery, ...StudyQuery];
+
+// The difference between the extracts and the query is that the query contains the parent query values
+// TODO - make it into a self-cpontained object that can generate either
+const SeriesExtract = [
+  SeriesDescription,
+  SeriesNumber,
+  SeriesInstanceUID,
+  Tags.Modality,
+  SeriesDate,
+  SeriesTime,
+  Tags.SpecificCharacterSet,
+  Tags.Manufacturer,
+  Tags.InstitutionName,
+  Tags.ReferringPhysicianName,
+  Tags.StationName,
+  Tags.OperatorsName,
+  Tags.ManufacturerModelName,
+  Tags.BodyPartExamined,
+  Tags.ProtocolName,
+  Tags.RequestedProcedureDescription,
+];
+const SeriesQuery = [StudyInstanceUID, ...SeriesExtract];
+
+const InstanceQuery = [
+  Tags.SOPInstanceUID,
+  Tags.InstanceNumber,
+  Tags.SeriesInstanceUID,
+  Tags.StudyInstanceUID,
+  Tags.ContentDate,
+  Tags.ContentTime,
+  Tags.AcquisitionDate,
+  Tags.AcquisitionTime,
+  Tags.AcquisitionNumber,
+  Tags.SamplesPerPixel,
+  Tags.PhotometricInterpretation,
+  Tags.PlanarConfiguration,
+  Tags.Rows,
+  Tags.Columns,
+  Tags.BitsAllocated,
+  Tags.BitsStored,
+  Tags.HighBit,
+  Tags.PixelRepresentation,
+  Tags.WindowCenter,
+  Tags.WindowWidth,
+  Tags.WindowCenterWidthExplanation,
+  Tags.InstanceCreationTime,
+];
+
+const ImageExtract = [
+  Tags.ImageType,
+  Tags.InstanceCreationDate,
+  Tags.SOPClassUID,
+  Tags.ConversionType,
+  Tags.ManufacturerModelName,
+  Tags.ContentDate,
+  Tags.AcquisitionDate,
+  Tags.SecondaryCaptureDeviceID,
+  Tags.DateOfSecondaryCapture,
+  Tags.SecondaryCaptureDeviceManufacturer,
+  Tags.SecondaryCaptureDeviceManufacturerModelName,
+  Tags.SecondaryCaptureDeviceSoftwareVersions,
+  Tags.SoftwareVersions,
+  Tags.SamplesPerPixel,
+  Tags.PhotometricInterpretation,
+  Tags.PlanarConfiguration,
+  Tags.Rows,
+  Tags.Columns,
+  Tags.BitsAllocated,
+  Tags.BitsStored,
+  Tags.HighBit,
+  Tags.PixelRepresentation,
+  Tags.WindowCenter,
+  Tags.WindowWidth,
+  Tags.WindowCenterWidthExplanation,
+  Tags.PatientPosition,
+  Tags.PatientOrientation,
+];
+
+const addHash = (data, type) => {
+  const existing = getValue(data,DeduppedHash);
+  if (existing) {
+    return existing;
+  }
+
+  const hashValue = hasher.hash(data);
+  setValue(data, DeduppedHash, hashValue );
+  setValue(data, DeduppedType, type );
+  return hashValue;
+};
+
+const TagSets = {
+  PatientQuery,
+  StudyQuery,
+  PatientStudyQuery,
+  SeriesQuery,
+  SeriesExtract,
+  InstanceQuery,
+  ImageExtract,
+
+  QueryExtract: { remove: false, hashRef: false },
+  RemoveExtract: { remove: true, hashRef: true },
+
+  extract: (data, type, tagSet, options) => {
+    const ret = {};
+    const { remove, hashRef } = options || {};
+    tagSet.forEach((tag) => {
+      const value = data[tag];
+      if (value) {
+        ret[tag] = value;
+        if (remove) delete data[tag];
+      }
+    });
+    const hashValue = addHash(ret, type);
+    if (hashRef) {
+      pushList(data,DeduppedRef,hashValue);
+    }
+    return ret;
+  },
+  addHash,
+};
+
+module.exports = TagSets;

package/lib/model/uids.js

@@ -0,0 +1,42 @@
+const octetStream = "application/octet-stream";
+const uncompressed = {
+  uncompressed: true,
+  gzip: true,
+  contentType: octetStream,
+};
+
+/**
+ * @see {@link https://dicom.nema.org/medical/dicom/current/output/chtml/part18/sect_8.7.3.3.2.html}
+ */
+const jpeg = "image/jpeg";
+const jls = "image/jls";
+const jll = "image/jll";
+const jxl = "image/x-jxl";
+const htj2k = "image/x-htj2k";
+const jp2 = "image/jp2";
+const rle = "image/dicom-rle";
+
+const uids = {
+  "1.2.840.10008.1.2": uncompressed,
+  "1.2.840.10008.1.2.1": uncompressed,
+  "1.2.840.10008.1.2.1.99": uncompressed,
+  "1.2.840.10008.1.2.2": uncompressed,
+  "1.2.840.10008.1.2.4.50": { contentType: jpeg, lossy: true },
+  "1.2.840.10008.1.2.4.51": { contentType: jpeg, lossy: true },
+  "1.2.840.10008.1.2.4.57": { contentType: jpeg },
+  "1.2.840.10008.1.2.4.70": { contentType: jll },
+  "1.2.840.10008.1.2.4.140": { contentType: jxl },
+  "1.2.840.10008.1.2.4.141": { contentType: jxl, lossy: true },
+  "1.2.840.10008.1.2.4.80": { contentType: jls },
+  "1.2.840.10008.1.2.4.81": { contentType: jls, lossy: true },
+  "1.2.840.10008.1.2.4.90": { contentType: jp2 },
+  "1.2.840.10008.1.2.4.91": { contentType: jp2 },
+  // From JPEG original data, lossless to JXL
+  "1.2.840.10008.1.2.4.142": { contentType: jxl, lossy: true },
+  "1.2.840.10008.1.2.4.150": { contentType: htj2k },
+  // **
+  "1.2.840.10008.1.2.5": { contentType: rle },
+  default: {},
+};
+
+module.exports = uids;

package/lib/operation/InstanceDeduplicate.js

@@ -0,0 +1,100 @@
+// TODO review returning type of some methods
+const JSONWriter = require("../writer/JSONWriter");
+const TagLists = require("../model/TagLists");
+const Tags = require("../dictionary/Tags");
+
+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) {
+  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 (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.isInstanceMetadata) {
+      // console.log("Writing instance metadata");
+      await JSONWriter(id.sopInstanceRootPath, "metadata", imageFrame);
+    }
+    if (!options.isDeduplicate && !options.isGroup) {
+      return;
+    }
+
+    if (!this.deduplicateSingleInstance) {
+      this.deduplicateSingleInstance = deduplicateSingleInstance;
+      this.verbose = options.verbose;
+    }
+
+    const deduppedInstance = await this.deduplicateSingleInstance(id, imageFrame);
+    if (deduppedInstance) {
+      // this refers to callee
+      await this.deduplicated(id, deduppedInstance);
+    }
+  };
+
+module.exports = InstanceDeduplicate;

package/lib/operation/ScanStudy.js

@@ -0,0 +1,20 @@
+const path = require("path");
+
+function ScanStudy(options) {
+  const { directoryName, deduplicatedRoot, deduplicatedInstancesRoot } = options;
+
+  return function run(dir, studyInstanceUid) {
+    const studyPath = path.join(directoryName, "studies", studyInstanceUid);
+    const deduplicatedPath = path.join(deduplicatedRoot, studyInstanceUid);
+    const deduplicatedInstancesPath = path.join(deduplicatedInstancesRoot, studyInstanceUid);
+    console.log("Scanning", dir, studyInstanceUid);
+    return this.completeStudy.getCurrentStudyData(this, {
+      studyPath,
+      deduplicatedPath,
+      deduplicatedInstancesPath,
+      studyInstanceUid,
+    });
+  };
+}
+
+module.exports = ScanStudy;