@cornerstonejs/tools 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/esm/stateManagement/segmentation/config/segmentationVisibility.js

@@ -1,18 +1,21 @@
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import { getSegmentationRepresentation } from '../getSegmentationRepresentation';
 import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
-function setRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility) {
-    const representation = SegmentationState.getRepresentation(segmentationRepresentationUID);
+import { setSegmentationRepresentationVisibility as _setSegmentationRepresentationVisibility } from '../setSegmentationRepresentationVisibility';
+import { getSegmentationRepresentationVisibility as _getSegmentationRepresentationVisibility } from '../getSegmentationRepresentationVisibility';
+import { getSegmentationRepresentationViewportStates } from '../getSegmentationRepresentationViewportStates';
+function setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility) {
+    const representation = getSegmentationRepresentation(segmentationRepresentationUID);
     if (!representation) {
         return;
     }
-    SegmentationState.setRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility);
+    _setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility);
     triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
-function getRepresentationVisibility(viewportId, segmentationRepresentationUID) {
-    return SegmentationState.getRepresentationVisibility(viewportId, segmentationRepresentationUID);
+function getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID) {
+    return _getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
 }
-function setSegmentsVisibility(viewport, segmentationRepresentationUID, segmentIndices, visibility) {
-    const hiddenSegments = getSegmentsHidden(viewport, segmentationRepresentationUID);
+function setSegmentIndicesVisibility(viewport, segmentationRepresentationUID, segmentIndices, visibility) {
+    const hiddenSegments = getHiddenSegmentIndices(viewport, segmentationRepresentationUID);
     segmentIndices.forEach((segmentIndex) => {
         visibility
             ? hiddenSegments.delete(segmentIndex)
@@ -21,22 +24,22 @@ function setSegmentsVisibility(viewport, segmentationRepresentationUID, segmentI
     triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
 function setSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex, visibility) {
-    const hiddenSegments = getSegmentsHidden(viewportId, segmentationRepresentationUID);
+    const hiddenSegments = getHiddenSegmentIndices(viewportId, segmentationRepresentationUID);
     visibility
         ? hiddenSegments.delete(segmentIndex)
         : hiddenSegments.add(segmentIndex);
     triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
 function getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex) {
-    const hiddenSegments = getSegmentsHidden(viewportId, segmentationRepresentationUID);
+    const hiddenSegments = getHiddenSegmentIndices(viewportId, segmentationRepresentationUID);
     return !hiddenSegments.has(segmentIndex);
 }
-function getSegmentsHidden(viewportId, segmentationRepresentationUID) {
-    const viewportRenderingState = SegmentationState.getRepresentationsRenderingStateForViewport(viewportId);
+function getHiddenSegmentIndices(viewportId, segmentationRepresentationUID) {
+    const viewportRenderingState = getSegmentationRepresentationViewportStates(viewportId);
     if (!viewportRenderingState) {
         return new Set();
     }
     return (viewportRenderingState[segmentationRepresentationUID]?.segmentsHidden ??
         new Set());
 }
-export { setRepresentationVisibility, getRepresentationVisibility, setSegmentsVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getSegmentsHidden, };
+export { setSegmentationRepresentationVisibility, getSegmentationRepresentationVisibility, setSegmentIndicesVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getHiddenSegmentIndices, };

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

@@ -11,11 +11,3 @@ export declare function convertVolumeToStackSegmentation({ segmentationId, optio
         removeOriginal?: boolean;
     };
 }): Promise<void>;
-export declare function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }: {
-    segmentationId: string;
-    viewportId: string;
-    imageIds: string[];
-    options?: {
-        removeOriginal?: boolean;
-    };
-}): Promise<void>;

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

@@ -1,94 +1,19 @@
-import { cache, eventTarget, getRenderingEngines, } from '@cornerstonejs/core';
-import { Events, SegmentationRepresentations } from '../../enums';
-import addRepresentations from './addRepresentations';
-import { triggerSegmentationRender } from '../../utilities/segmentation';
-import { getSegmentation } from './segmentationState';
-import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
+import { cache } from '@cornerstonejs/core';
+import { getSegmentation } from './getSegmentation';
+import { updateStackSegmentationState } from './helpers/updateStackSegmentationState';
 export async function computeStackSegmentationFromVolume({ volumeId, }) {
     const segmentationVolume = cache.getVolume(volumeId);
-    const hasCachedImages = segmentationVolume.imageCacheOffsetMap.size > 0;
-    let isAllImagesCached = false;
-    if (hasCachedImages) {
-        isAllImagesCached = segmentationVolume.imageIds.every((imageId) => cache.getImage(imageId));
-    }
-    const renderingEngine = getRenderingEngines()[0];
-    const volumeUsedInOtherViewports = renderingEngine
-        .getVolumeViewports()
-        .find((vp) => vp.hasVolumeId(volumeId));
-    segmentationVolume.decache(!volumeUsedInOtherViewports && isAllImagesCached);
-    const imageIds = _getLabelmapImageIdsForViewportForStackSegmentation(segmentationVolume);
-    return { imageIds };
+    return { imageIds: segmentationVolume.imageIds };
 }
 export async function convertVolumeToStackSegmentation({ segmentationId, options, }) {
     const segmentation = getSegmentation(segmentationId);
-    const data = segmentation.representationData
+    const { volumeId } = segmentation.representationData
         .LABELMAP;
-    const { imageIds } = await computeStackSegmentationFromVolume({
-        volumeId: data.volumeId,
-    });
+    const segmentationVolume = cache.getVolume(volumeId);
     await updateStackSegmentationState({
         segmentationId,
         viewportId: options.viewportId,
-        imageIds,
+        imageIds: segmentationVolume.imageIds,
         options,
     });
 }
-export async function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }) {
-    const segmentation = getSegmentation(segmentationId);
-    if (options?.removeOriginal) {
-        const data = segmentation.representationData
-            .LABELMAP;
-        if (cache.getVolume(data.volumeId)) {
-            cache.removeVolumeLoadObject(data.volumeId);
-        }
-        segmentation.representationData.LABELMAP = {
-            imageIds,
-        };
-    }
-    else {
-        segmentation.representationData.LABELMAP = {
-            ...segmentation.representationData.LABELMAP,
-            imageIds,
-        };
-    }
-    await addRepresentations(viewportId, [
-        {
-            segmentationId,
-            type: SegmentationRepresentations.Labelmap,
-        },
-    ]);
-    triggerSegmentationRender();
-    eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
-}
-function _getLabelmapImageIdsForViewportForStackSegmentation(segmentationVolume) {
-    if (segmentationVolume.additionalDetails?.imageIds) {
-        return segmentationVolume.additionalDetails.imageIds;
-    }
-    else if (segmentationVolume.referencedImageIds?.length &&
-        !segmentationVolume.referencedImageIds[0].startsWith('derived')) {
-        const segmentationImageIds = segmentationVolume.imageIds;
-        return [...segmentationImageIds].reverse();
-    }
-    else {
-        const referencedVolumeId = segmentationVolume.referencedVolumeId;
-        const referencedVolume = cache.getVolume(referencedVolumeId);
-        if (!referencedVolume) {
-            throw new Error('Cannot convert volumetric segmentation without referenced volume to stack segmentation yet');
-        }
-        if (!referencedVolume?.imageIds?.length) {
-            throw new Error('Cannot convert volumetric segmentation without imageIds to stack segmentation yet');
-        }
-        if (referencedVolume.imageIds?.[0].startsWith('derived')) {
-            throw new Error(`Cannot convert volume segmentation that is derived from another segmentation
-         to stack segmentation yet, include the additionalDetails.imageIds
-         in the volume segmentation in case you need it for the conversion`);
-        }
-        const referencedImageIds = referencedVolume.imageIds;
-        let segmentationImageIdsToUse = segmentationVolume.imageIds;
-        if (!segmentationImageIdsToUse?.length) {
-            segmentationImageIdsToUse =
-                segmentationVolume.convertToImageSlicesAndCache();
-        }
-        return [...segmentationImageIdsToUse].reverse();
-    }
-}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationDataModified.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationDataModified(segmentationId: string, modifiedSlicesToUse?: number[]): void;

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationDataModified.js

