@cornerstonejs/tools 3.10.31 → 3.11.1

package/dist/esm/config.d.ts

@@ -3,12 +3,23 @@ import type { Types } from '@cornerstonejs/core';
 import type { LabelmapSegmentationData } from './types/LabelmapTypes';
 import type { SurfaceSegmentationData } from './types/SurfaceTypes';
 import type SegmentationRepresentations from './enums/SegmentationRepresentations';
+export type SurfacesInfo = {
+    id: string;
+    points: number[];
+    polys: number[];
+    segmentIndex: number;
+};
 export type PolySegConversionOptions = {
     segmentIndices?: number[];
     segmentationId?: string;
     viewport?: Types.IStackViewport | Types.IVolumeViewport;
 };
 type ComputeRepresentationFn<T> = (segmentationId: string, options: PolySegConversionOptions) => Promise<T>;
+export type SurfaceClipResult = {
+    points: number[];
+    lines: number[];
+    numberOfCells: number;
+};
 type PolySegAddOn = {
     canComputeRequestedRepresentation: (segmentationId: string, representationType: SegmentationRepresentations) => boolean;
     init: () => void;
@@ -16,6 +27,9 @@ type PolySegAddOn = {
     computeLabelmapData: ComputeRepresentationFn<LabelmapSegmentationData>;
     computeSurfaceData: ComputeRepresentationFn<SurfaceSegmentationData>;
     updateSurfaceData: ComputeRepresentationFn<SurfaceSegmentationData>;
+    clipAndCacheSurfacesForViewport: (surfacesInfo: SurfacesInfo[], viewport: Types.IVolumeViewport) => Promise<Map<number, Map<string, SurfaceClipResult>>>;
+    extractContourData: (polyDataCache: Map<number, Map<string, SurfaceClipResult>>) => Map<number, SurfaceClipResult[]>;
+    createAndAddContourSegmentationsFromClippedSurfaces: (rawContourData: Map<number, SurfaceClipResult[]>, viewport: Types.IStackViewport | Types.IVolumeViewport, segmentationId: string) => Map<number, Set<string>>;
 };
 type AddOns = {
     polySeg: PolySegAddOn;

package/dist/esm/config.js

@@ -1,3 +1,5 @@
+import { eventTarget, triggerEvent } from '@cornerstonejs/core';
+import Events from './enums/Events';
 let config = {};
 export function getConfig() {
     return config;

package/dist/esm/tools/displayTools/Contour/contourDisplay.js

@@ -1,11 +1,14 @@
-import { getEnabledElementByViewportId } from '@cornerstonejs/core';
+import { cache, getEnabledElementByViewportId, Enums, utilities, } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
 import { handleContourSegmentation } from './contourHandler/handleContourSegmentation';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import removeContourFromElement from './removeContourFromElement';
 import { getPolySeg } from '../../../config';
 import { computeAndAddRepresentation } from '../../../utilities/segmentation/computeAndAddRepresentation';
-let polySegConversionInProgress = false;
+import { getUniqueSegmentIndices } from '../../../utilities/segmentation/getUniqueSegmentIndices';
+import { getAnnotation } from '../../../stateManagement/annotation/annotationState';
+import { vec3 } from 'gl-matrix';
+const polySegConversionInProgressForViewportId = new Map();
 const processedViewportSegmentations = new Map();
 function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
     const enabledElement = getEnabledElementByViewportId(viewportId);
@@ -26,13 +29,13 @@ async function render(viewport, contourRepresentation) {
         return;
     }
     let contourData = segmentation.representationData[Representations.Contour];
+    const polySeg = getPolySeg();
     if (!contourData &&
         getPolySeg()?.canComputeRequestedRepresentation(segmentationId, Representations.Contour) &&
-        !polySegConversionInProgress) {
-        polySegConversionInProgress = true;
-        const polySeg = getPolySeg();
+        !polySegConversionInProgressForViewportId.get(viewport.id)) {
+        polySegConversionInProgressForViewportId.set(viewport.id, true);
         contourData = await computeAndAddRepresentation(segmentationId, Representations.Contour, () => polySeg.computeContourData(segmentationId, { viewport }), () => undefined);
-        polySegConversionInProgress = false;
+        polySegConversionInProgressForViewportId.set(viewport.id, false);
     }
     else if (!contourData && !getPolySeg()) {
         console.debug(`No contour data found for segmentationId ${segmentationId} and PolySeg add-on is not configured. Unable to convert from other representations to contour. Please register PolySeg using cornerstoneTools.init({ addons: { polySeg } }) to enable automatic conversion.`);
@@ -43,8 +46,89 @@ async function render(viewport, contourRepresentation) {
     if (!contourData.geometryIds?.length) {
         return;
     }
+    let hasContourDataButNotMatchingViewport = false;
+    const viewportNormal = viewport.getCamera().viewPlaneNormal;
+    if (contourData.annotationUIDsMap) {
+        hasContourDataButNotMatchingViewport = !_checkContourNormalsMatchViewport(contourData.annotationUIDsMap, viewportNormal);
+    }
+    if (contourData.geometryIds.length > 0) {
+        hasContourDataButNotMatchingViewport = !_checkContourGeometryMatchViewport(contourData.geometryIds, viewportNormal);
+    }
+    const viewportProcessed = processedViewportSegmentations.get(viewport.id) || new Set();
+    if (hasContourDataButNotMatchingViewport &&
+        !polySegConversionInProgressForViewportId.get(viewport.id) &&
+        !viewportProcessed.has(segmentationId) &&
+        viewport.viewportStatus === Enums.ViewportStatus.RENDERED) {
+        polySegConversionInProgressForViewportId.set(viewport.id, true);
+        const segmentIndices = getUniqueSegmentIndices(segmentationId);
+        const surfacesInfo = await polySeg.computeSurfaceData(segmentationId, {
+            segmentIndices,
+            viewport,
+        });
+        const geometryIds = surfacesInfo.geometryIds;
+        const pointsAndPolys = [];
+        for (const geometryId of geometryIds.values()) {
+            const geometry = cache.getGeometry(geometryId);
+            const data = geometry.data;
+            pointsAndPolys.push({
+                points: data.points,
+                polys: data.polys,
+                segmentIndex: data.segmentIndex,
+                id: data.segmentIndex,
+            });
+        }
+        const polyDataCache = await polySeg.clipAndCacheSurfacesForViewport(pointsAndPolys, viewport);
+        const rawResults = polySeg.extractContourData(polyDataCache);
+        const annotationUIDsMap = polySeg.createAndAddContourSegmentationsFromClippedSurfaces(rawResults, viewport, segmentationId);
+        contourData.annotationUIDsMap = new Map([
+            ...contourData.annotationUIDsMap,
+            ...annotationUIDsMap,
+        ]);
+        viewportProcessed.add(segmentationId);
+        processedViewportSegmentations.set(viewport.id, viewportProcessed);
+        polySegConversionInProgressForViewportId.set(viewport.id, false);
+    }
     handleContourSegmentation(viewport, contourData.geometryIds, contourData.annotationUIDsMap, contourRepresentation);
 }
+function _checkContourGeometryMatchViewport(geometryIds, viewportNormal) {
+    const geometry = cache.getGeometry(geometryIds[0]);
+    if (!geometry) {
+        return false;
+    }
+    const geometryData = geometry.data;
+    const contours = geometryData.contours;
+    const points = contours[0].points;
+    const point1 = points[0];
+    const point2 = points[1];
+    const point3 = points[2];
+    let normal = vec3.cross(vec3.create(), vec3.sub(vec3.create(), point2, point1), vec3.sub(vec3.create(), point3, point1));
+    normal = vec3.normalize(vec3.create(), normal);
+    const dotProduct = vec3.dot(normal, viewportNormal);
+    return Math.abs(dotProduct) > 0.9;
+}
+function _checkContourNormalsMatchViewport(annotationUIDsMap, viewportNormal) {
+    const annotationUIDs = Array.from(annotationUIDsMap.values())
+        .flat()
+        .map((uidSet) => Array.from(uidSet))
+        .flat();
+    const randomAnnotationUIDs = utilities.getRandomSampleFromArray(annotationUIDs, 3);
+    for (const annotationUID of randomAnnotationUIDs) {
+        const annotation = getAnnotation(annotationUID);
+        if (annotation?.metadata) {
+            if (!annotation.metadata.viewPlaneNormal) {
+                continue;
+            }
+            const annotationNormal = annotation.metadata.viewPlaneNormal;
+            const dotProduct = Math.abs(viewportNormal[0] * annotationNormal[0] +
+                viewportNormal[1] * annotationNormal[1] +
+                viewportNormal[2] * annotationNormal[2]);
+            if (Math.abs(dotProduct - 1) > 0.01) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
 export default {
     render,
     removeRepresentation,

package/dist/esm/utilities/segmentation/getStatistics.js

@@ -56,6 +56,9 @@ async function calculateVolumeStatistics({ operationData, indices, unit, mode, }
         origin: imageData.getOrigin(),
         direction: imageData.getDirection(),
     };
+    if (!imageInfo.scalarData?.length) {
+        return;
+    }
     const stats = await getWebWorkerManager().executeTask('compute', 'calculateSegmentsStatisticsVolume', {
         segmentationInfo,
         imageInfo,

package/dist/esm/utilities/segmentation/utilsForWorker.js

@@ -121,7 +121,7 @@ export const getImageReferenceInfo = (segVolumeId, segImageIds) => {
     const refImage = cache.getImage(refImageId);
     const scalingModule = metaData.get('scalingModule', refImageId);
     const modalityUnitOptions = {
-        isPreScaled: Boolean(refImage.preScale?.scaled),
+        isPreScaled: Boolean(refImage?.preScale?.scaled),
         isSuvScaled: typeof scalingModule?.suvbw === 'number',
     };
     return { refImageId, modalityUnitOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.10.31",
+  "version": "3.11.1",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -103,7 +103,7 @@
     "canvas": "^3.1.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.10.31",
+    "@cornerstonejs/core": "^3.11.1",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -122,5 +122,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "f7d656d8b175c3ff00b145cdd5ceedf910afeda1"
+  "gitHead": "9e71e94884bd1c8734911b98ac67a5676fcaaecb"
 }