@cornerstonejs/tools 4.22.13 → 5.0.0

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

@@ -0,0 +1,267 @@
+import vtkImageMapper from '@kitware/vtk.js/Rendering/Core/ImageMapper';
+import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
+import { ActorRenderMode, Enums } from '@cornerstonejs/core';
+import { canRenderVolumeViewportLabelmapAsImage } from '../../../stateManagement/segmentation/helpers/labelmapImageMapperSupport';
+import { getLabelmap, getOrCreateLabelmapVolume, getLabelmaps, getLabelmapForImageId, getLabelmapForVolumeId, } from '../../../stateManagement/segmentation/helpers/labelmapSegmentationState';
+import { createLabelmapRepresentationUID, isLabelmapRepresentationUID, } from './labelmapRepresentationUID';
+import { applyPlanarOverlayDepthOffset, createSliceImageData, getSliceRenderingCamera, getSliceState, } from './volumeLabelmapSliceData';
+const OVERLAY_RENDERER_SUFFIX = 'labelmap-image-mapper-overlay';
+function isPlanarSliceRenderingViewport(viewport) {
+    const compatibilityViewport = viewport;
+    return (compatibilityViewport.type === Enums.ViewportType.PLANAR_NEXT &&
+        typeof compatibilityViewport.addImages === 'function' &&
+        typeof compatibilityViewport.getCurrentImageId === 'function' &&
+        typeof compatibilityViewport.render === 'function');
+}
+function createActorEntry(args) {
+    const mapper = vtkImageMapper.newInstance();
+    mapper.setInputData(args.imageData);
+    const actor = vtkImageSlice.newInstance();
+    actor.setMapper(mapper);
+    return {
+        uid: args.representationUID,
+        actor,
+        actorMapper: {
+            actor,
+            mapper,
+            renderMode: ActorRenderMode.VTK_IMAGE,
+        },
+        referencedId: args.referencedId,
+        representationUID: args.representationUID,
+    };
+}
+function getOverlayRendererId(viewportId) {
+    return `${viewportId}::${OVERLAY_RENDERER_SUFFIX}`;
+}
+function getOrCreateOverlayRenderer(viewport) {
+    const renderingEngine = viewport.getRenderingEngine();
+    const offscreenMultiRenderWindow = renderingEngine.getOffscreenMultiRenderWindow(viewport.id);
+    const overlayRendererId = getOverlayRendererId(viewport.id);
+    const baseRenderer = viewport.getRenderer();
+    const baseViewport = baseRenderer.getViewport();
+    let overlayRenderer = offscreenMultiRenderWindow.getRenderer(overlayRendererId);
+    if (!overlayRenderer) {
+        const renderWindow = offscreenMultiRenderWindow.getRenderWindow();
+        if (renderWindow.getNumberOfLayers() < 2) {
+            renderWindow.setNumberOfLayers(2);
+        }
+        offscreenMultiRenderWindow.addRenderer({
+            viewport: baseViewport,
+            id: overlayRendererId,
+            background: [0, 0, 0],
+        });
+        overlayRenderer = offscreenMultiRenderWindow.getRenderer(overlayRendererId);
+        overlayRenderer.setLayer(1);
+        overlayRenderer.setPreserveDepthBuffer(false);
+    }
+    overlayRenderer.setActiveCamera(baseRenderer.getActiveCamera());
+    overlayRenderer.setViewport(baseViewport[0], baseViewport[1], baseViewport[2], baseViewport[3]);
+    return overlayRenderer;
+}
+function moveActorToOverlayRenderer(viewport, actorEntry) {
+    const baseRenderer = viewport.getRenderer();
+    const overlayRenderer = getOrCreateOverlayRenderer(viewport);
+    baseRenderer.removeActor(actorEntry.actor);
+    overlayRenderer.addActor(actorEntry.actor);
+}
+export function getVolumeLabelmapImageMapperRepresentationUIDs(viewport, segmentationId, segmentation) {
+    if (!canRenderVolumeViewportLabelmapAsImage(viewport)) {
+        return [];
+    }
+    const useStablePlanarUID = isPlanarSliceRenderingViewport(viewport);
+    return getLabelmaps(segmentation)
+        .map((layer) => {
+        const volume = getOrCreateLabelmapVolume(layer);
+        if (!volume) {
+            return;
+        }
+        const state = getSliceState(viewport, volume);
+        if (!state) {
+            return;
+        }
+        return createLabelmapRepresentationUID({
+            segmentationId,
+            referencedId: layer.labelmapId,
+            ...(useStablePlanarUID ? {} : { sliceStateKey: state.key }),
+        });
+    })
+        .filter((value) => !!value);
+}
+export async function addVolumeLabelmapImageMapperActors(args) {
+    const { viewport, segmentation, segmentationId } = args;
+    if (!canRenderVolumeViewportLabelmapAsImage(viewport)) {
+        return;
+    }
+    if (isPlanarSliceRenderingViewport(viewport)) {
+        await addPlanarLabelmapImageMapperActors({
+            viewport,
+            segmentation,
+            segmentationId,
+        });
+        return;
+    }
+    getLabelmaps(segmentation).forEach((layer) => {
+        const volume = getOrCreateLabelmapVolume(layer);
+        if (!volume) {
+            return;
+        }
+        const sliceData = createSliceImageData(volume, viewport);
+        if (!sliceData) {
+            return;
+        }
+        const representationUID = createLabelmapRepresentationUID({
+            segmentationId,
+            referencedId: layer.labelmapId,
+            sliceStateKey: sliceData.state.key,
+        });
+        const actorEntry = createActorEntry({
+            imageData: sliceData.imageData,
+            referencedId: layer.labelmapId,
+            representationUID,
+        });
+        viewport.addActor(actorEntry);
+        moveActorToOverlayRenderer(viewport, actorEntry);
+    });
+}
+export function updateVolumeLabelmapImageMapperActors(args) {
+    const { viewport, segmentation, segmentationId, actorEntries } = args;
+    if (!canRenderVolumeViewportLabelmapAsImage(viewport)) {
+        return;
+    }
+    if (isPlanarSliceRenderingViewport(viewport)) {
+        updatePlanarLabelmapImageMapperActors({
+            viewport,
+            segmentation,
+            segmentationId,
+            actorEntries,
+        });
+        return;
+    }
+    const actorEntriesByLabelmapId = new Map((actorEntries ?? viewport.getActors())
+        .filter((actorEntry) => isLabelmapRepresentationUID(actorEntry.representationUID, segmentationId))
+        .map((actorEntry) => [actorEntry.referencedId, actorEntry]));
+    getLabelmaps(segmentation).forEach((layer) => {
+        const actorEntry = actorEntriesByLabelmapId.get(layer.labelmapId);
+        if (!actorEntry) {
+            return;
+        }
+        const volume = getOrCreateLabelmapVolume(layer);
+        if (!volume) {
+            return;
+        }
+        const sliceData = createSliceImageData(volume, viewport);
+        if (!sliceData) {
+            return;
+        }
+        const mapper = actorEntry.actor.getMapper();
+        mapper.setInputData(sliceData.imageData);
+        mapper.modified();
+        actorEntry.actor.modified?.();
+    });
+}
+export function removeVolumeLabelmapImageMapperActors(viewport, segmentationId) {
+    if (!(viewport.type === Enums.ViewportType.ORTHOGRAPHIC)) {
+        return;
+    }
+    if (!canRenderVolumeViewportLabelmapAsImage(viewport)) {
+        return;
+    }
+    const renderingEngine = viewport.getRenderingEngine();
+    const offscreenMultiRenderWindow = renderingEngine.getOffscreenMultiRenderWindow(viewport.id);
+    const overlayRenderer = offscreenMultiRenderWindow.getRenderer(getOverlayRendererId(viewport.id));
+    if (!overlayRenderer) {
+        return;
+    }
+    viewport
+        .getActors()
+        .filter((actorEntry) => isLabelmapRepresentationUID(actorEntry.representationUID, segmentationId))
+        .forEach((actorEntry) => {
+        overlayRenderer.removeActor(actorEntry.actor);
+    });
+    if (!overlayRenderer.getActors().length) {
+        offscreenMultiRenderWindow.removeRenderer(getOverlayRendererId(viewport.id));
+    }
+}
+export function getLabelmapForActorReference(segmentation, referencedId) {
+    if (!referencedId) {
+        return;
+    }
+    return (getLabelmap(segmentation, referencedId) ??
+        getLabelmapForImageId(segmentation, referencedId) ??
+        getLabelmapForVolumeId(segmentation, referencedId) ??
+        getLabelmaps(segmentation).find((layer) => layer.volumeId === referencedId));
+}
+async function addPlanarLabelmapImageMapperActors(args) {
+    const { viewport, segmentation, segmentationId } = args;
+    for (const [index, layer] of getLabelmaps(segmentation).entries()) {
+        const volume = getOrCreateLabelmapVolume(layer);
+        if (!volume) {
+            continue;
+        }
+        const sliceData = createSliceImageData(volume, viewport);
+        if (!sliceData) {
+            continue;
+        }
+        const currentImageId = viewport.getCurrentImageId() ??
+            volume.imageIds[Math.min(Math.max(sliceData.state.sliceIndex, 0), Math.max(volume.imageIds.length - 1, 0))];
+        if (!currentImageId) {
+            continue;
+        }
+        const representationUID = createLabelmapRepresentationUID({
+            segmentationId,
+            referencedId: layer.labelmapId,
+        });
+        await viewport.addImages([
+            {
+                dataId: representationUID,
+                imageId: currentImageId,
+                imageData: sliceData.imageData,
+                reference: {
+                    kind: 'segmentation',
+                    segmentationId,
+                    representationUID,
+                    labelmapId: layer.labelmapId,
+                },
+                useWorldCoordinateImageData: true,
+                callback: ({ imageActor }) => {
+                    const mapper = imageActor.getMapper();
+                    const camera = getSliceRenderingCamera(viewport);
+                    mapper.setInputData(sliceData.imageData);
+                    mapper.modified();
+                    if (camera) {
+                        applyPlanarOverlayDepthOffset(imageActor, camera.viewPlaneNormal, index + 1);
+                    }
+                },
+            },
+        ]);
+    }
+    viewport.render();
+}
+function updatePlanarLabelmapImageMapperActors(args) {
+    const { viewport, segmentation, segmentationId, actorEntries } = args;
+    const actorEntriesByLabelmapId = new Map((actorEntries ?? viewport.getActors())
+        .filter((actorEntry) => isLabelmapRepresentationUID(actorEntry.representationUID, segmentationId))
+        .map((actorEntry) => [actorEntry.referencedId, actorEntry]));
+    getLabelmaps(segmentation).forEach((layer, index) => {
+        const actorEntry = actorEntriesByLabelmapId.get(layer.labelmapId);
+        if (!actorEntry) {
+            return;
+        }
+        const volume = getOrCreateLabelmapVolume(layer);
+        if (!volume) {
+            return;
+        }
+        const sliceData = createSliceImageData(volume, viewport);
+        if (!sliceData) {
+            return;
+        }
+        const mapper = actorEntry.actor.getMapper();
+        mapper.setInputData(sliceData.imageData);
+        mapper.modified();
+        const camera = getSliceRenderingCamera(viewport);
+        if (camera) {
+            applyPlanarOverlayDepthOffset(actorEntry.actor, camera.viewPlaneNormal, index + 1);
+        }
+        actorEntry.actor.modified?.();
+    });
+}

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