@@ -0,0 +1,11 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+import { setSegmentationDirty } from '../../../utilities/segmentation/utilities';
+export function triggerSegmentationDataModified(segmentationId, modifiedSlicesToUse) {
+    const eventDetail = {
+        segmentationId,
+        modifiedSlicesToUse,
+    };
+    setSegmentationDirty(segmentationId);
+    triggerEvent(eventTarget, Events.SEGMENTATION_DATA_MODIFIED, eventDetail);
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationModified.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationModified(segmentationId?: string): void;

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationModified.js

@@ -0,0 +1,18 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+import { getSegmentations } from '../getSegmentations';
+export function triggerSegmentationModified(segmentationId) {
+    let segmentationIds;
+    if (segmentationId) {
+        segmentationIds = [segmentationId];
+    }
+    else {
+        segmentationIds = getSegmentations().map(({ segmentationId }) => segmentationId);
+    }
+    segmentationIds.forEach((segmentationId) => {
+        const eventDetail = {
+            segmentationId,
+        };
+        triggerEvent(eventTarget, Events.SEGMENTATION_MODIFIED, eventDetail);
+    });
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRemoved.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationRemoved(segmentationId: string): void;

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRemoved.js

@@ -0,0 +1,8 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+export function triggerSegmentationRemoved(segmentationId) {
+    const eventDetail = {
+        segmentationId,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_REMOVED, eventDetail);
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRepresentationModified.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationRepresentationModified(segmentationRepresentationUID: string): void;

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRepresentationModified.js

@@ -0,0 +1,8 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+export function triggerSegmentationRepresentationModified(segmentationRepresentationUID) {
+    const eventDetail = {
+        segmentationRepresentationUID,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_MODIFIED, eventDetail);
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRepresentationRemoved.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationRepresentationRemoved(segmentationRepresentationUID: string): void;

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRepresentationRemoved.js

@@ -0,0 +1,8 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+export function triggerSegmentationRepresentationRemoved(segmentationRepresentationUID) {
+    const eventDetail = {
+        segmentationRepresentationUID,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_REMOVED, eventDetail);
+}

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

@@ -0,0 +1 @@
+export declare function getActiveSegmentIndex(segmentationId: string): number | undefined;

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

@@ -0,0 +1,7 @@
+import { getSegmentation } from './getSegmentation';
+export function getActiveSegmentIndex(segmentationId) {
+    const segmentation = getSegmentation(segmentationId);
+    if (segmentation) {
+        return segmentation.activeSegmentIndex;
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+export declare function getActiveSegmentationRepresentation(viewportId: string): SegmentationRepresentation | undefined;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getActiveSegmentationRepresentation(viewportId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getActiveSegmentationRepresentation(viewportId);
+}

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

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+export declare function getAllSegmentationRepresentations(): SegmentationRepresentation[];

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

@@ -0,0 +1,6 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getAllSegmentationRepresentations() {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    const state = segmentationStateManager.getState();
+    return Object.values(state.representations);
+}

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

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function getColorLUT(index: number): Types.ColorLUT | undefined;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getColorLUT(index) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getColorLUT(index);
+}

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

@@ -0,0 +1 @@
+export declare function getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId?: string): string;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
+}

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

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentationConfig } from '../../types';
+export declare function getGlobalConfig(): SegmentationRepresentationConfig;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getGlobalConfig() {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getGlobalConfig();
+}

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

@@ -0,0 +1 @@
+export declare function getNextColorLUTIndex(): number;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getNextColorLUTIndex() {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getNextColorLUTIndex();
+}

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

@@ -0,0 +1,2 @@
+import type { SegmentRepresentationConfig } from '../../types/SegmentationStateTypes';
+export declare function getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getPerSegmentConfig(segmentationRepresentationUID) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getPerSegmentConfig(segmentationRepresentationUID);
+}

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

@@ -0,0 +1,2 @@
+import type { Segmentation } from '../../types';
+export declare function getSegmentation(segmentationId: string): Segmentation | undefined;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getSegmentation(segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getSegmentation(segmentationId);
+}

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

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+export declare function getSegmentationRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getSegmentationRepresentation(segmentationRepresentationUID) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getSegmentationRepresentation(segmentationRepresentationUID);
+}

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

