@cornerstonejs/tools 0.1.1

package/dist/cjs/tools/segmentation/strategies/fillRectangle.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fillOutsideRectangle = exports.fillInsideRectangle = void 0;
+const segmentation_1 = require("../../../utilities/segmentation");
+const utilities_1 = require("../../../utilities");
+const transformPhysicalToIndex_1 = __importDefault(require("../../../utilities/transformPhysicalToIndex"));
+const triggerSegmentationEvents_1 = require("../../../stateManagement/segmentation/triggerSegmentationEvents");
+function fillRectangle(enabledElement, operationData, inside = true) {
+    const { volume: segmentation, points, segmentsLocked, segmentIndex, segmentationDataUID, toolGroupUID, constraintFn, } = operationData;
+    const { imageData, dimensions, scalarData } = segmentation;
+    let rectangleCornersIJK = points.map((world) => {
+        return (0, transformPhysicalToIndex_1.default)(imageData, world);
+    });
+    rectangleCornersIJK = rectangleCornersIJK.map((point) => {
+        return point.map((coord) => {
+            return Math.round(coord);
+        });
+    });
+    const boundsIJK = (0, segmentation_1.getBoundingBoxAroundShape)(rectangleCornersIJK, dimensions);
+    if (boundsIJK.every(([min, max]) => min !== max)) {
+        throw new Error('Oblique segmentation tools are not supported yet');
+    }
+    const pointInRectangle = () => true;
+    const callback = ({ value, index, pointIJK }) => {
+        if (segmentsLocked.includes(value)) {
+            return;
+        }
+        if (!constraintFn) {
+            scalarData[index] = segmentIndex;
+            return;
+        }
+        if (constraintFn(pointIJK)) {
+            scalarData[index] = segmentIndex;
+        }
+    };
+    (0, utilities_1.pointInShapeCallback)(imageData, pointInRectangle, callback, boundsIJK);
+    (0, triggerSegmentationEvents_1.triggerSegmentationDataModified)(toolGroupUID, segmentationDataUID);
+}
+function fillInsideRectangle(enabledElement, operationData) {
+    fillRectangle(enabledElement, operationData, true);
+}
+exports.fillInsideRectangle = fillInsideRectangle;
+function fillOutsideRectangle(enabledElement, operationData) {
+    fillRectangle(enabledElement, operationData, false);
+}
+exports.fillOutsideRectangle = fillOutsideRectangle;
+//# sourceMappingURL=fillRectangle.js.map

package/dist/cjs/tools/segmentation/strategies/fillRectangle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fillRectangle.js","sourceRoot":"","sources":["../../../../../src/tools/segmentation/strategies/fillRectangle.ts"],"names":[],"mappings":";;;;;;AAGA,kEAA2E;AAC3E,kDAAyD;AACzD,2GAAkF;AAClF,+GAAiH;AAqBjH,SAAS,aAAa,CACpB,cAAqC,EACrC,aAA4B,EAC5B,MAAM,GAAG,IAAI;IAEb,MAAM,EACJ,MAAM,EAAE,YAAY,EACpB,MAAM,EACN,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,YAAY,GACb,GAAG,aAAa,CAAA;IACjB,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,YAAY,CAAA;IAE1D,IAAI,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC7C,OAAO,IAAA,kCAAwB,EAAC,SAAS,EAAE,KAAK,CAAC,CAAA;IACnD,CAAC,CAAC,CAAA;IAGF,mBAAmB,GAAG,mBAAmB,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACtD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YACzB,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;QAC1B,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,MAAM,SAAS,GAAG,IAAA,wCAAyB,EAAC,mBAAmB,EAAE,UAAU,CAAC,CAAA;IAE5E,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,GAAG,CAAC,EAAE;QAChD,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAA;KACpE;IAGD,MAAM,gBAAgB,GAAG,GAAG,EAAE,CAAC,IAAI,CAAA;IAEnC,MAAM,QAAQ,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE;QAC9C,IAAI,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;YAClC,OAAM;SACP;QAED,IAAI,CAAC,YAAY,EAAE;YACjB,UAAU,CAAC,KAAK,CAAC,GAAG,YAAY,CAAA;YAChC,OAAM;SACP;QAED,IAAI,YAAY,CAAC,QAAQ,CAAC,EAAE;YAC1B,UAAU,CAAC,KAAK,CAAC,GAAG,YAAY,CAAA;SACjC;IACH,CAAC,CAAA;IAED,IAAA,gCAAoB,EAAC,SAAS,EAAE,gBAAgB,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAA;IAEtE,IAAA,2DAA+B,EAAC,YAAY,EAAE,mBAAmB,CAAC,CAAA;AACpE,CAAC;AASD,SAAgB,mBAAmB,CACjC,cAAqC,EACrC,aAA4B;IAE5B,aAAa,CAAC,cAAc,EAAE,aAAa,EAAE,IAAI,CAAC,CAAA;AACpD,CAAC;AALD,kDAKC;AASD,SAAgB,oBAAoB,CAClC,cAAqC,EACrC,aAA4B;IAE5B,aAAa,CAAC,cAAc,EAAE,aAAa,EAAE,KAAK,CAAC,CAAA;AACrD,CAAC;AALD,oDAKC"}

