@cornerstonejs/tools 3.0.2 → 3.0.3

package/dist/esm/utilities/livewire/LiveWirePath.d.ts

@@ -0,0 +1,19 @@
+import type { Types } from '@cornerstonejs/core';
+export declare class LivewirePath {
+    pointArray: Types.Point2[];
+    private _controlPointIndexes;
+    constructor(inputPointArray?: Types.Point2[], inputControlPointIndexArray?: number[]);
+    getPoint(index: number): Types.Point2;
+    getLastPoint(): Types.Point2;
+    isControlPoint(point: Types.Point2): boolean;
+    addPoint(point: Types.Point2): void;
+    addControlPoint(point: Types.Point2): void;
+    getControlPoints(): Types.Point2[];
+    getNumControlPoints(): number;
+    removeLastControlPoint(): void;
+    getLastControlPoint(): Types.Point2;
+    removeLastPoints(count: number): void;
+    addPoints(newPointArray: Types.Point2[]): void;
+    prependPath(other: LivewirePath): void;
+    appendPath(other: LivewirePath): void;
+}

package/dist/esm/utilities/livewire/LiveWirePath.js

@@ -0,0 +1,71 @@
+export class LivewirePath {
+    constructor(inputPointArray, inputControlPointIndexArray) {
+        this.pointArray = inputPointArray ? inputPointArray.slice() : [];
+        this._controlPointIndexes = inputControlPointIndexArray
+            ? inputControlPointIndexArray.slice()
+            : [];
+    }
+    getPoint(index) {
+        return this.pointArray[index];
+    }
+    getLastPoint() {
+        return this.pointArray[this.pointArray.length - 1];
+    }
+    isControlPoint(point) {
+        const index = this.pointArray.indexOf(point);
+        if (index !== -1) {
+            return this._controlPointIndexes.indexOf(index) !== -1;
+        }
+        else {
+            throw new Error('Error: isControlPoint called with not in list point.');
+        }
+    }
+    addPoint(point) {
+        this.pointArray.push(point);
+    }
+    addControlPoint(point) {
+        const index = this.pointArray.indexOf(point);
+        if (index !== -1) {
+            this._controlPointIndexes.push(index);
+        }
+        else {
+            throw new Error('Cannot mark a non registered point as control point.');
+        }
+    }
+    getControlPoints() {
+        return this._controlPointIndexes.map((i) => this.pointArray[i]);
+    }
+    getNumControlPoints() {
+        return this._controlPointIndexes.length;
+    }
+    removeLastControlPoint() {
+        if (this._controlPointIndexes.length) {
+            this._controlPointIndexes.pop();
+        }
+    }
+    getLastControlPoint() {
+        if (this._controlPointIndexes.length) {
+            return this.pointArray[this._controlPointIndexes[this._controlPointIndexes.length - 1]];
+        }
+    }
+    removeLastPoints(count) {
+        this.pointArray.splice(this.pointArray.length - count, count);
+    }
+    addPoints(newPointArray) {
+        this.pointArray = this.pointArray.concat(newPointArray);
+    }
+    prependPath(other) {
+        const otherSize = other.pointArray.length;
+        const shiftedIndexArray = [];
+        this.pointArray = other.pointArray.concat(this.pointArray);
+        for (let i = 0; i < this._controlPointIndexes.length; ++i) {
+            shiftedIndexArray[i] = this._controlPointIndexes[i] + otherSize;
+        }
+        this._controlPointIndexes =
+            other._controlPointIndexes.concat(shiftedIndexArray);
+    }
+    appendPath(other) {
+        this.addPoints(other.pointArray);
+        other._controlPointIndexes.forEach((point) => this._controlPointIndexes.push(point));
+    }
+}

package/dist/esm/utilities/livewire/LivewireScissors.d.ts

