@cornerstonejs/tools 3.0.0-beta.2 → 3.0.0-beta.3

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/labelmapComputationStrategies.js

@@ -1,96 +0,0 @@
-import { VolumeViewport, volumeLoader, imageLoader } from '@cornerstonejs/core';
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
-import { getSegmentation } from '../../getSegmentation';
-import { convertContourToStackLabelmap, convertContourToVolumeLabelmap, } from './convertContourToLabelmap';
-import { convertSurfaceToVolumeLabelmap } from './convertSurfaceToLabelmap';
-import { computeStackLabelmapFromVolume } from '../../helpers/computeStackLabelmapFromVolume';
-export async function computeLabelmapData(segmentationId, options = {}) {
-    const segmentIndices = options.segmentIndices?.length
-        ? options.segmentIndices
-        : getUniqueSegmentIndices(segmentationId);
-    let rawLabelmapData;
-    const segmentation = getSegmentation(segmentationId);
-    const representationData = segmentation.representationData;
-    try {
-        if (representationData.Contour) {
-            rawLabelmapData = await computeLabelmapFromContourSegmentation(segmentationId, {
-                segmentIndices,
-                ...options,
-            });
-        }
-        else if (representationData.Surface) {
-            rawLabelmapData = await computeLabelmapFromSurfaceSegmentation(segmentation.segmentationId, {
-                segmentIndices,
-                ...options,
-            });
-        }
-    }
-    catch (error) {
-        console.error(error);
-        throw error;
-    }
-    if (!rawLabelmapData) {
-        throw new Error('Not enough data to convert to surface, currently only support converting volume labelmap to surface if available');
-    }
-    return rawLabelmapData;
-}
-async function computeLabelmapFromContourSegmentation(segmentationId, options = {}) {
-    const isVolume = options.viewport
-        ? options.viewport instanceof VolumeViewport
-        : true;
-    if (isVolume && !options.viewport) {
-        throw new Error('Cannot compute labelmap from contour segmentation without providing the viewport');
-    }
-    const segmentIndices = options.segmentIndices?.length
-        ? options.segmentIndices
-        : getUniqueSegmentIndices(segmentationId);
-    const segmentation = getSegmentation(segmentationId);
-    const representationData = segmentation.representationData.Contour;
-    const convertFunction = isVolume
-        ? convertContourToVolumeLabelmap
-        : convertContourToStackLabelmap;
-    const result = await convertFunction(representationData, {
-        segmentIndices,
-        viewport: options.viewport,
-    });
-    return result;
-}
-async function computeLabelmapFromSurfaceSegmentation(segmentationId, options = {}) {
-    const { viewport } = options;
-    const isVolume = viewport ? viewport instanceof VolumeViewport : true;
-    const segmentIndices = options.segmentIndices?.length
-        ? options.segmentIndices
-        : getUniqueSegmentIndices(segmentationId);
-    const segmentation = getSegmentation(segmentationId);
-    const segmentsGeometryIds = new Map();
-    const representationData = segmentation.representationData.Surface;
-    representationData.geometryIds.forEach((geometryId, segmentIndex) => {
-        if (segmentIndices.includes(segmentIndex)) {
-            segmentsGeometryIds.set(segmentIndex, geometryId);
-        }
-    });
-    if (isVolume && !viewport) {
-        throw new Error('Cannot compute labelmap from surface segmentation without providing the viewport');
-    }
-    let segmentationVolume;
-    if (isVolume) {
-        const volumeId = viewport.getVolumeId();
-        segmentationVolume =
-            volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId);
-    }
-    else {
-        const imageIds = options.viewport.getImageIds();
-        const segImages = imageLoader.createAndCacheDerivedLabelmapImages(imageIds);
-        const segImageIds = segImages.map((image) => image.imageId);
-        segmentationVolume = await volumeLoader.createAndCacheVolumeFromImages('generatedSegmentationVolumeId', segImageIds);
-    }
-    const result = await convertSurfaceToVolumeLabelmap({ geometryIds: segmentsGeometryIds }, segmentationVolume);
-    if (isVolume) {
-        return result;
-    }
-    const stackData = (await computeStackLabelmapFromVolume({
-        volumeId: segmentationVolume.volumeId,
-    }));
-    return stackData;
-}
-export { computeLabelmapFromContourSegmentation };

