@cornerstonejs/tools 3.15.6 → 3.16.0

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/calculateFanShapeCorners.d.ts

@@ -0,0 +1,8 @@
+import type { Types } from '@cornerstonejs/core';
+import type { FanShapeCorners, RefinementOptions } from './types';
+export declare function pickPoints(hull: Array<Types.Point2>, slack?: number): FanShapeCorners;
+export declare function computeEdgeBuffer(buffer: any, width: any, height: any): Float32Array;
+export declare function refineCornersDirectional(edgeBuf: Float32Array, width: number, height: number, rough: FanShapeCorners, contour: Array<Types.Point2>, opts?: RefinementOptions & {
+    slack?: number;
+}): FanShapeCorners;
+export declare function calculateFanShapeCorners(imageBuffer: any, width: any, height: any, hull: Array<Types.Point2>, roughContour: Array<Types.Point2>): FanShapeCorners;

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/calculateFanShapeCorners.js

@@ -0,0 +1,143 @@
+export function pickPoints(hull, slack = 7) {
+    if (!hull.length) {
+        throw new Error('Convex hull is empty');
+    }
+    const n = hull.length;
+    const next = (i) => (i + 1) % n;
+    const walk = (from, to) => {
+        const idx = [];
+        for (let i = from;; i = next(i)) {
+            idx.push(i);
+            if (i === to) {
+                break;
+            }
+        }
+        return idx;
+    };
+    let i2 = 0, i3 = 0;
+    for (let i = 1; i < n; i++) {
+        if (hull[i][0] < hull[i2][0]) {
+            i2 = i;
+        }
+        if (hull[i][0] > hull[i3][0]) {
+            i3 = i;
+        }
+    }
+    const P2 = hull[i2];
+    const P3 = hull[i3];
+    const pathA = walk(i2, i3);
+    const pathB = walk(i3, i2);
+    const globalYmin = Math.min(...hull.map((p) => p[1]));
+    const upperPath = pathA.some((i) => hull[i][1] === globalYmin)
+        ? pathA
+        : pathB;
+    const topY = Math.min(...upperPath.map((i) => hull[i][1]));
+    let arcPts = upperPath
+        .map((i) => hull[i])
+        .filter((p) => Math.abs(p[1] - topY) <= slack);
+    if (arcPts.length < 2) {
+        arcPts = upperPath
+            .map((i) => hull[i])
+            .sort((a, b) => a[1] - b[1])
+            .slice(0, 2);
+    }
+    const P1 = arcPts.reduce((best, p) => (p[0] < best[0] ? p : best), arcPts[0]);
+    const P4 = arcPts.reduce((best, p) => (p[0] > best[0] ? p : best), arcPts[0]);
+    return { P1, P2, P3, P4 };
+}
+export function computeEdgeBuffer(buffer, width, height) {
+    const total = width * height;
+    const channels = buffer.length / total;
+    if (![1, 3, 4].includes(channels)) {
+        throw new Error('Buffer must be 1,3 or 4 channels per pixel');
+    }
+    const gray = new Float32Array(total);
+    for (let i = 0; i < total; i++) {
+        if (channels === 1) {
+            gray[i] = buffer[i];
+        }
+        else {
+            const base = i * channels;
+            const r = buffer[base];
+            const g = buffer[base + 1];
+            const b = buffer[base + 2];
+            gray[i] = 0.299 * r + 0.587 * g + 0.114 * b;
+        }
+    }
+    const edgeBuf = new Float32Array(total);
+    for (let y = 1; y < height - 1; y++) {
+        for (let x = 1; x < width - 1; x++) {
+            const idx = y * width + x;
+            const i00 = idx - width - 1;
+            const i01 = idx - width;
+            const i02 = idx - width + 1;
+            const i10 = idx - 1;
+            const i11 = idx;
+            const i12 = idx + 1;
+            const i20 = idx + width - 1;
+            const i21 = idx + width;
+            const i22 = idx + width + 1;
+            const gx = -gray[i00] +
+                gray[i02] +
+                -2 * gray[i10] +
+                2 * gray[i12] +
+                -gray[i20] +
+                gray[i22];
+            const gy = gray[i00] +
+                2 * gray[i01] +
+                gray[i02] -
+                gray[i20] -
+                2 * gray[i21] -
+                gray[i22];
+            edgeBuf[idx] = Math.hypot(gx, gy);
+        }
+    }
+    return edgeBuf;
+}
+export function refineCornersDirectional(edgeBuf, width, height, rough, contour, opts = {}) {
+    const { maxDist = 15, slack = 2 } = opts;
+    const directions = {
+        P1: { dx: -1, dy: -1 },
+        P2: { dx: -1, dy: +1 },
+        P3: { dx: +1, dy: +1 },
+        P4: { dx: +1, dy: -1 },
+    };
+    function snapQuadrant(pt, { dx, dy }, threshold = 5) {
+        const xmin = dx < 0 ? pt[0] - maxDist : pt[0] - slack;
+        const xmax = dx < 0 ? pt[0] + slack : pt[0] + maxDist;
+        const ymin = dy < 0 ? pt[1] - maxDist : pt[1] - slack;
+        const ymax = dy < 0 ? pt[1] + slack : pt[1] + maxDist;
+        let best = pt;
+        for (const [cx, cy] of contour) {
+            if (cx < xmin || cx > xmax || cy < ymin || cy > ymax) {
+                continue;
+            }
+            const xi = Math.round(cx);
+            const yi = Math.round(cy);
+            if (xi < 0 || xi >= width || yi < 0 || yi >= height) {
+                continue;
+            }
+            const xAlign = (xi - best[0]) * dx;
+            const yAlign = (yi - best[0]) * dy;
+            const v = edgeBuf[yi * width + xi];
+            if (v > threshold && (xAlign > 0 || yAlign > 0)) {
+                best = [cx, cy];
+            }
+        }
+        return best;
+    }
+    return {
+        P1: snapQuadrant(rough.P1, directions.P1),
+        P2: snapQuadrant(rough.P2, directions.P2),
+        P3: snapQuadrant(rough.P3, directions.P3),
+        P4: snapQuadrant(rough.P4, directions.P4),
+    };
+}
+export function calculateFanShapeCorners(imageBuffer, width, height, hull, roughContour) {
+    const rough = pickPoints(hull);
+    const refined = refineCornersDirectional(imageBuffer, width, height, rough, roughContour, {
+        maxDist: 20,
+        step: 0.5,
+    });
+    return refined;
+}

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/deriveFanGeometry.d.ts