@@ -0,0 +1,27 @@
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
+import { type Types } from '@cornerstonejs/core';
+type ImageMapperSliceState = {
+    key: string;
+    xAxis: number;
+    xSign: 1 | -1;
+    yAxis: number;
+    ySign: 1 | -1;
+    sliceAxis: number;
+    sliceIndex: number;
+};
+type SliceRenderingViewport = Types.IViewport & {
+    getCamera?: () => Pick<Types.ICamera, 'focalPoint' | 'viewPlaneNormal' | 'viewUp'>;
+    getResolvedView?: () => {
+        toICamera?: () => Pick<Types.ICamera, 'focalPoint' | 'viewPlaneNormal' | 'viewUp'>;
+    } | undefined;
+};
+declare function applyPlanarOverlayDepthOffset(actor: vtkImageSlice, viewPlaneNormal: Types.Point3, overlayOrder: number): void;
+declare function getSliceRenderingCamera(viewport: SliceRenderingViewport): Pick<Types.ICamera, 'focalPoint' | 'viewPlaneNormal' | 'viewUp'> | undefined;
+declare function getSliceState(viewport: SliceRenderingViewport, volume: Types.IImageVolume): ImageMapperSliceState | undefined;
+declare function createSliceImageData(volume: Types.IImageVolume, viewport: SliceRenderingViewport): {
+    imageData: vtkImageData;
+    state: ImageMapperSliceState;
+} | undefined;
+export { applyPlanarOverlayDepthOffset, createSliceImageData, getSliceRenderingCamera, getSliceState, };
+export type { ImageMapperSliceState, SliceRenderingViewport };

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