package/dist/esm/stateManagement/segmentation/polySeg/Surface/computeAndAddSurfaceRepresentation.d.ts

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

package/dist/esm/stateManagement/segmentation/polySeg/Surface/computeAndAddSurfaceRepresentation.js

@@ -1,7 +0,0 @@
-import { SegmentationRepresentations } from '../../../../enums';
-import { computeAndAddRepresentation } from '../computeAndAddRepresentation';
-import { computeSurfaceData } from './surfaceComputationStrategies';
-import { updateSurfaceData } from './updateSurfaceData';
-export function computeAndAddSurfaceRepresentation(segmentationId, options = {}) {
-    return computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Surface, () => computeSurfaceData(segmentationId, options), () => updateSurfaceData(segmentationId));
-}

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertContourToSurface.d.ts

@@ -1,3 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import type { ContourSegmentationData } from '../../../../types';
-export declare function convertContourToSurface(contourRepresentationData: ContourSegmentationData, segmentIndex: number): Promise<Types.SurfaceData>;

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertContourToSurface.js

@@ -1,37 +0,0 @@
-import { Enums, eventTarget, triggerEvent, getWebWorkerManager, } from '@cornerstonejs/core';
-import { getAnnotation } from '../../../annotation/annotationState';
-import { WorkerTypes } from '../../../../enums';
-const workerManager = getWebWorkerManager();
-const triggerWorkerProgress = (eventTarget, progress, id) => {
-    triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
-        progress,
-        type: WorkerTypes.POLYSEG_CONTOUR_TO_SURFACE,
-        id,
-    });
-};
-export async function convertContourToSurface(contourRepresentationData, segmentIndex) {
-    const { annotationUIDsMap } = contourRepresentationData;
-    const polylines = [];
-    const numPointsArray = [];
-    const annotationUIDs = annotationUIDsMap.get(segmentIndex);
-    for (const annotationUID of annotationUIDs) {
-        const annotation = getAnnotation(annotationUID);
-        const { polyline } = annotation.data
-            .contour;
-        numPointsArray.push(polyline.length);
-        polyline.forEach((polyline) => polylines.push(...polyline));
-    }
-    triggerWorkerProgress(eventTarget, 0, segmentIndex);
-    const results = await workerManager.executeTask('polySeg', 'convertContourToSurface', {
-        polylines,
-        numPointsArray,
-    }, {
-        callbacks: [
-            (progress) => {
-                triggerWorkerProgress(eventTarget, progress, segmentIndex);
-            },
-        ],
-    });
-    triggerWorkerProgress(eventTarget, 100, segmentIndex);
-    return results;
-}

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertLabelmapToSurface.d.ts

@@ -1,3 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import type { LabelmapSegmentationData } from '../../../../types/LabelmapTypes';
-export declare function convertLabelmapToSurface(labelmapRepresentationData: LabelmapSegmentationData, segmentIndex: number): Promise<Types.SurfaceData>;

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertLabelmapToSurface.js