@@ -0,0 +1,38 @@
+import type { Types } from '@cornerstonejs/core';
+export declare class LivewireScissors {
+    private searchGranularityBits;
+    private searchGranularity;
+    readonly width: number;
+    readonly height: number;
+    private grayscalePixelData;
+    private laplace;
+    private gradMagnitude;
+    private gradXNew;
+    private gradYNew;
+    private startPoint;
+    private visited;
+    private parents;
+    private costs;
+    private priorityQueueNew;
+    constructor(grayscalePixelData: Types.PixelDataTypedArray, width: number, height: number);
+    startSearch(startPoint: Types.Point2): void;
+    findMinNearby(testPoint: Types.Point2, delta?: number): Types.Point2;
+    findPathToPoint(targetPoint: Types.Point2): Types.Point2[];
+    private _getPointIndex;
+    private _getPointCoordinate;
+    private _getDeltaX;
+    private _getDeltaY;
+    private _getGradientMagnitude;
+    private _getLaplace;
+    private _computeGradient;
+    private _computeLaplace;
+    private _computeGradientX;
+    private _computeGradientY;
+    private _getGradientUnitVector;
+    private _getGradientDirection;
+    getCost(pointA: any, pointB: any): number;
+    private _getWeightedDistance;
+    private _getNeighborPoints;
+    private _getPointCost;
+    static createInstanceFromRawPixelData(pixelData: Float32Array, width: number, height: number, voiRange: Types.VOIRange): LivewireScissors;
+}

package/dist/esm/utilities/livewire/LivewireScissors.js

