@cornerstonejs/adapters 3.0.0-beta.5 → 3.0.0-beta.6

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

@@ -11,22 +11,22 @@ import RectangleRoi from './RectangleRoi.js';
 import * as Segmentation from './Segmentation.js';
 import ParametricMapObj from './ParametricMap.js';
 
-var CornerstoneSR = {
-  Length: Length,
-  FreehandRoi: FreehandRoi,
-  Bidirectional: Bidirectional,
-  EllipticalRoi: EllipticalRoi,
-  CircleRoi: CircleRoi,
-  ArrowAnnotate: ArrowAnnotate,
-  MeasurementReport: MeasurementReport,
-  CobbAngle: CobbAngle,
-  Angle: Angle,
-  RectangleRoi: RectangleRoi
+const CornerstoneSR = {
+  Length,
+  FreehandRoi,
+  Bidirectional,
+  EllipticalRoi,
+  CircleRoi,
+  ArrowAnnotate,
+  MeasurementReport,
+  CobbAngle,
+  Angle,
+  RectangleRoi
 };
-var CornerstoneSEG = {
-  Segmentation: Segmentation
+const CornerstoneSEG = {
+  Segmentation
 };
-var CornerstonePMAP = {
+const CornerstonePMAP = {
   ParametricMap: ParametricMapObj
 };
 

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

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

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

@@ -1,109 +1,98 @@
-import { slicedToArray as _slicedToArray, createClass as _createClass, defineProperty as _defineProperty, 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 _Angle;
-var TID300CobbAngle = utilities.TID300.CobbAngle;
-var MEASUREMENT_TYPE = "Angle";
-var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(MEASUREMENT_TYPE);
-var Angle = /*#__PURE__*/function () {
-  function Angle() {
-    _classCallCheck(this, Angle);
-  }
-  return _createClass(Angle, null, [{
-    key: "getMeasurementData",
-    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
-      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Angle.toolType),
-        defaultState = _MeasurementReport$ge.defaultState,
-        NUMGroup = _MeasurementReport$ge.NUMGroup,
-        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], worldCoords[3]],
-          activeHandleIndex: 0,
-          textBox: {
-            hasMoved: false
-          }
-        },
-        cachedStats: _defineProperty({}, "imageId:".concat(referencedImageId), {
-          angle: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
-        }),
-        frameNumber: ReferencedFrameNumber
-      };
-      return state;
+const {
+  CobbAngle: TID300CobbAngle
+} = utilities.TID300;
+class Angle extends BaseAdapter3D {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+    const {
+      defaultState,
+      NUMGroup,
+      SCOORDGroup,
+      ReferencedFrameNumber
+    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Angle.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);
     }
-  }, {
-    key: "getTID300RepresentationArguments",
-    value: function getTID300RepresentationArguments(tool, worldToImageCoords) {
-      var data = tool.data,
-        finding = tool.finding,
-        findingSites = tool.findingSites,
-        metadata = tool.metadata;
-      var _data$cachedStats = data.cachedStats,
-        cachedStats = _data$cachedStats === void 0 ? {} : _data$cachedStats,
-        handles = data.handles;
-      var referencedImageId = metadata.referencedImageId;
-      if (!referencedImageId) {
-        throw new Error("Angle.getTID300RepresentationArguments: referencedImageId is not defined");
-      }
-      var start1 = worldToImageCoords(referencedImageId, handles.points[0]);
-      var middle = worldToImageCoords(referencedImageId, handles.points[1]);
-      var end = worldToImageCoords(referencedImageId, handles.points[2]);
-      var point1 = {
-        x: start1[0],
-        y: start1[1]
-      };
-      var point2 = {
-        x: middle[0],
-        y: middle[1]
-      };
-      var point3 = point2;
-      var point4 = {
-        x: end[0],
-        y: end[1]
-      };
-      var _ref = cachedStats["imageId:".concat(referencedImageId)] || {},
-        angle = _ref.angle;
-      return {
-        point1: point1,
-        point2: point2,
-        point3: point3,
-        point4: point4,
-        rAngle: angle,
-        trackingIdentifierTextValue: trackingIdentifierTextValue,
-        finding: finding,
-        findingSites: findingSites || []
-      };
-    }
-  }]);
-}();
-_Angle = Angle;
-_Angle.toolType = MEASUREMENT_TYPE;
-_Angle.utilityToolType = MEASUREMENT_TYPE;
-_Angle.TID300Representation = TID300CobbAngle;
-_Angle.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
-  if (!TrackingIdentifier.includes(":")) {
-    return false;
+    const state = defaultState;
+    state.annotation.data = {
+      handles: {
+        points: [worldCoords[0], worldCoords[1], worldCoords[3]],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {
+        ["imageId:".concat(referencedImageId)]: {
+          angle: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
+        }
+      },
+      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 {
+      cachedStats = {},
+      handles
+    } = data;
+    const {
+      referencedImageId
+    } = metadata;
+    if (!referencedImageId) {
+      throw new Error("Angle.getTID300RepresentationArguments: referencedImageId is not defined");
+    }
+    const start1 = worldToImageCoords(referencedImageId, handles.points[0]);
+    const middle = worldToImageCoords(referencedImageId, handles.points[1]);
+    const end = worldToImageCoords(referencedImageId, handles.points[2]);
+    const point1 = {
+      x: start1[0],
+      y: start1[1]
+    };
+    const point2 = {
+      x: middle[0],
+      y: middle[1]
+    };
+    const point3 = point2;
+    const point4 = {
+      x: end[0],
+      y: end[1]
+    };
+    const {
+      angle
+    } = cachedStats["imageId:".concat(referencedImageId)] || {};
+    return {
+      point1,
+      point2,
+      point3,
+      point4,
+      rAngle: angle,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding,
+      findingSites: findingSites || []
+    };
   }
-  return toolType === MEASUREMENT_TYPE;
-};
-MeasurementReport.registerTool(Angle);
+}
+_Angle = Angle;
+(() => {
+  _Angle.init("Angle", TID300CobbAngle);
+  _Angle.registerLegacy();
+})();
 
 export { Angle as default };

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

