@cornerstonejs/tools 5.0.0-beta.1 → 5.0.0

package/dist/esm/stateManagement/segmentation/labelmapModel/normalizeLabelmapSegmentationData.js

@@ -0,0 +1,75 @@
+const SOURCE_REPRESENTATION_NAME = 'binaryLabelmap';
+function getSegmentOrder(segmentation) {
+    if (segmentation.segmentOrder?.length) {
+        return [...segmentation.segmentOrder];
+    }
+    return Object.keys(segmentation.segments)
+        .map(Number)
+        .sort((a, b) => a - b);
+}
+function getPrimaryLabelmapId(segmentationId) {
+    return `${segmentationId}-storage-0`;
+}
+function getPrimaryLabelmapType(labelmapData) {
+    return labelmapData.volumeId ? 'volume' : 'stack';
+}
+function createPrimaryLabelmapLayer(segmentation, labelmapData, labelmapId = getPrimaryLabelmapId(segmentation.segmentationId)) {
+    const layer = {
+        labelmapId,
+        type: getPrimaryLabelmapType(labelmapData),
+        labelToSegmentIndex: {},
+    };
+    if (labelmapData.volumeId != null) {
+        layer.volumeId = labelmapData.volumeId;
+    }
+    if (labelmapData.referencedVolumeId != null) {
+        layer.referencedVolumeId = labelmapData.referencedVolumeId;
+    }
+    if (labelmapData.referencedImageIds != null) {
+        layer.referencedImageIds = labelmapData.referencedImageIds;
+    }
+    if (labelmapData.imageIds != null) {
+        layer.imageIds = labelmapData.imageIds;
+    }
+    return layer;
+}
+function resolvePrimaryLabelmapId(segmentation, labelmapData) {
+    const storedLabelmapId = labelmapData.primaryLabelmapId;
+    if (storedLabelmapId && labelmapData.labelmaps?.[storedLabelmapId]) {
+        return storedLabelmapId;
+    }
+    const fallbackLabelmapId = Object.keys(labelmapData.labelmaps ?? {})[0] ??
+        getPrimaryLabelmapId(segmentation.segmentationId);
+    labelmapData.primaryLabelmapId = fallbackLabelmapId;
+    return fallbackLabelmapId;
+}
+function ensureLabelmapState(segmentation) {
+    const labelmapData = segmentation.representationData.Labelmap;
+    if (!labelmapData) {
+        return;
+    }
+    labelmapData.labelmaps ||= {};
+    const primaryLabelmapId = resolvePrimaryLabelmapId(segmentation, labelmapData);
+    labelmapData.labelmaps[primaryLabelmapId] ||= createPrimaryLabelmapLayer(segmentation, labelmapData, primaryLabelmapId);
+    labelmapData.segmentBindings ||= {};
+    labelmapData.sourceRepresentationName ||= SOURCE_REPRESENTATION_NAME;
+    getSegmentOrder(segmentation).forEach((segmentIndex) => {
+        labelmapData.segmentBindings[segmentIndex] ||= {
+            labelmapId: primaryLabelmapId,
+            labelValue: segmentIndex,
+        };
+    });
+    Object.values(labelmapData.labelmaps).forEach((layer) => {
+        layer.labelToSegmentIndex = {};
+    });
+    Object.entries(labelmapData.segmentBindings).forEach(([segmentIndex, binding]) => {
+        const layer = labelmapData.labelmaps[binding.labelmapId];
+        if (!layer) {
+            return;
+        }
+        layer.labelToSegmentIndex ||= {};
+        layer.labelToSegmentIndex[binding.labelValue] = Number(segmentIndex);
+    });
+    return labelmapData;
+}
+export { SOURCE_REPRESENTATION_NAME, ensureLabelmapState, getPrimaryLabelmapId, getSegmentOrder, };

package/dist/esm/stateManagement/segmentation/labelmapModel/privateLabelmap.d.ts