@@ -0,0 +1,305 @@
+import { utilities } from '@cornerstonejs/core';
+import { BucketQueue } from '../BucketQueue';
+const { isEqual } = utilities;
+const MAX_UINT32 = 4294967295;
+const TWO_THIRD_PI = 2 / (3 * Math.PI);
+export class LivewireScissors {
+    constructor(grayscalePixelData, width, height) {
+        this._getPointIndex = (row, col) => {
+            const { width } = this;
+            return row * width + col;
+        };
+        this._getPointCoordinate = (index) => {
+            const x = index % this.width;
+            const y = Math.floor(index / this.width);
+            return [x, y];
+        };
+        this._getPointCost = (pointIndex) => {
+            return Math.round(this.searchGranularity * this.costs[pointIndex]);
+        };
+        const numPixels = grayscalePixelData.length;
+        this.searchGranularityBits = 8;
+        this.searchGranularity = 1 << this.searchGranularityBits;
+        this.width = width;
+        this.height = height;
+        this.grayscalePixelData = grayscalePixelData;
+        this.laplace = null;
+        this.gradXNew = null;
+        this.gradYNew = null;
+        this.laplace = this._computeLaplace();
+        this.gradMagnitude = this._computeGradient();
+        this.gradXNew = this._computeGradientX();
+        this.gradYNew = this._computeGradientY();
+        this.visited = new Array(numPixels);
+        this.parents = new Uint32Array(numPixels);
+        this.costs = new Float32Array(numPixels);
+    }
+    startSearch(startPoint) {
+        const startPointIndex = this._getPointIndex(startPoint[1], startPoint[0]);
+        this.startPoint = null;
+        this.visited.fill(false);
+        this.parents.fill(MAX_UINT32);
+        this.costs.fill(Infinity);
+        this.priorityQueueNew = new BucketQueue({
+            numBits: this.searchGranularityBits,
+            getPriority: this._getPointCost,
+        });
+        this.startPoint = startPoint;
+        this.costs[startPointIndex] = 0;
+        this.priorityQueueNew.push(startPointIndex);
+    }
+    findMinNearby(testPoint, delta = 2) {
+        const [x, y] = testPoint;
+        const { costs } = this;
+        const xRange = [
+            Math.max(0, x - delta),
+            Math.min(x + delta + 1, this.width),
+        ];
+        const yRange = [
+            Math.max(0, y - delta),
+            Math.min(y + delta + 1, this.height),
+        ];
+        let minValue = costs[this._getPointIndex(y, x)] * 0.8;
+        let minPoint = testPoint;
+        for (let xTest = xRange[0]; xTest < xRange[1]; xTest++) {
+            for (let yTest = yRange[0]; yTest < yRange[1]; yTest++) {
+                const distanceCost = 1 -
+                    (Math.abs(xTest - testPoint[0]) + Math.abs(yTest - testPoint[1])) /
+                        delta /
+                        2;
+                const weightCost = costs[this._getPointIndex(yTest, xTest)];
+                const weight = weightCost * 0.8 + distanceCost * 0.2;
+                if (weight < minValue) {
+                    minPoint = [xTest, yTest];
+                    minValue = weight;
+                }
+            }
+        }
+        return minPoint;
+    }
+    findPathToPoint(targetPoint) {
+        if (!this.startPoint) {
+            throw new Error('There is no search in progress');
+        }
+        const { startPoint, _getPointIndex: index, _getPointCoordinate: coord, } = this;
+        const startPointIndex = index(startPoint[1], startPoint[0]);
+        const targetPointIndex = index(targetPoint[1], targetPoint[0]);
+        const { visited: visited, parents: parents, costs: cost, priorityQueueNew: priorityQueue, } = this;
+        if (targetPointIndex === startPointIndex) {
+            return [];
+        }
+        while (!priorityQueue.isEmpty() &&
+            parents[targetPointIndex] === MAX_UINT32) {
+            const pointIndex = priorityQueue.pop();
+            if (visited[pointIndex]) {
+                continue;
+            }
+            const point = coord(pointIndex);
+            const neighborsPoints = this._getNeighborPoints(point);
+            visited[pointIndex] = true;
+            for (let i = 0, len = neighborsPoints.length; i < len; i++) {
+                const neighborPoint = neighborsPoints[i];
+                const neighborPointIndex = index(neighborPoint[1], neighborPoint[0]);
+                const dist = this._getWeightedDistance(point, neighborPoint);
+                const neighborCost = cost[pointIndex] + dist;
+                if (neighborCost < cost[neighborPointIndex]) {
+                    if (cost[neighborPointIndex] !== Infinity) {
+                        priorityQueue.remove(neighborPointIndex);
+                    }
+                    cost[neighborPointIndex] = neighborCost;
+                    parents[neighborPointIndex] = pointIndex;
+                    priorityQueue.push(neighborPointIndex);
+                }
+            }
+        }
+        const pathPoints = [];
+        let pathPointIndex = targetPointIndex;
+        while (pathPointIndex !== MAX_UINT32) {
+            pathPoints.push(coord(pathPointIndex));
+            pathPointIndex = parents[pathPointIndex];
+        }
+        return pathPoints.reverse();
+    }
+    _getDeltaX(x, y) {
+        const { grayscalePixelData: data, width } = this;
+        let index = this._getPointIndex(y, x);
+        if (x + 1 === width) {
+            index--;
+        }
+        return data[index + 1] - data[index];
+    }
+    _getDeltaY(x, y) {
+        const { grayscalePixelData: data, width, height } = this;
+        let index = this._getPointIndex(y, x);
+        if (y + 1 === height) {
+            index -= width;
+        }
+        return data[index] - data[index + width];
+    }
+    _getGradientMagnitude(x, y) {
+        const dx = this._getDeltaX(x, y);
+        const dy = this._getDeltaY(x, y);
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    _getLaplace(x, y) {
+        const { grayscalePixelData: data, _getPointIndex: index } = this;
+        const p02 = data[index(y - 2, x)];
+        const p11 = data[index(y - 1, x - 1)];
+        const p12 = data[index(y - 1, x)];
+        const p13 = data[index(y - 1, x + 1)];
+        const p20 = data[index(y, x - 2)];
+        const p21 = data[index(y, x - 1)];
+        const p22 = data[index(y, x)];
+        const p23 = data[index(y, x + 1)];
+        const p24 = data[index(y, x + 2)];
+        const p31 = data[index(y + 1, x - 1)];
+        const p32 = data[index(y + 1, x)];
+        const p33 = data[index(y + 1, x + 1)];
+        const p42 = data[index(y + 2, x)];
+        let lap = p02;
+        lap += p11 + 2 * p12 + p13;
+        lap += p20 + 2 * p21 - 16 * p22 + 2 * p23 + p24;
+        lap += p31 + 2 * p32 + p33;
+        lap += p42;
+        return lap;
+    }
+    _computeGradient() {
+        const { width, height } = this;
+        const gradient = new Float32Array(width * height);
+        let pixelIndex = 0;
+        let max = 0;
+        let x = 0;
+        let y = 0;
+        for (y = 0; y < height - 1; y++) {
+            for (x = 0; x < width - 1; x++) {
+                gradient[pixelIndex] = this._getGradientMagnitude(x, y);
+                max = Math.max(gradient[pixelIndex], max);
+                pixelIndex++;
+            }
+            gradient[pixelIndex] = gradient[pixelIndex - 1];
+            pixelIndex++;
+        }
+        for (let len = gradient.length; pixelIndex < len; pixelIndex++) {
+            gradient[pixelIndex] = gradient[pixelIndex - width];
+        }
+        for (let i = 0, len = gradient.length; i < len; i++) {
+            gradient[i] = 1 - gradient[i] / max;
+        }
+        return gradient;
+    }
+    _computeLaplace() {
+        const { width, height, _getPointIndex: index } = this;
+        const laplace = new Float32Array(width * height);
+        laplace.fill(1, 0, index(2, 0));
+        for (let y = 2; y < height - 2; y++) {
+            laplace[index(y, 0)] = 1;
+            laplace[index(y, 1)] = 1;
+            for (let x = 2; x < width - 2; x++) {
+                laplace[index(y, x)] = this._getLaplace(x, y) > 0.33 ? 0 : 1;
+            }
+            laplace[index(y, width - 2)] = 1;
+            laplace[index(y, width - 1)] = 1;
+        }
+        laplace.fill(1, index(height - 2, 0));
+        return laplace;
+    }
+    _computeGradientX() {
+        const { width, height } = this;
+        const gradX = new Float32Array(width * height);
+        let pixelIndex = 0;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                gradX[pixelIndex++] = this._getDeltaX(x, y);
+            }
+        }
+        return gradX;
+    }
+    _computeGradientY() {
+        const { width, height } = this;
+        const gradY = new Float32Array(width * height);
+        let pixelIndex = 0;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                gradY[pixelIndex++] = this._getDeltaY(x, y);
+            }
+        }
+        return gradY;
+    }
+    _getGradientUnitVector(px, py) {
+        const { gradXNew, gradYNew, _getPointIndex: index } = this;
+        const pointGradX = gradXNew[index(py, px)];
+        const pointGradY = gradYNew[index(py, px)];
+        let gradVecLen = Math.sqrt(pointGradX * pointGradX + pointGradY * pointGradY);
+        gradVecLen = Math.max(gradVecLen, 1e-100);
+        return [pointGradX / gradVecLen, pointGradY / gradVecLen];
+    }
+    _getGradientDirection(px, py, qx, qy) {
+        const dgpUnitVec = this._getGradientUnitVector(px, py);
+        const gdqUnitVec = this._getGradientUnitVector(qx, qy);
+        let dp = dgpUnitVec[1] * (qx - px) - dgpUnitVec[0] * (qy - py);
+        let dq = gdqUnitVec[1] * (qx - px) - gdqUnitVec[0] * (qy - py);
+        if (dp < 0) {
+            dp = -dp;
+            dq = -dq;
+        }
+        if (px !== qx && py !== qy) {
+            dp *= Math.SQRT1_2;
+            dq *= Math.SQRT1_2;
+        }
+        dq = Math.min(Math.max(dq, -1), 1);
+        const direction = TWO_THIRD_PI * (Math.acos(Math.min(dp, 1)) + Math.acos(dq));
+        if (isNaN(direction) || !isFinite(direction)) {
+            console.warn('Found non-direction:', px, py, qx, qy, dp, dq, direction);
+            return 1;
+        }
+        return direction;
+    }
+    getCost(pointA, pointB) {
+        return this._getWeightedDistance(pointA, pointB);
+    }
+    _getWeightedDistance(pointA, pointB) {
+        const { _getPointIndex: index, width, height } = this;
+        const [aX, aY] = pointA;
+        const [bX, bY] = pointB;
+        if (bX < 0 || bX >= width || bY < 0 || bY >= height) {
+            return 1;
+        }
+        if (aX < 0 || aY < 0 || aX >= width || aY >= height) {
+            return 0;
+        }
+        const bIndex = index(bY, bX);
+        let gradient = this.gradMagnitude[bIndex];
+        if (aX === bX || aY === bY) {
+            gradient *= Math.SQRT1_2;
+        }
+        const laplace = this.laplace[bIndex];
+        const direction = this._getGradientDirection(aX, aY, bX, bY);
+        return 0.43 * gradient + 0.43 * laplace + 0.11 * direction;
+    }
+    _getNeighborPoints(point) {
+        const { width, height } = this;
+        const list = [];
+        const sx = Math.max(point[0] - 1, 0);
+        const sy = Math.max(point[1] - 1, 0);
+        const ex = Math.min(point[0] + 1, width - 1);
+        const ey = Math.min(point[1] + 1, height - 1);
+        for (let y = sy; y <= ey; y++) {
+            for (let x = sx; x <= ex; x++) {
+                if (x !== point[0] || y !== point[1]) {
+                    list.push([x, y]);
+                }
+            }
+        }
+        return list;
+    }
+    static createInstanceFromRawPixelData(pixelData, width, height, voiRange) {
+        const numPixels = pixelData.length;
+        const grayscalePixelData = new Float32Array(numPixels);
+        const { lower: minPixelValue, upper: maxPixelValue } = voiRange;
+        const pixelRange = maxPixelValue - minPixelValue;
+        for (let i = 0, len = pixelData.length; i < len; i++) {
+            grayscalePixelData[i] = Math.max(0, Math.min(1, (pixelData[i] - minPixelValue) / pixelRange));
+        }
+        return new LivewireScissors(grayscalePixelData, width, height);
+    }
+}

