@cornerstonejs/polymorphic-segmentation 3.0.0-beta.3 → 3.0.0-beta.4

package/dist/esm/Surface/createAndCacheSurfacesFromRaw.js

@@ -0,0 +1,34 @@
+import { Enums, geometryLoader } from '@cornerstonejs/core';
+import * as cornerstoneTools from '@cornerstonejs/tools';
+const { getSegmentation } = cornerstoneTools.segmentation.state;
+const { getSegmentIndexColor } = cornerstoneTools.segmentation.config.color;
+export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesData, options = {}) {
+    const segmentation = getSegmentation(segmentationId);
+    const geometryIds = new Map();
+    const promises = Object.keys(rawSurfacesData).map(async (index) => {
+        const rawSurfaceData = rawSurfacesData[index];
+        const segmentIndex = rawSurfaceData.segmentIndex;
+        const color = getSegmentIndexColor(options.viewport.id, segmentation.segmentationId, segmentIndex).slice(0, 3);
+        if (!color) {
+            throw new Error('No color found for segment index, unable to create surface');
+        }
+        const closedSurface = {
+            id: `segmentation_${segmentation.segmentationId}_surface_${segmentIndex}`,
+            color,
+            frameOfReferenceUID: 'test-frameOfReferenceUID',
+            points: rawSurfaceData.data.points,
+            polys: rawSurfaceData.data.polys,
+            segmentIndex,
+        };
+        const geometryId = closedSurface.id;
+        geometryIds.set(segmentIndex, geometryId);
+        return geometryLoader.createAndCacheGeometry(geometryId, {
+            type: Enums.GeometryType.SURFACE,
+            geometryData: closedSurface,
+        });
+    });
+    await Promise.all(promises);
+    return {
+        geometryIds,
+    };
+}

package/dist/esm/Surface/surfaceComputationStrategies.d.ts

@@ -0,0 +1,12 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PolySegConversionOptions } from '../types';
+export type RawSurfacesData = {
+    segmentIndex: number;
+    data: Types.SurfaceData;
+}[];
+export declare function computeSurfaceData(segmentationId: string, options?: PolySegConversionOptions): Promise<{
+    geometryIds: Map<number, string>;
+}>;
+declare function computeSurfaceFromLabelmapSegmentation(segmentationId: any, options?: PolySegConversionOptions): Promise<RawSurfacesData>;
+declare function computeSurfaceFromContourSegmentation(segmentationId: string, options?: PolySegConversionOptions): Promise<RawSurfacesData>;
+export { computeSurfaceFromContourSegmentation, computeSurfaceFromLabelmapSegmentation, };

package/dist/esm/Surface/surfaceComputationStrategies.js

