@cornerstonejs/tools 2.0.0-beta.16 → 2.0.0-beta.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.0.0-beta.16",
+  "version": "2.0.0-beta.18",
   "description": "Cornerstone3D Tools",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -34,11 +34,10 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^2.0.0-beta.16",
+    "@cornerstonejs/core": "^2.0.0-beta.18",
     "@icr/polyseg-wasm": "0.4.0",
     "@types/offscreencanvas": "2019.7.3",
     "comlink": "^4.4.1",
-    "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
   },
   "devDependencies": {
@@ -64,5 +63,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "d0e9bfba760e2ec0852330c40f8813f3e5860010"
+  "gitHead": "9deba0d375a5d8f5e4e6a9a1404be20a248ba339"
 }

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

@@ -1,3 +0,0 @@
-import { SegmentationRepresentationConfig, RepresentationPublicInput } from '../../types/SegmentationStateTypes';
-declare function addSegmentationRepresentation(toolGroupId: string, representationInput: RepresentationPublicInput, toolGroupSpecificConfig?: SegmentationRepresentationConfig): Promise<string>;
-export { addSegmentationRepresentation };

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

@@ -1,63 +0,0 @@
-import { utilities } from '@cornerstonejs/core';
-import * as SegmentationConfig from './config/segmentationConfig';
-import { addSegmentationRepresentation as addSegmentationRepresentationToState, getNextColorLUTIndex, addColorLUT, } from './segmentationState';
-import { getRepresentationSpecificConfig } from './helpers/getRepresentationSpecificConfig';
-import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
-import { getToolGroup } from '../../store/ToolGroupManager';
-import { triggerAnnotationRenderForViewportIds } from '../../utilities';
-import { SegmentationRepresentations } from '../../enums';
-async function addSegmentationRepresentation(toolGroupId, representationInput, toolGroupSpecificConfig) {
-    const { segmentationId, options = {} } = representationInput;
-    const segmentationRepresentationUID = representationInput.options?.segmentationRepresentationUID ||
-        utilities.uuidv4();
-    const segmentsHidden = new Set();
-    const colorLUTIndexToUse = getColorLUTIndex(options);
-    const toolGroupSpecificRepresentation = {
-        segmentationId,
-        segmentationRepresentationUID,
-        type: representationInput.type,
-        segmentsHidden,
-        colorLUTIndex: colorLUTIndexToUse,
-        active: true,
-        segmentationRepresentationSpecificConfig: {},
-        segmentSpecificConfig: {},
-        config: getRepresentationSpecificConfig(representationInput),
-        polySeg: options.polySeg,
-    };
-    if (toolGroupSpecificConfig) {
-        const currentToolGroupConfig = SegmentationConfig.getToolGroupSpecificConfig(toolGroupId);
-        const mergedConfig = utilities.deepMerge(currentToolGroupConfig, toolGroupSpecificConfig);
-        SegmentationConfig.setToolGroupSpecificConfig(toolGroupId, {
-            renderInactiveSegmentations: mergedConfig.renderInactiveSegmentations || true,
-            representations: {
-                ...mergedConfig.representations,
-            },
-        });
-    }
-    addSegmentationRepresentationToState(toolGroupId, toolGroupSpecificRepresentation);
-    if (representationInput.type === SegmentationRepresentations.Contour) {
-        getToolGroup(toolGroupId)
-            .getViewportsInfo()
-            .forEach(({ viewportId }) => {
-            triggerAnnotationRenderForViewportIds([viewportId]);
-        });
-    }
-    return segmentationRepresentationUID;
-}
-function getColorLUTIndex(options = {}) {
-    const colorLUTOrIndexInput = options.colorLUTOrIndex;
-    let colorLUTIndexToUse;
-    if (typeof colorLUTOrIndexInput === 'number') {
-        colorLUTIndexToUse = colorLUTOrIndexInput;
-    }
-    else {
-        const nextIndex = getNextColorLUTIndex();
-        const colorLUTToAdd = Array.isArray(colorLUTOrIndexInput)
-            ? colorLUTOrIndexInput
-            : CORNERSTONE_COLOR_LUT;
-        addColorLUT(colorLUTToAdd, nextIndex);
-        colorLUTIndexToUse = nextIndex;
-    }
-    return colorLUTIndexToUse;
-}
-export { addSegmentationRepresentation };

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

@@ -1,3 +0,0 @@
-import { SegmentationRepresentationConfig, RepresentationPublicInput } from '../../types/SegmentationStateTypes';
-declare function addSegmentationRepresentations(toolGroupId: string, representationInputArray: RepresentationPublicInput[], toolGroupSpecificRepresentationConfig?: SegmentationRepresentationConfig): Promise<string[]>;
-export default addSegmentationRepresentations;

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