package/dist/cjs/tools/segmentation/strategies/fillSphere.d.ts

@@ -0,0 +1,15 @@
+import type { Types } from '@cornerstonejs/core';
+declare type OperationData = {
+    points: [Types.Point3, Types.Point3, Types.Point3, Types.Point3];
+    volume: Types.IImageVolume;
+    toolGroupUID: string;
+    segmentIndex: number;
+    segmentationDataUID: string;
+    segmentsLocked: number[];
+    viewPlaneNormal: Types.Point3;
+    viewUp: Types.Point3;
+    constraintFn: () => boolean;
+};
+export declare function fillInsideSphere(enabledElement: Types.IEnabledElement, operationData: OperationData): void;
+export declare function fillOutsideSphere(enabledElement: Types.IEnabledElement, operationData: OperationData): void;
+export {};

package/dist/cjs/tools/segmentation/strategies/fillSphere.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fillOutsideSphere = exports.fillInsideSphere = void 0;
+const triggerSegmentationEvents_1 = require("../../../stateManagement/segmentation/triggerSegmentationEvents");
+const utilities_1 = require("../../../utilities");
+function fillSphere(enabledElement, operationData, _inside = true) {
+    const { viewport } = enabledElement;
+    const { volume: segmentation, segmentsLocked, segmentIndex, toolGroupUID, segmentationDataUID, points, } = operationData;
+    const { scalarData, imageData } = segmentation;
+    const callback = ({ index, value }) => {
+        if (segmentsLocked.includes(value)) {
+            return;
+        }
+        scalarData[index] = segmentIndex;
+    };
+    (0, utilities_1.pointInSurroundingSphereCallback)(viewport, imageData, [points[0], points[1]], callback);
+    (0, triggerSegmentationEvents_1.triggerSegmentationDataModified)(toolGroupUID, segmentationDataUID);
+}
+function fillInsideSphere(enabledElement, operationData) {
+    fillSphere(enabledElement, operationData, true);
+}
+exports.fillInsideSphere = fillInsideSphere;
+function fillOutsideSphere(enabledElement, operationData) {
+    fillSphere(enabledElement, operationData, false);
+}
+exports.fillOutsideSphere = fillOutsideSphere;
+//# sourceMappingURL=fillSphere.js.map