@@ -0,0 +1,76 @@
+import * as cornerstoneTools from '@cornerstonejs/tools';
+import { convertContourToSurface } from './convertContourToSurface';
+import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
+import { convertLabelmapToSurface } from './convertLabelmapToSurface';
+const { getUniqueSegmentIndices } = cornerstoneTools.utilities.segmentation;
+const { getSegmentation } = cornerstoneTools.segmentation.state;
+export async function computeSurfaceData(segmentationId, options = {}) {
+    const segmentIndices = options.segmentIndices?.length
+        ? options.segmentIndices
+        : getUniqueSegmentIndices(segmentationId);
+    let rawSurfacesData;
+    const segmentation = getSegmentation(segmentationId);
+    const representationData = segmentation.representationData;
+    try {
+        if (representationData.Contour) {
+            rawSurfacesData = await computeSurfaceFromContourSegmentation(segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+        else if (representationData.Labelmap) {
+            rawSurfacesData = await computeSurfaceFromLabelmapSegmentation(segmentation.segmentationId, {
+                segmentIndices,
+                ...options,
+            });
+        }
+    }
+    catch (error) {
+        console.error(error);
+        throw error;
+    }
+    if (!rawSurfacesData) {
+        throw new Error('Not enough data to convert to surface, currently only support converting volume labelmap to surface if available');
+    }
+    const surfacesData = await createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesData, options);
+    return surfacesData;
+}
+async function computeSurfaceFromLabelmapSegmentation(segmentationId, options = {}) {
+    const segmentation = getSegmentation(segmentationId);
+    if (!segmentation?.representationData?.Labelmap) {
+        console.warn('Only support surface update from labelmaps');
+        return;
+    }
+    const labelmapRepresentationData = segmentation.representationData.Labelmap;
+    const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
+    const promises = segmentIndices.map((index) => {
+        const surface = convertLabelmapToSurface(labelmapRepresentationData, index);
+        return surface;
+    });
+    const surfaces = await Promise.allSettled(promises);
+    const errors = surfaces.filter((p) => p.status === 'rejected');
+    if (errors.length > 0) {
+        console.error(errors);
+        throw new Error('Failed to convert labelmap to surface');
+    }
+    const rawSurfacesData = surfaces
+        .map((surface, index) => {
+        if (surface.status === 'fulfilled') {
+            return { segmentIndex: segmentIndices[index], data: surface.value };
+        }
+    })
+        .filter(Boolean);
+    return rawSurfacesData;
+}
+async function computeSurfaceFromContourSegmentation(segmentationId, options = {}) {
+    const segmentation = getSegmentation(segmentationId);
+    const contourRepresentationData = segmentation.representationData.Contour;
+    const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
+    const promises = segmentIndices.map(async (index) => {
+        const surface = await convertContourToSurface(contourRepresentationData, index);
+        return { segmentIndex: index, data: surface };
+    });
+    const surfaces = await Promise.all(promises);
+    return surfaces;
+}
+export { computeSurfaceFromContourSegmentation, computeSurfaceFromLabelmapSegmentation, };

package/dist/esm/Surface/updateSurfaceData.d.ts

@@ -0,0 +1 @@
+export declare function updateSurfaceData(segmentationId: any): Promise<void>;

package/dist/esm/Surface/updateSurfaceData.js

@@ -0,0 +1,55 @@
+import { cache } from '@cornerstonejs/core';
+import * as cornerstoneTools from '@cornerstonejs/tools';
+import { computeSurfaceFromLabelmapSegmentation } from './surfaceComputationStrategies';
+import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
+const { utilities: { segmentation: { getUniqueSegmentIndices }, }, segmentation: { state: { getViewportIdsWithSegmentation, getSegmentation, getSegmentationRepresentation, }, triggerSegmentationEvents: { triggerSegmentationModified }, }, Enums: { SegmentationRepresentations }, } = cornerstoneTools;
+export async function updateSurfaceData(segmentationId) {
+    const surfacesObj = await computeSurfaceFromLabelmapSegmentation(segmentationId);
+    if (!surfacesObj) {
+        return;
+    }
+    const segmentation = getSegmentation(segmentationId);
+    const indices = getUniqueSegmentIndices(segmentationId);
+    if (!indices.length) {
+        const geometryIds = segmentation.representationData.Surface.geometryIds;
+        geometryIds.forEach((geometryId) => {
+            const geometry = cache.getGeometry(geometryId);
+            const surface = geometry.data;
+            surface.points = [];
+            surface.polys = [];
+        });
+        triggerSegmentationModified(segmentationId);
+        return;
+    }
+    const promises = surfacesObj.map(({ data, segmentIndex }) => {
+        const geometryId = `segmentation_${segmentationId}_surface_${segmentIndex}`;
+        const geometry = cache.getGeometry(geometryId);
+        if (!geometry) {
+            const viewportIds = getViewportIdsWithSegmentation(segmentationId);
+            return viewportIds.map((viewportId) => {
+                const surfaceRepresentation = getSegmentationRepresentation(viewportId, {
+                    segmentationId,
+                    type: SegmentationRepresentations.Surface,
+                });
+                return [surfaceRepresentation].map((surfaceRepresentation) => {
+                    segmentation.representationData.Surface.geometryIds.set(segmentIndex, geometryId);
+                    return createAndCacheSurfacesFromRaw(segmentationId, [{ segmentIndex, data }], {
+                        segmentationId: surfaceRepresentation.segmentationId,
+                    });
+                });
+            });
+        }
+        else if (indices.includes(segmentIndex)) {
+            const surface = geometry.data;
+            surface.points = data.points;
+            surface.polys = data.polys;
+        }
+        else {
+            const surface = geometry.data;
+            surface.points = [];
+            surface.polys = [];
+        }
+    });
+    await Promise.all(promises);
+    triggerSegmentationModified(segmentationId);
+}

package/dist/esm/canComputeRequestedRepresentation.d.ts

@@ -0,0 +1,4 @@
+import { Enums } from '@cornerstonejs/tools';
+declare const SegmentationRepresentations: typeof Enums.SegmentationRepresentations;
+declare function canComputeRequestedRepresentation(segmentationId: string, type: typeof SegmentationRepresentations): boolean;
+export { canComputeRequestedRepresentation };

package/dist/esm/canComputeRequestedRepresentation.js

@@ -0,0 +1,59 @@
+import { Enums, segmentation, utilities } from '@cornerstonejs/tools';
+const { SegmentationRepresentations } = Enums;
+const { getSegmentation } = segmentation.state;
+const { validateLabelmap } = utilities.segmentation;
+const conversionPaths = new Map([
+    [
+        SegmentationRepresentations.Labelmap,
+        new Set([
+            SegmentationRepresentations.Surface,
+            SegmentationRepresentations.Contour,
+        ]),
+    ],
+    [
+        SegmentationRepresentations.Contour,
+        new Set([
+            SegmentationRepresentations.Labelmap,
+            SegmentationRepresentations.Surface,
+        ]),
+    ],
+    [
+        SegmentationRepresentations.Surface,
+        new Set([SegmentationRepresentations.Labelmap]),
+    ],
+]);
+function canComputeRequestedRepresentation(segmentationId, type) {
+    const { representationData } = getSegmentation(segmentationId);
+    const existingRepresentationTypes = getExistingRepresentationTypes(representationData);
+    return existingRepresentationTypes.some((existingRepresentationType) => canConvertFromTo(existingRepresentationType, type));
+}
+function getExistingRepresentationTypes(representationData) {
+    const supportedTypes = [];
+    Object.keys(representationData).forEach((representationType) => {
+        const representationTypeData = representationData[representationType];
+        let validateFn;
+        switch (representationType) {
+            case SegmentationRepresentations.Labelmap:
+                validateFn = validateLabelmap.validate;
+                break;
+        }
+        if (validateFn) {
+            try {
+                validateFn(representationTypeData);
+                supportedTypes.push(representationType);
+            }
+            catch (error) {
+                console.warn(`Validation failed for labelmap of type ${representationType}`);
+            }
+        }
+        else {
+            supportedTypes.push(representationType);
+        }
+    });
+    return supportedTypes;
+}
+async function canConvertFromTo(fromRepresentationType, toRepresentationType) {
+    return (conversionPaths.get(fromRepresentationType)?.has(toRepresentationType) ||
+        false);
+}
+export { canComputeRequestedRepresentation };

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+import { computeContourData } from './Contour/contourComputationStrategies';
+import { computeLabelmapData } from './Labelmap/labelmapComputationStrategies';
+import { computeSurfaceData } from './Surface/surfaceComputationStrategies';
+import { canComputeRequestedRepresentation } from './canComputeRequestedRepresentation';
+import { updateSurfaceData } from './Surface/updateSurfaceData';
+declare function init(): void;
+export { canComputeRequestedRepresentation, computeContourData, computeLabelmapData, computeSurfaceData, updateSurfaceData, init, };

package/dist/esm/index.js

@@ -0,0 +1,10 @@
+import { computeContourData } from './Contour/contourComputationStrategies';
+import { computeLabelmapData } from './Labelmap/labelmapComputationStrategies';
+import { computeSurfaceData } from './Surface/surfaceComputationStrategies';
+import { canComputeRequestedRepresentation } from './canComputeRequestedRepresentation';
+import { updateSurfaceData } from './Surface/updateSurfaceData';
+import { registerPolySegWorker } from './registerPolySegWorker';
+function init() {
+    registerPolySegWorker();
+}
+export { canComputeRequestedRepresentation, computeContourData, computeLabelmapData, computeSurfaceData, updateSurfaceData, init, };

package/dist/esm/registerPolySegWorker.d.ts

@@ -0,0 +1 @@
+export declare function registerPolySegWorker(): void;

package/dist/esm/registerPolySegWorker.js

@@ -0,0 +1,23 @@
+import { getWebWorkerManager } from '@cornerstonejs/core';
+let registered = false;
+export function registerPolySegWorker() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    const workerFn = () => {
+        return new Worker(new URL('./workers/polySegConverters.js', import.meta.url), {
+            name: 'polySeg',
+            type: 'module',
+        });
+    };
+    const workerManager = getWebWorkerManager();
+    const options = {
+        maxWorkerInstances: 1,
+        autoTerminateOnIdle: {
+            enabled: true,
+            idleTimeThreshold: 2000,
+        },
+    };
+    workerManager.registerWorker('polySeg', workerFn, options);
+}

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

