@cornerstonejs/tools 3.31.10 → 3.31.12

package/dist/esm/tools/segmentation/strategies/fillCircle.d.ts

@@ -1,11 +1,8 @@
-import { vec3 } from 'gl-matrix';
 import type { Types } from '@cornerstonejs/core';
 import BrushStrategy from './BrushStrategy';
-declare function createPointInEllipse(worldInfo: {
-    topLeftWorld: Types.Point3;
-    bottomRightWorld: Types.Point3;
-    center: Types.Point3 | vec3;
-}): (pointLPS: Types.Point3) => boolean;
+import type { CanvasCoordinates } from '../../../types';
+export declare function getEllipseCornersFromCanvasCoordinates(canvasCoordinates: CanvasCoordinates): Array<Types.Point2>;
+declare function createPointInEllipse(cornersInWorld?: Types.Point3[]): (pointLPS: Types.Point3) => boolean;
 declare const CIRCLE_STRATEGY: BrushStrategy;
 declare const CIRCLE_THRESHOLD_STRATEGY: BrushStrategy;
 declare const fillInsideCircle: (enabledElement: any, operationData: any) => unknown;

package/dist/esm/tools/segmentation/strategies/fillCircle.js

@@ -1,50 +1,67 @@
 import { vec3 } from 'gl-matrix';
 import { utilities as csUtils } from '@cornerstonejs/core';
-import { getCanvasEllipseCorners, precalculatePointInEllipse, } from '../../../utilities/math/ellipse';
 import { getBoundingBoxAroundShapeIJK } from '../../../utilities/boundingBox';
 import BrushStrategy from './BrushStrategy';
 import { StrategyCallbacks } from '../../../enums';
 import compositions from './compositions';
 import { pointInSphere } from '../../../utilities/math/sphere';
 const { transformWorldToIndex, isEqual } = csUtils;
+export function getEllipseCornersFromCanvasCoordinates(canvasCoordinates) {
+    const [bottom, top, left, right] = canvasCoordinates;
+    const topLeft = [left[0], top[1]];
+    const bottomRight = [right[0], bottom[1]];
+    const bottomLeft = [left[0], bottom[1]];
+    const topRight = [right[0], top[1]];
+    return [topLeft, bottomRight, bottomLeft, topRight];
+}
 const initializeCircle = {
     [StrategyCallbacks.Initialize]: (operationData) => {
         const { points, viewport, segmentationImageData, } = operationData;
         if (!points) {
             return;
         }
-        const center = vec3.fromValues(0, 0, 0);
-        points.forEach((point) => {
-            vec3.add(center, center, point);
-        });
-        vec3.scale(center, center, 1 / points.length);
+        const center = vec3.create();
+        if (points.length >= 2) {
+            vec3.add(center, points[0], points[1]);
+            vec3.scale(center, center, 0.5);
+        }
+        else {
+            vec3.copy(center, points[0]);
+        }
         operationData.centerWorld = center;
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
         const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-        const [topLeftCanvas, bottomRightCanvas] = getCanvasEllipseCorners(canvasCoordinates);
-        const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
-        const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
+        const corners = getEllipseCornersFromCanvasCoordinates(canvasCoordinates);
+        const cornersInWorld = corners.map((corner) => viewport.canvasToWorld(corner));
         const circleCornersIJK = points.map((world) => {
             return transformWorldToIndex(segmentationImageData, world);
         });
         const boundsIJK = getBoundingBoxAroundShapeIJK(circleCornersIJK, segmentationImageData.getDimensions());
-        operationData.isInObject = createPointInEllipse({
-            topLeftWorld,
-            bottomRightWorld,
-            center,
-        });
+        operationData.isInObject = createPointInEllipse(cornersInWorld);
         operationData.isInObjectBoundsIJK = boundsIJK;
     },
 };