@@ -0,0 +1,5 @@
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+import type { LabelmapLayer } from '../../../types/LabelmapTypes';
+declare function createPrivateLabelmap(segmentation: Segmentation, sourceLabelmap: LabelmapLayer): LabelmapLayer;
+declare function moveSegmentToPrivateLabelmap(segmentation: Segmentation, segmentIndex: number): LabelmapLayer | undefined;
+export { createPrivateLabelmap, moveSegmentToPrivateLabelmap };

package/dist/esm/stateManagement/segmentation/labelmapModel/privateLabelmap.js

@@ -0,0 +1,106 @@
+import { cache, imageLoader, utilities as csUtils, volumeLoader, } from '@cornerstonejs/core';
+import { getLabelmap, registerLabelmap } from './labelmapLayerStore';
+import { getSegmentBinding, getSegmentsOnLabelmap, setSegmentBinding, } from './labelmapSegmentBindings';
+import { syncLegacyLabelmapData } from './labelmapLegacyAdapter';
+function createPrivateVolumeLabelmap(segmentation, sourceLabelmap) {
+    const sourceVolume = cache.getVolume(sourceLabelmap.volumeId);
+    const volumeId = `${segmentation.segmentationId}-storage-${csUtils.uuidv4()}`;
+    const referencedVolumeId = sourceLabelmap.referencedVolumeId ??
+        sourceVolume?.referencedVolumeId ??
+        sourceLabelmap.volumeId;
+    const volume = volumeLoader.createAndCacheDerivedLabelmapVolume(referencedVolumeId, {
+        volumeId,
+    });
+    return {
+        labelmapId: volumeId,
+        type: 'volume',
+        volumeId,
+        imageIds: volume.imageIds,
+        referencedVolumeId,
+        referencedImageIds: sourceLabelmap.referencedImageIds ?? sourceVolume?.referencedImageIds,
+        labelToSegmentIndex: {},
+    };
+}
+function createPrivateStackLabelmap(segmentation, sourceLabelmap) {
+    const referencedImageIds = sourceLabelmap.referencedImageIds ?? sourceLabelmap.imageIds ?? [];
+    const sourceImageIds = sourceLabelmap.imageIds ?? [];
+    const sourceImage = sourceImageIds[0]
+        ? cache.getImage(sourceImageIds[0])
+        : null;
+    const targetType = sourceImage?.voxelManager?.getConstructor?.().name ?? 'Uint8Array';
+    const images = imageLoader.createAndCacheDerivedImages(referencedImageIds, {
+        getDerivedImageId: (referencedImageId) => `${segmentation.segmentationId}-storage-${csUtils.uuidv4()}-${referencedImageId.slice(-12)}`,
+        targetBuffer: {
+            type: targetType,
+        },
+    });
+    return {
+        labelmapId: `${segmentation.segmentationId}-storage-${csUtils.uuidv4()}`,
+        type: 'stack',
+        imageIds: images.map((image) => image.imageId),
+        referencedVolumeId: sourceLabelmap.referencedVolumeId,
+        referencedImageIds,
+        labelToSegmentIndex: {},
+    };
+}
+function createPrivateLabelmap(segmentation, sourceLabelmap) {
+    if (sourceLabelmap.imageIds?.length ||
+        sourceLabelmap.referencedImageIds?.length) {
+        return createPrivateStackLabelmap(segmentation, sourceLabelmap);
+    }
+    if (sourceLabelmap.volumeId) {
+        return createPrivateVolumeLabelmap(segmentation, sourceLabelmap);
+    }
+    return createPrivateStackLabelmap(segmentation, sourceLabelmap);
+}
+function moveSegmentToPrivateLabelmap(segmentation, segmentIndex) {
+    const binding = getSegmentBinding(segmentation, segmentIndex);
+    if (!binding) {
+        return;
+    }
+    const sourceLabelmap = getLabelmap(segmentation, binding.labelmapId);
+    if (!sourceLabelmap) {
+        return;
+    }
+    if (getSegmentsOnLabelmap(segmentation, sourceLabelmap.labelmapId).length <= 1) {
+        return sourceLabelmap;
+    }
+    const privateLabelmap = createPrivateLabelmap(segmentation, sourceLabelmap);
+    registerLabelmap(segmentation, privateLabelmap);
+    if (sourceLabelmap.volumeId && privateLabelmap.volumeId) {
+        const sourceVolume = cache.getVolume(sourceLabelmap.volumeId);
+        const targetVolume = cache.getVolume(privateLabelmap.volumeId);
+        sourceVolume.voxelManager.forEach(({ value, index }) => {
+            if (value !== binding.labelValue) {
+                return;
+            }
+            targetVolume.voxelManager.setAtIndex(index, 1);
+            sourceVolume.voxelManager.setAtIndex(index, 0);
+        });
+    }
+    else {
+        const sourceImageIds = sourceLabelmap.imageIds ?? [];
+        const targetImageIds = privateLabelmap.imageIds ?? [];
+        sourceImageIds.forEach((imageId, imageIndex) => {
+            const sourceImage = cache.getImage(imageId);
+            const targetImage = cache.getImage(targetImageIds[imageIndex]);
+            if (!sourceImage || !targetImage) {
+                return;
+            }
+            sourceImage.voxelManager.forEach(({ value, index }) => {
+                if (value !== binding.labelValue) {
+                    return;
+                }
+                targetImage.voxelManager.setAtIndex(index, 1);
+                sourceImage.voxelManager.setAtIndex(index, 0);
+            });
+        });
+    }
+    setSegmentBinding(segmentation, segmentIndex, {
+        labelmapId: privateLabelmap.labelmapId,
+        labelValue: 1,
+    });
+    syncLegacyLabelmapData(segmentation);
+    return privateLabelmap;
+}
+export { createPrivateLabelmap, moveSegmentToPrivateLabelmap };