@@ -1,44 +0,0 @@
-import { cache, eventTarget, getWebWorkerManager, triggerEvent, Enums, } from '@cornerstonejs/core';
-import { computeVolumeLabelmapFromStack } from '../../helpers/computeVolumeLabelmapFromStack';
-import { WorkerTypes } from '../../../../enums';
-const workerManager = getWebWorkerManager();
-const triggerWorkerProgress = (eventTarget, progress, id) => {
-    triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
-        progress,
-        type: WorkerTypes.POLYSEG_LABELMAP_TO_SURFACE,
-        id,
-    });
-};
-export async function convertLabelmapToSurface(labelmapRepresentationData, segmentIndex) {
-    let volumeId;
-    if (labelmapRepresentationData.volumeId) {
-        volumeId = labelmapRepresentationData
-            .volumeId;
-    }
-    else {
-        const { imageIds } = labelmapRepresentationData;
-        ({ volumeId } = await computeVolumeLabelmapFromStack({
-            imageIds,
-        }));
-    }
-    const volume = cache.getVolume(volumeId);
-    const scalarData = volume.voxelManager.getCompleteScalarDataArray();
-    const { dimensions, spacing, origin, direction } = volume;
-    triggerWorkerProgress(eventTarget, 0, segmentIndex);
-    const results = await workerManager.executeTask('polySeg', 'convertLabelmapToSurface', {
-        scalarData,
-        dimensions,
-        spacing,
-        origin,
-        direction,
-        segmentIndex,
-    }, {
-        callbacks: [
-            (progress) => {
-                triggerWorkerProgress(eventTarget, progress, segmentIndex);
-            },
-        ],
-    });
-    triggerWorkerProgress(eventTarget, 100, segmentIndex);
-    return results;
-}

package/dist/esm/stateManagement/segmentation/polySeg/Surface/createAndCacheSurfacesFromRaw.d.ts

@@ -1,5 +0,0 @@
-import type { RawSurfacesData } from './surfaceComputationStrategies';
-import type { PolySegConversionOptions } from '../../../../types';
-export declare function createAndCacheSurfacesFromRaw(segmentationId: string, rawSurfacesData: RawSurfacesData, options?: PolySegConversionOptions): Promise<{
-    geometryIds: Map<number, string>;
-}>;

package/dist/esm/stateManagement/segmentation/polySeg/Surface/createAndCacheSurfacesFromRaw.js

@@ -1,33 +0,0 @@
-import { Enums, geometryLoader } from '@cornerstonejs/core';
-import { getSegmentIndexColor } from '../../config/segmentationColor';
-import { getSegmentation } from '../../getSegmentation';
-export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesData, options = {}) {
-    const segmentation = getSegmentation(segmentationId);
-    const geometryIds = new Map();
-    const promises = Object.keys(rawSurfacesData).map(async (index) => {
-        const rawSurfaceData = rawSurfacesData[index];
-        const segmentIndex = rawSurfaceData.segmentIndex;
-        const color = getSegmentIndexColor(options.viewport.id, segmentation.segmentationId, segmentIndex).slice(0, 3);
-        if (!color) {
-            throw new Error('No color found for segment index, unable to create surface');
-        }
-        const closedSurface = {
-            id: `segmentation_${segmentation.segmentationId}_surface_${segmentIndex}`,
-            color,
-            frameOfReferenceUID: 'test-frameOfReferenceUID',
-            points: rawSurfaceData.data.points,
-            polys: rawSurfaceData.data.polys,
-            segmentIndex,
-        };
-        const geometryId = closedSurface.id;
-        geometryIds.set(segmentIndex, geometryId);
-        return geometryLoader.createAndCacheGeometry(geometryId, {
-            type: Enums.GeometryType.SURFACE,
-            geometryData: closedSurface,
-        });
-    });
-    await Promise.all(promises);
-    return {
-        geometryIds,
-    };
-}

package/dist/esm/stateManagement/segmentation/polySeg/Surface/surfaceComputationStrategies.d.ts

@@ -1,12 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import type { PolySegConversionOptions } from '../../../../types';
-export type RawSurfacesData = {
-    segmentIndex: number;
-    data: Types.SurfaceData;
-}[];
-export declare function computeSurfaceData(segmentationId: string, options?: PolySegConversionOptions): Promise<{
-    geometryIds: Map<number, string>;
-}>;
-declare function computeSurfaceFromLabelmapSegmentation(segmentationId: any, options?: PolySegConversionOptions): Promise<RawSurfacesData>;
-declare function computeSurfaceFromContourSegmentation(segmentationId: string, options?: PolySegConversionOptions): Promise<RawSurfacesData>;
-export { computeSurfaceFromContourSegmentation, computeSurfaceFromLabelmapSegmentation, };

