@cornerstonejs/tools 3.0.2 → 3.0.4

package/dist/esm/tools/displayTools/Contour/contourHandler/handleContourSegmentation.js

@@ -0,0 +1,77 @@
+import { addAnnotation } from '../../../../stateManagement/annotation/annotationState';
+import { cache, utilities } from '@cornerstonejs/core';
+import { getClosestImageIdForStackViewport } from '../../../../utilities/annotationHydration';
+import { addContourSegmentationAnnotation } from '../../../../utilities/contourSegmentation';
+import { validateGeometry } from './utils';
+import { SegmentationRepresentations } from '../../../../enums';
+import { segmentationStyle } from '../../../../stateManagement/segmentation/SegmentationStyle';
+function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, contourRepresentation) {
+    if (annotationUIDsMap.size) {
+        viewport.render();
+    }
+    else {
+        addContourSetsToElement(viewport, geometryIds, contourRepresentation);
+    }
+}
+function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
+    const { segmentationId } = contourRepresentation;
+    const segmentSpecificMap = new Map();
+    geometryIds.forEach((geometryId) => {
+        const geometry = cache.getGeometry(geometryId);
+        if (!geometry) {
+            console.warn(`No geometry found for geometryId ${geometryId}. Skipping render.`);
+            return;
+        }
+        const segmentIndex = geometry.data.segmentIndex;
+        validateGeometry(geometry);
+        const segmentSpecificConfig = segmentationStyle.getStyle({
+            viewportId: viewport.id,
+            segmentationId,
+            type: SegmentationRepresentations.Contour,
+            segmentIndex,
+        });
+        const contourSet = geometry.data;
+        const viewPlaneNormal = viewport.getCamera().viewPlaneNormal;
+        contourSet.contours.forEach((contour) => {
+            const { points, color, id } = contour;
+            const referencedImageId = getClosestImageIdForStackViewport(viewport, points[0], viewPlaneNormal);
+            const contourSegmentationAnnotation = {
+                annotationUID: utilities.uuidv4(),
+                data: {
+                    contour: {
+                        closed: true,
+                        polyline: points,
+                    },
+                    segmentation: {
+                        segmentationId,
+                        segmentIndex,
+                        color,
+                        id,
+                    },
+                    handles: {},
+                },
+                handles: {},
+                highlighted: false,
+                autoGenerated: false,
+                invalidated: false,
+                isLocked: true,
+                isVisible: true,
+                metadata: {
+                    referencedImageId,
+                    toolName: 'PlanarFreehandContourSegmentationTool',
+                    FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
+                    viewPlaneNormal: viewport.getCamera().viewPlaneNormal,
+                },
+            };
+            const annotationGroupSelector = viewport.element;
+            addAnnotation(contourSegmentationAnnotation, annotationGroupSelector);
+            addContourSegmentationAnnotation(contourSegmentationAnnotation);
+        });
+        if (segmentSpecificConfig) {
+            segmentSpecificMap.set(segmentIndex, segmentSpecificConfig);
+        }
+    });
+    viewport.resetCamera();
+    viewport.render();
+}
+export { handleContourSegmentation, addContourSetsToElement };

package/dist/esm/tools/displayTools/Contour/contourHandler/utils.d.ts

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+export declare function validateGeometry(geometry: Types.IGeometry): void;
+export declare function getPolyData(contourSet: Types.IContourSet): vtkPolyData;

package/dist/esm/tools/displayTools/Contour/contourHandler/utils.js

@@ -0,0 +1,41 @@
+import { Enums } from '@cornerstonejs/core';
+import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
+import vtkPoints from '@kitware/vtk.js/Common/Core/Points';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+export function validateGeometry(geometry) {
+    if (!geometry) {
+        throw new Error(`No contours found for geometryId ${geometry.id}`);
+    }
+    const geometryId = geometry.id;
+    if (geometry.type !== Enums.GeometryType.CONTOUR) {
+        throw new Error(`Geometry type ${geometry.type} not supported for rendering.`);
+    }
+    if (!geometry.data) {
+        console.warn(`No contours found for geometryId ${geometryId}. Skipping render.`);
+        return;
+    }
+}
+export function getPolyData(contourSet) {
+    const pointArray = [];
+    const points = vtkPoints.newInstance();
+    const lines = vtkCellArray.newInstance();
+    let pointIndex = 0;
+    contourSet.contours.forEach((contour) => {
+        const pointList = contour.points;
+        const flatPoints = contour.flatPointsArray;
+        const type = contour.type;
+        const pointIndexes = pointList.map((_, pointListIndex) => pointListIndex + pointIndex);
+        if (type === Enums.ContourType.CLOSED_PLANAR) {
+            pointIndexes.push(pointIndexes[0]);
+        }
+        const linePoints = Float32Array.from(flatPoints);
+        pointArray.push(...linePoints);
+        lines.insertNextCell([...pointIndexes]);
+        pointIndex = pointIndex + pointList.length;
+    });
+    points.setData(pointArray, 3);
+    const polygon = vtkPolyData.newInstance();
+    polygon.setPoints(points);
+    polygon.setLines(lines);
+    return polygon;
+}