package/dist/esm/stateManagement/segmentation/models/SegmentModel.d.ts

@@ -0,0 +1,11 @@
+import type { Segment, Segmentation } from '../../../types/SegmentationStateTypes';
+import type { SegmentLabelmapBindingState } from '../../../types/LabelmapTypes';
+export default class SegmentModel {
+    private readonly segmentation;
+    private readonly state;
+    constructor(segmentation: Segmentation, state: Segment);
+    get segmentIndex(): number;
+    get label(): string;
+    get binding(): SegmentLabelmapBindingState | undefined;
+    toState(): Segment;
+}

package/dist/esm/stateManagement/segmentation/models/SegmentModel.js

@@ -0,0 +1,19 @@
+import { getSegmentBinding } from '../helpers/labelmapSegmentationState';
+export default class SegmentModel {
+    constructor(segmentation, state) {
+        this.segmentation = segmentation;
+        this.state = state;
+    }
+    get segmentIndex() {
+        return this.state.segmentIndex;
+    }
+    get label() {
+        return this.state.label;
+    }
+    get binding() {
+        return getSegmentBinding(this.segmentation, this.state.segmentIndex);
+    }
+    toState() {
+        return this.state;
+    }
+}

package/dist/esm/stateManagement/segmentation/models/SegmentationModel.d.ts

@@ -0,0 +1,12 @@
+import type { Segmentation } from '../../../types/SegmentationStateTypes';
+import type { LabelmapLayer } from '../../../types/LabelmapTypes';
+import SegmentModel from './SegmentModel';
+export default class SegmentationModel {
+    private readonly state;
+    constructor(state: Segmentation);
+    get segmentationId(): string;
+    get segments(): SegmentModel[];
+    getLabelmaps(): LabelmapLayer[];
+    getBinding(segmentIndex: number): import("../../../types/LabelmapTypes").SegmentLabelmapBindingState;
+    toState(): Segmentation;
+}

package/dist/esm/stateManagement/segmentation/models/SegmentationModel.js