@@ -0,0 +1,185 @@
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
+import { utilities } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
+import { DIRECTION_ALIGNMENT_TOLERANCE } from '../../../stateManagement/segmentation/helpers/labelmapImageMapperSupport';
+const PLANAR_OVERLAY_DEPTH_EPSILON = 1e-4;
+function applyPlanarOverlayDepthOffset(actor, viewPlaneNormal, overlayOrder) {
+    if (overlayOrder <= 0) {
+        actor.setPosition(0, 0, 0);
+        return;
+    }
+    const [x, y, z] = vec3.normalize(vec3.create(), viewPlaneNormal);
+    const offset = overlayOrder * PLANAR_OVERLAY_DEPTH_EPSILON;
+    actor.setPosition(x * offset, y * offset, z * offset);
+}
+function matchAxis(vector, axes) {
+    let bestAxis = -1;
+    let bestDot = 0;
+    axes.forEach((axisVector, axis) => {
+        const dot = vec3.dot(vector, axisVector);
+        if (Math.abs(dot) > Math.abs(bestDot)) {
+            bestAxis = axis;
+            bestDot = dot;
+        }
+    });
+    if (bestAxis === -1 || Math.abs(bestDot) < DIRECTION_ALIGNMENT_TOLERANCE) {
+        return;
+    }
+    return {
+        axis: bestAxis,
+        sign: bestDot >= 0 ? 1 : -1,
+    };
+}
+function getSliceRenderingCamera(viewport) {
+    const resolvedCamera = viewport.getResolvedView?.()?.toICamera?.();
+    const normalizedResolvedCamera = normalizeSliceRenderingCamera(resolvedCamera);
+    if (normalizedResolvedCamera) {
+        return normalizedResolvedCamera;
+    }
+    const legacyCamera = viewport.getCamera?.();
+    const normalizedLegacyCamera = normalizeSliceRenderingCamera(legacyCamera);
+    return normalizedLegacyCamera;
+}
+function normalizeSliceRenderingCamera(camera) {
+    const candidate = camera;
+    const focalPoint = toPoint3(candidate?.focalPoint);
+    const viewPlaneNormal = toPoint3(candidate?.viewPlaneNormal);
+    const viewUp = toPoint3(candidate?.viewUp);
+    if (!focalPoint || !viewPlaneNormal || !viewUp) {
+        return;
+    }
+    return {
+        focalPoint,
+        viewPlaneNormal,
+        viewUp,
+    };
+}
+function toPoint3(value) {
+    const candidate = value;
+    if (!candidate || typeof candidate.length !== 'number') {
+        return;
+    }
+    if (candidate.length < 3) {
+        return;
+    }
+    const point = [
+        Number(candidate[0]),
+        Number(candidate[1]),
+        Number(candidate[2]),
+    ];
+    return point.every(Number.isFinite) ? point : undefined;
+}
+function getVolumeAxes(volume) {
+    const { direction } = volume;
+    return [
+        [direction[0], direction[1], direction[2]],
+        [direction[3], direction[4], direction[5]],
+        [direction[6], direction[7], direction[8]],
+    ];
+}
+function getSliceState(viewport, volume) {
+    const camera = getSliceRenderingCamera(viewport);
+    if (!camera) {
+        return;
+    }
+    const { viewPlaneNormal, viewUp, focalPoint } = camera;
+    const xDirection = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), viewPlaneNormal, viewUp));
+    const yDirection = vec3.normalize(vec3.create(), viewUp);
+    const axes = getVolumeAxes(volume);
+    const xAxis = matchAxis(xDirection, axes);
+    const yAxis = matchAxis(yDirection, axes);
+    const sliceAxis = matchAxis(viewPlaneNormal, axes);
+    if (!xAxis || !yAxis || !sliceAxis) {
+        return;
+    }
+    const distinctAxes = new Set([xAxis.axis, yAxis.axis, sliceAxis.axis]);
+    if (distinctAxes.size !== 3) {
+        return;
+    }
+    const continuousIndex = utilities.transformWorldToIndexContinuous(volume.imageData, focalPoint);
+    const sliceIndex = Math.floor(continuousIndex[sliceAxis.axis] + 0.5 - 1e-6);
+    if (sliceIndex < 0 || sliceIndex >= volume.dimensions[sliceAxis.axis]) {
+        return;
+    }
+    return {
+        key: [
+            sliceAxis.axis,
+            sliceIndex,
+            xAxis.axis,
+            xAxis.sign,
+            yAxis.axis,
+            yAxis.sign,
+        ].join(':'),
+        xAxis: xAxis.axis,
+        xSign: xAxis.sign,
+        yAxis: yAxis.axis,
+        ySign: yAxis.sign,
+        sliceAxis: sliceAxis.axis,
+        sliceIndex,
+    };
+}
+function createSliceImageData(volume, viewport) {
+    const state = getSliceState(viewport, volume);
+    if (!state) {
+        return;
+    }
+    const axisVectors = getVolumeAxes(volume);
+    const { dimensions, spacing, voxelManager } = volume;
+    const width = dimensions[state.xAxis];
+    const height = dimensions[state.yAxis];
+    const SliceDataConstructor = voxelManager.getConstructor();
+    const pixelData = new SliceDataConstructor(width * height);
+    const ijk = [0, 0, 0];
+    ijk[state.sliceAxis] = state.sliceIndex;
+    const xStart = state.xSign > 0 ? 0 : width - 1;
+    const xStep = state.xSign > 0 ? 1 : -1;
+    const yStart = state.ySign > 0 ? 0 : height - 1;
+    const yStep = state.ySign > 0 ? 1 : -1;
+    for (let y = 0, srcY = yStart; y < height; y++, srcY += yStep) {
+        ijk[state.yAxis] = srcY;
+        const rowOffset = y * width;
+        for (let x = 0, srcX = xStart; x < width; x++, srcX += xStep) {
+            ijk[state.xAxis] = srcX;
+            pixelData[rowOffset + x] = Number(voxelManager.getAtIJK(ijk[0], ijk[1], ijk[2]));
+        }
+    }
+    const originIndex = [0, 0, 0];
+    originIndex[state.sliceAxis] = state.sliceIndex;
+    originIndex[state.xAxis] = state.xSign > 0 ? 0 : width - 1;
+    originIndex[state.yAxis] = state.ySign > 0 ? 0 : height - 1;
+    const xDirection = axisVectors[state.xAxis].map((value) => value * state.xSign);
+    const yDirection = axisVectors[state.yAxis].map((value) => value * state.ySign);
+    const camera = getSliceRenderingCamera(viewport);
+    if (!camera) {
+        return;
+    }
+    const zDirection = vec3.normalize(vec3.create(), camera.viewPlaneNormal);
+    const dataType = vtkDataArray.getDataType(pixelData);
+    const scalarArray = vtkDataArray.newInstance({
+        dataType,
+        name: 'Pixels',
+        numberOfComponents: 1,
+        values: pixelData,
+    });
+    const imageData = vtkImageData.newInstance();
+    imageData.set({ dataType, numberOfComponents: 1 }, true);
+    imageData.setDimensions(width, height, 1);
+    imageData.setSpacing([spacing[state.xAxis], spacing[state.yAxis], 1]);
+    imageData.setDirection(new Float32Array([
+        ...xDirection,
+        ...yDirection,
+        zDirection[0],
+        zDirection[1],
+        zDirection[2],
+    ]));
+    imageData.setOrigin(utilities.transformIndexToWorld(volume.imageData, originIndex));
+    imageData.getPointData().setScalars(scalarArray);
+    imageData.modified();
+    return {
+        imageData,
+        state,
+    };
+}
+export { applyPlanarOverlayDepthOffset, createSliceImageData, getSliceRenderingCamera, getSliceState, };