@@ -1,6 +1,6 @@
-export default ArrowAnnotate;
-declare class ArrowAnnotate {
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
+import BaseAdapter3D from "./BaseAdapter3D";
+declare class ArrowAnnotate extends BaseAdapter3D {
+    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any, _trackingIdentifier: any): {
         description: any;
         sopInstanceUid: any;
         annotation: {
@@ -23,13 +23,7 @@ declare class ArrowAnnotate {
         }[];
         trackingIdentifierTextValue: string;
         findingSites: any;
+        finding: any;
     };
 }
-declare namespace ArrowAnnotate {
-    export { ARROW_ANNOTATE as toolType };
-    export { ARROW_ANNOTATE as utilityToolType };
-    export { TID300Point as TID300Representation };
-    export function isValidCornerstoneTrackingIdentifier(TrackingIdentifier: any): boolean;
-}
-declare const ARROW_ANNOTATE: "ArrowAnnotate";
-declare const TID300Point: any;
+export default ArrowAnnotate;

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

@@ -1,130 +1,118 @@
-import { slicedToArray as _slicedToArray, createClass as _createClass, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
 import MeasurementReport from './MeasurementReport.js';
 import { utilities } from 'dcmjs';
-import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import BaseAdapter3D from './BaseAdapter3D.js';
 import CodingScheme from './CodingScheme.js';
 
-var TID300Point = utilities.TID300.Point;
-var ARROW_ANNOTATE = "ArrowAnnotate";
-var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(ARROW_ANNOTATE);
-var codeValues = CodingScheme.codeValues,
-  CodingSchemeDesignator = CodingScheme.CodingSchemeDesignator;
-var ArrowAnnotate = /*#__PURE__*/function () {
-  function ArrowAnnotate() {
-    _classCallCheck(this, ArrowAnnotate);
-  }
-  return _createClass(ArrowAnnotate, null, [{
-    key: "getMeasurementData",
-    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
-      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, ArrowAnnotate.toolType),
-        defaultState = _MeasurementReport$ge.defaultState,
-        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
-        ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
-      var referencedImageId = defaultState.annotation.metadata.referencedImageId;
-      var text = defaultState.annotation.metadata.label;
-      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 _ArrowAnnotate;
+const {
+  Point: TID300Point
+} = utilities.TID300;
+const {
+  codeValues
+} = CodingScheme;
+class ArrowAnnotate extends BaseAdapter3D {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, _trackingIdentifier) {
+    const {
+      defaultState,
+      SCOORDGroup,
+      ReferencedFrameNumber
+    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, ArrowAnnotate.toolType);
+    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
+    const text = defaultState.annotation.metadata.label;
+    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);
+    }
+    if (worldCoords.length === 1) {
+      const imagePixelModule = metadata.get("imagePixelModule", referencedImageId);
+      let xOffset = 10;
+      let yOffset = 10;
+      if (imagePixelModule) {
+        const {
+          columns,
+          rows
+        } = imagePixelModule;
+        xOffset = columns / 10;
+        yOffset = rows / 10;
       }
-
-      // Since the arrowAnnotate measurement is just a point, to generate the tool state
-      // we derive the second point based on the image size relative to the first point.
-      if (worldCoords.length === 1) {
-        var imagePixelModule = metadata.get("imagePixelModule", referencedImageId);
-        var xOffset = 10;
-        var yOffset = 10;
-        if (imagePixelModule) {
-          var columns = imagePixelModule.columns,
-            rows = imagePixelModule.rows;
-          xOffset = columns / 10;
-          yOffset = rows / 10;
+      const secondPoint = imageToWorldCoords(referencedImageId, [GraphicData[0] + xOffset, GraphicData[1] + yOffset]);
+      worldCoords.push(secondPoint);
+    }
+    const state = defaultState;
+    state.annotation.data = {
+      text,
+      handles: {
+        arrowFirst: true,
+        points: [worldCoords[0], worldCoords[1]],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
         }
-        var secondPoint = imageToWorldCoords(referencedImageId, [GraphicData[0] + xOffset, GraphicData[1] + yOffset]);
-        worldCoords.push(secondPoint);
-      }
-      var state = defaultState;
-      state.annotation.data = {
-        text: text,
-        handles: {
-          arrowFirst: true,
-          points: [worldCoords[0], worldCoords[1]],
-          activeHandleIndex: 0,
-          textBox: {
-            hasMoved: false
-          }
-        },
-        frameNumber: ReferencedFrameNumber
-      };
-      return state;
+      },
+      frameNumber: ReferencedFrameNumber
+    };
+    return state;
+  }
+  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+    const {
+      data,
+      metadata,
+      findingSites
+    } = tool;
+    let {
+      finding
+    } = tool;
+    const {
+      referencedImageId
+    } = metadata;
+    if (!referencedImageId) {
+      throw new Error("ArrowAnnotate.getTID300RepresentationArguments: referencedImageId is not defined");
     }
-  }, {
-    key: "getTID300RepresentationArguments",
-    value: function getTID300RepresentationArguments(tool, worldToImageCoords) {
-      var data = tool.data,
-        metadata = tool.metadata;
-      var finding = tool.finding,
-        findingSites = tool.findingSites;
-      var referencedImageId = metadata.referencedImageId;
-      if (!referencedImageId) {
-        throw new Error("ArrowAnnotate.getTID300RepresentationArguments: referencedImageId is not defined");
-      }
-      var _data$handles = data.handles,
-        points = _data$handles.points,
-        arrowFirst = _data$handles.arrowFirst;
-      var point;
-      var point2;
-      if (arrowFirst) {
-        point = points[0];
-        point2 = points[1];
-      } else {
-        point = points[1];
-        point2 = points[0];
-      }
-      var pointImage = worldToImageCoords(referencedImageId, point);
-      var pointImage2 = worldToImageCoords(referencedImageId, point2);
-      var TID300RepresentationArguments = {
-        points: [{
-          x: pointImage[0],
-          y: pointImage[1]
-        }, {
-          x: pointImage2[0],
-          y: pointImage2[1]
-        }],
-        trackingIdentifierTextValue: trackingIdentifierTextValue,
-        findingSites: findingSites || []
+    const {
+      points,
+      arrowFirst
+    } = data.handles;
+    let point;
+    let point2;
+    if (arrowFirst) {
+      point = points[0];
+      point2 = points[1];
+    } else {
+      point = points[1];
+      point2 = points[0];
+    }
+    const pointImage = worldToImageCoords(referencedImageId, point);
+    const pointImage2 = worldToImageCoords(referencedImageId, point2);
+    const TID300RepresentationArguments = {
+      points: [{
+        x: pointImage[0],
+        y: pointImage[1]
+      }, {
+        x: pointImage2[0],
+        y: pointImage2[1]
+      }],
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      findingSites: findingSites || [],
+      finding
+    };
+    if (!finding || finding.CodeValue !== codeValues.CORNERSTONEFREETEXT) {
+      finding = {
+        CodeValue: codeValues.CORNERSTONEFREETEXT,
+        CodingSchemeDesignator: CodingScheme.CodingSchemeDesignator,
+        CodeMeaning: data.text
       };
-
-      // If freetext finding isn't present, add it from the tool text.
-      if (!finding || finding.CodeValue !== codeValues.CORNERSTONEFREETEXT) {
-        finding = {
-          CodeValue: codeValues.CORNERSTONEFREETEXT,
-          CodingSchemeDesignator: CodingSchemeDesignator,
-          CodeMeaning: data.text
-        };
-      }
-      TID300RepresentationArguments.finding = finding;
-      return TID300RepresentationArguments;
     }
-  }]);
-}();
-ArrowAnnotate.toolType = ARROW_ANNOTATE;
-ArrowAnnotate.utilityToolType = ARROW_ANNOTATE;
-ArrowAnnotate.TID300Representation = TID300Point;
-ArrowAnnotate.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
-  if (!TrackingIdentifier.includes(":")) {
-    return false;
-  }
-  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;
+    return TID300RepresentationArguments;
   }