@@ -0,0 +1,23 @@
+import SegmentModel from './SegmentModel';
+import { ensureLabelmapState, getLabelmaps, getSegmentBinding, } from '../helpers/labelmapSegmentationState';
+export default class SegmentationModel {
+    constructor(state) {
+        this.state = state;
+        ensureLabelmapState(state);
+    }
+    get segmentationId() {
+        return this.state.segmentationId;
+    }
+    get segments() {
+        return Object.values(this.state.segments).map((segment) => new SegmentModel(this.state, segment));
+    }
+    getLabelmaps() {
+        return getLabelmaps(this.state);
+    }
+    getBinding(segmentIndex) {
+        return getSegmentBinding(this.state, segmentIndex);
+    }
+    toState() {
+        return this.state;
+    }
+}

package/dist/esm/stateManagement/segmentation/removeSegmentationRepresentations.js

@@ -1,11 +1,9 @@
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
-import labelmapDisplay from '../../tools/displayTools/Labelmap/labelmapDisplay';
-import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
 import { getSegmentationRepresentations } from './getSegmentationRepresentation';
 import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
-import { surfaceDisplay } from '../../tools/displayTools/Surface';
 import { removeSegmentationListener } from './segmentationEventManager';
+import { getSegmentationRepresentationDisplay } from './SegmentationRepresentationDisplayRegistry';
 function removeSegmentationRepresentation(viewportId, specifier, immediate) {
     return _removeSegmentationRepresentations(viewportId, specifier, immediate);
 }