@@ -1,14 +0,0 @@
-import { getToolGroup } from '../../store/ToolGroupManager';
-import { addSegmentationRepresentation } from './addSegmentationRepresentation';
-async function addSegmentationRepresentations(toolGroupId, representationInputArray, toolGroupSpecificRepresentationConfig) {
-    const toolGroup = getToolGroup(toolGroupId);
-    if (!toolGroup) {
-        throw new Error(`No tool group found for toolGroupId: ${toolGroupId}`);
-    }
-    const promises = representationInputArray.map((representationInput) => {
-        return addSegmentationRepresentation(toolGroupId, representationInput, toolGroupSpecificRepresentationConfig);
-    });
-    const segmentationRepresentationUIDs = await Promise.all(promises);
-    return segmentationRepresentationUIDs;
-}
-export default addSegmentationRepresentations;

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

@@ -1,2 +0,0 @@
-import { RepresentationPublicInput } from '../../../types';
-export declare function getRepresentationSpecificConfig(representationInput: RepresentationPublicInput): {};

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

@@ -1,2 +0,0 @@
-declare function removeSegmentationsFromToolGroup(toolGroupId: string, segmentationRepresentationUIDs?: string[] | undefined, immediate?: boolean): void;
-export default removeSegmentationsFromToolGroup;

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

@@ -1,39 +0,0 @@
-import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
-import { labelmapDisplay } from '../../tools/displayTools/Labelmap';
-import { contourDisplay } from '../../tools/displayTools/Contour';
-import { getSegmentationRepresentations, getSegmentationRepresentationByUID, } from './segmentationState';
-function removeSegmentationsFromToolGroup(toolGroupId, segmentationRepresentationUIDs, immediate) {
-    const toolGroupSegRepresentations = getSegmentationRepresentations(toolGroupId);
-    if (!toolGroupSegRepresentations ||
-        toolGroupSegRepresentations.length === 0) {
-        return;
-    }
-    const toolGroupSegRepresentationUIDs = toolGroupSegRepresentations.map((representation) => representation.segmentationRepresentationUID);
-    let segRepresentationUIDsToRemove = segmentationRepresentationUIDs;
-    if (segRepresentationUIDsToRemove) {
-        const invalidSegRepresentationUIDs = segmentationRepresentationUIDs.filter((segRepresentationUID) => !toolGroupSegRepresentationUIDs.includes(segRepresentationUID));
-        if (invalidSegRepresentationUIDs.length > 0) {
-            throw new Error(`The following segmentationRepresentationUIDs are not part of the toolGroup: ${JSON.stringify(invalidSegRepresentationUIDs)}`);
-        }
-    }
-    else {
-        segRepresentationUIDsToRemove = toolGroupSegRepresentationUIDs;
-    }
-    segRepresentationUIDsToRemove.forEach((segmentationDataUID) => {
-        _removeSegmentation(toolGroupId, segmentationDataUID, immediate);
-    });
-}
-function _removeSegmentation(toolGroupId, segmentationRepresentationUID, immediate) {
-    const segmentationRepresentation = getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-    const { type } = segmentationRepresentation;
-    if (type === SegmentationRepresentations.Labelmap) {
-        labelmapDisplay.removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID, immediate);
-    }
-    else if (type === SegmentationRepresentations.Contour) {
-        contourDisplay.removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID, immediate);
-    }
-    else {
-        throw new Error(`The representation ${type} is not supported yet`);
-    }
-}
-export default removeSegmentationsFromToolGroup;

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

@@ -1,13 +0,0 @@
-import { PublicToolProps, ToolProps } from '../../types';
-import { BaseTool } from '../base';
-import { SegmentationRepresentationConfig } from '../../types/SegmentationStateTypes';
-declare class SegmentationDisplayTool extends BaseTool {
-    static toolName: any;
-    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
-    onSetToolEnabled(): void;
-    onSetToolDisabled(): void;
-    renderSegmentation: (toolGroupId: string) => void;
-    addPlanarFreeHandToolIfAbsent(toolGroupId: any): void;
-    _getMergedRepresentationsConfig(toolGroupId: string): SegmentationRepresentationConfig;
-}
-export default SegmentationDisplayTool;

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