@@ -0,0 +1,2 @@
+import type { FanGeometry, FanShapeCorners } from './types';
+export declare function deriveFanGeometry(params: FanShapeCorners): FanGeometry;

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/deriveFanGeometry.js

@@ -0,0 +1,32 @@
+import { intersectLine } from '../../../../utilities/math/line';
+function angleRad(center, p) {
+    return Math.atan2(p[1] - center[1], p[0] - center[0]);
+}
+export function deriveFanGeometry(params) {
+    const { P1, P2, P3, P4 } = params;
+    const centerResult = intersectLine(P1, P2, P4, P3, true);
+    if (!centerResult) {
+        throw new Error('Fan edges appear parallel — no apex found');
+    }
+    const center = centerResult;
+    let startAngle = angleRad(center, P1) * (180 / Math.PI);
+    let endAngle = angleRad(center, P4) * (180 / Math.PI);
+    if (endAngle <= startAngle) {
+        const tempAngle = startAngle;
+        startAngle = endAngle;
+        endAngle = tempAngle;
+    }
+    const d1 = Math.hypot(P1[0] - center[0], P1[1] - center[1]);
+    const d4 = Math.hypot(P4[0] - center[0], P4[1] - center[1]);
+    const d2 = Math.hypot(P2[0] - center[0], P2[1] - center[1]);
+    const d3 = Math.hypot(P3[0] - center[0], P3[1] - center[1]);
+    const innerRadius = Math.min(d1, d4);
+    const outerRadius = Math.max(d2, d3);
+    return {
+        center,
+        startAngle,
+        endAngle,
+        innerRadius,
+        outerRadius,
+    };
+}

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction.d.ts

@@ -0,0 +1,7 @@
+import type { Types } from '@cornerstonejs/core';
+import type { FanShapeContour, ContourExportOptions, PixelDataResult, FanGeometryResult } from './types';
+export declare function exportContourJpeg(pixelData: Types.PixelDataTypedArray, width: number, height: number, contour: FanShapeContour, opts?: ContourExportOptions): string;
+export declare function getPixelData(imageId: string): PixelDataResult | undefined;
+export default function saveBinaryData(url: string, filename: string): void;
+export declare function downloadFanJpeg(imageId: string, contourType?: number): void;
+export declare function calculateFanGeometry(imageId: string): FanGeometryResult | undefined;

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction.js