package/dist/esm/stateManagement/segmentation/polySeg/Surface/surfaceComputationStrategies.js

@@ -1,75 +0,0 @@
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
-import { getSegmentation } from '../../getSegmentation';
-import { convertContourToSurface } from './convertContourToSurface';
-import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
-import { convertLabelmapToSurface } from './convertLabelmapToSurface';
-export async function computeSurfaceData(segmentationId, options = {}) {
-    const segmentIndices = options.segmentIndices?.length
-        ? options.segmentIndices
-        : getUniqueSegmentIndices(segmentationId);
-    let rawSurfacesData;
-    const segmentation = getSegmentation(segmentationId);
-    const representationData = segmentation.representationData;
-    try {
-        if (representationData.Contour) {
-            rawSurfacesData = await computeSurfaceFromContourSegmentation(segmentationId, {
-                segmentIndices,
-                ...options,
-            });
-        }
-        else if (representationData.Labelmap) {
-            rawSurfacesData = await computeSurfaceFromLabelmapSegmentation(segmentation.segmentationId, {
-                segmentIndices,
-                ...options,
-            });
-        }
-    }
-    catch (error) {
-        console.error(error);
-        throw error;
-    }
-    if (!rawSurfacesData) {
-        throw new Error('Not enough data to convert to surface, currently only support converting volume labelmap to surface if available');
-    }
-    const surfacesData = await createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesData, options);
-    return surfacesData;
-}
-async function computeSurfaceFromLabelmapSegmentation(segmentationId, options = {}) {
-    const segmentation = getSegmentation(segmentationId);
-    if (!segmentation?.representationData?.Labelmap) {
-        console.warn('Only support surface update from labelmaps');
-        return;
-    }
-    const labelmapRepresentationData = segmentation.representationData.Labelmap;
-    const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
-    const promises = segmentIndices.map((index) => {
-        const surface = convertLabelmapToSurface(labelmapRepresentationData, index);
-        return surface;
-    });
-    const surfaces = await Promise.allSettled(promises);
-    const errors = surfaces.filter((p) => p.status === 'rejected');
-    if (errors.length > 0) {
-        console.error(errors);
-        throw new Error('Failed to convert labelmap to surface');
-    }
-    const rawSurfacesData = surfaces
-        .map((surface, index) => {
-        if (surface.status === 'fulfilled') {
-            return { segmentIndex: segmentIndices[index], data: surface.value };
-        }
-    })
-        .filter(Boolean);
-    return rawSurfacesData;
-}
-async function computeSurfaceFromContourSegmentation(segmentationId, options = {}) {
-    const segmentation = getSegmentation(segmentationId);
-    const contourRepresentationData = segmentation.representationData.Contour;
-    const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
-    const promises = segmentIndices.map(async (index) => {
-        const surface = await convertContourToSurface(contourRepresentationData, index);
-        return { segmentIndex: index, data: surface };
-    });
-    const surfaces = await Promise.all(promises);
-    return surfaces;
-}
-export { computeSurfaceFromContourSegmentation, computeSurfaceFromLabelmapSegmentation, };

package/dist/esm/stateManagement/segmentation/polySeg/Surface/updateSurfaceData.d.ts

@@ -1 +0,0 @@
-export declare function updateSurfaceData(segmentationId: any): Promise<void>;

package/dist/esm/stateManagement/segmentation/polySeg/Surface/updateSurfaceData.js