-  return toolType === ARROW_ANNOTATE;
-};
-MeasurementReport.registerTool(ArrowAnnotate);
+}
+_ArrowAnnotate = ArrowAnnotate;
+(() => {
+  _ArrowAnnotate.init("ArrowAnnotate", TID300Point);
+  _ArrowAnnotate.registerLegacy();
+})();
 
 export { ArrowAnnotate as default };

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

@@ -0,0 +1,43 @@
+import { type AdapterOptions, type MeasurementAdapter } from "./MeasurementReport";
+export type Point = {
+    x: number;
+    y: number;
+    z?: number;
+};
+export type TID300Arguments = {
+    points?: Point[];
+    point1?: Point;
+    point2?: Point;
+    trackingIdentifierTextValue: string;
+    findingSites: [];
+    finding: any;
+    [key: string]: unknown;
+};
+export default class BaseAdapter3D {
+    static toolType: string;
+    static TID300Representation: any;
+    static trackingIdentifierTextValue: string;
+    static trackingIdentifiers: Set<string>;
+    static parentType: string;
+    static init(toolType: string, representation: any, options?: AdapterOptions): void;
+    static registerLegacy(): void;
+    static registerSubType(adapter: MeasurementAdapter, toolType: string, replace?: any): any;
+    static isValidCornerstoneTrackingIdentifier(trackingIdentifier: string): boolean;
+    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, _imageToWorldCoords: any, metadata: any, trackingIdentifier?: string): {
+        description: any;
+        sopInstanceUid: any;
+        annotation: {
+            annotationUID: any;
+            metadata: {
+                toolName: any;
+                referencedImageId: any;
+                FrameOfReferenceUID: any;
+                label: string;
+            };
+            data: any;
+        };
+        finding: any;
+        findingSites: any[];
+    };
+    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): TID300Arguments;
+}

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