@@ -0,0 +1,171 @@
+import { cache } from '@cornerstonejs/core';
+import { segmentLargestUSOutlineFromBuffer } from './segmentLargestUSOutlineFromBuffer';
+import { generateConvexHullFromContour } from './generateConvexHullFromContour';
+import { calculateFanShapeCorners } from './calculateFanShapeCorners';
+import { deriveFanGeometry } from './deriveFanGeometry';
+export function exportContourJpeg(pixelData, width, height, contour, opts = {}) {
+    const { strokeStyle = '#f00', lineWidth = 2, quality = 0.92 } = opts;
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    const totalPixels = width * height;
+    const channels = pixelData.length / totalPixels;
+    const imgData = ctx.createImageData(width, height);
+    const out = imgData.data;
+    for (let i = 0; i < totalPixels; i++) {
+        const baseIn = i * channels;
+        const baseOut = i * 4;
+        if (channels === 1) {
+            const v = pixelData[baseIn];
+            out[baseOut] = v;
+            out[baseOut + 1] = v;
+            out[baseOut + 2] = v;
+            out[baseOut + 3] = 255;
+        }
+        else {
+            out[baseOut] = pixelData[baseIn];
+            out[baseOut + 1] = pixelData[baseIn + 1];
+            out[baseOut + 2] = pixelData[baseIn + 2];
+            out[baseOut + 3] = channels === 4 ? pixelData[baseIn + 3] : 255;
+        }
+    }
+    ctx.putImageData(imgData, 0, 0);
+    if (contour.length > 0) {
+        ctx.strokeStyle = strokeStyle;
+        ctx.lineWidth = lineWidth;
+        ctx.beginPath();
+        ctx.moveTo(contour[0][0] + 0.5, contour[0][1] + 0.5);
+        for (let i = 1; i < contour.length; i++) {
+            ctx.lineTo(contour[i][0] + 0.5, contour[i][1] + 0.5);
+        }
+        ctx.closePath();
+        ctx.stroke();
+    }
+    return canvas.toDataURL('image/jpeg', quality);
+}
+export function getPixelData(imageId) {
+    const image = cache.getImage(imageId);
+    if (!image) {
+        return;
+    }
+    const width = image.width;
+    const height = image.height;
+    const pixelData = image.getPixelData();
+    return {
+        pixelData,
+        width,
+        height,
+    };
+}
+export default function saveBinaryData(url, filename) {
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.style.display = 'none';
+    a.click();
+    a.remove();
+}
+function exportFanJpeg(pixelData, width, height, fan, opts = {}) {
+    const { center, startAngle: startAngleInDegrees, endAngle: endAngleInDegrees, innerRadius, outerRadius, } = fan;
+    const { strokeStyle = '#0ff', lineWidth = 2, quality = 0.92 } = opts;
+    const startAngle = (startAngleInDegrees * Math.PI) / 180;
+    const endAngle = (endAngleInDegrees * Math.PI) / 180;
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    const total = width * height;
+    const channels = pixelData.length / total;
+    const imgData = ctx.createImageData(width, height);
+    const out = imgData.data;
+    for (let i = 0; i < total; i++) {
+        const baseOut = i * 4;
+        if (channels === 1) {
+            const v = pixelData[i];
+            out[baseOut] = v;
+            out[baseOut + 1] = v;
+            out[baseOut + 2] = v;
+            out[baseOut + 3] = 255;
+        }
+        else {
+            const baseIn = i * channels;
+            out[baseOut] = pixelData[baseIn];
+            out[baseOut + 1] = pixelData[baseIn + 1];
+            out[baseOut + 2] = pixelData[baseIn + 2];
+            out[baseOut + 3] = channels === 4 ? pixelData[baseIn + 3] : 255;
+        }
+    }
+    ctx.putImageData(imgData, 0, 0);
+    ctx.beginPath();
+    for (let a = startAngle; a <= endAngle; a += 0.01) {
+        const x = center[0] + innerRadius * Math.cos(a);
+        const y = center[1] + innerRadius * Math.sin(a);
+        if (a === startAngle) {
+            ctx.moveTo(x, y);
+        }
+        else {
+            ctx.lineTo(x, y);
+        }
+    }
+    for (let a = endAngle; a >= startAngle; a -= 0.01) {
+        const x = center[0] + outerRadius * Math.cos(a);
+        const y = center[1] + outerRadius * Math.sin(a);
+        ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+    ctx.strokeStyle = strokeStyle;
+    ctx.lineWidth = lineWidth;
+    ctx.stroke();
+    return canvas.toDataURL('image/jpeg', quality);
+}
+export function downloadFanJpeg(imageId, contourType = 5) {
+    const { contour, simplified, hull, refined, fanGeometry } = calculateFanGeometry(imageId);
+    const { pixelData, width, height } = getPixelData(imageId) || {};
+    if (!pixelData) {
+        return;
+    }
+    let jpegDataUrl;
+    if (contourType === 1) {
+        jpegDataUrl = exportContourJpeg(pixelData, width, height, contour);
+    }
+    else if (contourType === 2) {
+        jpegDataUrl = exportContourJpeg(pixelData, width, height, simplified);
+    }
+    else if (contourType === 3) {
+        jpegDataUrl = exportContourJpeg(pixelData, width, height, hull);
+    }
+    else if (contourType === 4) {
+        jpegDataUrl = exportContourJpeg(pixelData, width, height, [
+            refined.P1,
+            refined.P2,
+            refined.P3,
+            refined.P4,
+        ]);
+    }
+    else {
+        jpegDataUrl = exportFanJpeg(pixelData, width, height, fanGeometry, {
+            strokeStyle: '#f00',
+            lineWidth: 3,
+            quality: 0.95,
+        });
+    }
+    saveBinaryData(jpegDataUrl, 'contour.jpg');
+}
+export function calculateFanGeometry(imageId) {
+    const { pixelData, width, height } = getPixelData(imageId) || {};
+    if (!pixelData) {
+        return;
+    }
+    const contour = segmentLargestUSOutlineFromBuffer(pixelData, width, height);
+    const { simplified, hull } = generateConvexHullFromContour(contour);
+    const refined = calculateFanShapeCorners(pixelData, width, height, hull, simplified);
+    const fanGeometry = deriveFanGeometry({
+        P1: refined.P1,
+        P2: refined.P2,
+        P3: refined.P3,
+        P4: refined.P4,
+    });
+    return { contour, simplified, hull, refined, fanGeometry };
+}

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/generateConvexHullFromContour.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function generateConvexHullFromContour(contour: Array<Types.Point2>): {
+    simplified: Types.Point2[];
+    hull: Types.Point2[];
+};

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/generateConvexHullFromContour.js

@@ -0,0 +1,6 @@
+import { utilities } from '@cornerstonejs/tools';
+export function generateConvexHullFromContour(contour) {
+    const simplified = utilities.math.polyline.decimate(contour, 2);
+    const hull = utilities.math.polyline.convexHull(simplified);
+    return { simplified, hull };
+}

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/segmentLargestUSOutlineFromBuffer.d.ts

@@ -0,0 +1,2 @@
+import type { FanShapeContour } from './types';
+export declare function segmentLargestUSOutlineFromBuffer(buffer: any, width: any, height: any): FanShapeContour;

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/segmentLargestUSOutlineFromBuffer.js

@@ -0,0 +1,123 @@
+import { floodFill } from '../../../../utilities/segmentation';
+export function segmentLargestUSOutlineFromBuffer(buffer, width, height) {
+    const totalPixels = width * height;
+    const channelCount = buffer.length / totalPixels;
+    if (![1, 3, 4].includes(channelCount)) {
+        throw new Error('Buffer must be 1, 3, or 4 channels per pixel');
+    }
+    const mask = Array.from({ length: height }, () => new Array(width).fill(false));
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const pixelIndex = y * width + x;
+            const base = pixelIndex * channelCount;
+            let isForeground = false;
+            for (let c = 0; c < Math.min(3, channelCount); c++) {
+                if (buffer[base + c] > 0) {
+                    isForeground = true;
+                    break;
+                }
+            }
+            mask[y][x] = isForeground;
+        }
+    }
+    const labels = Array.from({ length: height }, () => new Array(width).fill(0));
+    let currentLabel = 0;
+    const regionSizes = {};
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            if (mask[y][x] && labels[y][x] === 0) {
+                currentLabel++;
+                const getter = (px, py) => {
+                    if (px < 0 || px >= width || py < 0 || py >= height) {
+                        return false;
+                    }
+                    return mask[py][px] && labels[py][px] === 0;
+                };
+                let pixelCount = 0;
+                const options = {
+                    onFlood: (px, py) => {
+                        labels[py][px] = currentLabel;
+                        pixelCount++;
+                    },
+                    diagonals: false,
+                };
+                floodFill(getter, [x, y], options);
+                regionSizes[currentLabel] = pixelCount;
+            }
+        }
+    }
+    if (currentLabel === 0) {
+        return [];
+    }
+    const largestLabel = Object.keys(regionSizes).reduce((a, b) => regionSizes[a] > regionSizes[b] ? a : b);
+    function isBorder(x, y) {
+        if (labels[y][x] !== +largestLabel) {
+            return false;
+        }
+        for (const [dx, dy] of [
+            [1, 0],
+            [-1, 0],
+            [0, 1],
+            [0, -1],
+        ]) {
+            const nx = x + dx, ny = y + dy;
+            if (nx < 0 ||
+                nx >= width ||
+                ny < 0 ||
+                ny >= height ||
+                labels[ny][nx] !== +largestLabel) {
+                return true;
+            }
+        }
+        return false;
+    }
+    let start = null;
+    outer: for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            if (isBorder(x, y)) {
+                start = [x, y];
+                break outer;
+            }
+        }
+    }
+    if (!start) {
+        return [];
+    }
+    const dirs = [
+        [1, 0],
+        [1, 1],
+        [0, 1],
+        [-1, 1],
+        [-1, 0],
+        [-1, -1],
+        [0, -1],
+        [1, -1],
+    ];
+    const contour = [];
+    let current = start;
+    let prev = [start[0] - 1, start[1]];
+    do {
+        contour.push([current[0], current[1]]);
+        const dx0 = prev[0] - current[0], dy0 = prev[1] - current[1];
+        let startDir = dirs.findIndex((d) => d[0] === dx0 && d[1] === dy0);
+        if (startDir < 0) {
+            startDir = 0;
+        }
+        let nextPt = null;
+        for (let k = 1; k <= 8; k++) {
+            const [dx, dy] = dirs[(startDir + k) % 8];
+            const nx = current[0] + dx, ny = current[1] + dy;
+            if (nx >= 0 && nx < width && ny >= 0 && ny < height && isBorder(nx, ny)) {
+                nextPt = [nx, ny];
+                const [bdx, bdy] = dirs[(startDir + k - 1 + 8) % 8];
+                prev = [current[0] + bdx, current[1] + bdy];
+                break;
+            }
+        }
+        if (!nextPt) {
+            break;
+        }
+        current = nextPt;
+    } while (current[0] !== start[0] || current[1] !== start[1]);
+    return contour;
+}

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/utils/types.d.ts

