@cornerstonejs/tools 5.1.0 → 5.1.1

package/dist/esm/tools/annotation/WholeBodySegmentTool.js

@@ -4,6 +4,7 @@ import { drawPolyline as drawPolylineSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import { Events } from '../../enums';
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
+import getViewportICamera from '../../utilities/getViewportICamera';
 import { growCut } from '../../utilities/segmentation';
 import GrowCutBaseTool from '../base/GrowCutBaseTool';
 const NEGATIVE_PIXEL_RANGE = [-Infinity, -995];
@@ -167,7 +168,7 @@ class WholeBodySegmentTool extends GrowCutBaseTool {
         return [ijkLineP1, ijkLineP2];
     }
     _getCuboidIJKEdgePointsFromProjectedWorldPoint(viewport, worldEdgePoint) {
-        const { viewPlaneNormal } = viewport.getCamera();
+        const { viewPlaneNormal } = getViewportICamera(viewport);
         return this._projectWorldPointAcrossSlices(viewport, worldEdgePoint, viewPlaneNormal);
     }
     _getWorldCuboidCornerPoints(viewport, worldSquarePoints) {
@@ -202,7 +203,7 @@ class WholeBodySegmentTool extends GrowCutBaseTool {
         const volume = this._getViewportVolume(viewport);
         const { dimensions } = volume;
         const ijkPoint = transformWorldToIndex(volume.imageData, worldPoint);
-        const { viewUp, viewPlaneNormal } = viewport.getCamera();
+        const { viewUp, viewPlaneNormal } = getViewportICamera(viewport);
         const vecRow = vec3.cross(vec3.create(), viewUp, viewPlaneNormal);
         const axis = vecRow.findIndex((n) => csUtils.isEqual(Math.abs(n), 1));
         const ijkLineP1 = [...ijkPoint];

package/dist/esm/tools/annotation/planarFreehandROITool/drawLoop.js

@@ -13,7 +13,6 @@ import { removeAnnotation } from '../../../stateManagement/annotation/annotation
 import { ContourWindingDirection } from '../../../types/ContourAnnotation';
 const { addCanvasPointsToArray, pointsAreWithinCloseContourProximity, getFirstLineSegmentIntersectionIndexes, getSubPixelSpacingAndXYDirections, } = polyline;
 function activateDraw(evt, annotation, viewportIdsToRender) {
-    this.isDrawing = true;
     const eventDetail = evt.detail;
     const { currentPoints, element } = eventDetail;
     const canvasPos = currentPoints.canvas;
@@ -25,6 +24,7 @@ function activateDraw(evt, annotation, viewportIdsToRender) {
     if (!spacing || !xDir || !yDir) {
         return;
     }
+    this.isDrawing = true;
     this.drawData = {
         canvasPoints: [canvasPos],
         polylineIndex: 0,

package/dist/esm/tools/base/AnnotationTool.js

@@ -314,6 +314,12 @@ class AnnotationTool extends AnnotationDisplayTool {
             else if (viewport instanceof BaseVolumeViewport) {
                 referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
             }
+            else if (csUtils.isGenericViewport(viewport)) {
+                const genericViewport = viewport;
+                referencedImageId = genericViewport.getViewReference?.({
+                    points: [points[0]],
+                })?.referencedImageId;
+            }
             else {
                 throw new Error('Unsupported viewport type');
             }

package/dist/esm/tools/base/GrowCutBaseTool.js

@@ -1,5 +1,6 @@
 import { getEnabledElement, utilities as csUtils, cache, getRenderingEngine, volumeLoader, imageLoader, ImageVolume, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
+import getViewportICamera from '../../utilities/getViewportICamera';
 import { SegmentationRepresentations } from '../../enums';
 import { segmentIndex as segmentIndexController, state as segmentationState, activeSegmentation, } from '../../stateManagement/segmentation';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
@@ -28,7 +29,7 @@ class GrowCutBaseTool extends BaseTool {
         const { world: worldPoint } = currentPoints;
         const enabledElement = getEnabledElement(element);
         const { viewport, renderingEngine } = enabledElement;
-        const { viewUp } = viewport.getCamera();
+        const { viewUp } = getViewportICamera(viewport);
         const { segmentationId, segmentIndex, labelmapVolumeId, referencedVolumeId, } = await this.getLabelmapSegmentationData(viewport);
         if (!this._isOrthogonalView(viewport, referencedVolumeId)) {
             throw new Error('Oblique view is not supported yet');
@@ -223,7 +224,7 @@ class GrowCutBaseTool extends BaseTool {
     _isOrthogonalView(viewport, referencedVolumeId) {
         const volume = cache.getVolume(referencedVolumeId);
         const volumeImageData = volume.imageData;
-        const camera = viewport.getCamera();
+        const camera = getViewportICamera(viewport);
         const { ijkVecColDir, ijkVecSliceDir } = csUtils.getVolumeDirectionVectors(volumeImageData, camera);
         return [ijkVecColDir, ijkVecSliceDir].every((vec) => csUtils.isEqual(Math.abs(vec[0]), 1) ||
             csUtils.isEqual(Math.abs(vec[1]), 1) ||

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

@@ -1,6 +1,7 @@
 import { cache, getEnabledElementByViewportId, Enums, utilities, } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
 import { handleContourSegmentation } from './contourHandler/handleContourSegmentation';
+import getViewportICamera from '../../../utilities/getViewportICamera';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import removeContourFromElement from './removeContourFromElement';
 import { getPolySeg } from '../../../config';
@@ -51,7 +52,7 @@ async function render(viewport, contourRepresentation) {
         return;
     }
     let hasContourDataButNotMatchingViewport = false;
-    const viewportNormal = viewport.getCamera().viewPlaneNormal;
+    const viewportNormal = getViewportICamera(viewport).viewPlaneNormal;
     if (contourData.annotationUIDsMap) {
         hasContourDataButNotMatchingViewport = !_checkContourNormalsMatchViewport(contourData.annotationUIDsMap, viewportNormal);
     }

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

@@ -2,6 +2,7 @@ import { addAnnotation } from '../../../../stateManagement/annotation/annotation
 import { cache, utilities } from '@cornerstonejs/core';
 import { getClosestImageIdForStackViewport } from '../../../../utilities/annotationHydration';
 import { addContourSegmentationAnnotation } from '../../../../utilities/contourSegmentation';
+import getViewportICamera from '../../../../utilities/getViewportICamera';
 import { validateGeometry } from './utils';
 import { SegmentationRepresentations } from '../../../../enums';
 import { segmentationStyle } from '../../../../stateManagement/segmentation/SegmentationStyle';
@@ -31,7 +32,7 @@ function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
             segmentIndex,
         });
         const contourSet = geometry.data;
-        const viewPlaneNormal = viewport.getCamera().viewPlaneNormal;
+        const viewPlaneNormal = getViewportICamera(viewport).viewPlaneNormal;
         contourSet.contours.forEach((contour) => {
             const { points, color, id } = contour;
             const referencedImageId = getClosestImageIdForStackViewport(viewport, points[0], viewPlaneNormal);
@@ -60,7 +61,7 @@ function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
                     referencedImageId,
                     toolName: 'PlanarFreehandContourSegmentationTool',
                     FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
-                    viewPlaneNormal: viewport.getCamera().viewPlaneNormal,
+                    viewPlaneNormal,
                 },
             };
             const annotationGroupSelector = viewport.element;

package/dist/esm/tools/displayTools/Labelmap/labelmapRenderPlan/legacyVolumePlan.js

@@ -47,7 +47,7 @@ async function mountLegacyVolumeLabelmap({ config, labelMapData, segmentation, s
         }
         labelmapLayers.push({
             labelmapId: volumeId,
-            type: 'volume',
+            storageKind: 'volume',
             volumeId,
             imageIds: cache.getVolume(volumeId)?.imageIds,
         });
@@ -56,16 +56,28 @@ async function mountLegacyVolumeLabelmap({ config, labelMapData, segmentation, s
     let useIndependentComponents = blendMode === Enums.BlendModes.LABELMAP_EDGE_PROJECTION_BLEND;
     if (useIndependentComponents) {
         const referenceVolumeId = volumeCompatibleViewport.getVolumeId?.();
-        const baseVolume = cache.getVolume(referenceVolumeId);
-        const segVolume = cache.getVolume(labelmapLayers[0]?.volumeId);
-        const segDims = segVolume.dimensions;
-        const refDims = baseVolume.dimensions;
-        if (segDims[0] !== refDims[0] ||
-            segDims[1] !== refDims[1] ||
-            segDims[2] !== refDims[2]) {
+        const segLabelmapVolumeId = labelmapLayers[0]?.volumeId;
+        const baseVolume = referenceVolumeId
+            ? cache.getVolume(referenceVolumeId)
+            : undefined;
+        const segVolume = segLabelmapVolumeId
+            ? cache.getVolume(segLabelmapVolumeId)
+            : undefined;
+        if (!baseVolume || !segVolume) {
             useIndependentComponents = false;
             blendMode = Enums.BlendModes.MAXIMUM_INTENSITY_BLEND;
-            console.debug('Dimensions mismatch - falling back to regular volume addition');
+            console.debug('Independent components unavailable (missing reference or segmentation volume) - falling back to regular volume addition');
+        }
+        else {
+            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 = labelmapLayers.map((layer) => ({

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

@@ -1,5 +1,6 @@
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
 import { ActorRenderMode, cache, utilities, } from '@cornerstonejs/core';
 import { triggerSegmentationRender } from '../../../stateManagement/segmentation/SegmentationRenderingEngine';
 import { updateLabelmapSegmentationImageReferences } from '../../../stateManagement/segmentation/updateLabelmapSegmentationImageReferences';
@@ -22,6 +23,7 @@ export function syncStackLabelmapActors(viewport, segmentationId) {
     const derivedImageIdSet = new Set(derivedImageIds);
     const labelmapActorEntries = getLabelmapActorEntries(viewport.id, segmentationId) ?? [];
     const staleActorEntries = labelmapActorEntries.filter((actorEntry) => !derivedImageIdSet.has(actorEntry.referencedId));
+    const inheritedLabelmapStyle = captureLabelmapActorStyle(staleActorEntries[0]?.actor);
     let shouldTriggerSegmentationRender = false;
     let shouldRenderViewport = staleActorEntries.length > 0;
     if (staleActorEntries.length) {
@@ -104,6 +106,7 @@ export function syncStackLabelmapActors(viewport, segmentationId) {
                         representationUID,
                         callback: ({ imageActor }) => {
                             imageActor.getMapper().setInputData(imageData);
+                            applyInheritedLabelmapStyle(imageActor, inheritedLabelmapStyle);
                         },
                     },
                 ]);
@@ -133,3 +136,36 @@ export function syncStackLabelmapActors(viewport, segmentationId) {
         viewport.render();
     }
 }
+function captureLabelmapActorStyle(actor) {
+    const prop = actor?.getProperty?.();
+    if (!prop) {
+        return undefined;
+    }
+    return {
+        cfun: prop.getRGBTransferFunction?.(0),
+        ofun: prop.getScalarOpacity?.(0),
+    };
+}
+function applyInheritedLabelmapStyle(actor, style) {
+    const prop = actor?.getProperty?.();
+    if (!prop) {
+        return;
+    }
+    if (style?.cfun && prop.setRGBTransferFunction) {
+        prop.setRGBTransferFunction(0, style.cfun);
+    }
+    if (style?.ofun && prop.setScalarOpacity) {
+        prop.setScalarOpacity(0, style.ofun);
+    }
+    else if (prop.setScalarOpacity) {
+        const ofun = vtkPiecewiseFunction.newInstance();
+        ofun.addPoint(0, 0);
+        ofun.addPoint(1, 1);
+        ofun.setClamping(false);
+        prop.setScalarOpacity(0, ofun);
+    }
+    prop.setUseLookupTableScalarRange?.(true);
+    prop.setInterpolationTypeToNearest?.();
+    actor?.setForceTranslucent?.(true);
+    actor?.setForceOpaque?.(false);
+}

package/dist/esm/tools/segmentation/CircleScissorsTool.js

@@ -6,6 +6,7 @@ import { Events } from '../../enums';
 import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
+import getViewportICamera from '../../utilities/getViewportICamera';
 import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, config as segmentationConfig, } from '../../stateManagement/segmentation';
 import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
 import getViewportLabelmapRenderMode from '../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
@@ -37,7 +38,7 @@ class CircleScissorsTool extends LabelmapBaseTool {
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
             this.isDrawing = true;
-            const camera = viewport.getCamera();
+            const camera = getViewportICamera(viewport);
             const { viewPlaneNormal, viewUp } = camera;
             const activeLabelmapSegmentation = activeSegmentation.getActiveSegmentation(viewport.id);
             if (!activeLabelmapSegmentation) {

package/dist/esm/tools/segmentation/RectangleScissorsTool.js

@@ -7,6 +7,7 @@ import { Events, SegmentationRepresentations } from '../../enums';
 import { drawRect as drawRectSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
+import getViewportICamera from '../../utilities/getViewportICamera';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
 import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
 import getViewportLabelmapRenderMode from '../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
@@ -35,7 +36,7 @@ class RectangleScissorsTool extends LabelmapBaseTool {
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
             this.isDrawing = true;
-            const camera = viewport.getCamera();
+            const camera = getViewportICamera(viewport);
             const { viewPlaneNormal, viewUp } = camera;
             const activeLabelmapSegmentation = activeSegmentation.getActiveSegmentation(viewport.id);
             if (!activeLabelmapSegmentation) {

package/dist/esm/tools/segmentation/SegmentBidirectionalTool.js

@@ -7,6 +7,7 @@ import { drawLine as drawLineSvg, drawHandles as drawHandlesSvg, } from '../../d
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import { hideElementCursor } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
+import getViewportICamera from '../../utilities/getViewportICamera';
 import BidirectionalTool from '../annotation/BidirectionalTool';
 import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
 class SegmentBidirectionalTool extends BidirectionalTool {
@@ -118,7 +119,7 @@ class SegmentBidirectionalTool extends BidirectionalTool {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
         this.isDrawing = true;
-        const camera = viewport.getCamera();
+        const camera = getViewportICamera(viewport);
         const { viewPlaneNormal, viewUp } = camera;
         const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
         const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();

package/dist/esm/tools/segmentation/strategies/fillRectangle.js

@@ -1,6 +1,7 @@
 import { vec3 } from 'gl-matrix';
 import { utilities as csUtils, StackViewport } from '@cornerstonejs/core';
 import { getBoundingBoxAroundShapeIJK } from '../../../utilities/boundingBox';
+import getViewportICamera from '../../../utilities/getViewportICamera';
 import BrushStrategy from './BrushStrategy';
 import { StrategyCallbacks } from '../../../enums';
 import compositions from './compositions';
@@ -47,7 +48,7 @@ function createPointInRectangle(viewport, points, segmentationImageData) {
     vec3.normalize(normal, normal);
     const direction = segmentationImageData.getDirection();
     const spacing = segmentationImageData.getSpacing();
-    const { viewPlaneNormal } = viewport.getCamera();
+    const { viewPlaneNormal } = getViewportICamera(viewport);
     const EPS = csUtils.getSpacingInNormalDirection({
         direction,
         spacing,

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

@@ -17,7 +17,7 @@ export type LabelmapStyle = BaseLabelmapStyle & InactiveLabelmapStyle;
 export type LabelmapLayerType = 'volume' | 'stack';
 export type LabelmapLayer = {
     labelmapId: string;
-    type: LabelmapLayerType;
+    storageKind: LabelmapLayerType;
     volumeId?: string;
     geometryVolumeId?: string;
     referencedVolumeId?: string;

package/dist/esm/utilities/cine/playClip.js

@@ -339,6 +339,31 @@ function _createDynamicVolumeViewportCinePlayContext(volume) {
         },
     };
 }
+function _createGenericViewportCinePlayContext(viewport, waitForRendered) {
+    return {
+        get numScrollSteps() {
+            return viewport.getNumberOfSlices();
+        },
+        get currentStepIndex() {
+            return viewport.getSliceIndex();
+        },
+        get frameTimeVectorEnabled() {
+            return viewport.getCurrentMode() === 'stack';
+        },
+        waitForRenderedCount: 0,
+        scroll(delta) {
+            const status = viewport.viewportStatus;
+            if (this.waitForRenderedCount <= waitForRendered &&
+                status !== undefined &&
+                status !== ViewportStatus.RENDERED) {
+                this.waitForRenderedCount++;
+                return;
+            }
+            this.waitForRenderedCount = 0;
+            csUtils.scroll(viewport, { delta, debounceLoading: debounced });
+        },
+    };
+}
 function _createCinePlayContext(viewport, playClipOptions) {
     if (viewport instanceof StackViewport) {
         return _createStackViewportCinePlayContext(viewport, playClipOptions.waitForRendered ?? 30);
@@ -353,6 +378,9 @@ function _createCinePlayContext(viewport, playClipOptions) {
     if (viewport instanceof VideoViewport) {
         return _createVideoViewportCinePlayContext(viewport, playClipOptions.waitForRendered ?? 30);
     }
+    if (csUtils.isGenericViewport(viewport)) {
+        return _createGenericViewportCinePlayContext(viewport, playClipOptions.waitForRendered ?? 30);
+    }
     throw new Error('Unknown viewport type');
 }
 export { playClip, stopClip };

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

@@ -0,0 +1,11 @@
+import { type Types } from '@cornerstonejs/core';
+export declare function getSlabThicknessOrDefault(viewport: Types.IViewport): number;
+export declare function jumpToFocalPoint(viewport: Types.IViewport, cameraFocalPoint: Types.Point3): void;
+export interface NativeSourceProperties {
+    properties: Record<string, unknown>;
+    rotation?: number;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+    currentImageId?: string;
+}
+export declare function getNativeSourceProperties(viewport: Types.IViewport): NativeSourceProperties;

package/dist/esm/utilities/genericViewportToolHelpers.js

@@ -0,0 +1,37 @@
+import { CONSTANTS, utilities as csUtils, } from '@cornerstonejs/core';
+import { getViewportPresentation } from './viewportPresentation';
+const { RENDERING_DEFAULTS } = CONSTANTS;
+export function getSlabThicknessOrDefault(viewport) {
+    if (csUtils.isGenericViewport(viewport)) {
+        return RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+    }
+    return viewport.getSlabThickness();
+}
+export function jumpToFocalPoint(viewport, cameraFocalPoint) {
+    if (csUtils.isGenericViewport(viewport)) {
+        viewport.setViewReference({ cameraFocalPoint });
+    }
+}
+export function getNativeSourceProperties(viewport) {
+    if (!csUtils.viewportSupportsDisplaySetPresentation(viewport)) {
+        return { properties: {} };
+    }
+    const sourceDataId = viewport.getSourceDataId();
+    const properties = {
+        ...((sourceDataId
+            ? viewport.getDisplaySetPresentation(sourceDataId)
+            : {}) ?? {}),
+    };
+    const voiLUTFunction = properties.VOILUTFunction ?? properties.voiLUTFunction;
+    if (voiLUTFunction !== undefined) {
+        properties.VOILUTFunction = voiLUTFunction;
+    }
+    const presentation = (getViewportPresentation(viewport) ?? {});
+    return {
+        properties,
+        rotation: presentation.rotation,
+        flipHorizontal: presentation.flipHorizontal,
+        flipVertical: presentation.flipVertical,
+        currentImageId: viewport.getCurrentImageId(),
+    };
+}

package/dist/esm/utilities/getVOIMultipliers.js

@@ -1,12 +1,10 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
-import { isViewportPreScaled } from './viewport';
 const DEFAULT_MULTIPLIER = 4;
 function getVOIMultipliers(viewport, volumeId, options) {
-    const modality = csUtils.getViewportModality(viewport, volumeId);
+    const { modality, isPreScaled } = csUtils.getScalingDescriptor(viewport, volumeId) ?? {};
     if (modality === 'PT') {
         const { clientWidth, clientHeight } = viewport.element;
         const ptMultiplier = 5 / Math.max(clientWidth, clientHeight);
-        const isPreScaled = isViewportPreScaled(viewport, volumeId);
         const { fixedPTWindowWidth = true } = options ?? {};
         const xMultiplier = fixedPTWindowWidth ? 0 : ptMultiplier;
         return isPreScaled

package/dist/esm/utilities/getViewportICamera.js

@@ -1,7 +1,8 @@
 import { utilities } from '@cornerstonejs/core';
 export default function getViewportICamera(viewport, viewReference = viewport.getViewReference()) {
-    const genericViewport = viewport;
-    const camera = (genericViewport.getResolvedView?.()?.toICamera?.() ||
+    const camera = ((utilities.isGenericViewport(viewport)
+        ? viewport.getResolvedView()?.toICamera()
+        : undefined) ||
         viewport.getCamera?.() ||
         {});
     const focalPoint = utilities.clonePoint3(viewReference?.cameraFocalPoint || camera.focalPoint);

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

@@ -43,4 +43,5 @@ import { moveAnnotationToViewPlane } from './moveAnnotationToViewPlane';
 import { safeStructuredClone } from './safeStructuredClone';
 import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume';
 import * as usFanExtraction from '../tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, draw3D, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, };
+import { jumpToFocalPoint } from './genericViewportToolHelpers';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, draw3D, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, jumpToFocalPoint, };

package/dist/esm/utilities/index.js

@@ -43,4 +43,5 @@ import { moveAnnotationToViewPlane } from './moveAnnotationToViewPlane';
 import { safeStructuredClone } from './safeStructuredClone';
 import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume';
 import * as usFanExtraction from '../tools/annotation/UltrasoundPleuraBLineTool/utils/fanExtraction';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, draw3D, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, };
+import { jumpToFocalPoint } from './genericViewportToolHelpers';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, draw3D, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, usFanExtraction, setAnnotationLabel, moveAnnotationToViewPlane, safeStructuredClone, getOrCreateImageVolume, jumpToFocalPoint, };

package/dist/esm/utilities/math/polyline/getSubPixelSpacingAndXYDirections.js

@@ -1,11 +1,15 @@
-import { StackViewport } from '@cornerstonejs/core';
+import { StackViewport, utilities as csUtils } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
+import getViewportICamera from '../../getViewportICamera';
 const EPSILON = 1e-3;
 const getSubPixelSpacingAndXYDirections = (viewport, subPixelResolution) => {
     let spacing;
     let xDir;
     let yDir;
-    if (viewport instanceof StackViewport) {
+    const isGeneric = csUtils.isGenericViewport(viewport);
+    const isImageSlice = viewport instanceof StackViewport ||
+        (isGeneric && csUtils.getViewportContentMode(viewport) === 'stack');
+    if (isImageSlice) {
         const imageData = viewport.getImageData();
         if (!imageData) {
             return;
@@ -17,7 +21,7 @@ const getSubPixelSpacingAndXYDirections = (viewport, subPixelResolution) => {
     else {
         const imageData = viewport.getImageData();
         const { direction, spacing: volumeSpacing } = imageData;
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const { viewPlaneNormal, viewUp } = (isGeneric ? getViewportICamera(viewport) : viewport.getCamera());
         const iVector = direction.slice(0, 3);
         const jVector = direction.slice(3, 6);
         const kVector = direction.slice(6, 9);

package/dist/esm/utilities/planar/filterAnnotationsForDisplay.js

@@ -1,8 +1,13 @@
 import { StackViewport, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
 import filterAnnotationsWithinSlice from './filterAnnotationsWithinSlice';
+import getViewportICamera from '../getViewportICamera';
 export default function filterAnnotationsForDisplay(viewport, annotations, filterOptions = {}) {
-    if (viewport instanceof VolumeViewport) {
-        const camera = viewport.getCamera();
+    const isLegacyVolume = viewport instanceof VolumeViewport;
+    const isNativeVolume = csUtils.getViewportContentMode(viewport) === 'volume';
+    if (isLegacyVolume || isNativeVolume) {
+        const camera = isLegacyVolume
+            ? viewport.getCamera()
+            : getViewportICamera(viewport);
         const { spacingInNormalDirection } = csUtils.getTargetVolumeAndSpacingInNormalDir(viewport, camera);
         return filterAnnotationsWithinSlice(annotations, camera, spacingInNormalDirection);
     }

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

@@ -1,4 +1,5 @@
 import { BaseVolumeViewport, cache, utilities } from '@cornerstonejs/core';
+import getViewportICamera from '../getViewportICamera';
 import { SegmentationRepresentations } from '../../enums';
 import { getSegmentation, getCurrentLabelmapImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
 import { getAnnotation } from '../../stateManagement';
@@ -75,7 +76,7 @@ export function getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, { vi
 export function getSegmentIndexAtWorldForContour(segmentation, worldPoint, { viewport }) {
     const contourData = segmentation.representationData.Contour;
     const segmentIndices = Array.from(contourData.annotationUIDsMap.keys());
-    const { viewPlaneNormal } = viewport.getCamera();
+    const { viewPlaneNormal } = getViewportICamera(viewport);
     for (const segmentIndex of segmentIndices) {
         const annotationsSet = contourData.annotationUIDsMap.get(segmentIndex);
         if (!annotationsSet) {

package/dist/esm/utilities/segmentation/growCut/runGrowCutForSphere.js

@@ -1,5 +1,6 @@
 import { quat, vec3 } from 'gl-matrix';
 import { utilities as csUtils, cache, volumeLoader } from '@cornerstonejs/core';
+import getViewportICamera from '../../getViewportICamera';
 import { run } from './runGrowCut';
 import { getSphereBoundsInfo } from '../../getSphereBoundsInfo';
 const { transformWorldToIndex } = csUtils;
@@ -29,7 +30,7 @@ function _getSphereBoundsInfo(referencedVolume, sphereInfo) {
 }
 function _createSubVolumeFromSphere(referencedVolume, sphereInfo, viewport) {
     const refVolImageData = referencedVolume.imageData;
-    const camera = viewport.getCamera();
+    const camera = getViewportICamera(viewport);
     const { ijkVecRowDir, ijkVecColDir } = csUtils.getVolumeDirectionVectors(refVolImageData, camera);
     const obliqueView = [ijkVecRowDir, ijkVecColDir].some((vec) => !csUtils.isEqual(Math.abs(vec[0]), 1) &&
         !csUtils.isEqual(Math.abs(vec[1]), 1) &&
@@ -113,7 +114,7 @@ function _setNegativeSeedValues(subVolume, labelmap, sphereInfo, viewport, optio
     const subVolPixelData = subVolume.voxelManager.getCompleteScalarDataArray();
     const [columns, rows, numSlices] = labelmap.dimensions;
     const numPixelsPerSlice = columns * rows;
-    const { worldVecRowDir, worldVecSliceDir } = csUtils.getVolumeDirectionVectors(labelmap.imageData, viewport.getCamera());
+    const { worldVecRowDir, worldVecSliceDir } = csUtils.getVolumeDirectionVectors(labelmap.imageData, getViewportICamera(viewport));
     const ijkSphereCenter = transformWorldToIndex(subVolume.imageData, sphereInfo.center);
     const referencePixelValue = subVolPixelData[ijkSphereCenter[2] * columns * rows +
         ijkSphereCenter[1] * columns +

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

@@ -0,0 +1,3 @@
+import { type Types } from '@cornerstonejs/core';
+export default function setViewportCamera(viewport: Types.IViewport, camera: Partial<Types.ICamera>): void;
+export declare function resetViewportCamera(viewport: Types.IViewport, options?: unknown): void;

package/dist/esm/utilities/setViewportCamera.js

@@ -0,0 +1,58 @@
+import { utilities, Enums } from '@cornerstonejs/core';
+function normalizeVec3(v) {
+    const length = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    return length > 0 ? [v[0] / length, v[1] / length, v[2] / length] : v;
+}
+export default function setViewportCamera(viewport, camera) {
+    const vp = viewport;
+    if (utilities.isGenericViewport(viewport)) {
+        if (viewport.type === Enums.ViewportType.PLANAR_NEXT &&
+            typeof vp.setViewReference === 'function') {
+            const ref = viewport.getViewReference();
+            const focalPoint = camera.focalPoint ?? ref?.cameraFocalPoint;
+            const viewUp = camera.viewUp ?? ref?.viewUp;
+            let viewPlaneNormal = camera.viewPlaneNormal;
+            if (!viewPlaneNormal && camera.position && focalPoint) {
+                viewPlaneNormal = normalizeVec3([
+                    camera.position[0] - focalPoint[0],
+                    camera.position[1] - focalPoint[1],
+                    camera.position[2] - focalPoint[2],
+                ]);
+            }
+            const rotatingVp = viewport;
+            const readResolvedScale = () => rotatingVp.getResolvedView?.()?.toICamera?.()?.parallelScale;
+            const beforeScale = readResolvedScale();
+            const beforeZoom = rotatingVp.getZoom?.();
+            vp.setViewReference({
+                ...ref,
+                cameraFocalPoint: focalPoint,
+                viewPlaneNormal,
+                viewUp,
+            });
+            rotatingVp.invalidateResolvedView?.();
+            const afterScale = readResolvedScale();
+            if (beforeScale &&
+                afterScale &&
+                typeof beforeZoom === 'number' &&
+                typeof rotatingVp.setZoom === 'function') {
+                const newZoom = (afterScale * beforeZoom) / beforeScale;
+                if (Number.isFinite(newZoom) && newZoom > 0) {
+                    rotatingVp.setZoom(newZoom);
+                }
+            }
+            viewport.render();
+            return;
+        }
+        vp.setViewState?.(camera);
+        return;
+    }
+    vp.setCamera?.(camera);
+}
+export function resetViewportCamera(viewport, options) {
+    const vp = viewport;
+    if (utilities.isGenericViewport(viewport)) {
+        vp.resetViewState?.(options);
+        return;
+    }
+    vp.resetCamera?.(options);
+}

package/dist/esm/utilities/stackPrefetch/stackPrefetchUtils.js

@@ -1,5 +1,6 @@
-import { getEnabledElement, StackViewport, Enums } from '@cornerstonejs/core';
+import { getEnabledElement, Enums, utilities } from '@cornerstonejs/core';
 import { getToolState } from './state';
+import { viewportSupportsImageSlices } from '../viewportCapabilities';
 export const requestType = Enums.RequestType.Prefetch;
 export const priority = 0;
 export function range(lowEnd, highEnd) {
@@ -34,7 +35,10 @@ export function getStackData(element) {
         return null;
     }
     const { viewport } = enabledElement;
-    if (!(viewport instanceof StackViewport)) {
+    if (!viewportSupportsImageSlices(viewport) ||
+        utilities.viewportIsInVolumeMode(viewport) ||
+        (utilities.viewportSupportsVolumeCompatibility(viewport) &&
+            !utilities.isGenericViewport(viewport))) {
         return null;
     }
     return {