@@ -1,59 +0,0 @@
-import { cache } from '@cornerstonejs/core';
-import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
-import { getViewportIdsWithSegmentation } from '../../getViewportIdsWithSegmentation';
-import { getSegmentation } from '../../getSegmentation';
-import { triggerSegmentationModified } from '../../triggerSegmentationEvents';
-import { getSegmentationRepresentation } from '../../getSegmentationRepresentation';
-import { SegmentationRepresentations } from '../../../../enums';
-import { computeSurfaceFromLabelmapSegmentation } from './surfaceComputationStrategies';
-import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
-export async function updateSurfaceData(segmentationId) {
-    const surfacesObj = await computeSurfaceFromLabelmapSegmentation(segmentationId);
-    if (!surfacesObj) {
-        return;
-    }
-    const segmentation = getSegmentation(segmentationId);
-    const indices = getUniqueSegmentIndices(segmentationId);
-    if (!indices.length) {
-        const geometryIds = segmentation.representationData.Surface.geometryIds;
-        geometryIds.forEach((geometryId) => {
-            const geometry = cache.getGeometry(geometryId);
-            const surface = geometry.data;
-            surface.points = [];
-            surface.polys = [];
-        });
-        triggerSegmentationModified(segmentationId);
-        return;
-    }
-    const promises = surfacesObj.map(({ data, segmentIndex }) => {
-        const geometryId = `segmentation_${segmentationId}_surface_${segmentIndex}`;
-        const geometry = cache.getGeometry(geometryId);
-        if (!geometry) {
-            const viewportIds = getViewportIdsWithSegmentation(segmentationId);
-            return viewportIds.map((viewportId) => {
-                const surfaceRepresentation = getSegmentationRepresentation(viewportId, {
-                    segmentationId,
-                    type: SegmentationRepresentations.Surface,
-                });
-                return [surfaceRepresentation].map((surfaceRepresentation) => {
-                    segmentation.representationData.Surface.geometryIds.set(segmentIndex, geometryId);
-                    return createAndCacheSurfacesFromRaw(segmentationId, [{ segmentIndex, data }], {
-                        segmentationId: surfaceRepresentation.segmentationId,
-                    });
-                });
-            });
-        }
-        else if (indices.includes(segmentIndex)) {
-            const surface = geometry.data;
-            surface.points = data.points;
-            surface.polys = data.polys;
-        }
-        else {
-            const surface = geometry.data;
-            surface.points = [];
-            surface.polys = [];
-        }
-    });
-    await Promise.all(promises);
-    triggerSegmentationModified(segmentationId);
-}

package/dist/esm/stateManagement/segmentation/polySeg/canComputeRequestedRepresentation.d.ts

@@ -1,3 +0,0 @@
-import { SegmentationRepresentations } from '../../../enums';
-declare function canComputeRequestedRepresentation(segmentationId: string, type: SegmentationRepresentations): boolean;
-export { canComputeRequestedRepresentation };

package/dist/esm/stateManagement/segmentation/polySeg/canComputeRequestedRepresentation.js

@@ -1,58 +0,0 @@
-import { SegmentationRepresentations } from '../../../enums';
-import { getSegmentation } from '../getSegmentation';
-import { validate as validateLabelmap } from '../../../tools/displayTools/Labelmap/validateLabelmap';
-const conversionPaths = new Map([
-    [
-        SegmentationRepresentations.Labelmap,
-        new Set([
-            SegmentationRepresentations.Surface,
-            SegmentationRepresentations.Contour,
-        ]),
-    ],
-    [
-        SegmentationRepresentations.Contour,
-        new Set([
-            SegmentationRepresentations.Labelmap,
-            SegmentationRepresentations.Surface,
-        ]),
-    ],
-    [
-        SegmentationRepresentations.Surface,
-        new Set([SegmentationRepresentations.Labelmap]),
-    ],
-]);
-function canComputeRequestedRepresentation(segmentationId, type) {
-    const { representationData } = getSegmentation(segmentationId);
-    const existingRepresentationTypes = getExistingRepresentationTypes(representationData);
-    return existingRepresentationTypes.some((existingRepresentationType) => canConvertFromTo(existingRepresentationType, type));
-}
-function getExistingRepresentationTypes(representationData) {
-    const supportedTypes = [];
-    Object.keys(representationData).forEach((representationType) => {
-        const representationTypeData = representationData[representationType];
-        let validateFn;
-        switch (representationType) {
-            case SegmentationRepresentations.Labelmap:
-                validateFn = validateLabelmap;
-                break;
-        }
-        if (validateFn) {
-            try {
-                validateFn(representationTypeData);
-                supportedTypes.push(representationType);
-            }
-            catch (error) {
-                console.warn(`Validation failed for labelmap of type ${representationType}`);
-            }
-        }
-        else {
-            supportedTypes.push(representationType);
-        }
-    });
-    return supportedTypes;
-}
-async function canConvertFromTo(fromRepresentationType, toRepresentationType) {
-    return (conversionPaths.get(fromRepresentationType)?.has(toRepresentationType) ||
-        false);
-}
-export { canComputeRequestedRepresentation };

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