@@ -0,0 +1,92 @@
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import MeasurementReport from './MeasurementReport.js';
+
+class BaseAdapter3D {
+  static init(toolType, representation, options) {
+    this.toolType = toolType;
+    if (BaseAdapter3D.toolType) {
+      throw new Error("Base adapter tool type set to ".concat(this.toolType, " while setting ").concat(toolType));
+    }
+    this.parentType = options === null || options === void 0 ? void 0 : options.parentType;
+    this.trackingIdentifiers = new Set();
+    this.TID300Representation = representation;
+    if (this.parentType) {
+      this.trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(this.parentType, ":").concat(this.toolType);
+      const alternateTrackingIdentifier = "".concat(CORNERSTONE_3D_TAG, ":").concat(this.toolType);
+      this.trackingIdentifiers.add(alternateTrackingIdentifier);
+    } else {
+      this.trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(toolType);
+    }
+    this.trackingIdentifiers.add(this.trackingIdentifierTextValue);
+    MeasurementReport.registerTool(this);
+  }
+  static registerLegacy() {
+    this.trackingIdentifiers.add("cornerstoneTools@^4.0.0:".concat(this.toolType));
+  }
+  static registerSubType(adapter, toolType, replace) {
+    const subAdapter = Object.create(adapter);
+    subAdapter.init(toolType, adapter.TID300Representation, {
+      parentType: adapter.parentType || adapter.toolType,
+      replace
+    });
+    return subAdapter;
+  }
+  static isValidCornerstoneTrackingIdentifier(trackingIdentifier) {
+    if (this.trackingIdentifiers.has(trackingIdentifier)) {
+      return true;
+    }
+    if (!trackingIdentifier.includes(":")) {
+      return false;
+    }
+    return trackingIdentifier.startsWith(this.trackingIdentifierTextValue);
+  }
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, _imageToWorldCoords, metadata, trackingIdentifier) {
+    const {
+      defaultState: state,
+      ReferencedFrameNumber
+    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    state.annotation.data = {
+      cachedStats: {},
+      frameNumber: ReferencedFrameNumber,
+      seriesLevel: (trackingIdentifier === null || trackingIdentifier === void 0 ? void 0 : trackingIdentifier.indexOf(":Series")) > 0
+    };
+    return state;
+  }
+  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+    const {
+      data,
+      metadata
+    } = tool;
+    const {
+      finding,
+      findingSites
+    } = tool;
+    const {
+      referencedImageId
+    } = metadata;
+    if (!referencedImageId) {
+      throw new Error("Probe.getTID300RepresentationArguments: referencedImageId is not defined");
+    }
+    const {
+      handles: {
+        points = []
+      }
+    } = data;
+    const pointsImage = points.map(point => {
+      const pointImage = worldToImageCoords(referencedImageId, point);
+      return {
+        x: pointImage[0],
+        y: pointImage[1]
+      };
+    });
+    const tidArguments = {
+      points: pointsImage,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      findingSites: findingSites || [],
+      finding
+    };
+    return tidArguments;
+  }
+}
+
+export { BaseAdapter3D as default };

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

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