@@ -1,101 +0,0 @@
-import { getEnabledElementByIds, utilities as csUtils, } from '@cornerstonejs/core';
-import Representations from '../../enums/SegmentationRepresentations';
-import { config as segmentationConfig } from '../../stateManagement/segmentation';
-import { setSegmentationVisibility } from '../../stateManagement/segmentation/config/segmentationVisibility';
-import { getSegmentationRepresentations } from '../../stateManagement/segmentation/segmentationState';
-import { getToolGroup } from '../../store/ToolGroupManager';
-import { BaseTool } from '../base';
-import { surfaceDisplay } from './Surface';
-import { contourDisplay } from './Contour';
-import { labelmapDisplay } from './Labelmap';
-import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
-import { addTool, state } from '../../store';
-import PlanarFreehandContourSegmentationTool from '../annotation/PlanarFreehandContourSegmentationTool';
-const planarContourToolName = PlanarFreehandContourSegmentationTool.toolName;
-class SegmentationDisplayTool extends BaseTool {
-    constructor(toolProps = {}, defaultToolProps = {
-        configuration: {},
-    }) {
-        super(toolProps, defaultToolProps);
-        this.renderSegmentation = (toolGroupId) => {
-            const toolGroup = getToolGroup(toolGroupId);
-            if (!toolGroup) {
-                return;
-            }
-            const toolGroupSegmentationRepresentations = getSegmentationRepresentations(toolGroupId);
-            if (!toolGroupSegmentationRepresentations ||
-                toolGroupSegmentationRepresentations.length === 0) {
-                return;
-            }
-            const toolGroupViewports = toolGroup.viewportsInfo.map(({ renderingEngineId, viewportId }) => {
-                const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
-                if (enabledElement) {
-                    return enabledElement.viewport;
-                }
-            });
-            const segmentationRenderList = toolGroupSegmentationRepresentations.map((representation) => {
-                const config = this._getMergedRepresentationsConfig(toolGroupId);
-                const viewportsRenderList = [];
-                const renderers = {
-                    [Representations.Labelmap]: labelmapDisplay,
-                    [Representations.Contour]: contourDisplay,
-                    [Representations.Surface]: surfaceDisplay,
-                };
-                if (representation.type === SegmentationRepresentations.Contour) {
-                    this.addPlanarFreeHandToolIfAbsent(toolGroupId);
-                }
-                const display = renderers[representation.type];
-                for (const viewport of toolGroupViewports) {
-                    const renderedViewport = display.render(viewport, representation, config);
-                    viewportsRenderList.push(renderedViewport);
-                }
-                return viewportsRenderList;
-            });
-            Promise.allSettled(segmentationRenderList).then(() => {
-                toolGroupViewports.forEach((viewport) => {
-                    viewport.render();
-                });
-            });
-        };
-    }
-    onSetToolEnabled() {
-        const toolGroupId = this.toolGroupId;
-        const toolGroupSegmentationRepresentations = getSegmentationRepresentations(toolGroupId);
-        if (!toolGroupSegmentationRepresentations ||
-            toolGroupSegmentationRepresentations.length === 0) {
-            return;
-        }
-        toolGroupSegmentationRepresentations.forEach((segmentationRepresentation) => {
-            setSegmentationVisibility(toolGroupId, segmentationRepresentation.segmentationRepresentationUID, true);
-        });
-    }
-    onSetToolDisabled() {
-        const toolGroupId = this.toolGroupId;
-        const toolGroupSegmentationRepresentations = getSegmentationRepresentations(toolGroupId);
-        if (!toolGroupSegmentationRepresentations ||
-            toolGroupSegmentationRepresentations.length === 0) {
-            return;
-        }
-        toolGroupSegmentationRepresentations.forEach((segmentationRepresentation) => {
-            setSegmentationVisibility(toolGroupId, segmentationRepresentation.segmentationRepresentationUID, false);
-        });
-    }
-    addPlanarFreeHandToolIfAbsent(toolGroupId) {
-        if (!(planarContourToolName in state.tools)) {
-            addTool(PlanarFreehandContourSegmentationTool);
-        }
-        const toolGroup = getToolGroup(toolGroupId);
-        if (!toolGroup.hasTool(planarContourToolName)) {
-            toolGroup.addTool(planarContourToolName);
-            toolGroup.setToolPassive(planarContourToolName);
-        }
-    }
-    _getMergedRepresentationsConfig(toolGroupId) {
-        const toolGroupConfig = segmentationConfig.getToolGroupSpecificConfig(toolGroupId);
-        const globalConfig = segmentationConfig.getGlobalConfig();
-        const mergedConfig = csUtils.deepMerge(globalConfig, toolGroupConfig);
-        return mergedConfig;
-    }
-}
-SegmentationDisplayTool.toolName = 'SegmentationDisplay';
-export default SegmentationDisplayTool;

package/dist/esm/utilities/segmentation/getSegmentAtLabelmapBorder.d.ts

@@ -1,7 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-type Options = {
-    viewport?: Types.IViewport;
-    searchRadius?: number;
-};
-export declare function getSegmentAtLabelmapBorder(segmentationId: string, worldPoint: Types.Point3, { viewport, searchRadius }: Options): number;
-export {};

package/dist/esm/utilities/segmentation/getSegmentAtWorldPoint.d.ts

@@ -1,11 +0,0 @@
-import type { Types } from '@cornerstonejs/core';
-import { SegmentationRepresentations } from '../../enums';
-import { Segmentation } from '../../types';
-type Options = {
-    representationType?: SegmentationRepresentations;
-    viewport?: Types.IViewport;
-};
-export declare function getSegmentAtWorldPoint(segmentationId: string, worldPoint: Types.Point3, options?: Options): number;
-export declare function getSegmentAtWorldForLabelmap(segmentation: Segmentation, worldPoint: Types.Point3, { viewport }: Options): number | undefined;
-export declare function getSegmentAtWorldForContour(segmentation: Segmentation, worldPoint: Types.Point3, { viewport }: Options): number;
-export {};