package/dist/esm/utilities/math/aabb/distanceToPoint.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function distanceToPoint(aabb: Types.AABB2, point: Types.Point2): number;

package/dist/esm/utilities/math/aabb/distanceToPoint.js

@@ -0,0 +1,4 @@
+import distanceToPointSquared from './distanceToPointSquared';
+export default function distanceToPoint(aabb, point) {
+    return Math.sqrt(distanceToPointSquared(aabb, point));
+}

package/dist/esm/utilities/math/aabb/distanceToPointSquared.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function distanceToPointSquared(aabb: Types.AABB2, point: Types.Point2): number;

package/dist/esm/utilities/math/aabb/distanceToPointSquared.js

@@ -0,0 +1,20 @@
+export default function distanceToPointSquared(aabb, point) {
+    const aabbWidth = aabb.maxX - aabb.minX;
+    const aabbHeight = aabb.maxY - aabb.minY;
+    const aabbSize = [aabbWidth, aabbHeight];
+    const aabbCenter = [
+        aabb.minX + aabbWidth / 2,
+        aabb.minY + aabbHeight / 2,
+    ];
+    const translatedPoint = [
+        Math.abs(point[0] - aabbCenter[0]),
+        Math.abs(point[1] - aabbCenter[1]),
+    ];
+    const dx = translatedPoint[0] - aabbSize[0] * 0.5;
+    const dy = translatedPoint[1] - aabbSize[1] * 0.5;
+    if (dx > 0 && dy > 0) {
+        return dx * dx + dy * dy;
+    }
+    const dist = Math.max(dx, 0) + Math.max(dy, 0);
+    return dist * dist;
+}

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