@@ -1,5 +0,0 @@
-import { computeAndAddSurfaceRepresentation } from './Surface/computeAndAddSurfaceRepresentation';
-import { computeAndAddLabelmapRepresentation } from './Labelmap/computeAndAddLabelmapRepresentation';
-import { computeAndAddContourRepresentation } from './Contour/computeAndAddContourRepresentation';
-import { canComputeRequestedRepresentation } from './canComputeRequestedRepresentation';
-export { canComputeRequestedRepresentation, computeAndAddSurfaceRepresentation, computeAndAddLabelmapRepresentation, computeAndAddContourRepresentation, };

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

@@ -1,5 +0,0 @@
-import { computeAndAddSurfaceRepresentation } from './Surface/computeAndAddSurfaceRepresentation';
-import { computeAndAddLabelmapRepresentation } from './Labelmap/computeAndAddLabelmapRepresentation';
-import { computeAndAddContourRepresentation } from './Contour/computeAndAddContourRepresentation';
-import { canComputeRequestedRepresentation } from './canComputeRequestedRepresentation';
-export { canComputeRequestedRepresentation, computeAndAddSurfaceRepresentation, computeAndAddLabelmapRepresentation, computeAndAddContourRepresentation, };

package/dist/esm/stateManagement/segmentation/polySeg/registerPolySegWorker.d.ts

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

package/dist/esm/tools/segmentation/strategies/compositions/labelmapInterpolation.d.ts

@@ -1,12 +0,0 @@
-import type { InitializedOperationData } from '../BrushStrategy';
-type MorphologicalContourInterpolationOptions = {
-    label?: number;
-    axis?: number;
-    noHeuristicAlignment?: boolean;
-    noUseDistanceTransform?: boolean;
-    useCustomSlicePositions?: boolean;
-};
-declare const _default: {
-    interpolate: (operationData: InitializedOperationData, configuration: MorphologicalContourInterpolationOptions) => Promise<InitializedOperationData>;
-};
-export default _default;

package/dist/esm/tools/segmentation/strategies/compositions/labelmapInterpolation.js