package/dist/cjs/tools/segmentation/strategies/fillSphere.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fillSphere.js","sourceRoot":"","sources":["../../../../../src/tools/segmentation/strategies/fillSphere.ts"],"names":[],"mappings":";;;AAEA,+GAAiH;AACjH,kDAAqE;AAcrE,SAAS,UAAU,CACjB,cAAqC,EACrC,aAA4B,EAC5B,OAAO,GAAG,IAAI;IAEd,MAAM,EAAE,QAAQ,EAAE,GAAG,cAAc,CAAA;IACnC,MAAM,EACJ,MAAM,EAAE,YAAY,EACpB,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,MAAM,GACP,GAAG,aAAa,CAAA;IAEjB,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,YAAY,CAAA;IAE9C,MAAM,QAAQ,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE;QACpC,IAAI,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;YAClC,OAAM;SACP;QACD,UAAU,CAAC,KAAK,CAAC,GAAG,YAAY,CAAA;IAClC,CAAC,CAAA;IAED,IAAA,4CAAgC,EAC9B,QAAiC,EACjC,SAAS,EACT,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EACtB,QAAQ,CACT,CAAA;IAED,IAAA,2DAA+B,EAAC,YAAY,EAAE,mBAAmB,CAAC,CAAA;AACpE,CAAC;AAQD,SAAgB,gBAAgB,CAC9B,cAAqC,EACrC,aAA4B;IAE5B,UAAU,CAAC,cAAc,EAAE,aAAa,EAAE,IAAI,CAAC,CAAA;AACjD,CAAC;AALD,4CAKC;AAQD,SAAgB,iBAAiB,CAC/B,cAAqC,EACrC,aAA4B;IAE5B,UAAU,CAAC,cAAc,EAAE,aAAa,EAAE,KAAK,CAAC,CAAA;AAClD,CAAC;AALD,8CAKC"}

package/dist/cjs/tools/segmentation/strategies/index.d.ts

@@ -0,0 +1,3 @@
+import { fillInsideRectangle, fillOutsideRectangle } from './fillRectangle';
+import { fillInsideCircle, fillOutsideCircle } from './fillCircle';
+export { fillInsideRectangle, fillOutsideRectangle, fillInsideCircle, fillOutsideCircle, };