@@ -0,0 +1,3 @@
+export { default as intersectAABB } from './intersectAABB';
+export { default as distanceToPoint } from './distanceToPoint';
+export { default as distanceToPointSquared } from './distanceToPointSquared';

package/dist/esm/utilities/math/aabb/index.js

@@ -0,0 +1,3 @@
+export { default as intersectAABB } from './intersectAABB';
+export { default as distanceToPoint } from './distanceToPoint';
+export { default as distanceToPointSquared } from './distanceToPointSquared';

package/dist/esm/utilities/math/aabb/intersectAABB.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function intersectAABB(aabb1: Types.AABB2, aabb2: Types.AABB2): boolean;

package/dist/esm/utilities/math/aabb/intersectAABB.js

@@ -0,0 +1,6 @@
+export default function intersectAABB(aabb1, aabb2) {
+    return (aabb1.minX <= aabb2.maxX &&
+        aabb1.maxX >= aabb2.minX &&
+        aabb1.minY <= aabb2.maxY &&
+        aabb1.maxY >= aabb2.minY);
+}

package/dist/esm/utilities/math/angle/angleBetweenLines.d.ts

@@ -0,0 +1,6 @@
+import type { Types } from '@cornerstonejs/core';
+type Line2D = [Types.Point2, Types.Point2];
+type Line3D = [Types.Point3, Types.Point3];
+type Line = Line2D | Line3D;
+export default function angleBetweenLines(line1: Line, line2: Line): number;
+export {};