@@ -0,0 +1,6 @@
+import type { Types } from '@cornerstonejs/core';
+export type PolySegConversionOptions = {
+    segmentIndices?: number[];
+    segmentationId?: string;
+    viewport?: Types.IStackViewport | Types.IVolumeViewport;
+};

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

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

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

@@ -0,0 +1,16 @@
+import type { Types } from '@cornerstonejs/core';
+export type SurfacesInfo = {
+    id: string;
+    points: number[];
+    polys: number[];
+    segmentIndex: number;
+};
+export type SurfaceClipResult = {
+    points: number[];
+    lines: number[];
+    numberOfCells: number;
+};
+export type PolyDataClipCacheType = Map<number, Map<string, SurfaceClipResult>>;
+export declare function clipAndCacheSurfacesForViewport(surfacesInfo: SurfacesInfo[], viewport: Types.IVolumeViewport): Promise<PolyDataClipCacheType>;
+export declare function generateCacheId(viewport: any, viewPlaneNormal: any, sliceIndex: any): string;
+export declare function updatePolyDataCache(segmentIndex: number, cacheId: string, polyDataResult: SurfaceClipResult): void;

package/dist/esm/utilities/clipAndCacheSurfacesForViewport.js

@@ -0,0 +1,88 @@
+import { Enums, getWebWorkerManager, eventTarget, triggerEvent, } from '@cornerstonejs/core';
+import { Enums as ToolsEnums, utilities } from '@cornerstonejs/tools';
+import { registerPolySegWorker } from '../registerPolySegWorker';
+const workerManager = getWebWorkerManager();
+const { WorkerTypes } = ToolsEnums;
+const { pointToString } = utilities;
+const polyDataCache = new Map();
+const surfacesAABBCache = new Map();
+const triggerWorkerProgress = (eventTarget, progress) => {
+    triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+        progress,
+        type: WorkerTypes.SURFACE_CLIPPING,
+    });
+};
+export async function clipAndCacheSurfacesForViewport(surfacesInfo, viewport) {
+    registerPolySegWorker();
+    const planesInfo = viewport.getSlicesClippingPlanes?.();
+    if (!planesInfo) {
+        return;
+    }
+    const currentSliceIndex = viewport.getSliceIndex();
+    planesInfo.sort((a, b) => {
+        const diffA = Math.abs(a.sliceIndex - currentSliceIndex);
+        const diffB = Math.abs(b.sliceIndex - currentSliceIndex);
+        return diffA - diffB;
+    });
+    triggerWorkerProgress(eventTarget, 0);
+    await updateSurfacesAABBCache(surfacesInfo);
+    const surfacesAABB = new Map();
+    surfacesInfo.forEach((surface) => {
+        surfacesAABB.set(surface.id, surfacesAABBCache.get(surface.id));
+    });
+    const camera = viewport.getCamera();
+    await workerManager
+        .executeTask('polySeg', 'cutSurfacesIntoPlanes', {
+        surfacesInfo,
+        planesInfo,
+        surfacesAABB,
+    }, {
+        callbacks: [
+            ({ progress }) => {
+                triggerWorkerProgress(eventTarget, progress);
+            },
+            ({ sliceIndex, polyDataResults }) => {
+                polyDataResults.forEach((polyDataResult, segmentIndex) => {
+                    const segmentIndexNumber = Number(segmentIndex);
+                    const cacheId = generateCacheId(viewport, camera.viewPlaneNormal, sliceIndex);
+                    updatePolyDataCache(segmentIndexNumber, cacheId, polyDataResult);
+                });
+            },
+        ],
+    })
+        .catch((error) => {
+        console.error(error);
+    });
+    triggerWorkerProgress(eventTarget, 100);
+    return polyDataCache;
+}
+async function updateSurfacesAABBCache(surfacesInfo) {
+    const surfacesWithoutAABB = surfacesInfo.filter((surface) => !surfacesAABBCache.has(surface.id));
+    if (!surfacesWithoutAABB.length) {
+        return;
+    }
+    const surfacesAABB = await workerManager.executeTask('polySeg', 'getSurfacesAABBs', {
+        surfacesInfo: surfacesWithoutAABB,
+    }, {
+        callbacks: [
+            ({ progress }) => {
+                triggerWorkerProgress(eventTarget, progress);
+            },
+        ],
+    });
+    surfacesAABB.forEach((aabb, id) => {
+        surfacesAABBCache.set(id, aabb);
+    });
+}
+export function generateCacheId(viewport, viewPlaneNormal, sliceIndex) {
+    return `${viewport.id}-${pointToString(viewPlaneNormal)}-${sliceIndex}`;
+}
+export function updatePolyDataCache(segmentIndex, cacheId, polyDataResult) {
+    const { points, lines, numberOfCells } = polyDataResult;
+    let segmentCache = polyDataCache.get(segmentIndex);
+    if (!segmentCache) {
+        segmentCache = new Map();
+        polyDataCache.set(segmentIndex, segmentCache);
+    }
+    segmentCache.set(cacheId, { points, lines, numberOfCells });
+}

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

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

package/dist/esm/utilities/index.js

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

package/dist/esm/workers/polySegConverters.d.ts

@@ -0,0 +1 @@
+export {};