-function createPointInEllipse(worldInfo) {
-    const { topLeftWorld, bottomRightWorld, center } = worldInfo;
-    const xRadius = Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2;
-    const yRadius = Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2;
-    const zRadius = Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2;
-    const radius = Math.max(xRadius, yRadius, zRadius);
-    if (isEqual(xRadius, radius) &&
-        isEqual(yRadius, radius) &&
-        isEqual(zRadius, radius)) {
+function createPointInEllipse(cornersInWorld = []) {
+    if (!cornersInWorld || cornersInWorld.length !== 4) {
+        throw new Error('createPointInEllipse: cornersInWorld must have 4 points');
+    }
+    const [topLeft, bottomRight, bottomLeft, topRight] = cornersInWorld;
+    const center = vec3.create();
+    vec3.add(center, topLeft, bottomRight);
+    vec3.scale(center, center, 0.5);
+    const majorAxisVec = vec3.create();
+    vec3.subtract(majorAxisVec, topRight, topLeft);
+    const xRadius = vec3.length(majorAxisVec) / 2;
+    vec3.normalize(majorAxisVec, majorAxisVec);
+    const minorAxisVec = vec3.create();
+    vec3.subtract(minorAxisVec, bottomLeft, topLeft);
+    const yRadius = vec3.length(minorAxisVec) / 2;
+    vec3.normalize(minorAxisVec, minorAxisVec);
+    const normal = vec3.create();
+    vec3.cross(normal, majorAxisVec, minorAxisVec);
+    vec3.normalize(normal, normal);
+    if (isEqual(xRadius, yRadius)) {
+        const radius = xRadius;
         const sphereObj = {
             center,
             radius,
@@ -52,14 +69,20 @@ function createPointInEllipse(worldInfo) {
         };
         return (pointLPS) => pointInSphere(sphereObj, pointLPS);
     }
-    const ellipseObj = {
-        center: center,
-        xRadius,
-        yRadius,
-        zRadius,
+    return (pointLPS) => {
+        const pointVec = vec3.create();
+        vec3.subtract(pointVec, pointLPS, center);
+        const distToPlane = vec3.dot(pointVec, normal);
+        const proj = vec3.create();
+        vec3.scaleAndAdd(proj, pointVec, normal, -distToPlane);
+        const fromTopLeft = vec3.create();
+        const centerToTopLeft = vec3.create();
+        vec3.subtract(centerToTopLeft, center, topLeft);
+        vec3.subtract(fromTopLeft, proj, centerToTopLeft);
+        const x = vec3.dot(fromTopLeft, majorAxisVec);
+        const y = vec3.dot(fromTopLeft, minorAxisVec);
+        return (x * x) / (xRadius * xRadius) + (y * y) / (yRadius * yRadius) <= 1;
     };
-    const { precalculated } = precalculatePointInEllipse(ellipseObj, {});
-    return precalculated;
 }
 const CIRCLE_STRATEGY = new BrushStrategy('Circle', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);
 const CIRCLE_THRESHOLD_STRATEGY = new BrushStrategy('CircleThreshold', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval, compositions.labelmapStatistics);

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

@@ -1,16 +1,13 @@
 import { vec3 } from 'gl-matrix';
 import { utilities as csUtils, StackViewport } from '@cornerstonejs/core';
-import { getBoundingBoxAroundShapeIJK, getBoundingBoxAroundShapeWorld, } from '../../../utilities/boundingBox';
-import { triggerSegmentationDataModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
-import { getStrategyData } from './utils/getStrategyData';
-import { isAxisAlignedRectangle } from '../../../utilities/rectangleROITool/isAxisAlignedRectangle';
+import { getBoundingBoxAroundShapeIJK } from '../../../utilities/boundingBox';
 import BrushStrategy from './BrushStrategy';
 import { StrategyCallbacks } from '../../../enums';
 import compositions from './compositions';
 const { transformWorldToIndex } = csUtils;
 const initializeRectangle = {
     [StrategyCallbacks.Initialize]: (operationData) => {
-        const { points, imageVoxelManager, viewport, segmentationImageData, segmentationVoxelManager, } = operationData;
+        const { points, viewport, segmentationImageData, } = operationData;
         if (!points) {
             return;
         }
@@ -36,8 +33,18 @@ function createPointInRectangle(viewport, points, segmentationImageData) {
         });
     });
     const boundsIJK = getBoundingBoxAroundShapeIJK(rectangleCornersIJK, segmentationImageData.getDimensions());
-    const isStackViewport = viewport instanceof StackViewport;
-    const isAligned = isStackViewport || isAxisAlignedRectangle(rectangleCornersIJK);
+    const [p0, p1, p2, p3] = points;
+    const axisU = vec3.create();
+    const axisV = vec3.create();
+    vec3.subtract(axisU, p1, p0);
+    vec3.subtract(axisV, p3, p0);
+    const uLen = vec3.length(axisU);
+    const vLen = vec3.length(axisV);
+    vec3.normalize(axisU, axisU);
+    vec3.normalize(axisV, axisV);
+    const normal = vec3.create();
+    vec3.cross(normal, axisU, axisV);
+    vec3.normalize(normal, normal);
     const direction = segmentationImageData.getDirection();
     const spacing = segmentationImageData.getSpacing();
     const { viewPlaneNormal } = viewport.getCamera();
@@ -45,23 +52,18 @@ function createPointInRectangle(viewport, points, segmentationImageData) {
         direction,
         spacing,
     }, viewPlaneNormal);
-    const pointsBoundsLPS = getBoundingBoxAroundShapeWorld(points);
-    let [[xMin, xMax], [yMin, yMax], [zMin, zMax]] = pointsBoundsLPS;
-    xMin -= EPS;
-    xMax += EPS;
-    yMin -= EPS;
-    yMax += EPS;
-    zMin -= EPS;
-    zMax += EPS;
-    const pointInShapeFn = isAligned
-        ? () => true
-        : (pointLPS) => {
-            const [x, y, z] = pointLPS;
-            const xInside = x >= xMin && x <= xMax;
-            const yInside = y >= yMin && y <= yMax;
-            const zInside = z >= zMin && z <= zMax;
-            return xInside && yInside && zInside;
-        };
+    const pointInShapeFn = (pointLPS) => {
+        const v = vec3.create();
+        vec3.subtract(v, pointLPS, p0);
+        const u = vec3.dot(v, axisU);
+        const vproj = vec3.dot(v, axisV);
+        const d = Math.abs(vec3.dot(v, normal));
+        return (u >= -EPS &&
+            u <= uLen + EPS &&
+            vproj >= -EPS &&
+            vproj <= vLen + EPS &&
+            d <= EPS);
+    };
     return { boundsIJK, pointInShapeFn };
 }
 const RECTANGLE_STRATEGY = new BrushStrategy('Rectangle', compositions.regionFill, compositions.setValue, initializeRectangle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);

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

@@ -3,7 +3,7 @@ import { vec3 } from 'gl-matrix';
 import BrushStrategy from './BrushStrategy';
 import compositions from './compositions';
 import StrategyCallbacks from '../../../enums/StrategyCallbacks';
-import { createEllipseInPoint } from './fillCircle';
+import { createEllipseInPoint, getEllipseCornersFromCanvasCoordinates, } from './fillCircle';
 const { transformWorldToIndex } = csUtils;
 import { getSphereBoundsInfoFromViewport } from '../../../utilities/getSphereBoundsInfo';
 const sphereComposition = {
@@ -12,20 +12,22 @@ const sphereComposition = {
         if (!points) {
             return;
         }
-        const center = vec3.fromValues(0, 0, 0);
-        points.forEach((point) => {
-            vec3.add(center, center, point);
-        });
-        vec3.scale(center, center, 1 / points.length);
+        const center = vec3.create();
+        if (points.length >= 2) {
+            vec3.add(center, points[0], points[1]);
+            vec3.scale(center, center, 0.5);
+        }
+        else {
+            vec3.copy(center, points[0]);
+        }
         operationData.centerWorld = center;
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
-        const { boundsIJK: newBoundsIJK, topLeftWorld, bottomRightWorld, } = getSphereBoundsInfoFromViewport(points.slice(0, 2), segmentationImageData, viewport);
+        const { boundsIJK: newBoundsIJK } = getSphereBoundsInfoFromViewport(points.slice(0, 2), segmentationImageData, viewport);
+        const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+        const corners = getEllipseCornersFromCanvasCoordinates(canvasCoordinates);
+        const cornersInWorld = corners.map((corner) => viewport.canvasToWorld(corner));
         operationData.isInObjectBoundsIJK = newBoundsIJK;
-        operationData.isInObject = createEllipseInPoint({
-            topLeftWorld,
-            bottomRightWorld,
-            center,
-        });
+        operationData.isInObject = createEllipseInPoint(cornersInWorld);
     },
 };
 const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics, compositions.ensureSegmentationVolumeFor3DManipulation);

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.31.10";
+export declare const version = "3.31.12";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.31.10';
+export const version = '3.31.12';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.31.10",
+  "version": "3.31.12",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "^3.1.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.31.10",
+    "@cornerstonejs/core": "^3.31.12",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "df57f1e6505d3e058dbe3d9715da2d2cba89fe5a"
+  "gitHead": "56d8740d4fc313de859611b51e1d10b42cc6ffa1"
 }