package/dist/esm/tools/displayTools/registerBuiltInSegmentationRepresentationDisplays.d.ts

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

package/dist/esm/tools/displayTools/registerBuiltInSegmentationRepresentationDisplays.js

@@ -0,0 +1,16 @@
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+import { registerSegmentationRepresentationDisplay, } from '../../stateManagement/segmentation/SegmentationRepresentationDisplayRegistry';
+import contourDisplay from './Contour/contourDisplay';
+import labelmapDisplay from './Labelmap/labelmapDisplay';
+import surfaceDisplay from './Surface/surfaceDisplay';
+let builtInDisplaysRegistered = false;
+export function registerBuiltInSegmentationRepresentationDisplays() {
+    if (builtInDisplaysRegistered) {
+        return;
+    }
+    registerSegmentationRepresentationDisplay(SegmentationRepresentations.Labelmap, labelmapDisplay);
+    registerSegmentationRepresentationDisplay(SegmentationRepresentations.Contour, contourDisplay);
+    registerSegmentationRepresentationDisplay(SegmentationRepresentations.Surface, surfaceDisplay);
+    builtInDisplaysRegistered = true;
+}
+registerBuiltInSegmentationRepresentationDisplays();

package/dist/esm/tools/segmentation/BrushTool.d.ts

@@ -4,11 +4,18 @@ import LabelmapBaseTool from './LabelmapBaseTool';
 declare class BrushTool extends LabelmapBaseTool {
     static toolName: any;
     private _lastDragInfo;
+    private _lazyEdit;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
-    onSetToolPassive: (evt: any) => void;
+    onSetToolPassive: (_evt: any) => void;
     onSetToolEnabled: () => void;
-    onSetToolDisabled: (evt: any) => void;
+    onSetToolDisabled: (_evt: any) => void;
     private disableCursor;
+    private _isLazyLabelmapEditingEnabled;
+    private _resetLazyEditState;
+    private _clearPendingLazyPreviewCleanup;
+    private _refreshCursor;
+    private _scheduleLazyPreviewCleanup;
+    private _captureLazyPreviewCircle;
     preMouseDownCallback: (evt: EventTypes.MouseDownActivateEventType) => boolean;
     mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
     previewCallback: () => void;