@cornerstonejs/adapters 3.0.0-beta.5 → 3.0.0

package/dist/esm/adapters/Cornerstone3D/Segmentation/labelmapImagesFromBuffer.js

@@ -1,177 +1,160 @@
-import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime, toConsumableArray as _toConsumableArray } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import { imageLoader } from '@cornerstonejs/core';
-import { data, normalizers, utilities } from 'dcmjs';
+import { utilities, data, normalizers } from 'dcmjs';
 import ndarray from 'ndarray';
 import checkOrientation from '../../helpers/checkOrientation.js';
-import { calculateCentroid, checkSEGsOverlapping, unpackPixelData, getValidOrientations, getSegmentMetadata, readFromUnpackedChunks, alignPixelDataWithSourceData, getSegmentIndex, findReferenceSourceImageId } from '../../Cornerstone/Segmentation_4X.js';
+import { getValidOrientations, getSegmentMetadata, unpackPixelData, checkSEGsOverlapping, calculateCentroid, readFromUnpackedChunks, alignPixelDataWithSourceData, getSegmentIndex, findReferenceSourceImageId } from '../../Cornerstone/Segmentation_4X.js';
 
-var DicomMessage = data.DicomMessage,
-  DicomMetaDictionary = data.DicomMetaDictionary;
-var Normalizer = normalizers.Normalizer;
-var decode = utilities.compression.decode;
-function createLabelmapsFromBufferInternal(_x, _x2, _x3, _x4) {
-  return _createLabelmapsFromBufferInternal.apply(this, arguments);
-}
-function _createLabelmapsFromBufferInternal() {
-  _createLabelmapsFromBufferInternal = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(referencedImageIds, arrayBuffer, metadataProvider, options) {
-    var _options$skipOverlapp, skipOverlapping, _options$tolerance, tolerance, _options$TypedArrayCo, TypedArrayConstructor, _options$maxBytesPerC, maxBytesPerChunk, dicomData, dataset, multiframe, imagePlaneModule, generalSeriesModule, SeriesInstanceUID, ImageOrientationPatient, validOrientations, segMetadata, TransferSyntaxUID, pixelData, pixelDataChunks, rleEncodedFrames, orientation, sopUIDImageIdIndexMap, overlapping, insertFunction, segmentsOnFrameArray, segmentsOnFrame, imageIdMaps, labelMapImages, i, referenceImageId, labelMapImage, segmentsPixelIndices, overlappingSegments, centroidXYZ;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          _options$skipOverlapp = options.skipOverlapping, skipOverlapping = _options$skipOverlapp === void 0 ? false : _options$skipOverlapp, _options$tolerance = options.tolerance, tolerance = _options$tolerance === void 0 ? 1e-3 : _options$tolerance, _options$TypedArrayCo = options.TypedArrayConstructor, TypedArrayConstructor = _options$TypedArrayCo === void 0 ? Uint8Array : _options$TypedArrayCo, _options$maxBytesPerC = options.maxBytesPerChunk, maxBytesPerChunk = _options$maxBytesPerC === void 0 ? 199000000 : _options$maxBytesPerC;
-          dicomData = DicomMessage.readFile(arrayBuffer);
-          dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
-          dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
-          multiframe = Normalizer.normalizeToDataset([dataset]);
-          imagePlaneModule = metadataProvider.get("imagePlaneModule", referencedImageIds[0]);
-          generalSeriesModule = metadataProvider.get("generalSeriesModule", referencedImageIds[0]);
-          SeriesInstanceUID = generalSeriesModule.seriesInstanceUID;
-          if (!imagePlaneModule) {
-            console.warn("Insufficient metadata, imagePlaneModule missing.");
-          }
-          ImageOrientationPatient = Array.isArray(imagePlaneModule.rowCosines) ? [].concat(_toConsumableArray(imagePlaneModule.rowCosines), _toConsumableArray(imagePlaneModule.columnCosines)) : [imagePlaneModule.rowCosines.x, imagePlaneModule.rowCosines.y, imagePlaneModule.rowCosines.z, imagePlaneModule.columnCosines.x, imagePlaneModule.columnCosines.y, imagePlaneModule.columnCosines.z];
-          validOrientations = getValidOrientations(ImageOrientationPatient);
-          segMetadata = getSegmentMetadata(multiframe, SeriesInstanceUID);
-          TransferSyntaxUID = multiframe._meta.TransferSyntaxUID.Value[0];
-          if (!(TransferSyntaxUID === "1.2.840.10008.1.2.5")) {
-            _context.next = 22;
-            break;
-          }
-          rleEncodedFrames = Array.isArray(multiframe.PixelData) ? multiframe.PixelData : [multiframe.PixelData];
-          pixelData = decode(rleEncodedFrames, multiframe.Rows, multiframe.Columns);
-          if (!(multiframe.BitsStored === 1)) {
-            _context.next = 19;
-            break;
-          }
-          console.warn("No implementation for rle + bit packing.");
-          return _context.abrupt("return");
-        case 19:
-          pixelDataChunks = [pixelData];
-          _context.next = 25;
-          break;
-        case 22:
-          pixelDataChunks = unpackPixelData(multiframe, {
-            maxBytesPerChunk: maxBytesPerChunk
-          });
-          if (pixelDataChunks) {
-            _context.next = 25;
-            break;
-          }
-          throw new Error("Fractional segmentations are not yet supported");
-        case 25:
-          orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, referencedImageIds.length], tolerance);
-          sopUIDImageIdIndexMap = referencedImageIds.reduce(function (acc, imageId) {
-            var _metadataProvider$get = metadataProvider.get("generalImageModule", imageId),
-              sopInstanceUID = _metadataProvider$get.sopInstanceUID;
-            acc[sopInstanceUID] = imageId;
-            return acc;
-          }, {});
-          overlapping = false;
-          if (!skipOverlapping) {
-            overlapping = checkSEGsOverlapping(pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, sopUIDImageIdIndexMap);
-          }
-          _context.t0 = orientation;
-          _context.next = _context.t0 === "Planar" ? 32 : _context.t0 === "Perpendicular" ? 38 : _context.t0 === "Oblique" ? 39 : 40;
-          break;
-        case 32:
-          if (!overlapping) {
-            _context.next = 36;
-            break;
-          }
-          throw new Error("Overlapping segmentations are not yet supported.");
-        case 36:
-          insertFunction = insertPixelDataPlanar;
-        case 37:
-          return _context.abrupt("break", 40);
-        case 38:
-          throw new Error("Segmentations orthogonal to the acquisition plane of the source data are not yet supported.");
-        case 39:
-          throw new Error("Segmentations oblique to the acquisition plane of the source data are not yet supported.");
-        case 40:
-          segmentsOnFrameArray = [];
-          segmentsOnFrameArray[0] = [];
-          segmentsOnFrame = [];
-          imageIdMaps = {
-            indices: {},
-            metadata: {}
-          };
-          labelMapImages = [];
-          for (i = 0; i < referencedImageIds.length; i++) {
-            referenceImageId = referencedImageIds[i];
-            imageIdMaps.indices[referenceImageId] = i;
-            imageIdMaps.metadata[referenceImageId] = metadataProvider.get("instance", referenceImageId);
-            labelMapImage = imageLoader.createAndCacheDerivedLabelmapImage(referenceImageId);
-            labelMapImages.push(labelMapImage);
-          }
-          segmentsPixelIndices = new Map();
-          _context.next = 49;
-          return insertFunction(segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps);
-        case 49:
-          overlappingSegments = _context.sent;
-          centroidXYZ = new Map();
-          segmentsPixelIndices.forEach(function (imageIdIndexBufferIndex, segmentIndex) {
-            var centroids = calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider, referencedImageIds);
-            centroidXYZ.set(segmentIndex, centroids);
-          });
-          return _context.abrupt("return", {
-            labelMapImages: [labelMapImages],
-            segMetadata: segMetadata,
-            segmentsOnFrame: segmentsOnFrame,
-            segmentsOnFrameArray: segmentsOnFrameArray,
-            centroids: centroidXYZ,
-            overlappingSegments: overlappingSegments
-          });
-        case 53:
-        case "end":
-          return _context.stop();
+const {
+  DicomMessage,
+  DicomMetaDictionary
+} = data;
+const {
+  Normalizer
+} = normalizers;
+const {
+  decode
+} = utilities.compression;
+async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer, metadataProvider, options) {
+  const {
+    skipOverlapping = false,
+    tolerance = 1e-3,
+    TypedArrayConstructor = Uint8Array,
+    maxBytesPerChunk = 199000000
+  } = options;
+  const dicomData = DicomMessage.readFile(arrayBuffer);
+  const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+  dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+  const multiframe = Normalizer.normalizeToDataset([dataset]);
+  const imagePlaneModule = metadataProvider.get("imagePlaneModule", referencedImageIds[0]);
+  const generalSeriesModule = metadataProvider.get("generalSeriesModule", referencedImageIds[0]);
+  const SeriesInstanceUID = generalSeriesModule.seriesInstanceUID;
+  if (!imagePlaneModule) {
+    console.warn("Insufficient metadata, imagePlaneModule missing.");
+  }
+  const ImageOrientationPatient = Array.isArray(imagePlaneModule.rowCosines) ? [...imagePlaneModule.rowCosines, ...imagePlaneModule.columnCosines] : [imagePlaneModule.rowCosines.x, imagePlaneModule.rowCosines.y, imagePlaneModule.rowCosines.z, imagePlaneModule.columnCosines.x, imagePlaneModule.columnCosines.y, imagePlaneModule.columnCosines.z];
+  const validOrientations = getValidOrientations(ImageOrientationPatient);
+  const segMetadata = getSegmentMetadata(multiframe, SeriesInstanceUID);
+  const TransferSyntaxUID = multiframe._meta.TransferSyntaxUID.Value[0];
+  let pixelData;
+  let pixelDataChunks;
+  if (TransferSyntaxUID === "1.2.840.10008.1.2.5") {
+    const rleEncodedFrames = Array.isArray(multiframe.PixelData) ? multiframe.PixelData : [multiframe.PixelData];
+    pixelData = decode(rleEncodedFrames, multiframe.Rows, multiframe.Columns);
+    if (multiframe.BitsStored === 1) {
+      console.warn("No implementation for rle + bit packing.");
+      return;
+    }
+    pixelDataChunks = [pixelData];
+  } else {
+    pixelDataChunks = unpackPixelData(multiframe, {
+      maxBytesPerChunk
+    });
+    if (!pixelDataChunks) {
+      throw new Error("Fractional segmentations are not yet supported");
+    }
+  }
+  const orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, referencedImageIds.length], tolerance);
+  const sopUIDImageIdIndexMap = referencedImageIds.reduce((acc, imageId) => {
+    const {
+      sopInstanceUID
+    } = metadataProvider.get("generalImageModule", imageId);
+    acc[sopInstanceUID] = imageId;
+    return acc;
+  }, {});
+  let overlapping = false;
+  if (!skipOverlapping) {
+    overlapping = checkSEGsOverlapping(pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, sopUIDImageIdIndexMap);
+  }
+  let insertFunction;
+  switch (orientation) {
+    case "Planar":
+      if (overlapping) {
+        throw new Error("Overlapping segmentations are not yet supported.");
+      } else {
+        insertFunction = insertPixelDataPlanar;
       }
-    }, _callee);
-  }));
-  return _createLabelmapsFromBufferInternal.apply(this, arguments);
+      break;
+    case "Perpendicular":
+      throw new Error("Segmentations orthogonal to the acquisition plane of the source data are not yet supported.");
+    case "Oblique":
+      throw new Error("Segmentations oblique to the acquisition plane of the source data are not yet supported.");
+  }
+  const segmentsOnFrameArray = [];
+  segmentsOnFrameArray[0] = [];
+  const segmentsOnFrame = [];
+  const imageIdMaps = {
+    indices: {},
+    metadata: {}
+  };
+  const labelMapImages = [];
+  for (let i = 0; i < referencedImageIds.length; i++) {
+    const referenceImageId = referencedImageIds[i];
+    imageIdMaps.indices[referenceImageId] = i;
+    imageIdMaps.metadata[referenceImageId] = metadataProvider.get("instance", referenceImageId);
+    const labelMapImage = imageLoader.createAndCacheDerivedLabelmapImage(referenceImageId);
+    labelMapImages.push(labelMapImage);
+  }
+  const segmentsPixelIndices = new Map();
+  const overlappingSegments = await insertFunction(segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps);
+  const centroidXYZ = new Map();
+  segmentsPixelIndices.forEach((imageIdIndexBufferIndex, segmentIndex) => {
+    const centroids = calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider, referencedImageIds);
+    centroidXYZ.set(segmentIndex, centroids);
+  });
+  return {
+    labelMapImages: [labelMapImages],
+    segMetadata,
+    segmentsOnFrame,
+    segmentsOnFrameArray,
+    centroids: centroidXYZ,
+    overlappingSegments
+  };
 }
 function insertPixelDataPlanar(segmentsOnFrame, labelMapImages, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps) {
-  var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
-    Rows = multiframe.Rows,
-    Columns = multiframe.Columns;
-  var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
-  var sliceLength = Columns * Rows;
-  var groupsLen = PerFrameFunctionalGroupsSequence.length;
-  var overlapping = false;
-  return new Promise(function (resolve) {
-    for (var i = 0; i < groupsLen; ++i) {
-      var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
-      var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-      var view = readFromUnpackedChunks(pixelData, i * sliceLength, sliceLength);
-      var pixelDataI2D = ndarray(view, [Rows, Columns]);
-      var alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
+  const {
+    SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence,
+    Rows,
+    Columns
+  } = multiframe;
+  const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
+  const sliceLength = Columns * Rows;
+  const groupsLen = PerFrameFunctionalGroupsSequence.length;
+  let overlapping = false;
+  return new Promise(resolve => {
+    for (let i = 0; i < groupsLen; ++i) {
+      const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
+      const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+      const view = readFromUnpackedChunks(pixelData, i * sliceLength, sliceLength);
+      const pixelDataI2D = ndarray(view, [Rows, Columns]);
+      const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
       if (!alignedPixelDataI) {
         throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
       }
-      var segmentIndex = getSegmentIndex(multiframe, i);
+      const segmentIndex = getSegmentIndex(multiframe, i);
       if (segmentIndex === undefined) {
         throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
       }
       if (!segmentsPixelIndices.has(segmentIndex)) {
         segmentsPixelIndices.set(segmentIndex, {});
       }
-      var imageId = findReferenceSourceImageId(multiframe, i, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+      const imageId = findReferenceSourceImageId(multiframe, i, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
       if (!imageId) {
         console.warn("Image not present in stack, can't import frame : " + i + ".");
         continue;
       }
-      var sourceImageMetadata = imageIdMaps.metadata[imageId];
+      const sourceImageMetadata = imageIdMaps.metadata[imageId];
       if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
         throw new Error("Individual SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
       }
-      var imageIdIndex = imageIdMaps.indices[imageId];
-      var labelmapImage = labelMapImages[imageIdIndex];
-      var labelmap2DView = labelmapImage.getPixelData();
-      var data = alignedPixelDataI.data;
-      var indexCache = [];
-      for (var j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
+      const imageIdIndex = imageIdMaps.indices[imageId];
+      const labelmapImage = labelMapImages[imageIdIndex];
+      const labelmap2DView = labelmapImage.getPixelData();
+      const data = alignedPixelDataI.data;
+      const indexCache = [];
+      for (let j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
         if (data[j]) {
-          for (var x = j; x < len; ++x) {
+          for (let x = j; x < len; ++x) {
             if (data[x]) {
               if (!overlapping && labelmap2DView[x] !== 0) {
                 overlapping = true;
@@ -187,7 +170,7 @@ function insertPixelDataPlanar(segmentsOnFrame, labelMapImages, pixelData, multi
           break;
         }
       }
-      var segmentIndexObject = segmentsPixelIndices.get(segmentIndex);
+      const segmentIndexObject = segmentsPixelIndices.get(segmentIndex);
       segmentIndexObject[imageIdIndex] = indexCache;
       segmentsPixelIndices.set(segmentIndex, segmentIndexObject);
     }

package/dist/esm/adapters/Cornerstone3D/UltrasoundDirectional.d.ts

@@ -1,8 +1,5 @@
-declare class UltrasoundDirectional {
-    static toolType: string;
-    static utilityToolType: string;
-    static TID300Representation: any;
-    static isValidCornerstoneTrackingIdentifier: (TrackingIdentifier: any) => boolean;
+import BaseAdapter3D from "./BaseAdapter3D";
+declare class UltrasoundDirectional extends BaseAdapter3D {
     static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
         description: any;
         sopInstanceUid: any;

package/dist/esm/adapters/Cornerstone3D/UltrasoundDirectional.js

@@ -1,93 +1,77 @@
-import { slicedToArray as _slicedToArray, createClass as _createClass, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
 import { utilities } from 'dcmjs';
-import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
 import MeasurementReport from './MeasurementReport.js';
+import BaseAdapter3D from './BaseAdapter3D.js';
 
 var _UltrasoundDirectional;
-var TID300Length = utilities.TID300.Length;
-var ULTRASOUND_DIRECTIONAL = "UltrasoundDirectionalTool";
-var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(ULTRASOUND_DIRECTIONAL);
-var UltrasoundDirectional = /*#__PURE__*/function () {
-  function UltrasoundDirectional() {
-    _classCallCheck(this, UltrasoundDirectional);
-  }
-  return _createClass(UltrasoundDirectional, null, [{
-    key: "getMeasurementData",
-    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
-      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, UltrasoundDirectional.toolType),
-        defaultState = _MeasurementReport$ge.defaultState,
-        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
-        ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
-      var referencedImageId = defaultState.annotation.metadata.referencedImageId;
-      var GraphicData = SCOORDGroup.GraphicData;
-      var worldCoords = [];
-      for (var i = 0; i < GraphicData.length; i += 2) {
-        var point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-        worldCoords.push(point);
-      }
-      var state = defaultState;
-      state.annotation.data = {
-        handles: {
-          points: [worldCoords[0], worldCoords[1]],
-          activeHandleIndex: 0,
-          textBox: {
-            hasMoved: false
-          }
-        },
-        cachedStats: {},
-        frameNumber: ReferencedFrameNumber
-      };
-      return state;
-    }
-  }, {
-    key: "getTID300RepresentationArguments",
-    value: function getTID300RepresentationArguments(tool, worldToImageCoords) {
-      var data = tool.data,
-        finding = tool.finding,
-        findingSites = tool.findingSites,
-        metadata = tool.metadata;
-      var handles = data.handles;
-      var referencedImageId = metadata.referencedImageId;
-      if (!referencedImageId) {
-        throw new Error("UltrasoundDirectionalTool.getTID300RepresentationArguments: referencedImageId is not defined");
-      }
-      var start = worldToImageCoords(referencedImageId, handles.points[0]);
-      var end = worldToImageCoords(referencedImageId, handles.points[1]);
-      var point1 = {
-        x: start[0],
-        y: start[1]
-      };
-      var point2 = {
-        x: end[0],
-        y: end[1]
-      };
-      return {
-        point1: point1,
-        point2: point2,
-        trackingIdentifierTextValue: trackingIdentifierTextValue,
-        finding: finding,
-        findingSites: findingSites || []
-      };
+const {
+  Length: TID300Length
+} = utilities.TID300;
+class UltrasoundDirectional extends BaseAdapter3D {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+    const {
+      defaultState,
+      SCOORDGroup,
+      ReferencedFrameNumber
+    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, UltrasoundDirectional.toolType);
+    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
+    const {
+      GraphicData
+    } = SCOORDGroup;
+    const worldCoords = [];
+    for (let i = 0; i < GraphicData.length; i += 2) {
+      const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
+      worldCoords.push(point);
     }
-  }]);
-}();
-_UltrasoundDirectional = UltrasoundDirectional;
-_UltrasoundDirectional.toolType = ULTRASOUND_DIRECTIONAL;
-_UltrasoundDirectional.utilityToolType = ULTRASOUND_DIRECTIONAL;
-_UltrasoundDirectional.TID300Representation = TID300Length;
-_UltrasoundDirectional.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
-  if (!TrackingIdentifier.includes(":")) {
-    return false;
+    const state = defaultState;
+    state.annotation.data = {
+      handles: {
+        points: [worldCoords[0], worldCoords[1]],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {},
+      frameNumber: ReferencedFrameNumber
+    };
+    return state;
   }
-  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
-    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
-    cornerstone3DTag = _TrackingIdentifier$s2[0],
-    toolType = _TrackingIdentifier$s2[1];
-  if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
-    return false;
+  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      handles
+    } = data;
+    const {
+      referencedImageId
+    } = metadata;
+    if (!referencedImageId) {
+      throw new Error("UltrasoundDirectionalTool.getTID300RepresentationArguments: referencedImageId is not defined");
+    }
+    const start = worldToImageCoords(referencedImageId, handles.points[0]);
+    const end = worldToImageCoords(referencedImageId, handles.points[1]);
+    const point1 = {
+      x: start[0],
+      y: start[1]
+    };
+    const point2 = {
+      x: end[0],
+      y: end[1]
+    };
+    return {
+      point1,
+      point2,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding,
+      findingSites: findingSites || []
+    };
   }
-  return toolType === ULTRASOUND_DIRECTIONAL;
-};
-MeasurementReport.registerTool(UltrasoundDirectional);
+}
+_UltrasoundDirectional = UltrasoundDirectional;
+_UltrasoundDirectional.init("UltrasoundDirectionalTool", TID300Length);
 
 export { UltrasoundDirectional as default };

package/dist/esm/adapters/Cornerstone3D/index.d.ts

@@ -10,10 +10,13 @@ import Length from "./Length";
 import PlanarFreehandROI from "./PlanarFreehandROI";
 import Probe from "./Probe";
 import UltrasoundDirectional from "./UltrasoundDirectional";
+import BaseAdapter3D from "./BaseAdapter3D";
 import * as Segmentation from "./Segmentation";
 import * as ParametricMap from "./ParametricMap";
 import * as RTSS from "./RTStruct";
+import KeyImage from "./KeyImage";
 declare const Cornerstone3DSR: {
+    BaseAdapter3D: typeof BaseAdapter3D;
     Bidirectional: typeof Bidirectional;
     CobbAngle: typeof CobbAngle;
     Angle: typeof Angle;
@@ -25,6 +28,7 @@ declare const Cornerstone3DSR: {
     Probe: typeof Probe;
     PlanarFreehandROI: typeof PlanarFreehandROI;
     UltrasoundDirectional: typeof UltrasoundDirectional;
+    KeyImage: typeof KeyImage;
     MeasurementReport: typeof MeasurementReport;
     CodeScheme: {
         CodingSchemeDesignator: string;

package/dist/esm/adapters/Cornerstone3D/index.js

@@ -12,33 +12,37 @@ import Length from './Length.js';
 import PlanarFreehandROI from './PlanarFreehandROI.js';
 import Probe from './Probe.js';
 import UltrasoundDirectional from './UltrasoundDirectional.js';
+import BaseAdapter3D from './BaseAdapter3D.js';
 import * as index from './Segmentation/index.js';
 import * as index$1 from './ParametricMap/index.js';
 import * as index$2 from './RTStruct/index.js';
+import KeyImage from './KeyImage.js';
 
-var Cornerstone3DSR = {
-  Bidirectional: Bidirectional,
-  CobbAngle: CobbAngle,
-  Angle: Angle,
-  Length: Length,
-  CircleROI: CircleROI,
-  EllipticalROI: EllipticalROI,
-  RectangleROI: RectangleROI,
-  ArrowAnnotate: ArrowAnnotate,
-  Probe: Probe,
-  PlanarFreehandROI: PlanarFreehandROI,
-  UltrasoundDirectional: UltrasoundDirectional,
-  MeasurementReport: MeasurementReport,
+const Cornerstone3DSR = {
+  BaseAdapter3D,
+  Bidirectional,
+  CobbAngle,
+  Angle,
+  Length,
+  CircleROI,
+  EllipticalROI,
+  RectangleROI,
+  ArrowAnnotate,
+  Probe,
+  PlanarFreehandROI,
+  UltrasoundDirectional,
+  KeyImage,
+  MeasurementReport,
   CodeScheme: CodingScheme,
-  CORNERSTONE_3D_TAG: CORNERSTONE_3D_TAG
+  CORNERSTONE_3D_TAG
 };
-var Cornerstone3DSEG = {
+const Cornerstone3DSEG = {
   Segmentation: index
 };
-var Cornerstone3DPMAP = {
+const Cornerstone3DPMAP = {
   ParametricMap: index$1
 };
-var Cornerstone3DRT = {
+const Cornerstone3DRT = {
   RTSS: index$2
 };