@@ -0,0 +1,2 @@
+import type { RepresentationConfig } from '../../types';
+export declare function getSegmentationRepresentationConfig(segmentationRepresentationUID: string): RepresentationConfig;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getSegmentationRepresentationConfig(segmentationRepresentationUID) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getSegmentationRepresentationConfig(segmentationRepresentationUID);
+}

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

@@ -0,0 +1,7 @@
+export declare function getSegmentationRepresentationViewportStates(viewportId: string): {
+    [segRepUID: string]: {
+        visible: boolean;
+        segmentsHidden: Set<number>;
+        active: boolean;
+    };
+};

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

@@ -0,0 +1,6 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getSegmentationRepresentationViewportStates(viewportId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    const state = segmentationStateManager.getState();
+    return state.viewports?.[viewportId] || {};
+}

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

@@ -0,0 +1 @@
+export declare function getSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
+}

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

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+export declare function getSegmentationRepresentations(viewportId: string): SegmentationRepresentation[] | [];

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

@@ -0,0 +1,12 @@
+import { getSegmentationRepresentation } from './getSegmentationRepresentation';
+import { getSegmentationRepresentationViewportStates } from './getSegmentationRepresentationViewportStates';
+export function getSegmentationRepresentations(viewportId) {
+    const viewportRenderingState = getSegmentationRepresentationViewportStates(viewportId);
+    if (!viewportRenderingState) {
+        return [];
+    }
+    const segRepUIDs = Object.keys(viewportRenderingState);
+    return segRepUIDs
+        .map((segRepUID) => getSegmentationRepresentation(segRepUID))
+        .filter(Boolean);
+}

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

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+export declare function getSegmentationRepresentationsForSegmentation(segmentationId: string): SegmentationRepresentation[];

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