@@ -1,60 +0,0 @@
-import { utilities, peerImport } from '@cornerstonejs/core';
-import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
-import getItkImage from '../utils/getItkImage';
-import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
-import PreviewMethods from './preview';
-export default {
-    [StrategyCallbacks.Interpolate]: async (operationData, configuration) => {
-        const { segmentationImageData, segmentIndex, preview, segmentationVoxelManager, previewSegmentIndex, previewVoxelManager, } = operationData;
-        if (preview) {
-            const callback = ({ index }) => {
-                segmentationVoxelManager.setAtIndex(index, segmentIndex);
-            };
-            previewVoxelManager.forEach(callback);
-        }
-        let itkModule;
-        try {
-            itkModule = await peerImport('@itk-wasm/morphological-contour-interpolation');
-            if (!itkModule) {
-                throw new Error('Module not found');
-            }
-        }
-        catch (error) {
-            console.warn("Warning: '@itk-wasm/morphological-contour-interpolation' module not found. Please install it separately.");
-            return operationData;
-        }
-        let inputImage;
-        try {
-            inputImage = await getItkImage(segmentationImageData, 'interpolation');
-            if (!inputImage) {
-                throw new Error('Failed to get ITK image');
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Failed to get ITK image for interpolation');
-            return operationData;
-        }
-        const outputPromise = itkModule.morphologicalContourInterpolation(inputImage, {
-            ...configuration,
-            label: segmentIndex,
-            webWorker: false,
-        });
-        outputPromise.then((value) => {
-            const { outputImage } = value;
-            const previewColors = operationData.configuration?.preview?.previewColors;
-            const assignIndex = previewSegmentIndex ?? (previewColors ? 255 : segmentIndex);
-            operationData.previewColors ||= previewColors;
-            operationData.previewSegmentIndex ||= previewColors ? 255 : undefined;
-            PreviewMethods[StrategyCallbacks.Initialize](operationData);
-            segmentationVoxelManager.forEach(({ value: originalValue, index }) => {
-                const newValue = outputImage.data[index];
-                if (newValue === originalValue) {
-                    return;
-                }
-                previewVoxelManager.setAtIndex(index, assignIndex);
-            });
-            triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices(), assignIndex);
-        });
-        return operationData;
-    },
-};

package/dist/esm/tools/segmentation/strategies/utils/getItkImage.d.ts

@@ -1 +0,0 @@
-export default function getItkImage(imageData: any, imageName?: string): Promise<unknown>;

package/dist/esm/tools/segmentation/strategies/utils/getItkImage.js

@@ -1,49 +0,0 @@
-import { peerImport } from '@cornerstonejs/core';
-export default async function getItkImage(imageData, imageName) {
-    let Image, ImageType, IntTypes, FloatTypes, PixelTypes;
-    try {
-        const itkModule = await peerImport('itk-wasm');
-        if (!itkModule) {
-            throw new Error('Module not found');
-        }
-        ({ Image, ImageType, IntTypes, FloatTypes, PixelTypes } = itkModule);
-    }
-    catch (error) {
-        console.warn("Warning: 'itk-wasm' module not found. Please install it separately.");
-        return null;
-    }
-    const dataTypesMap = {
-        Int8: IntTypes.Int8,
-        UInt8: IntTypes.UInt8,
-        Int16: IntTypes.Int16,
-        UInt16: IntTypes.UInt16,
-        Int32: IntTypes.Int32,
-        UInt32: IntTypes.UInt32,
-        Int64: IntTypes.Int64,
-        UInt64: IntTypes.UInt64,
-        Float32: FloatTypes.Float32,
-        Float64: FloatTypes.Float64,
-    };
-    const { voxelManager } = imageData.get('voxelManager');
-    const { numberOfComponents } = imageData.get('numberOfComponents');
-    const scalarData = voxelManager.getCompleteScalarDataArray();
-    const dimensions = imageData.getDimensions();
-    const origin = imageData.getOrigin();
-    const spacing = imageData.getSpacing();
-    const directionArray = imageData.getDirection();
-    const direction = new Float64Array(directionArray);
-    const dataType = scalarData.constructor.name
-        .replace(/^Ui/, 'UI')
-        .replace(/Array$/, '');
-    const metadata = undefined;
-    const imageType = new ImageType(dimensions.length, dataTypesMap[dataType], PixelTypes.Scalar, numberOfComponents);
-    const image = new Image(imageType);
-    image.name = imageName;
-    image.origin = origin;
-    image.spacing = spacing;
-    image.direction = direction;
-    image.size = dimensions;
-    image.metadata = metadata;
-    image.data = scalarData;
-    return image;
-}

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

@@ -1,6 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-export type PolySegConversionOptions = {
-    segmentIndices?: number[];
-    segmentationId?: string;
-    viewport?: Types.IStackViewport | Types.IVolumeViewport;
-};