larvitar 3.8.9 → 3.8.12

package/dist/imaging/MetaDataTypes.d.ts

@@ -2324,7 +2324,7 @@ export type MetaDataTypes = {
     x0040a136?: number;
     x0040a138?: number;
     x0040a13a?: string;
-    x0040a160?: number;
+    x0040a160?: string;
     x0040a167?: MetaDataTypes[];
     x0040a168?: MetaDataTypes[];
     x0040a16a?: string;
@@ -2346,7 +2346,7 @@ export type MetaDataTypes = {
     x0040a300?: MetaDataTypes[];
     x0040a301?: MetaDataTypes[];
     x0040a307?: string;
-    x0040a30a?: number;
+    x0040a30a?: string;
     x0040a313?: MetaDataTypes[];
     x0040a33a?: string;
     x0040a340?: MetaDataTypes[];

package/dist/imaging/srUtils.d.ts

@@ -0,0 +1,50 @@
+import { MetaData, RenderOptions, Series, SRNode, SRParseResult, SRStyleConfig, SRViewerData } from "./types";
+/**
+ * Check if a DICOM series is a Structured Report (SR)
+ * @param {Series} serie - The DICOM series object
+ * @return {boolean} - True if the series is an SR
+ */
+export declare const isSR: (serie: Series) => boolean;
+/**
+ * Parse DICOM SR metadata into a structured header and tree representation
+ * @param {MetaData} metadata - The DICOM SR metadata object
+ * @return {SRParseResult} - Object containing header fields and content tree
+ */
+export declare const parseSR: (metadata: MetaData) => SRParseResult;
+/**
+ * This function returns pure data without creating DOM elements
+ *
+ * @param {MetaData} metadata - The DICOM SR metadata
+ * @return {SRViewerData} - Structured data for custom rendering
+ */
+export declare const getSRData: (metadata: MetaData) => SRViewerData;
+/**
+ * Render a complete SR tree as an interactive DOM structure
+ * @param {SRNode[]} tree - Array of root SR nodes
+ * @param {RenderOptions} opts - Rendering options (expandDepth, etc.)
+ * @return {HTMLElement} - The rendered tree as a DOM element
+ */
+export declare const renderSRTree: (tree: SRNode[], opts?: RenderOptions) => HTMLElement;
+/**
+ * @param {MetaData} metadata - The DICOM SR metadata
+ * @param {RenderOptions} opts - Rendering options
+ * @return {HTMLElement} - The complete SR viewer DOM element
+ */
+export declare const createSRViewer: (metadata: MetaData, opts?: RenderOptions) => HTMLElement;
+/**
+ * Mount a complete SR viewer UI into a container element
+ * @param {MetaData} metadata - The DICOM SR metadata
+ * @param {string} containerElementId - The DOM element to mount into
+ * @param {RenderOptions} opts - Rendering options
+ */
+export declare const mountSRViewer: (metadata: MetaData, containerElementId: string, opts?: RenderOptions) => void;
+/**
+ * Inject CSS styles for the SR viewer into the document head
+ * @param {SRStyleConfig} styleConfig - Optional style configuration object
+ */
+export declare const injectSRStyles: (styleConfig?: SRStyleConfig) => void;
+/**
+ * Update existing SR styles without full re-injection
+ * @param {SRStyleConfig} styleConfig - Style configuration to apply
+ */
+export declare const updateSRStyles: (styleConfig: SRStyleConfig) => void;

package/dist/imaging/tools/custom/CobbAngleTool.d.ts

@@ -0,0 +1,48 @@
+import cornerstone from "cornerstone-core";
+import { Coords, EventData, HandlePosition, HandleTextBox, MeasurementData } from "../types";
+declare const BaseAnnotationTool: any;
+interface CobbAngleHandles {
+    point0: HandlePosition;
+    point1: HandlePosition;
+    point2?: HandlePosition;
+    point3?: HandlePosition;
+    textBox: HandleTextBox;
+}
+type CobbAngleMeasurementData = MeasurementData & {
+    complete: boolean;
+    value?: number;
+    handles: CobbAngleHandles;
+};
+type DrawPhase = "idle" | "seg1Move" | "seg2Wait" | "seg2Move";
+export default class CobbAngleTool extends BaseAnnotationTool {
+    _phase: DrawPhase;
+    constructor(props?: any);
+    createNewMeasurement(eventData: EventData): CobbAngleMeasurementData | undefined;
+    addNewMeasurement(evt: {
+        detail: EventData;
+    }, _interactionType?: string): void;
+    pointNearTool(element: HTMLElement, data: CobbAngleMeasurementData, coords: Coords, interactionType?: string): boolean;
+    distanceFromPoint(element: HTMLElement, data: CobbAngleMeasurementData, coords: Coords): number;
+    renderToolData(evt: {
+        detail: EventData;
+    }): void;
+    _activateDraw(element: HTMLElement): void;
+    _deactivateDraw(element: HTMLElement): void;
+    _onMouseMove: (evt: {
+        detail: EventData;
+    }) => void;
+    _onMouseClick: (evt: {
+        detail: EventData;
+    }) => void;
+    handleSelectedCallback(evt: {
+        detail: EventData;
+    }, data: CobbAngleMeasurementData, handle: HandlePosition, interactionType?: string): void;
+    toolSelectedCallback(evt: {
+        detail: EventData;
+    }, annotation: CobbAngleMeasurementData, interactionType?: string): void;
+    updateCachedStats(image: cornerstone.Image, element: HTMLElement, data: CobbAngleMeasurementData): void;
+    _updateStats(_image: cornerstone.Image | undefined, _element: HTMLElement, data: CobbAngleMeasurementData): void;
+    _segDistCanvas(element: HTMLElement, p1: Coords, p2: Coords, canvasCoords: Coords): number;
+    _segDistPixel(element: HTMLElement, p1: Coords, p2: Coords, pixelCoords: Coords): number;
+}
+export {};

package/dist/imaging/tools/custom/NorbergAngleTool.d.ts

@@ -0,0 +1,22 @@
+declare const BaseAnnotationTool: any;
+import { Coords, EventData, Handles, MeasurementData } from "../types";
+/**
+ * @public
+ * @class NorbergAngleTool
+ * @memberof Tools.Annotation
+ * @classdesc Tool for measuring distances with adjustable angle segments at both endpoints.
+ * Shows angle arcs and allows 45-degree adjustment segments.
+ * @extends Tools.Base.BaseAnnotationTool
+ */
+export default class NorbergAngleTool extends BaseAnnotationTool {
+    configuration: any;
+    constructor(props?: any);
+    createNewMeasurement(eventData: EventData): MeasurementData | undefined;
+    pointNearTool(element: HTMLElement, data: MeasurementData, coords: Coords): boolean;
+    activateHandleNearCursor(element: HTMLElement, handles: Handles, coords: Coords, distanceThreshold: number): void;
+    updateCachedStats(image: any, element: HTMLElement, data: MeasurementData): void;
+    drawAngleArc(context: CanvasRenderingContext2D, centerPoint: Coords, startAngleDegrees: number, endAngleDegrees: number, radius: number, color: string, counterClockwise?: boolean): void;
+    drawAngleLabel(context: CanvasRenderingContext2D, point: Coords, angle: number, labelAngle: number, distance: number, color: string): void;
+    renderToolData(evt: any): void;
+}
+export {};

package/dist/imaging/tools/custom/TPAAnnotationTool.d.ts

@@ -0,0 +1,135 @@
+import { Coords, EventData, HandlePosition, MeasurementMouseEvent, TPAAnnotation, TPAMeasurementState } from "../types";
+declare const BaseAnnotationTool: any;
+export default class TPAAnnotationTool extends BaseAnnotationTool {
+    private currentState;
+    private currentAnnotation;
+    private isDragging;
+    constructor(props?: any);
+    createNewMeasurement(eventData: EventData): {
+        visible: boolean;
+        active: boolean;
+        color: undefined;
+        invalidated: boolean;
+        handles: {
+            ftaStart: {
+                x: number;
+                y: number;
+                highlight: boolean;
+                active: boolean;
+            };
+            ftaEnd: {
+                x: number;
+                y: number;
+                highlight: boolean;
+                active: boolean;
+            };
+            mtpStart: {
+                x: number;
+                y: number;
+                highlight: boolean;
+                active: boolean;
+            };
+            mtpEnd: {
+                x: number;
+                y: number;
+                highlight: boolean;
+                active: boolean;
+            };
+            refStart: {
+                x: number;
+                y: number;
+                highlight: boolean;
+                active: boolean;
+            };
+            refEnd: {
+                x: number;
+                y: number;
+                highlight: boolean;
+                active: boolean;
+            };
+            intersectionPoint: {
+                x: number;
+                y: number;
+            };
+            ftaTextBox: {
+                active: boolean;
+                hasMoved: boolean;
+                movesIndependently: boolean;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                hasBoundingBox: boolean;
+                x: number;
+                y: number;
+            };
+            mtpTextBox: {
+                active: boolean;
+                hasMoved: boolean;
+                movesIndependently: boolean;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                hasBoundingBox: boolean;
+                x: number;
+                y: number;
+            };
+            refTextBox: {
+                active: boolean;
+                hasMoved: boolean;
+                movesIndependently: boolean;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                hasBoundingBox: boolean;
+                x: number;
+                y: number;
+            };
+            tpaTextBox: {
+                active: boolean;
+                hasMoved: boolean;
+                movesIndependently: boolean;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                hasBoundingBox: boolean;
+                x: number;
+                y: number;
+            };
+        };
+        cachedStats: {
+            tpaAngle: number;
+            ftaLength: number;
+            mtpLength: number;
+        };
+        measurementState: TPAMeasurementState;
+    } | null;
+    addNewMeasurement(evt: MeasurementMouseEvent): TPAAnnotation | null;
+    mouseMoveCallback(evt: MeasurementMouseEvent): void;
+    mouseDragCallback(evt: MeasurementMouseEvent): void;
+    /**
+     * Extracted logic to finalize the Functional Tibial Axis (Step 1)
+     */
+    private _finishFTA;
+    /**
+     * Extracted logic to finalize the Medial Tibial Plateau (Step 2)
+     */
+    private _finishMTP;
+    preMouseDownCallback(evt: MeasurementMouseEvent): void;
+    mouseUpCallback(evt: MeasurementMouseEvent): void;
+    /**
+     * Computes the intersection point of the infinite MTP line with the
+     * infinite FTA line using parametric line-line intersection.
+     *
+     */
+    computeLineLineIntersection(p1: Coords, d1: Coords, // FTA: point + direction
+    p2: Coords, d2: Coords): Coords | null;
+    computeReferenceLineAndAngle(data: any): void;
+    updateCachedStats(image: any, element: HTMLElement, data: any): any;
+    renderToolData(evt: MeasurementMouseEvent): void;
+    /**
+     * The arc sweeps from the Reference Line direction to the MTP direction
+     */
+    drawAngleArc(context: CanvasRenderingContext2D, element: HTMLElement, handles: any, cachedStats: any, color: string): void;
+    pointNearTool(element: HTMLElement, data: any, coords: Coords, interactionType: string): boolean;
+    isPointNearHandle(element: HTMLElement, handle: HandlePosition, coords: Coords, PROXIMITY_DISTANCE: number): boolean;
+    isPointNearLine(element: HTMLElement, startHandle: HandlePosition, endHandle: HandlePosition, coords: Coords, PROXIMITY_DISTANCE: number): boolean;
+    PROXIMITY_DISTANCEToLineSegment(point: Coords, lineStart: Coords, lineEnd: Coords): number;
+    getHandleNearImagePoint(element: HTMLElement, data: any, coords: Coords, interactionType: string): any;
+}
+export {};

package/dist/imaging/tools/custom/VHSAnnotationTool.d.ts

@@ -0,0 +1,31 @@
+import { Coords, EventData, HandlePosition, Handles, MeasurementMouseEvent, VHSAnnotationData, VHSCachedStats } from "../types";
+declare const BaseAnnotationTool: any;
+export default class VHSAnnotationTool extends BaseAnnotationTool {
+    private currentState;
+    private currentAnnotation;
+    private isDragging;
+    private _throttledMouseMove;
+    private _throttledMouseDrag;
+    constructor(props?: Record<string, unknown>);
+    createNewMeasurement(eventData: EventData): VHSAnnotationData | null;
+    calculateDistance(point1: Coords, point2: Coords): number;
+    addNewMeasurement(evt: MeasurementMouseEvent): VHSAnnotationData | null;
+    mouseMoveCallback(evt: MeasurementMouseEvent): void;
+    private _mouseMoveImpl;
+    mouseDragCallback(evt: MeasurementMouseEvent): void;
+    private _mouseDragImpl;
+    private _completeSegment;
+    mouseUpCallback(evt: MeasurementMouseEvent): void;
+    preMouseDownCallback(evt: MeasurementMouseEvent): void;
+    private _autoPositionTextBox;
+    renderToolData(evt: MeasurementMouseEvent): void;
+    drawProjectionVisualization(context: CanvasRenderingContext2D, element: HTMLElement, handles: Handles, label: string, color: string, offset: number, cachedStats: VHSCachedStats): void;
+    drawTick(context: CanvasRenderingContext2D, element: HTMLElement, point: Coords, angle: number, color: string): void;
+    updateCachedStats(image: unknown, element: HTMLElement, data: VHSAnnotationData): VHSCachedStats;
+    pointNearTool(element: HTMLElement, data: VHSAnnotationData, coords: Coords, interactionType: string): boolean;
+    isPointNearHandle(element: HTMLElement, handle: HandlePosition, coords: Coords, distance: number): boolean;
+    isPointNearLine(element: HTMLElement, startHandle: HandlePosition, endHandle: HandlePosition, coords: Coords, distance: number): boolean;
+    distanceToLineSegment(point: Coords, lineStart: Coords, lineEnd: Coords): number;
+    getHandleNearImagePoint(element: HTMLElement, data: VHSAnnotationData, coords: Coords, interactionType: string): HandlePosition | null;
+}
+export {};

package/dist/imaging/tools/custom/gridTool.d.ts

@@ -0,0 +1,88 @@
+import { EnabledElement, Image } from "cornerstone-core";
+declare const BaseTool: any;
+import { Coords, MeasurementMouseEvent } from "../types";
+/**
+ * @public
+ * @class GridTool
+ * @memberof Tools.Base
+ * @classdesc Tool for drawing a grid with customizable parameters on image,
+ * such as grid dimension and center position
+ * @extends Tools.Base
+ */
+export declare class GridTool extends BaseTool {
+    center: Coords | null;
+    constructor(props?: {});
+    /**
+     * function triggered when tool is set to active
+     *
+     * @private
+     * @param {HTMLElement} element - The viewport element to add event listeners to.
+     * @modifies {element}
+     * @returns {Promise<void>}
+     */
+    activeCallback(element: HTMLElement): Promise<void>;
+    triggerInputGridDimensionChange(event: any): void;
+    /**
+     * function triggered when tool is set to disabled
+     *
+     * @private
+     * @param {HTMLElement} element - The viewport element to add remove listeners to.
+     * @modifies {element}
+     * @returns {void}
+     */
+    disabledCallback(element: HTMLElement): void;
+    /**
+     * function triggered when tool is set to passive
+     *
+     * @private
+     * @param {HTMLElement} element - The viewport element to add remove listeners to.
+     * @modifies {element}
+     * @returns {void}
+     */
+    passiveCallback(element: HTMLElement): void;
+    /**
+     * function to change center of the grid position on user click
+     *
+     * @private
+     * @param {MeasurementMouseEvent} evt - The click event
+     * @returns {void}
+     */
+    handleMouseClick(evt: MeasurementMouseEvent): void;
+    /**
+     * @private
+     * @param {MeasurementMouseEvent} evt - The click event
+     * @returns {void}
+     */
+    renderToolData(evt: MeasurementMouseEvent): void;
+    /**
+     * function to trigger the draw grid
+     * @private
+     * @param {EnabledElement} enabledElement
+     * @returns {void}
+     */
+    triggerDrawGrid(enabledElement: EnabledElement): void;
+    /**
+     * function to draw the grid
+     * @private
+     * @param {CanvasRenderingContext2D} context
+     * @param {number} xCenter
+     * @param {number} yCenter
+     * @param {Coords} start
+     * @param {Coords} end
+     * @param {number} patternWidth
+     * @param {number} patternHeight
+     * @param {number} dashWidth
+     * @param {number} dashHeight
+     * @param {string} lightGray
+     * @param {string} darkGray
+     * @returns {void}
+     */
+    drawDashedGrid(context: CanvasRenderingContext2D, xCenter: number, yCenter: number, start: Coords, end: Coords, patternWidth: number, patternHeight: number, dashWidth: number, dashHeight: number, imageDashHeight: number, imageDashWidth: number, lightGray: string, darkGray: string, image: Image, element: HTMLElement): void;
+    /**
+     * returns grid's pixelArray
+     * @private
+     * @returns {number[]}
+     */
+    getGridPixelArray(): any;
+}
+export {};

package/dist/imaging/tools/custom/utils/gridToolUtils/gridToolUtils.d.ts

@@ -0,0 +1,27 @@
+import { Image, CanvasCoordinate } from "cornerstone-core";
+import { Coords } from "../../../types";
+export type GridData = {
+    from: Coords;
+    to: Coords;
+    color: string;
+};
+export declare function handleElement(element: HTMLElement): Promise<any>;
+export declare function validatePixelSpacing(spacingX: number, spacingY: number, minPixelSpacing: number): void;
+export declare function mmToPixels(mm: number, pixelSpacing: any): number;
+export declare function findImageCoords(element: HTMLElement, image: Image): {
+    start: CanvasCoordinate;
+    end: CanvasCoordinate;
+};
+export declare function convertDimensionsToCanvas(element: HTMLElement, width: number, height: number): {
+    width: number;
+    height: number;
+};
+export declare function getColors(bitDepth: number, colorFractionLight: number, colorFractionDark: number): {
+    lightGray: string;
+    darkGray: string;
+    lightColorCode: number;
+    darkColorCode: number;
+};
+export declare function drawDashedLine(context: CanvasRenderingContext2D, from: Coords, to: Coords, color: string): void;
+export declare function drawVerticalLines(context: CanvasRenderingContext2D, xCenter: number, start: Coords, end: Coords, patternWidth: number, dashWidth: number, dashHeight: number, imageDashHeight: number, imageDashWidth: number, lightGray: string, darkGray: string, gridPixelArray: number[], image: Image, element: HTMLElement): void;
+export declare function drawHorizontalLines(context: CanvasRenderingContext2D, yCenter: number, start: Coords, end: Coords, patternHeight: number, dashWidth: number, dashHeight: number, imageDashHeight: number, imageDashWidth: number, lightGray: string, darkGray: string, gridPixelArray: number[], image: Image, element: HTMLElement): void;

package/dist/imaging/tools/types.d.ts

@@ -385,6 +385,14 @@ export type PixelSpacing = {
     colPixelSpacing: number;
 };
 export interface MeasurementData {
+    startSegmentAngle?: number;
+    startSegmentLength?: number;
+    endSegmentAngle?: number;
+    endSegmentLength?: number;
+    endAngleCustomized?: boolean;
+    endSegmentCustomized?: boolean;
+    startAngleCustomized?: boolean;
+    startSegmentCustomized?: boolean;
     computeMeasurements?: boolean;
     polyBoundingBox?: Rectangle;
     meanStdDev?: {
@@ -458,6 +466,12 @@ export type Rectangle = {
     height: number;
 };
 export interface Handles {
+    vertebralStart?: HandlePosition;
+    vertebralEnd?: HandlePosition;
+    longAxisEnd?: HandlePosition;
+    longAxisStart?: HandlePosition;
+    shortAxisStart?: HandlePosition;
+    shortAxisEnd?: HandlePosition;
     start?: HandlePosition;
     end?: HandlePosition;
     offset?: number;
@@ -465,6 +479,8 @@ export interface Handles {
     initialRotation?: number;
     points?: HandlePosition[];
     invalidHandlePlacement?: boolean;
+    endAngleHandle?: HandlePosition;
+    startAngleHandle?: HandlePosition;
 }
 export interface MeasurementMouseEvent {
     detail: EventData;
@@ -543,4 +559,98 @@ export type ThresholdsBrushProp = {
     };
     mixins: string[];
 };
+export interface VHSCachedStats {
+    vertebralLength: number;
+    longAxisLength: number;
+    shortAxisLength: number;
+    longAxisProjection: number;
+    shortAxisProjection: number;
+    longAxisAngle: number;
+    shortAxisAngle: number;
+    longAxisVHS: number;
+    shortAxisVHS: number;
+    totalVHS: number;
+}
+export interface VHSAnnotationData {
+    visible: boolean;
+    active: boolean;
+    color: string | undefined;
+    invalidated: boolean;
+    handles: {
+        vertebralStart: HandlePosition;
+        vertebralEnd: HandlePosition;
+        longAxisStart: HandlePosition;
+        longAxisEnd: HandlePosition;
+        shortAxisStart: HandlePosition;
+        shortAxisEnd: HandlePosition;
+        vertebralTextBox: HandleTextBox;
+        longAxisTextBox: HandleTextBox;
+        shortAxisTextBox: HandleTextBox;
+        vhsTextBox: HandleTextBox;
+    };
+    cachedStats: VHSCachedStats;
+    measurementState: VHSMeasurementState;
+}
+export declare enum VHSMeasurementState {
+    IDLE = 0,
+    VERTEBRAL_START = 1,
+    VERTEBRAL_END = 2,
+    LONG_AXIS_START = 3,
+    LONG_AXIS_END = 4,
+    SHORT_AXIS_START = 5,
+    SHORT_AXIS_END = 6,
+    COMPLETE = 7
+}
+export declare enum TPAMeasurementState {
+    IDLE = 0,
+    FUNCTIONAL_AXIS_START = 1,// Dragging FTA line
+    FUNCTIONAL_AXIS_END = 2,// FTA complete, waiting for MTP start click
+    MEDIAL_PLATEAU_START = 3,// Dragging MTP line
+    MEDIAL_PLATEAU_END = 4,// MTP complete → compute REF + angle
+    COMPLETE = 5
+}
+export interface TPACachedStats {
+    tpaAngle: number;
+    ftaLength: number;
+    mtpLength: number;
+    mtpNx?: number;
+    mtpNy?: number;
+    perpNx?: number;
+    perpNy?: number;
+}
+export interface TPAAnnotation {
+    visible: boolean;
+    active: boolean;
+    color?: string;
+    invalidated: boolean;
+    measurementState: TPAMeasurementState;
+    handles: {
+        ftaStart: HandlePosition;
+        ftaEnd: HandlePosition;
+        ftaTextBox: HandleTextBox;
+        mtpStart: HandlePosition;
+        mtpEnd: HandlePosition;
+        mtpTextBox: HandleTextBox;
+        refStart: HandlePosition;
+        refEnd: HandlePosition;
+        intersectionPoint: Coords;
+        refTextBox: HandleTextBox;
+        tpaTextBox: HandleTextBox;
+    };
+    cachedStats: TPACachedStats;
+}
+export type GridConfig = {
+    setup: GridSettings;
+    gridPixelArray: number[];
+};
+export type GridSettings = {
+    minRows: number;
+    minColumns: number;
+    dashHeightMM: number;
+    dashWidthMM: number;
+    colorFractionLight: number;
+    colorFractionDark: number;
+    minPixelSpacing: number;
+    gridDimensionMM: number;
+};
 export {};