@@ -0,0 +1,5 @@
+import { getAllSegmentationRepresentations } from './getAllSegmentationRepresentations';
+export function getSegmentationRepresentationsForSegmentation(segmentationId) {
+    const allRepresentations = getAllSegmentationRepresentations();
+    return allRepresentations.filter((representation) => representation.segmentationId === segmentationId);
+}

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

@@ -0,0 +1,2 @@
+import type { Segmentation } from '../../types';
+export declare function getSegmentations(): Segmentation[] | [];

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

@@ -0,0 +1,6 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getSegmentations() {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    const state = segmentationStateManager.getState();
+    return state.segmentations;
+}

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

@@ -0,0 +1 @@
+export declare function getViewportIdsWithSegmentation(segmentationId: string): string[];

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

@@ -0,0 +1,10 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getViewportIdsWithSegmentation(segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    const state = segmentationStateManager.getState();
+    const viewports = state.viewports;
+    return Object.keys(viewports).filter((viewportId) => {
+        const viewport = viewports[viewportId];
+        return Object.keys(viewport).some((segRepUID) => state.representations[segRepUID].segmentationId === segmentationId);
+    });
+}

package/dist/esm/stateManagement/segmentation/helpers/clipAndCacheSurfacesForViewport.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 export type SurfacesInfo = {
     id: string;
     points: number[];

package/dist/esm/stateManagement/segmentation/helpers/clipAndCacheSurfacesForViewport.js

@@ -1,6 +1,6 @@
 import { Enums, getWebWorkerManager, eventTarget, triggerEvent, } from '@cornerstonejs/core';
 import { WorkerTypes } from '../../../enums';
-import { pointToString } from '../../../utilities';
+import { pointToString } from '../../../utilities/pointToString';
 import { registerPolySegWorker } from '../polySeg/registerPolySegWorker';
 const workerManager = getWebWorkerManager();
 const polyDataCache = new Map();

package/dist/esm/stateManagement/segmentation/helpers/normalizeSegmentationInput.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationPublicInput, Segmentation } from '../../../types/SegmentationStateTypes';
+import type { SegmentationPublicInput, Segmentation } from '../../../types/SegmentationStateTypes';
 declare function normalizeSegmentationInput(segmentationInput: SegmentationPublicInput): Segmentation;
 export default normalizeSegmentationInput;

package/dist/esm/stateManagement/segmentation/helpers/updateStackSegmentationState.d.ts

@@ -0,0 +1,8 @@
+export declare function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }: {
+    segmentationId: string;
+    viewportId: string;
+    imageIds: string[];
+    options?: {
+        removeOriginal?: boolean;
+    };
+}): Promise<void>;