@@ -56,14 +54,12 @@ function _removeRepresentationObject(viewportId, segmentationId, type, immediate
         type,
     });
     representations.forEach((representation) => {
-        if (representation.type === SegmentationRepresentations.Labelmap) {
-            labelmapDisplay.removeRepresentation(viewportId, representation.segmentationId, immediate);
+        const display = getSegmentationRepresentationDisplay(representation.type);
+        if (display) {
+            display.removeRepresentation(viewportId, representation.segmentationId, immediate);
         }
-        else if (representation.type === SegmentationRepresentations.Contour) {
-            contourDisplay.removeRepresentation(viewportId, representation.segmentationId, immediate);
-        }
-        else if (representation.type === SegmentationRepresentations.Surface) {
-            surfaceDisplay.removeRepresentation(viewportId, representation.segmentationId, immediate);
+        else {
+            console.warn(`No display registered for segmentation representation type ${representation.type}.`);
         }
         removeSegmentationListener(representation.segmentationId, representation.type);
     });

package/dist/esm/stateManagement/segmentation/segmentIndex.js

@@ -5,6 +5,7 @@ import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 import { getActiveSegmentIndex } from './getActiveSegmentIndex';
 import { getSegmentationRepresentations } from './getSegmentationRepresentation';
+import { ensureLabelmapState, getSegmentBinding, getLabelmaps, setSegmentBinding, syncLegacyLabelmapData, } from './helpers/labelmapSegmentationState';
 function setActiveSegmentIndex(segmentationId, segmentIndex) {
     const segmentation = getSegmentation(segmentationId);
     if (typeof segmentIndex === 'string') {
@@ -22,6 +23,29 @@ function setActiveSegmentIndex(segmentationId, segmentIndex) {
             cachedStats: {},
             active: false,
         };
+        if (segmentation.representationData?.Labelmap) {
+            ensureLabelmapState(segmentation);
+            const primaryLayer = getLabelmaps(segmentation)[0];
+            if (primaryLayer) {
+                setSegmentBinding(segmentation, segmentIndex, {
+                    labelmapId: primaryLayer.labelmapId,
+                    labelValue: segmentIndex,
+                });
+                syncLegacyLabelmapData(segmentation);
+            }
+        }
+    }
+    if (segmentation.representationData?.Labelmap &&
+        !getSegmentBinding(segmentation, segmentIndex)) {
+        ensureLabelmapState(segmentation);
+        const primaryLayer = getLabelmaps(segmentation)[0];
+        if (primaryLayer) {
+            setSegmentBinding(segmentation, segmentIndex, {
+                labelmapId: primaryLayer.labelmapId,
+                labelValue: segmentIndex,
+            });
+            syncLegacyLabelmapData(segmentation);
+        }
     }
     if (segmentation.segments[segmentIndex].active !== true) {
         segmentation.segments[segmentIndex].active = true;

package/dist/esm/stateManagement/segmentation/segmentationEventManager.js

@@ -2,18 +2,11 @@ import { eventTarget } from '@cornerstonejs/core';
 import { Events, SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 import debounce from '../../utilities/debounce';
-import surfaceDisplay from '../../tools/displayTools/Surface/surfaceDisplay';
-import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
-import labelmapDisplay from '../../tools/displayTools/Labelmap/labelmapDisplay';
 import { getSegmentation } from './getSegmentation';
-const renderers = {
-    [SegmentationRepresentations.Labelmap]: labelmapDisplay,
-    [SegmentationRepresentations.Contour]: contourDisplay,
-    [SegmentationRepresentations.Surface]: surfaceDisplay,
-};
+import { getSegmentationRepresentationDisplay } from './SegmentationRepresentationDisplayRegistry';
 const segmentationListeners = new Map();
 export function addDefaultSegmentationListener(viewport, segmentationId, representationType) {
-    const updateFunction = renderers[representationType].getUpdateFunction(viewport);
+    const updateFunction = getSegmentationRepresentationDisplay(representationType)?.getUpdateFunction(viewport);
     if (updateFunction) {
         addSegmentationListener(segmentationId, representationType, updateFunction);
     }

package/dist/esm/stateManagement/segmentation/segmentationState.d.ts

@@ -14,4 +14,5 @@ import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegme
 import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
 import { getSegmentationRepresentation, getSegmentationRepresentations, getSegmentationRepresentationsBySegmentationId } from './getSegmentationRepresentation';
 declare function destroy(): void;
-export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, getViewportSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };
+declare function getDefaultSegmentationStateManager(): import("./SegmentationStateManager").default;
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, getViewportSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, getDefaultSegmentationStateManager, };

package/dist/esm/stateManagement/segmentation/segmentationState.js

@@ -17,4 +17,7 @@ import { defaultSegmentationStateManager } from './SegmentationStateManager';
 function destroy() {
     defaultSegmentationStateManager.resetState();
 }
-export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, getViewportSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };
+function getDefaultSegmentationStateManager() {
+    return defaultSegmentationStateManager;
+}
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, getViewportSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, getDefaultSegmentationStateManager, };

package/dist/esm/store/SynchronizerManager/Synchronizer.d.ts

@@ -8,7 +8,9 @@ type auxiliaryEvent = {
 export type SynchronizerOptions = {
     auxiliaryEvents?: auxiliaryEvent[];
     eventSource?: eventSource;
-    viewPresentation?: Types.ViewPresentation;
+    viewPresentation?: Types.ViewPresentationSelector;
+    syncInvertState?: boolean;
+    syncColormap?: boolean;
 };
 declare class Synchronizer {
     private _enabled;

package/dist/esm/store/state.js

@@ -1,3 +1,4 @@
+import { utilities } from '@cornerstonejs/core';
 import svgNodeCache, { resetSvgNodeCache } from './svgNodeCache';
 const defaultState = {
     isInteractingWithTool: false,
@@ -22,7 +23,7 @@ let state = {
 function resetCornerstoneToolsState() {
     resetSvgNodeCache();
     state = {
-        ...structuredClone({
+        ...utilities.deepClone({
             ...defaultState,
             svgNodeCache: {},
         }),

package/dist/esm/synchronizers/callbacks/imageSliceSyncCallback.js

@@ -1,7 +1,16 @@
 import { vec3, mat4 } from 'gl-matrix';
-import { getRenderingEngine, metaData, utilities, VolumeViewport, } from '@cornerstonejs/core';
+import { ActorRenderMode, getRenderingEngine, metaData, utilities, VolumeViewport, } from '@cornerstonejs/core';
 import areViewportsCoplanar from './areViewportsCoplanar';
 const getSpatialRegistration = (targetId, sourceId) => utilities.spatialRegistrationMetadataProvider.get('spatialRegistrationModule', targetId, sourceId);
+function isVolumeSliceViewport(viewport) {
+    if (viewport instanceof VolumeViewport) {
+        return true;
+    }
+    const getDefaultActor = viewport.getDefaultActor;
+    const renderMode = getDefaultActor?.call(viewport)?.actorMapper?.renderMode;
+    return (renderMode === ActorRenderMode.CPU_VOLUME ||
+        renderMode === ActorRenderMode.VTK_VOLUME_SLICE);
+}
 export default async function imageSliceSyncCallback(synchronizerInstance, sourceViewport, targetViewport) {
     const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
     if (!renderingEngine) {
@@ -39,11 +48,11 @@ export default async function imageSliceSyncCallback(synchronizerInstance, sourc
     const targetImagePositionPatientWithRegistrationMatrix = vec3.transformMat4(vec3.create(), sourceImagePositionPatient, registrationMatrixMat4);
     const closestImageIdIndex2 = _getClosestImageIdIndex(targetImagePositionPatientWithRegistrationMatrix, targetImageIds);
     let imageIndexToSet = closestImageIdIndex2.index;
-    if (tViewport instanceof VolumeViewport) {
+    if (isVolumeSliceViewport(tViewport)) {
         imageIndexToSet = targetImageIds.length - closestImageIdIndex2.index - 1;
     }
     if (closestImageIdIndex2.index !== -1 &&
-        tViewport.getCurrentImageIdIndex() !== closestImageIdIndex2.index) {
+        tViewport.getCurrentImageIdIndex() !== imageIndexToSet) {
         await utilities.jumpToSlice(tViewport.element, {
             imageIndex: imageIndexToSet,
         });

package/dist/esm/synchronizers/callbacks/presentationViewSyncCallback.js

@@ -1,4 +1,5 @@
 import { getRenderingEngine } from '@cornerstonejs/core';
+import { applyViewportPresentation, getViewportPresentation, } from '../../utilities/viewportPresentation';
 export default function presentationViewSyncCallback(_synchronizerInstance, sourceViewport, targetViewport, _sourceEvent, options) {
     const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
     if (!renderingEngine) {
@@ -6,7 +7,9 @@ export default function presentationViewSyncCallback(_synchronizerInstance, sour
     }
     const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
     const sViewport = renderingEngine.getViewport(sourceViewport.viewportId);
-    const presentationView = sViewport.getViewPresentation(options);
-    tViewport.setViewPresentation(presentationView);
+    const presentationView = getViewportPresentation(sViewport, options);
+    if (!applyViewportPresentation(tViewport, presentationView)) {
+        return;
+    }
     tViewport.render();
 }

package/dist/esm/synchronizers/callbacks/zoomPanSyncCallback.js

@@ -1,4 +1,43 @@
-import { getRenderingEngine } from '@cornerstonejs/core';
+import { getRenderingEngine, viewportHasPan, viewportHasZoom, viewportProjection, } from '@cornerstonejs/core';
+const zoomPanProjectionSelector = {
+    pan: true,
+    zoom: true,
+};
+function viewportHasViewStateSetter(viewport) {
+    return (Boolean(viewport) &&
+        typeof viewport === 'object' &&
+        'setViewState' in viewport &&
+        typeof viewport.setViewState === 'function');
+}
+function syncProjectionZoomPan(sourceViewport, targetViewport, options) {
+    if (!viewportHasViewStateSetter(targetViewport)) {
+        return false;
+    }
+    const sourcePresentation = viewportProjection.getPresentation(sourceViewport, {
+        selector: zoomPanProjectionSelector,
+    });
+    if (!sourcePresentation) {
+        return false;
+    }
+    const presentationPatch = {};
+    if (options?.syncZoom !== false &&
+        typeof sourcePresentation.zoom === 'number') {
+        presentationPatch.zoom = sourcePresentation.zoom;
+    }
+    if (options?.syncPan !== false && sourcePresentation.pan) {
+        presentationPatch.pan = sourcePresentation.pan;
+    }
+    if (presentationPatch.zoom === undefined &&
+        presentationPatch.pan === undefined) {
+        return false;
+    }
+    const nextViewState = viewportProjection.withPresentation(targetViewport, presentationPatch);
+    if (!nextViewState) {
+        return false;
+    }
+    targetViewport.setViewState(nextViewState);
+    return true;
+}
 export default function zoomPanSyncCallback(synchronizerInstance, sourceViewport, targetViewport) {
     const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
     if (!renderingEngine) {
@@ -7,11 +46,20 @@ export default function zoomPanSyncCallback(synchronizerInstance, sourceViewport
     const options = synchronizerInstance.getOptions(targetViewport.viewportId);
     const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
     const sViewport = renderingEngine.getViewport(sourceViewport.viewportId);
-    if (options?.syncZoom !== false) {
+    const syncedByProjection = syncProjectionZoomPan(sViewport, tViewport, options);
+    if (syncedByProjection) {
+        tViewport.render();
+        return;
+    }
+    if (options?.syncZoom !== false &&
+        viewportHasZoom(sViewport) &&
+        viewportHasZoom(tViewport)) {
         const srcZoom = sViewport.getZoom();
         tViewport.setZoom(srcZoom);
     }
-    if (options?.syncPan !== false) {
+    if (options?.syncPan !== false &&
+        viewportHasPan(sViewport) &&
+        viewportHasPan(tViewport)) {
         const srcPan = sViewport.getPan();
         tViewport.setPan(srcPan);
     }

package/dist/esm/synchronizers/synchronizers/createPresentationViewSynchronizer.d.ts

@@ -1,3 +1,3 @@
 import { type Types } from '@cornerstonejs/core';
 import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
-export default function createPresentationViewSynchronizer(synchronizerName: string, options?: Types.ViewPresentation): Synchronizer;
+export default function createPresentationViewSynchronizer(synchronizerName: string, options?: Types.ViewPresentationSelector): Synchronizer;

package/dist/esm/tools/AdvancedMagnifyTool.js

@@ -27,7 +27,6 @@ var AdvancedMagnifyToolActions;
 const ADVANCED_MAGNIFY_TOOL_NAME = 'AdvancedMagnify';
 const PARALLEL_THRESHOLD = 1 - CONSTANTS.EPSILON;
 class AdvancedMagnifyTool extends AnnotationTool {
-    static { this.Actions = AdvancedMagnifyToolActions; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -455,6 +454,7 @@ class AdvancedMagnifyTool extends AnnotationTool {
         }
     }
 }
+AdvancedMagnifyTool.Actions = AdvancedMagnifyToolActions;
 class AdvancedMagnifyViewportManager {
     constructor() {
         this.createViewport = (annotation, viewportInfo) => {
@@ -902,6 +902,7 @@ class AdvancedMagnifyViewport {
     _syncViewportsCameras(sourceViewport, magnifyViewport) {
         const worldPos = sourceViewport.canvasToWorld(this.position);
         const parallelScale = this._convertZoomFactorToParallelScale(sourceViewport, magnifyViewport, this.zoomFactor);
+        const { flipHorizontal, flipVertical } = sourceViewport.getCamera();
         const { focalPoint, position, viewPlaneNormal } = magnifyViewport.getCamera();
         const distance = Math.sqrt(Math.pow(focalPoint[0] - position[0], 2) +
             Math.pow(focalPoint[1] - position[1], 2) +
@@ -920,6 +921,8 @@ class AdvancedMagnifyViewport {
             parallelScale,
             focalPoint: updatedFocalPoint,
             position: updatedPosition,
+            flipHorizontal,
+            flipVertical,
         });
     }
     _syncStackViewports(sourceViewport, magnifyViewport) {

package/dist/esm/tools/CrosshairsTool.d.ts

@@ -16,6 +16,10 @@ export type CrosshairsAnnotation = Annotation & {
 };
 declare class CrosshairsTool extends AnnotationTool {
     static toolName: any;
+    static minimalModeExamples: Map<string, {
+        enabled: boolean;
+        lineLengthInPx: number;
+    }>;
     toolCenter: Types.Point3;
     _getReferenceLineColor?: (viewportId: string) => string;
     _getReferenceLineControllable?: (viewportId: string) => boolean;