@@ -0,0 +1,41 @@
+import type { Types } from '@cornerstonejs/core';
+export type FanShapeContour = Types.Point2[];
+export interface FanGeometry {
+    center: Types.Point2;
+    startAngle: number;
+    endAngle: number;
+    innerRadius: number;
+    outerRadius: number;
+}
+export interface ContourExportOptions {
+    strokeStyle?: string;
+    lineWidth?: number;
+    quality?: number;
+}
+export interface FanExportOptions {
+    strokeStyle?: string;
+    lineWidth?: number;
+    quality?: number;
+}
+export interface FanShapeCorners {
+    P1: Types.Point2;
+    P2: Types.Point2;
+    P3: Types.Point2;
+    P4: Types.Point2;
+}
+export interface PixelDataResult {
+    pixelData: Types.PixelDataTypedArray;
+    width: number;
+    height: number;
+}
+export interface RefinementOptions {
+    maxDist?: number;
+    step?: number;
+}
+export interface FanGeometryResult {
+    contour: FanShapeContour;
+    simplified: FanShapeContour;
+    hull: FanShapeContour;
+    refined: FanShapeCorners;
+    fanGeometry: FanGeometry;
+}

package/dist/esm/tools/index.d.ts

@@ -37,6 +37,7 @@ import ArrowAnnotateTool from './annotation/ArrowAnnotateTool';
 import AngleTool from './annotation/AngleTool';
 import CobbAngleTool from './annotation/CobbAngleTool';
 import UltrasoundDirectionalTool from './annotation/UltrasoundDirectionalTool';