package/dist/esm/stateManagement/segmentation/helpers/updateStackSegmentationState.js

@@ -0,0 +1,31 @@
+import { cache, eventTarget } from '@cornerstonejs/core';
+import { Events, SegmentationRepresentations } from '../../../enums';
+import { getSegmentation } from '../getSegmentation';
+import { triggerSegmentationDataModified } from '../triggerSegmentationEvents';
+import addSegmentationRepresentations from '../addSegmentationRepresentations';
+export async function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }) {
+    const segmentation = getSegmentation(segmentationId);
+    if (options?.removeOriginal) {
+        const data = segmentation.representationData
+            .LABELMAP;
+        if (cache.getVolume(data.volumeId)) {
+            cache.removeVolumeLoadObject(data.volumeId);
+        }
+        segmentation.representationData.LABELMAP = {
+            imageIds,
+        };
+    }
+    else {
+        segmentation.representationData.LABELMAP = {
+            ...segmentation.representationData.LABELMAP,
+            imageIds,
+        };
+    }
+    await addSegmentationRepresentations(viewportId, [
+        {
+            segmentationId,
+            type: SegmentationRepresentations.Labelmap,
+        },
+    ]);
+    eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
+}

package/dist/esm/stateManagement/segmentation/helpers/validateSegmentationInput.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
+import type { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
 declare function validateSegmentationInput(segmentationInputArray: SegmentationPublicInput[]): void;
 export default validateSegmentationInput;

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

@@ -1,8 +1,7 @@
-import removeRepresentationsFromViewport from './removeRepresentationsFromViewport';
+import removeSegmentationRepresentations from './removeSegmentationRepresentations';
 import addSegmentations from './addSegmentations';
-import addRepresentations from './addRepresentations';
+import addSegmentationRepresentations from './addSegmentationRepresentations';
 import addRepresentationData from './addRepresentationData';
-import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
 import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
@@ -10,5 +9,6 @@ import * as state from './segmentationState';
 import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
+import { convertStackToVolumeSegmentation } from './SegmentationStateManager';
 import * as polySegManager from './polySeg';
-export { addSegmentations, addRepresentations, removeRepresentationsFromViewport, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };
+export { addSegmentations, addSegmentationRepresentations, removeSegmentationRepresentations, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };

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

@@ -1,8 +1,7 @@
-import removeRepresentationsFromViewport from './removeRepresentationsFromViewport';
+import removeSegmentationRepresentations from './removeSegmentationRepresentations';
 import addSegmentations from './addSegmentations';
-import addRepresentations from './addRepresentations';
+import addSegmentationRepresentations from './addSegmentationRepresentations';
 import addRepresentationData from './addRepresentationData';
-import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
 import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
@@ -10,5 +9,6 @@ import * as state from './segmentationState';
 import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
+import { convertStackToVolumeSegmentation } from './SegmentationStateManager';
 import * as polySegManager from './polySeg';
-export { addSegmentations, addRepresentations, removeRepresentationsFromViewport, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };
+export { addSegmentations, addSegmentationRepresentations, removeSegmentationRepresentations, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };

package/dist/esm/stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation.d.ts

@@ -1,4 +1,4 @@
-import { PolySegConversionOptions } from '../../../../types';
+import type { PolySegConversionOptions } from '../../../../types';
 export declare function computeAndAddContourRepresentation(segmentationId: string, options?: PolySegConversionOptions): Promise<{
     annotationUIDsMap: Map<number, Set<string>>;
 }>;

package/dist/esm/stateManagement/segmentation/polySeg/Contour/contourComputationStrategies.d.ts

@@ -1,5 +1,5 @@
-import { PolySegConversionOptions } from '../../../../types';
-import { SurfaceClipResult } from '../../helpers/clipAndCacheSurfacesForViewport';
+import type { PolySegConversionOptions } from '../../../../types';
+import type { SurfaceClipResult } from '../../helpers/clipAndCacheSurfacesForViewport';
 export type RawContourData = Map<number, SurfaceClipResult[]>;
 export declare function computeContourData(segmentationId: string, options?: PolySegConversionOptions): Promise<{
     annotationUIDsMap: Map<number, Set<string>>;