package/dist/esm/tools/displayTools/Contour/index.d.ts

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

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

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

package/dist/esm/tools/displayTools/Contour/removeContourFromElement.d.ts

@@ -0,0 +1,2 @@
+declare function removeContourFromElement(viewportId: string, segmentationId: string, removeFromCache?: boolean): void;
+export default removeContourFromElement;

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

@@ -0,0 +1,12 @@
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+import { removeAnnotation } from '../../../stateManagement';
+function removeContourFromElement(viewportId, segmentationId, removeFromCache = false) {
+    const segmentation = getSegmentation(segmentationId);
+    const { annotationUIDsMap } = segmentation.representationData.Contour;
+    annotationUIDsMap.forEach((annotationSet) => {
+        annotationSet.forEach((annotationUID) => {
+            removeAnnotation(annotationUID);
+        });
+    });
+}
+export default removeContourFromElement;

package/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.d.ts

@@ -0,0 +1,7 @@
+import type { LabelmapSegmentationData } from '../../../types/LabelmapTypes';
+import type { LabelmapRenderingConfig } from '../../../types/SegmentationStateTypes';
+declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationId: string, config: LabelmapRenderingConfig): Promise<void | {
+    uid: string;
+    actor: any;
+}>;
+export default addLabelmapToElement;

package/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.js

@@ -0,0 +1,93 @@
+import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, cache, BaseVolumeViewport, volumeLoader, utilities, } from '@cornerstonejs/core';
+import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+import { triggerSegmentationDataModified, triggerSegmentationModified, } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { SegmentationRepresentations } from '../../../enums';
+import { addVolumesAsIndependentComponents } from './addVolumesAsIndependentComponents';
+const { uuidv4 } = utilities;
+async function addLabelmapToElement(element, labelMapData, segmentationId, config) {
+    const enabledElement = getEnabledElement(element);
+    const { renderingEngine, viewport } = enabledElement;
+    const { id: viewportId } = viewport;
+    const visibility = true;
+    const immediateRender = false;
+    const suppressEvents = true;
+    if (viewport instanceof BaseVolumeViewport) {
+        const volumeLabelMapData = labelMapData;
+        const volumeId = _ensureVolumeHasVolumeId(volumeLabelMapData, segmentationId);
+        if (!cache.getVolume(volumeId)) {
+            await _handleMissingVolume(labelMapData);
+        }
+        let blendMode = config?.blendMode ?? Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
+        let useIndependentComponents = blendMode === Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND;
+        if (useIndependentComponents) {
+            const referenceVolumeId = viewport.getVolumeId();
+            const baseVolume = cache.getVolume(referenceVolumeId);
+            const segVolume = cache.getVolume(volumeId);
+            const segDims = segVolume.dimensions;
+            const refDims = baseVolume.dimensions;
+            if (segDims[0] !== refDims[0] ||
+                segDims[1] !== refDims[1] ||
+                segDims[2] !== refDims[2]) {
+                useIndependentComponents = false;
+                blendMode = Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
+                console.debug('Dimensions mismatch - falling back to regular volume addition');
+            }
+        }
+        const volumeInputs = [
+            {
+                volumeId,
+                visibility,
+                representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
+                useIndependentComponents,
+                blendMode,
+            },
+        ];
+        if (!volumeInputs[0].useIndependentComponents) {
+            await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
+        }
+        else {
+            const result = await addVolumesAsIndependentComponents({
+                viewport,
+                volumeInputs,
+                segmentationId,
+            });
+            return result;
+        }
+    }
+    else {
+        const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+        const stackInputs = [
+            {
+                imageId: segmentationImageId,
+                representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
+            },
+        ];
+        addImageSlicesToViewports(renderingEngine, stackInputs, [viewportId]);
+    }
+    triggerSegmentationDataModified(segmentationId);
+}
+function _ensureVolumeHasVolumeId(labelMapData, segmentationId) {
+    let { volumeId } = labelMapData;
+    if (!volumeId) {
+        volumeId = uuidv4();
+        const segmentation = getSegmentation(segmentationId);
+        segmentation.representationData.Labelmap = {
+            ...segmentation.representationData.Labelmap,
+            volumeId,
+        };
+        labelMapData.volumeId = volumeId;
+        triggerSegmentationModified(segmentationId);
+    }
+    return volumeId;
+}
+async function _handleMissingVolume(labelMapData) {
+    const stackData = labelMapData;
+    const hasImageIds = stackData.imageIds.length > 0;
+    if (!hasImageIds) {
+        throw new Error('cannot create labelmap, no imageIds found for the volume labelmap');
+    }
+    const volume = await volumeLoader.createAndCacheVolumeFromImages(labelMapData.volumeId || uuidv4(), stackData.imageIds);
+    return volume;
+}
+export default addLabelmapToElement;