package/dist/cjs/tools/segmentation/strategies/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fillOutsideCircle = exports.fillInsideCircle = exports.fillOutsideRectangle = exports.fillInsideRectangle = void 0;
+const fillRectangle_1 = require("./fillRectangle");
+Object.defineProperty(exports, "fillInsideRectangle", { enumerable: true, get: function () { return fillRectangle_1.fillInsideRectangle; } });
+Object.defineProperty(exports, "fillOutsideRectangle", { enumerable: true, get: function () { return fillRectangle_1.fillOutsideRectangle; } });
+const fillCircle_1 = require("./fillCircle");
+Object.defineProperty(exports, "fillInsideCircle", { enumerable: true, get: function () { return fillCircle_1.fillInsideCircle; } });
+Object.defineProperty(exports, "fillOutsideCircle", { enumerable: true, get: function () { return fillCircle_1.fillOutsideCircle; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/tools/segmentation/strategies/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/tools/segmentation/strategies/index.ts"],"names":[],"mappings":";;;AAAA,mDAA2E;AAIzE,oGAJO,mCAAmB,OAIP;AACnB,qGAL4B,oCAAoB,OAK5B;AAJtB,6CAAkE;AAKhE,iGALO,6BAAgB,OAKP;AAChB,kGANyB,8BAAiB,OAMzB"}

package/dist/cjs/types/AnnotationTypes.d.ts

@@ -0,0 +1,43 @@
+import type { Types } from '@cornerstonejs/core';
+declare type Annotation = {
+    annotationUID?: string;
+    highlighted?: boolean;
+    isLocked?: boolean;
+    invalidated?: boolean;
+    metadata: {
+        cameraPosition?: Types.Point3;
+        cameraFocalPoint?: Types.Point3;
+        viewPlaneNormal?: Types.Point3;
+        viewUp?: Types.Point3;
+        FrameOfReferenceUID: string;
+        toolName: string;
+        referencedImageId?: string;
+        volumeUID?: string;
+    };
+    data: {
+        handles?: {
+            points?: Types.Point3[];
+            activeHandleIndex?: number | null;
+            textBox?: {
+                hasMoved: boolean;
+                worldPosition: Types.Point3;
+                worldBoundingBox: {
+                    topLeft: Types.Point3;
+                    topRight: Types.Point3;
+                    bottomLeft: Types.Point3;
+                    bottomRight: Types.Point3;
+                };
+            };
+            [key: string]: any;
+        };
+        cachedStats?: unknown;
+    };
+};
+declare type Annotations = Array<Annotation>;
+declare type FrameOfReferenceSpecificAnnotations = {
+    [key: string]: Annotations;
+};
+declare type AnnotationState = {
+    [key: string]: FrameOfReferenceSpecificAnnotations;
+};
+export { FrameOfReferenceSpecificAnnotations, AnnotationState, Annotations, Annotation, };

package/dist/cjs/types/AnnotationTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AnnotationTypes.js.map

package/dist/cjs/types/AnnotationTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnnotationTypes.js","sourceRoot":"","sources":["../../../src/types/AnnotationTypes.ts"],"names":[],"mappings":""}

package/dist/cjs/types/CursorTypes.d.ts

@@ -0,0 +1,11 @@
+export declare type SVGPoint = {
+    x: number;
+    y: number;
+};
+export declare type SVGCursorDescriptor = {
+    iconContent: string;
+    iconSize: number;
+    viewBox: SVGPoint;
+    mousePoint: SVGPoint;
+    mousePointerGroupString: string;
+};

package/dist/cjs/types/CursorTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=CursorTypes.js.map

package/dist/cjs/types/CursorTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CursorTypes.js","sourceRoot":"","sources":["../../../src/types/CursorTypes.ts"],"names":[],"mappings":""}

package/dist/cjs/types/EventTypes.d.ts

@@ -0,0 +1,140 @@
+import { Types } from '@cornerstonejs/core';
+import { Annotation } from './AnnotationTypes';
+import IPoints from './IPoints';
+declare type NormalizedMouseEventDetail = {
+    event: Record<string, unknown> | MouseEvent;
+    eventName: string;
+    renderingEngineUID: string;
+    viewportUID: string;
+    camera: Record<string, unknown>;
+    element: HTMLElement;
+};
+declare type AnnotationAddedEventDetail = {
+    viewportUID: string;
+    renderingEngineUID: string;
+    annotation: Annotation;
+};
+declare type AnnotationModifiedEventDetail = {
+    viewportUID: string;
+    renderingEngineUID: string;
+    annotation: Annotation;
+};
+declare type AnnotationRemovedEventDetail = {
+    viewportUID: string;
+    renderingEngineUID: string;
+    annotation: Annotation;
+};
+declare type AnnotationSelectionChangeEventDetail = {
+    added: Array<Annotation>;
+    removed: Array<Annotation>;
+    selection: Array<Annotation>;
+};
+declare type AnnotationLockChangeEventDetail = {
+    added: Array<Annotation>;
+    removed: Array<Annotation>;
+    locked: Array<Annotation>;
+};
+declare type AnnotationRenderedEventDetail = {
+    element: HTMLElement;
+    viewportUID: string;
+    renderingEngineUID: string;
+};
+declare type SegmentationDataModifiedEventDetail = {
+    toolGroupUID: string;
+    segmentationDataUID: string;
+};
+declare type SegmentationRenderedEventDetail = {
+    viewportUID: string;
+    toolGroupUID: string;
+};
+declare type SegmentationStateModifiedEventDetail = {
+    toolGroupUID: string;
+};
+declare type SegmentationGlobalStateModifiedEventDetail = {
+    segmentationUID: string;
+};
+declare type KeyDownEventDetail = {
+    element: HTMLElement;
+    viewportUID: string;
+    renderingEngineUID: string;
+    key: string;
+    keyCode: number;
+};
+declare type KeyUpEventDetail = KeyDownEventDetail;
+declare type MouseDownEventDetail = NormalizedMouseEventDetail & {
+    mouseButton: number;
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+declare type MouseDragEventDetail = NormalizedMouseEventDetail & {
+    mouseButton: number;
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+declare type MouseMoveEventDetail = NormalizedMouseEventDetail & {
+    currentPoints: IPoints;
+};
+declare type MouseUpEventDetail = NormalizedMouseEventDetail & {
+    mouseButton: number;
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+declare type MouseDownActivateEventDetail = NormalizedMouseEventDetail & {
+    mouseButton: number;
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+declare type MouseClickEventDetail = NormalizedMouseEventDetail & {
+    mouseButton: number;
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+declare type MouseDoubleClickEventDetail = NormalizedMouseEventDetail & {
+    startPoints: IPoints;
+    lastPoints: IPoints;
+    currentPoints: IPoints;
+    deltaPoints: IPoints;
+};
+declare type MouseWheelEventDetail = NormalizedMouseEventDetail & {
+    detail: Record<string, any>;
+    wheel: {
+        spinX: number;
+        spinY: number;
+        pixelX: number;
+        pixelY: number;
+        direction: number;
+    };
+    points: IPoints;
+};
+declare type NormalizedMouseEventType = Types.CustomEventType<NormalizedMouseEventDetail>;
+declare type AnnotationAddedEventType = Types.CustomEventType<AnnotationAddedEventDetail>;
+declare type AnnotationModifiedEventType = Types.CustomEventType<AnnotationModifiedEventDetail>;
+declare type AnnotationRemovedEventType = Types.CustomEventType<AnnotationRemovedEventDetail>;
+declare type AnnotationSelectionChangeEventType = Types.CustomEventType<AnnotationSelectionChangeEventDetail>;
+declare type AnnotationRenderedEventType = Types.CustomEventType<AnnotationRenderedEventDetail>;
+declare type AnnotationLockChangeEventType = Types.CustomEventType<AnnotationLockChangeEventDetail>;
+declare type SegmentationDataModifiedEventType = Types.CustomEventType<SegmentationDataModifiedEventDetail>;
+declare type SegmentationStateModifiedEventType = Types.CustomEventType<SegmentationStateModifiedEventDetail>;
+declare type SegmentationRenderedEventType = Types.CustomEventType<SegmentationRenderedEventDetail>;
+declare type SegmentationGlobalStateModifiedEventType = Types.CustomEventType<SegmentationGlobalStateModifiedEventDetail>;
+declare type KeyDownEventType = Types.CustomEventType<KeyDownEventDetail>;
+declare type KeyUpEventType = Types.CustomEventType<KeyUpEventDetail>;
+declare type MouseDownEventType = Types.CustomEventType<MouseDownEventDetail>;
+declare type MouseDownActivateEventType = Types.CustomEventType<MouseDownActivateEventDetail>;
+declare type MouseDragEventType = Types.CustomEventType<MouseDragEventDetail>;
+declare type MouseUpEventType = Types.CustomEventType<MouseUpEventDetail>;
+declare type MouseClickEventType = Types.CustomEventType<MouseClickEventDetail>;
+declare type MouseMoveEventType = Types.CustomEventType<MouseMoveEventDetail>;
+declare type MouseDoubleClickEventType = Types.CustomEventType<MouseDoubleClickEventDetail>;
+declare type MouseWheelEventType = Types.CustomEventType<MouseWheelEventDetail>;
+export { NormalizedMouseEventDetail, NormalizedMouseEventType, AnnotationAddedEventDetail, AnnotationAddedEventType, AnnotationModifiedEventDetail, AnnotationModifiedEventType, AnnotationRemovedEventDetail, AnnotationRemovedEventType, AnnotationSelectionChangeEventDetail, AnnotationSelectionChangeEventType, AnnotationRenderedEventDetail, AnnotationRenderedEventType, AnnotationLockChangeEventDetail, AnnotationLockChangeEventType, SegmentationDataModifiedEventType, SegmentationStateModifiedEventDetail, SegmentationStateModifiedEventType, SegmentationDataModifiedEventDetail, SegmentationRenderedEventType, SegmentationRenderedEventDetail, SegmentationGlobalStateModifiedEventType, SegmentationGlobalStateModifiedEventDetail, KeyDownEventDetail, KeyDownEventType, KeyUpEventDetail, KeyUpEventType, MouseDownEventDetail, MouseDownEventType, MouseDownActivateEventDetail, MouseDownActivateEventType, MouseDragEventDetail, MouseDragEventType, MouseUpEventDetail, MouseUpEventType, MouseClickEventDetail, MouseClickEventType, MouseMoveEventDetail, MouseMoveEventType, MouseDoubleClickEventDetail, MouseDoubleClickEventType, MouseWheelEventDetail, MouseWheelEventType, };

package/dist/cjs/types/EventTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=EventTypes.js.map

package/dist/cjs/types/EventTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventTypes.js","sourceRoot":"","sources":["../../../src/types/EventTypes.ts"],"names":[],"mappings":""}

package/dist/cjs/types/IPoints.d.ts

@@ -0,0 +1,8 @@
+import { Types } from '@cornerstonejs/core';
+declare type IPoints = {
+    page: Types.Point2;
+    client: Types.Point2;
+    canvas: Types.Point2;
+    world: Types.Point3;
+};
+export default IPoints;

package/dist/cjs/types/IPoints.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IPoints.js.map

package/dist/cjs/types/IPoints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IPoints.js","sourceRoot":"","sources":["../../../src/types/IPoints.ts"],"names":[],"mappings":""}

package/dist/cjs/types/ISetToolModeOptions.d.ts

@@ -0,0 +1,15 @@
+import { ToolModes, MouseBindings, KeyboardBindings } from '../enums';
+declare type ToolBindingMouseType = typeof MouseBindings[keyof typeof MouseBindings];
+declare type ToolBindingKeyboardType = typeof KeyboardBindings[keyof typeof KeyboardBindings];
+declare type IToolBinding = {
+    mouseButton: ToolBindingMouseType;
+    modifierKey?: ToolBindingKeyboardType;
+};
+declare type SetToolBindingsType = {
+    bindings: IToolBinding[];
+};
+declare type ToolOptionsType = {
+    bindings: IToolBinding[];
+    mode: ToolModes;
+};
+export { IToolBinding, SetToolBindingsType, ToolOptionsType };

package/dist/cjs/types/ISetToolModeOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ISetToolModeOptions.js.map

package/dist/cjs/types/ISetToolModeOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ISetToolModeOptions.js","sourceRoot":"","sources":["../../../src/types/ISetToolModeOptions.ts"],"names":[],"mappings":""}

package/dist/cjs/types/IToolGroup.d.ts

@@ -0,0 +1,42 @@
+import { Types } from '@cornerstonejs/core';
+import { SetToolBindingsType, ToolOptionsType } from './ISetToolModeOptions';
+export default interface IToolGroup {
+    _toolInstances: Record<string, any>;
+    uid: string;
+    viewportsInfo: Array<Types.IViewportUID>;
+    toolOptions: Record<string, any>;
+    getViewportUIDs: () => string[];
+    getToolInstance: {
+        (toolName: string): any;
+    };
+    addTool: {
+        (toolName: string, toolConfiguration?: any): void;
+    };
+    addViewport: {
+        (viewportUID: string, renderingEngineUID?: string): void;
+    };
+    removeViewports: {
+        (renderingEngineUID: string, viewportUID?: string): void;
+    };
+    setToolActive: {
+        (toolName: string, toolBindingsOption?: SetToolBindingsType): void;
+    };
+    setToolPassive: {
+        (toolName: string): void;
+    };
+    setToolEnabled: {
+        (toolName: string): void;
+    };
+    setToolDisabled: {
+        (toolName: string): void;
+    };
+    getToolOptions: {
+        (toolName: string): ToolOptionsType;
+    };
+    getActivePrimaryMouseButtonTool: {
+        (): undefined | string;
+    };
+    setViewportsCursorByToolName: {
+        (toolName: string, strategyName?: string): void;
+    };
+}

package/dist/cjs/types/IToolGroup.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IToolGroup.js.map

package/dist/cjs/types/IToolGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IToolGroup.js","sourceRoot":"","sources":["../../../src/types/IToolGroup.ts"],"names":[],"mappings":""}

package/dist/cjs/types/InteractionTypes.d.ts

@@ -0,0 +1,2 @@
+declare type InteractionTypes = 'Mouse';
+export default InteractionTypes;

package/dist/cjs/types/InteractionTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=InteractionTypes.js.map

package/dist/cjs/types/InteractionTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionTypes.js","sourceRoot":"","sources":["../../../src/types/InteractionTypes.ts"],"names":[],"mappings":""}

package/dist/cjs/types/InternalToolTypes.d.ts

@@ -0,0 +1,15 @@
+import { Types } from '@cornerstonejs/core';
+import { AnnotationTool } from '../tools';
+import { Annotation, Annotations } from './AnnotationTypes';
+declare type ToolAnnotationsPair = {
+    tool: AnnotationTool;
+    annotations: Annotations;
+};
+declare type ToolAnnotationPair = {
+    tool: AnnotationTool;
+    annotation: Annotation;
+};
+declare type ToolsWithMoveableHandles = ToolAnnotationPair & {
+    handle: Types.Point3;
+};
+export { ToolsWithMoveableHandles, ToolAnnotationsPair, ToolAnnotationPair };

package/dist/cjs/types/InternalToolTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=InternalToolTypes.js.map

package/dist/cjs/types/InternalToolTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InternalToolTypes.js","sourceRoot":"","sources":["../../../src/types/InternalToolTypes.ts"],"names":[],"mappings":""}

package/dist/cjs/types/PlanarBoundingBox.d.ts

@@ -0,0 +1,7 @@
+declare type PlanarBoundingBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export default PlanarBoundingBox;

package/dist/cjs/types/PlanarBoundingBox.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PlanarBoundingBox.js.map

package/dist/cjs/types/PlanarBoundingBox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlanarBoundingBox.js","sourceRoot":"","sources":["../../../src/types/PlanarBoundingBox.ts"],"names":[],"mappings":""}

package/dist/cjs/types/SegmentationRepresentationTypes.d.ts

@@ -0,0 +1,11 @@
+import type { vtkColorTransferFunction } from 'vtk.js/Sources/Rendering/Core/ColorTransferFunction';
+import type { vtkPiecewiseFunction } from 'vtk.js/Sources/Common/DataModel/PiecewiseFunction';
+import Representations from '../enums/SegmentationRepresentations';
+export declare type LabelmapRepresentation = {
+    type: typeof Representations.Labelmap;
+    config: {
+        cfun?: vtkColorTransferFunction;
+        ofun?: vtkPiecewiseFunction;
+    };
+};
+export declare type SegmentationRepresentation = LabelmapRepresentation;

package/dist/cjs/types/SegmentationRepresentationTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SegmentationRepresentationTypes.js.map

package/dist/cjs/types/SegmentationRepresentationTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SegmentationRepresentationTypes.js","sourceRoot":"","sources":["../../../src/types/SegmentationRepresentationTypes.ts"],"names":[],"mappings":""}

package/dist/cjs/types/SegmentationStateTypes.d.ts

@@ -0,0 +1,51 @@
+import { SegmentationRepresentation } from './SegmentationRepresentationTypes';
+import type { LabelmapConfig } from '../tools/displayTools/Labelmap/LabelmapConfig';
+export declare type Color = [number, number, number, number];
+export declare type ColorLUT = Array<Color>;
+export declare type RepresentationConfig = LabelmapConfig;
+export declare type SegmentationConfig = {
+    renderInactiveSegmentations: boolean;
+    representations: {
+        LABELMAP?: LabelmapConfig;
+    };
+};
+export declare type GlobalSegmentationData = {
+    volumeUID: string;
+    label: string;
+    referenceVolumeUID?: string;
+    referenceImageId?: string;
+    activeSegmentIndex: number;
+    segmentsLocked: Set<number>;
+    cachedStats: {
+        [key: string]: number;
+    };
+};
+export declare type GlobalSegmentationState = GlobalSegmentationData[];
+export declare type GlobalSegmentationStateWithConfig = {
+    segmentations: GlobalSegmentationState;
+    config: SegmentationConfig;
+};
+export declare type ToolGroupSpecificSegmentationData = {
+    volumeUID: string;
+    segmentationDataUID: string;
+    active: boolean;
+    segmentsHidden: Set<number>;
+    visibility: boolean;
+    colorLUTIndex: number;
+    representation: SegmentationRepresentation;
+};
+export declare type ToolGroupSpecificSegmentationState = ToolGroupSpecificSegmentationData[];
+export declare type ToolGroupSpecificSegmentationStateWithConfig = {
+    segmentations: ToolGroupSpecificSegmentationState;
+    config: SegmentationConfig;
+};
+export interface SegmentationState {
+    colorLutTables: ColorLUT[];
+    global: GlobalSegmentationStateWithConfig;
+    toolGroups: {
+        [key: string]: ToolGroupSpecificSegmentationStateWithConfig;
+    };
+}
+export declare type SegmentationDataInput = Partial<ToolGroupSpecificSegmentationData> & {
+    toolGroupUID: string;
+};

package/dist/cjs/types/SegmentationStateTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SegmentationStateTypes.js.map

package/dist/cjs/types/SegmentationStateTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SegmentationStateTypes.js","sourceRoot":"","sources":["../../../src/types/SegmentationStateTypes.ts"],"names":[],"mappings":""}

package/dist/cjs/types/ToolHandle.d.ts

@@ -0,0 +1,15 @@
+import type { Types } from '@cornerstonejs/core';
+declare type AnnotationHandle = Types.Point3;
+declare type TextBoxHandle = {
+    hasMoved: boolean;
+    worldBoundingBox: {
+        bottomLeft: Types.Point3;
+        bottomRight: Types.Point3;
+        topLeft: Types.Point3;
+        topRight: Types.Point3;
+    };
+    worldPosition: Types.Point3;
+};
+declare type ToolHandle = AnnotationHandle | TextBoxHandle;
+export default ToolHandle;
+export type { AnnotationHandle, TextBoxHandle };

package/dist/cjs/types/ToolHandle.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ToolHandle.js.map

package/dist/cjs/types/ToolHandle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolHandle.js","sourceRoot":"","sources":["../../../src/types/ToolHandle.ts"],"names":[],"mappings":""}

package/dist/cjs/types/ToolProps.d.ts

@@ -0,0 +1,9 @@
+declare type SharedToolProp = {
+    supportedInteractionTypes?: Array<string>;
+    configuration?: Record<string, any>;
+};
+export declare type ToolProps = SharedToolProp;
+export declare type PublicToolProps = SharedToolProp & {
+    name?: string;
+};
+export {};

package/dist/cjs/types/ToolProps.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ToolProps.js.map

package/dist/cjs/types/ToolProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolProps.js","sourceRoot":"","sources":["../../../src/types/ToolProps.ts"],"names":[],"mappings":""}