+import UltrasoundPleuraBLineTool from './annotation/UltrasoundPleuraBLineTool/UltrasoundPleuraBLineTool';
 import KeyImageTool from './annotation/KeyImageTool';
 import AnnotationEraserTool from './AnnotationEraserTool';
 import RegionSegmentTool from './annotation/RegionSegmentTool';
@@ -56,4 +57,4 @@ import SegmentSelectTool from './segmentation/SegmentSelectTool';
 import SegmentBidirectionalTool from './segmentation/SegmentBidirectionalTool';
 import * as strategies from './segmentation/strategies';
 import SegmentLabelTool from './segmentation/SegmentLabelTool';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, strategies, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, strategies, };

package/dist/esm/tools/index.js

@@ -37,6 +37,7 @@ import ArrowAnnotateTool from './annotation/ArrowAnnotateTool';
 import AngleTool from './annotation/AngleTool';
 import CobbAngleTool from './annotation/CobbAngleTool';
 import UltrasoundDirectionalTool from './annotation/UltrasoundDirectionalTool';
+import UltrasoundPleuraBLineTool from './annotation/UltrasoundPleuraBLineTool/UltrasoundPleuraBLineTool';
 import KeyImageTool from './annotation/KeyImageTool';
 import AnnotationEraserTool from './AnnotationEraserTool';
 import RegionSegmentTool from './annotation/RegionSegmentTool';