package/dist/esm/tools/displayTools/Labelmap/addVolumesAsIndependentComponents.d.ts

@@ -0,0 +1,10 @@
+import { type Types } from '@cornerstonejs/core';
+import type vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
+export declare function addVolumesAsIndependentComponents({ viewport, volumeInputs, segmentationId, }: {
+    viewport: Types.IVolumeViewport;
+    volumeInputs: Types.IVolumeInput[];
+    segmentationId: string;
+}): Promise<{
+    uid: string;
+    actor: vtkVolume;
+}>;

package/dist/esm/tools/displayTools/Labelmap/addVolumesAsIndependentComponents.js

@@ -0,0 +1,123 @@
+import { cache, Enums, convertMapperToNotSharedMapper, volumeLoader, eventTarget, createVolumeActor, } from '@cornerstonejs/core';
+import { Events, SegmentationRepresentations } from '../../../enums';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+const internalCache = new Map();
+const load = ({ cfun, ofun, actor }) => {
+    actor.getProperty().setRGBTransferFunction(1, cfun);
+    actor.getProperty().setScalarOpacity(1, ofun);
+};
+export async function addVolumesAsIndependentComponents({ viewport, volumeInputs, segmentationId, }) {
+    const defaultActor = viewport.getDefaultActor();
+    const { actor } = defaultActor;
+    const { uid, callback } = defaultActor;
+    const referenceVolumeId = viewport.getVolumeId();
+    if (internalCache.get(uid)?.added) {
+        return {
+            uid,
+            actor,
+        };
+    }
+    const volumeInputArray = volumeInputs;
+    const firstImageVolume = cache.getVolume(volumeInputArray[0].volumeId);
+    if (!firstImageVolume) {
+        throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist`);
+    }
+    const { volumeId } = volumeInputArray[0];
+    const segImageVolume = await volumeLoader.loadVolume(volumeId);
+    if (!segImageVolume) {
+        throw new Error(`segImageVolume with id: ${segImageVolume.volumeId} does not exist`);
+    }
+    const segVoxelManager = segImageVolume.voxelManager;
+    const { imageData: segImageData } = segImageVolume;
+    const baseVolume = cache.getVolume(referenceVolumeId);
+    const baseVoxelManager = baseVolume.voxelManager;
+    const newComp = 2;
+    const cubeData = new Float32Array(newComp * baseVolume.voxelManager.getScalarDataLength());
+    const dims = segImageData.getDimensions();
+    for (let z = 0; z < dims[2]; ++z) {
+        for (let y = 0; y < dims[1]; ++y) {
+            for (let x = 0; x < dims[0]; ++x) {
+                const iTuple = x + dims[0] * (y + dims[1] * z);
+                cubeData[iTuple * newComp + 0] = baseVoxelManager.getAtIndex(iTuple);
+                cubeData[iTuple * newComp + 1] = segVoxelManager.getAtIndex(iTuple);
+            }
+        }
+    }
+    viewport.removeActors([uid]);
+    const oldMapper = actor.getMapper();
+    const mapper = convertMapperToNotSharedMapper(oldMapper);
+    actor.setMapper(mapper);
+    mapper.setBlendMode(Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND);
+    const arrayAgain = mapper.getInputData().getPointData().getArray(0);
+    arrayAgain.setData(cubeData);
+    arrayAgain.setNumberOfComponents(2);
+    actor.getProperty().setColorMixPreset(1);
+    actor.getProperty().setForceNearestInterpolation(1, true);
+    actor.getProperty().setIndependentComponents(true);
+    viewport.addActor({
+        actor,
+        uid,
+        callback,
+        referencedId: referenceVolumeId,
+        representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
+    });
+    internalCache.set(uid, {
+        added: true,
+        segmentationRepresentationUID: `${segmentationId}`,
+        originalBlendMode: viewport.getBlendMode(),
+    });
+    actor.set({
+        preLoad: load,
+    });
+    function onSegmentationDataModified(evt) {
+        const { segmentationId, modifiedSlicesToUse } = evt.detail;
+        const { representationData } = getSegmentation(segmentationId);
+        const { volumeId: segVolumeId } = representationData.Labelmap;
+        if (segVolumeId !== segImageVolume.volumeId) {
+            return;
+        }
+        const segmentationVolume = cache.getVolume(segVolumeId);
+        const segVoxelManager = segmentationVolume.voxelManager;
+        const array = mapper.getInputData().getPointData().getArray(0);
+        const baseData = array.getData();
+        const newComp = 2;
+        const dims = segImageData.getDimensions();
+        const slices = modifiedSlicesToUse?.length
+            ? modifiedSlicesToUse
+            : Array.from({ length: dims[2] }, (_, i) => i);
+        for (const z of slices) {
+            for (let y = 0; y < dims[1]; ++y) {
+                for (let x = 0; x < dims[0]; ++x) {
+                    const iTuple = x + dims[0] * (y + dims[1] * z);
+                    baseData[iTuple * newComp + 1] = segVoxelManager.getAtIndex(iTuple);
+                }
+            }
+        }
+        array.setData(baseData);
+    }
+    eventTarget.addEventListener(Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified);
+    eventTarget.addEventListener(Events.SEGMENTATION_REPRESENTATION_REMOVED, async (evt) => {
+        eventTarget.removeEventListener(Events.SEGMENTATION_DATA_MODIFIED, onSegmentationDataModified);
+        const actorEntry = viewport.getActor(uid);
+        const { element, id } = viewport;
+        viewport.removeActors([uid]);
+        const actor = await createVolumeActor({
+            volumeId: uid,
+            blendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
+            callback: ({ volumeActor }) => {
+                if (actorEntry.callback) {
+                    actorEntry.callback({
+                        volumeActor,
+                        volumeId,
+                    });
+                }
+            },
+        }, element, id);
+        viewport.addActor({ actor, uid });
+        viewport.render();
+    });
+    return {
+        uid,
+        actor,
+    };
+}

package/dist/esm/tools/displayTools/Labelmap/index.d.ts

@@ -0,0 +1,4 @@
+import labelmapDisplay from './labelmapDisplay';
+import labelmapConfig from './labelmapConfig';
+import { validate as validateLabelmap, validatePublic as validateLabelmapPublic } from '../../../utilities/segmentation/validateLabelmap';
+export { labelmapDisplay, labelmapConfig, validateLabelmap, validateLabelmapPublic, };

package/dist/esm/tools/displayTools/Labelmap/index.js

@@ -0,0 +1,4 @@
+import labelmapDisplay from './labelmapDisplay';
+import labelmapConfig from './labelmapConfig';
+import { validate as validateLabelmap, validatePublic as validateLabelmapPublic, } from '../../../utilities/segmentation/validateLabelmap';
+export { labelmapDisplay, labelmapConfig, validateLabelmap, validateLabelmapPublic, };

package/dist/esm/tools/displayTools/Labelmap/labelmapConfig.d.ts

@@ -0,0 +1,3 @@
+import type { LabelmapStyle } from '../../../types/LabelmapTypes';
+declare function getDefaultLabelmapStyle(): LabelmapStyle;
+export default getDefaultLabelmapStyle;

package/dist/esm/tools/displayTools/Labelmap/labelmapConfig.js

@@ -0,0 +1,17 @@
+const defaultLabelmapConfig = {
+    renderOutline: true,
+    renderOutlineInactive: true,
+    outlineWidth: 3,
+    outlineWidthInactive: 2,
+    activeSegmentOutlineWidthDelta: 0,
+    renderFill: true,
+    renderFillInactive: true,
+    fillAlpha: 0.5,
+    fillAlphaInactive: 0.4,
+    outlineOpacity: 1,
+    outlineOpacityInactive: 0.85,
+};
+function getDefaultLabelmapStyle() {
+    return defaultLabelmapConfig;
+}
+export default getDefaultLabelmapStyle;

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.d.ts

@@ -0,0 +1,11 @@
+import type { Types } from '@cornerstonejs/core';
+import type { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
+export declare const MAX_NUMBER_COLORS = 255;
+declare function removeRepresentation(viewportId: string, segmentationId: string, renderImmediate?: boolean): void;
+declare function render(viewport: Types.IStackViewport | Types.IVolumeViewport, representation: LabelmapRepresentation): Promise<void>;
+declare const _default: {
+    render: typeof render;
+    removeRepresentation: typeof removeRepresentation;
+};
+export default _default;
+export { render, removeRepresentation };