@cornerstonejs/polymorphic-segmentation 3.22.0 → 3.22.2

package/dist/esm/Contour/utils/createAndAddContourSegmentationsFromClippedSurfaces.js

@@ -1,11 +1,104 @@
 import { utilities } from '@cornerstonejs/core';
 import { PlanarFreehandContourSegmentationTool, annotation, } from '@cornerstonejs/tools';
+import { vec3 } from 'gl-matrix';
+function findBestContourForNormalCalculation(lines, minPreferredPoints = 3) {
+    let bestContourIndex = 0;
+    let bestCount = 0;
+    let currentIndex = 0;
+    while (currentIndex < lines.length) {
+        const count = lines[currentIndex];
+        if (count < 2) {
+            currentIndex += count + 1;
+            continue;
+        }
+        if (count > minPreferredPoints && bestCount <= minPreferredPoints) {
+            bestContourIndex = currentIndex;
+            bestCount = count;
+            break;
+        }
+        else if (count > bestCount) {
+            bestContourIndex = currentIndex;
+            bestCount = count;
+        }
+        currentIndex += count + 1;
+    }
+    if (bestCount < 2) {
+        return null;
+    }
+    const pointIndices = lines.slice(bestContourIndex + 1, bestContourIndex + 1 + bestCount);
+    return {
+        contourIndex: bestContourIndex,
+        pointCount: bestCount,
+        pointIndices,
+    };
+}
+function isPolylineParallelToPlane(lines, points, planeNormal, dotProductTolerance = 0.99) {
+    const bestContour = findBestContourForNormalCalculation(lines);
+    if (!bestContour) {
+        return false;
+    }
+    const { pointCount: count, pointIndices: ids } = bestContour;
+    const _p_v1 = vec3.create();
+    const _p_v2 = vec3.create();
+    const _p_p0 = vec3.create();
+    const _p_p1 = vec3.create();
+    const _p_p2 = vec3.create();
+    const _p_polylineNormal = vec3.create();
+    const _p_planeNormal = vec3.create();
+    vec3.set(_p_p0, points[ids[0] * 3], points[ids[0] * 3 + 1], points[ids[0] * 3 + 2]);
+    let p1_found = false;
+    for (let i = 1; i < count; i++) {
+        vec3.set(_p_p1, points[ids[i] * 3], points[ids[i] * 3 + 1], points[ids[i] * 3 + 2]);
+        if (!vec3.equals(_p_p0, _p_p1)) {
+            p1_found = true;
+            break;
+        }
+    }
+    if (!p1_found) {
+        return false;
+    }
+    vec3.subtract(_p_v1, _p_p1, _p_p0);
+    let p2_found = false;
+    for (let i = 2; i < count; i++) {
+        vec3.set(_p_p2, points[ids[i] * 3], points[ids[i] * 3 + 1], points[ids[i] * 3 + 2]);
+        vec3.subtract(_p_v2, _p_p2, _p_p0);
+        vec3.cross(_p_polylineNormal, _p_v1, _p_v2);
+        if (vec3.length(_p_polylineNormal) > 1e-6) {
+            p2_found = true;
+            break;
+        }
+    }
+    vec3.normalize(_p_planeNormal, planeNormal);
+    if (p2_found) {
+        vec3.normalize(_p_polylineNormal, _p_polylineNormal);
+        const dot = vec3.dot(_p_polylineNormal, _p_planeNormal);
+        return Math.abs(dot) >= dotProductTolerance;
+    }
+    else {
+        vec3.normalize(_p_v1, _p_v1);
+        const dot = vec3.dot(_p_v1, _p_planeNormal);
+        return Math.abs(dot) >= dotProductTolerance;
+    }
+}
 const { addAnnotation } = annotation.state;
 export function createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId) {
     const annotationUIDsMap = new Map();
+    if (!viewport) {
+        console.warn('Invalid viewport given');
+        return;
+    }
+    const camera = viewport.getCamera();
+    if (!camera) {
+        console.warn('Camera not available in viewport');
+        return;
+    }
+    const planeNormal = camera.viewPlaneNormal;
     for (const [segmentIndex, contoursData] of rawContourData) {
         for (const contourData of contoursData) {
-            const { points } = contourData;
+            const { points, lines } = contourData;
+            if (!isPolylineParallelToPlane(lines, points, planeNormal)) {
+                continue;
+            }
             const { lineSegments, linesNumberOfPoints } = _extractLineSegments(contourData);
             for (let i = 0; i < lineSegments.length; i++) {
                 const line = lineSegments[i];

package/dist/esm/Contour/utils/extractContourData.js

@@ -1,5 +1,8 @@
 export function extractContourData(polyDataCache) {
     const rawResults = new Map();
+    if (!polyDataCache) {
+        return rawResults;
+    }
     for (const [segmentIndex, intersectionInfo] of polyDataCache) {
         const segmentIndexNumber = Number(segmentIndex);
         for (const [_, result] of intersectionInfo) {

package/dist/esm/Surface/convertContourToSurface.js

@@ -15,6 +15,9 @@ export async function convertContourToSurface(contourRepresentationData, segment
     const polylines = [];
     const numPointsArray = [];
     const annotationUIDs = annotationUIDsMap.get(segmentIndex);
+    if (!annotationUIDs) {
+        return;
+    }
     for (const annotationUID of annotationUIDs) {
         const annotation = getAnnotation(annotationUID);
         const { polyline } = annotation.data.contour;

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.22.0";
+export declare const version = "3.22.2";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.22.0';
+export const version = '3.22.2';

package/dist/esm/workers/polySegConverters.js

@@ -348,7 +348,7 @@ const polySegConverters = {
                         continue;
                     }
                     surfacePolyData.getPoints().setData(points, 3);
-                    surfacePolyData.getPolys().setData(polys, 3);
+                    surfacePolyData.getPolys().setData(polys);
                     surfacePolyData.modified();
                     cutter.setInputData(surfacePolyData);
                     plane1.setOrigin(origin);
@@ -361,18 +361,34 @@ const polySegConverters = {
                         continue;
                     }
                     const polyData = cutter.getOutputData();
+                    if (!polyData ||
+                        !polyData.getPoints() ||
+                        polyData.getPoints().getNumberOfPoints() === 0) {
+                        continue;
+                    }
                     const cutterOutput = polyData;
                     cutterOutput.buildLinks();
                     const loopExtraction = vtkContourLoopExtraction.newInstance();
                     loopExtraction.setInputData(cutterOutput);
-                    const loopOutput = loopExtraction.getOutputData();
-                    if (polyData) {
-                        polyDataResults.set(segmentIndex, {
-                            points: loopOutput.getPoints().getData(),
-                            lines: loopOutput.getLines().getData(),
-                            numberOfCells: loopOutput.getLines().getNumberOfCells(),
-                            segmentIndex,
-                        });
+                    try {
+                        loopExtraction.update();
+                        const loopOutput = loopExtraction.getOutputData();
+                        if (loopOutput &&
+                            loopOutput.getPoints() &&
+                            loopOutput.getLines() &&
+                            loopOutput.getPoints().getNumberOfPoints() > 0 &&
+                            loopOutput.getLines().getNumberOfCells() > 0) {
+                            polyDataResults.set(segmentIndex, {
+                                points: loopOutput.getPoints().getData(),
+                                lines: loopOutput.getLines().getData(),
+                                numberOfCells: loopOutput.getLines().getNumberOfCells(),
+                                segmentIndex,
+                            });
+                        }
+                    }
+                    catch (loopError) {
+                        console.warn('Error during loop extraction:', loopError);
+                        continue;
                     }
                 }
                 progressCallback({ progress: (index + 1) / numberOfPlanes });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/polymorphic-segmentation",
-  "version": "3.22.0",
+  "version": "3.22.2",
   "description": "Polymorphic Segmentation utility for Cornerstone3D",
   "files": [
     "dist"
@@ -54,9 +54,9 @@
     "@icr/polyseg-wasm": "0.4.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.22.0",
-    "@cornerstonejs/tools": "^3.22.0",
+    "@cornerstonejs/core": "^3.22.2",
+    "@cornerstonejs/tools": "^3.22.2",
     "@kitware/vtk.js": "32.12.1"
   },
-  "gitHead": "eae87d19be6d8bcdb00fa14fc747ab61ede54e1e"
+  "gitHead": "3d92fc6b7bb0483ba2a648a3207e3d29697690f0"
 }