@@ -56,4 +57,4 @@ import SegmentSelectTool from './segmentation/SegmentSelectTool';
 import SegmentBidirectionalTool from './segmentation/SegmentBidirectionalTool';
 import * as strategies from './segmentation/strategies';
 import SegmentLabelTool from './segmentation/SegmentLabelTool';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, strategies, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, strategies, };

package/dist/esm/types/ToolSpecificAnnotationTypes.d.ts

@@ -84,6 +84,16 @@ export interface LengthAnnotation extends Annotation {
         };
     };
 }
+export interface UltrasoundPleuraBLineAnnotation extends Annotation {
+    data: {
+        handles: {
+            points: [Types.Point3, Types.Point3];
+            activeHandleIndex: number | null;
+        };
+        annotationType: 'pleura' | 'bLine';
+        label: string;
+    };
+}
 export interface AdvancedMagnifyAnnotation extends Annotation {
     data: {
         zoomFactor: number;

package/dist/esm/utilities/index.d.ts

@@ -40,4 +40,5 @@ import * as geometricSurfaceUtils from './geometricSurfaceUtils';
 import setAnnotationLabel from './setAnnotationLabel';
 import { moveAnnotationToViewPlane } from './moveAnnotationToViewPlane';
 import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, setAnnotationLabel, moveAnnotationToViewPlane, getOrCreateImageVolume, };
+import * as usFanExtraction from '../tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, getOrCreateImageVolume, };

package/dist/esm/utilities/index.js

@@ -40,4 +40,5 @@ import * as geometricSurfaceUtils from './geometricSurfaceUtils';
 import setAnnotationLabel from './setAnnotationLabel';
 import { moveAnnotationToViewPlane } from './moveAnnotationToViewPlane';
 import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, setAnnotationLabel, moveAnnotationToViewPlane, getOrCreateImageVolume, };
+import * as usFanExtraction from '../tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, getOrCreateImageVolume, };

package/dist/esm/utilities/math/fan/fanUtils.d.ts

@@ -0,0 +1,10 @@
+import type { Types } from '@cornerstonejs/core';
+export type Interval = Types.Point2;
+export type FanPair = [Types.Point2, Types.Point2];
+export type FanPairs = FanPair[];
+export declare function angleFromCenter(center: Types.Point2, point: Types.Point2): number;
+export declare function intervalFromPoints(center: Types.Point2, pair: FanPair): Types.Point2;
+export declare function mergeIntervals(intervals: Interval[]): Interval[];
+export declare function subtractIntervals(blocked: Interval[], target: Interval): Interval[];
+export declare function clipInterval(inner: Types.Point2, outerMerged: Interval[]): Interval[];
+export declare function calculateInnerFanPercentage(center: Types.Point2, outerFanPairs: FanPairs, innerFanPairs: FanPairs): number;