package/dist/esm/utilities/math/angle/angleBetweenLines.js

@@ -0,0 +1,30 @@
+import { vec2, vec3 } from 'gl-matrix';
+function angleBetween3DLines(line1, line2) {
+    const [p1, p2] = line1;
+    const [p3, p4] = line2;
+    const v1 = vec3.sub(vec3.create(), p2, p1);
+    const v2 = vec3.sub(vec3.create(), p3, p4);
+    const dot = vec3.dot(v1, v2);
+    const v1Length = vec3.length(v1);
+    const v2Length = vec3.length(v2);
+    const cos = dot / (v1Length * v2Length);
+    const radian = Math.acos(cos);
+    return (radian * 180) / Math.PI;
+}
+function angleBetween2DLines(line1, line2) {
+    const [p1, p2] = line1;
+    const [p3, p4] = line2;
+    const v1 = vec2.sub(vec2.create(), p2, p1);
+    const v2 = vec2.sub(vec2.create(), p3, p4);
+    const dot = vec2.dot(v1, v2);
+    const v1Length = vec2.length(v1);
+    const v2Length = vec2.length(v2);
+    const cos = dot / (v1Length * v2Length);
+    return Math.acos(cos) * (180 / Math.PI);
+}
+export default function angleBetweenLines(line1, line2) {
+    const is3D = line1[0].length === 3;
+    return is3D
+        ? angleBetween3DLines(line1, line2)
+        : angleBetween2DLines(line1, line2);
+}

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

@@ -0,0 +1,2 @@
+import angleBetweenLines from './angleBetweenLines';
+export { angleBetweenLines };

package/dist/esm/utilities/math/angle/index.js

@@ -0,0 +1,2 @@
+import angleBetweenLines from './angleBetweenLines';
+export { angleBetweenLines };

package/dist/esm/utilities/math/basic/BasicStatsCalculator.d.ts

@@ -0,0 +1,26 @@
+import type { NamedStatistics } from '../../../types';
+import Calculator from './Calculator';
+export default class BasicStatsCalculator extends Calculator {
+    private static max;
+    private static min;
+    private static sum;
+    private static count;
+    private static maxIJK;
+    private static maxLPS;
+    private static minIJK;
+    private static minLPS;
+    private static runMean;
+    private static m2;
+    private static pointsInShape;
+    static statsInit(options: {
+        storePointData: boolean;
+    }): void;
+    static statsCallback: ({ value: newValue, pointLPS, pointIJK, }: {
+        value: any;
+        pointLPS?: any;
+        pointIJK?: any;
+    }) => void;
+    static getStatistics: (options?: {
+        unit: string;
+    }) => NamedStatistics;
+}