@cornerstonejs/adapters 1.58.1 → 1.58.2

package/dist/adapters.es.js

@@ -48430,6 +48430,262 @@ let state = {
   handleRadius: 6
 };
 
+const defaultContourConfig$1 = {
+  renderOutline: true,
+  outlineWidthAutoGenerated: 3,
+  outlineWidthActive: 2,
+  outlineWidthInactive: 1,
+  outlineOpacity: 1,
+  outlineOpacityInactive: 0.85,
+  outlineDashActive: undefined,
+  outlineDashInactive: undefined,
+  outlineDashAutoGenerated: '5,3',
+  activeSegmentOutlineWidthDelta: 0,
+  renderFill: true,
+  fillAlpha: 0.5,
+  fillAlphaInactive: 0.3,
+  fillAlphaAutoGenerated: 0.3
+};
+function getDefaultContourConfig() {
+  return defaultContourConfig$1;
+}
+
+const defaultLabelmapConfig$1 = {
+  renderOutline: true,
+  outlineWidthActive: 3,
+  outlineWidthInactive: 2,
+  activeSegmentOutlineWidthDelta: 0,
+  renderFill: true,
+  renderFillInactive: true,
+  fillAlpha: 0.7,
+  fillAlphaInactive: 0.65,
+  outlineOpacity: 1,
+  outlineOpacityInactive: 0.85
+};
+function getDefaultLabelmapConfig() {
+  return defaultLabelmapConfig$1;
+}
+
+const defaultSurfaceConfig$1 = {
+  renderFill: true,
+  fillAlpha: 1
+};
+function getDefaultSurfaceConfig() {
+  return defaultSurfaceConfig$1;
+}
+
+const defaultLabelmapConfig = getDefaultLabelmapConfig();
+const defaultContourConfig = getDefaultContourConfig();
+const defaultSurfaceConfig = getDefaultSurfaceConfig();
+const newGlobalConfig = {
+  renderInactiveSegmentations: true,
+  representations: {
+    [Representations.Labelmap]: defaultLabelmapConfig,
+    [Representations.Contour]: defaultContourConfig,
+    [Representations.Surface]: defaultSurfaceConfig
+  }
+};
+const initialDefaultState = {
+  colorLUT: [],
+  segmentations: [],
+  globalConfig: newGlobalConfig,
+  toolGroups: {}
+};
+class SegmentationStateManager {
+  constructor(uid) {
+    if (!uid) {
+      uid = uuidv4$1();
+    }
+    this.state = cloneDeep(initialDefaultState);
+    this.uid = uid;
+  }
+  getState() {
+    return this.state;
+  }
+  getToolGroups() {
+    return Object.keys(this.state.toolGroups);
+  }
+  getColorLUT(lutIndex) {
+    return this.state.colorLUT[lutIndex];
+  }
+  getNextColorLUTIndex() {
+    return this.state.colorLUT.length;
+  }
+  resetState() {
+    this.state = cloneDeep(initialDefaultState);
+  }
+  getSegmentation(segmentationId) {
+    return this.state.segmentations.find(segmentation => segmentation.segmentationId === segmentationId);
+  }
+  addSegmentation(segmentation) {
+    if (this.getSegmentation(segmentation.segmentationId)) {
+      throw new Error(`Segmentation with id ${segmentation.segmentationId} already exists`);
+    }
+    this.state.segmentations.push(segmentation);
+  }
+  getSegmentationRepresentations(toolGroupId) {
+    const toolGroupSegRepresentationsWithConfig = this.state.toolGroups[toolGroupId];
+    if (!toolGroupSegRepresentationsWithConfig) {
+      return;
+    }
+    return toolGroupSegRepresentationsWithConfig.segmentationRepresentations;
+  }
+  getAllSegmentationRepresentations() {
+    const toolGroupSegReps = {};
+    Object.entries(this.state.toolGroups).forEach(([toolGroupId, toolGroupSegRepresentationsWithConfig]) => {
+      toolGroupSegReps[toolGroupId] = toolGroupSegRepresentationsWithConfig.segmentationRepresentations;
+    });
+    return toolGroupSegReps;
+  }
+  addSegmentationRepresentation(toolGroupId, segmentationRepresentation) {
+    if (!this.state.toolGroups[toolGroupId]) {
+      this.state.toolGroups[toolGroupId] = {
+        segmentationRepresentations: [],
+        config: {}
+      };
+    }
+    this.state.toolGroups[toolGroupId].segmentationRepresentations.push(segmentationRepresentation);
+    this._handleActiveSegmentation(toolGroupId, segmentationRepresentation);
+  }
+  getGlobalConfig() {
+    return this.state.globalConfig;
+  }
+  setGlobalConfig(config) {
+    this.state.globalConfig = config;
+  }
+  getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID) {
+    const toolGroupSegRepresentations = this.getSegmentationRepresentations(toolGroupId);
+    const segmentationData = toolGroupSegRepresentations?.find(representation => representation.segmentationRepresentationUID === segmentationRepresentationUID);
+    return segmentationData;
+  }
+  removeSegmentation(segmentationId) {
+    this.state.segmentations = this.state.segmentations.filter(segmentation => segmentation.segmentationId !== segmentationId);
+  }
+  removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID) {
+    const toolGroupSegmentationRepresentations = this.getSegmentationRepresentations(toolGroupId);
+    if (!toolGroupSegmentationRepresentations || !toolGroupSegmentationRepresentations.length) {
+      throw new Error(`No viewport specific segmentation state found for viewport ${toolGroupId}`);
+    }
+    const state = toolGroupSegmentationRepresentations;
+    const index = state.findIndex(segData => segData.segmentationRepresentationUID === segmentationRepresentationUID);
+    if (index === -1) {
+      console.warn(`No viewport specific segmentation state data found for viewport ${toolGroupId} and segmentation data UID ${segmentationRepresentationUID}`);
+    }
+    const removedSegmentationRepresentation = toolGroupSegmentationRepresentations[index];
+    toolGroupSegmentationRepresentations.splice(index, 1);
+    this._handleActiveSegmentation(toolGroupId, removedSegmentationRepresentation);
+  }
+  setActiveSegmentationRepresentation(toolGroupId, segmentationRepresentationUID) {
+    const toolGroupSegmentations = this.getSegmentationRepresentations(toolGroupId);
+    if (!toolGroupSegmentations || !toolGroupSegmentations.length) {
+      throw new Error(`No segmentation data found for toolGroupId: ${toolGroupId}`);
+    }
+    const segmentationData = toolGroupSegmentations.find(segmentationData => segmentationData.segmentationRepresentationUID === segmentationRepresentationUID);
+    if (!segmentationData) {
+      throw new Error(`No segmentation data found for segmentation data UID ${segmentationRepresentationUID}`);
+    }
+    segmentationData.active = true;
+    this._handleActiveSegmentation(toolGroupId, segmentationData);
+  }
+  getToolGroupSpecificConfig(toolGroupId) {
+    const toolGroupStateWithConfig = this.state.toolGroups[toolGroupId];
+    if (!toolGroupStateWithConfig) {
+      return;
+    }
+    return toolGroupStateWithConfig.config;
+  }
+  getSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID) {
+    const segmentationRepresentation = this.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
+    if (!segmentationRepresentation) {
+      return;
+    }
+    return segmentationRepresentation.segmentationRepresentationSpecificConfig;
+  }
+  setSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID, config) {
+    const segmentationRepresentation = this.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
+    if (!segmentationRepresentation) {
+      return;
+    }
+    segmentationRepresentation.segmentationRepresentationSpecificConfig = config;
+  }
+  getSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, segmentIndex) {
+    const segmentationRepresentation = this.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
+    if (!segmentationRepresentation) {
+      return;
+    }
+    return segmentationRepresentation.segmentSpecificConfig[segmentIndex];
+  }
+  setSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, config, options) {
+    const segmentationRepresentation = this.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
+    if (!segmentationRepresentation) {
+      return;
+    }
+    if (!segmentationRepresentation.segmentSpecificConfig || options?.clear) {
+      segmentationRepresentation.segmentSpecificConfig = {};
+    }
+    Object.keys(config).forEach(key => {
+      segmentationRepresentation.segmentSpecificConfig[key] = config[key];
+    });
+  }
+  setSegmentationRepresentationConfig(toolGroupId, config) {
+    let toolGroupStateWithConfig = this.state.toolGroups[toolGroupId];
+    if (!toolGroupStateWithConfig) {
+      this.state.toolGroups[toolGroupId] = {
+        segmentationRepresentations: [],
+        config: {
+          renderInactiveSegmentations: true,
+          representations: {}
+        }
+      };
+      toolGroupStateWithConfig = this.state.toolGroups[toolGroupId];
+    }
+    toolGroupStateWithConfig.config = {
+      ...toolGroupStateWithConfig.config,
+      ...config
+    };
+  }
+  addColorLUT(colorLUT, lutIndex) {
+    if (this.state.colorLUT[lutIndex]) {
+      console.warn('Color LUT table already exists, overwriting');
+    }
+    this.state.colorLUT[lutIndex] = structuredClone(colorLUT);
+  }
+  removeColorLUT(colorLUTIndex) {
+    delete this.state.colorLUT[colorLUTIndex];
+  }
+  _handleActiveSegmentation(toolGroupId, recentlyAddedOrRemovedSegmentationRepresentation) {
+    const segmentationRepresentations = this.getSegmentationRepresentations(toolGroupId);
+    if (segmentationRepresentations.length === 0) {
+      return;
+    }
+    if (segmentationRepresentations.length === 1) {
+      segmentationRepresentations[0].active = true;
+      return;
+    }
+    const activeSegmentationRepresentations = segmentationRepresentations.filter(representation => representation.active);
+    if (activeSegmentationRepresentations.length === 0) {
+      segmentationRepresentations[0].active = true;
+      return;
+    }
+    if (recentlyAddedOrRemovedSegmentationRepresentation.active) {
+      segmentationRepresentations.forEach(representation => {
+        if (representation.segmentationRepresentationUID !== recentlyAddedOrRemovedSegmentationRepresentation.segmentationRepresentationUID) {
+          representation.active = false;
+        }
+      });
+    }
+  }
+}
+const defaultSegmentationStateManager = new SegmentationStateManager('DEFAULT');
+
+function getDefaultSegmentationStateManager() {
+  return defaultSegmentationStateManager;
+}
+function getSegmentation(segmentationId) {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  return segmentationStateManager.getSegmentation(segmentationId);
+}
+
 const {
   isEqual: isEqual$1
 } = utilities;
@@ -49370,6 +49626,7 @@ function updateContourPolyline(annotation, polylineData, transforms, options) {
   invalidateAnnotation(annotation);
 }
 
+const DEFAULT_CONTOUR_SEG_TOOLNAME = 'PlanarFreehandContourSegmentationTool';
 function getInterpolationData(viewportData, filterParams = []) {
   const {
     viewport,
@@ -49377,8 +49634,24 @@ function getInterpolationData(viewportData, filterParams = []) {
     annotation
   } = viewportData;
   const interpolationDatas = new Map();
-  const annotations = getAnnotations(annotation.metadata.toolName, viewport.element);
-  if (!annotations) {
+  const {
+    toolName,
+    originalToolName
+  } = annotation.metadata;
+  const testToolName = originalToolName || toolName;
+  const annotations = getAnnotations(testToolName, viewport.element) || [];
+  const modifiedAnnotations = getAnnotations(DEFAULT_CONTOUR_SEG_TOOLNAME, viewport.element);
+  if (modifiedAnnotations?.length) {
+    modifiedAnnotations.forEach(annotation => {
+      const {
+        metadata
+      } = annotation;
+      if (metadata.originalToolName === testToolName && !annotations.find(it => it === annotation)) {
+        annotations.push(annotation);
+      }
+    });
+  }
+  if (!annotations?.length) {
     return interpolationDatas;
   }
   for (let i = 0; i < sliceData.numberOfSlices; i++) {
@@ -49557,7 +49830,7 @@ function _getBoundingPair(sliceIndex, sliceRange, interpolationData) {
 const {
   PointsManager: PointsManager$1
 } = utilities;
-function selectHandles(polyline, handleCount = 8) {
+function selectHandles(polyline, handleCount = 12) {
   const handles = PointsManager$1.create3(handleCount);
   handles.sources = [];
   const {
@@ -49569,10 +49842,9 @@ function selectHandles(polyline, handleCount = 8) {
   } = polyline;
   const distance = 6;
   if (length < distance * 3) {
-    console.log('Adding subselect handles', handleCount, length);
     return polyline.subselect(handleCount);
   }
-  const interval = Math.min(30, Math.floor(length / 3));
+  const interval = Math.floor(Math.max(2 * length / handleCount, distance * 5));
   sourcePoints.forEach(() => destPoints.push(PointsManager$1.create3(handleCount)));
   const dotValues = createDotValues(polyline, distance);
   const minimumRegions = findMinimumRegions(dotValues, handleCount);
@@ -49731,12 +50003,10 @@ const {
   PointsManager
 } = utilities;
 const dP = 0.2;
-let interpolating = false;
 function interpolate(viewportData) {
-  if (interpolating || !viewportData.annotation) {
+  if (!viewportData.annotation) {
     return;
   }
-  interpolating = true;
   const {
     isInterpolationUpdate,
     annotation
@@ -49749,7 +50019,6 @@ function interpolate(viewportData) {
       }
       startInterpolation(viewportData);
     } finally {
-      interpolating = false;
       if (isInterpolationUpdate) {
         annotation.autoGenerated = true;
       }
@@ -50117,6 +50386,31 @@ function deleteRelatedAnnotations(viewportData) {
   }
 }
 
+function addContourSegmentationAnnotation(annotation) {
+  if (!annotation.data.segmentation) {
+    throw new Error('addContourSegmentationAnnotation: annotation does not have a segmentation data');
+  }
+  const {
+    segmentationId,
+    segmentIndex
+  } = annotation.data.segmentation;
+  const segmentation = getSegmentation(segmentationId);
+  if (!segmentation.representationData.CONTOUR) {
+    segmentation.representationData.CONTOUR = {
+      annotationUIDsMap: new Map()
+    };
+  }
+  const {
+    annotationUIDsMap
+  } = segmentation.representationData.CONTOUR;
+  let annotationsUIDsSet = annotationUIDsMap.get(segmentIndex);
+  if (!annotationsUIDsSet) {
+    annotationsUIDsSet = new Set();
+    annotationUIDsMap.set(segmentIndex, annotationsUIDsSet);
+  }
+  annotationUIDsMap.set(segmentIndex, annotationsUIDsSet.add(annotation.annotationUID));
+}
+
 const {
   uuidv4
 } = utilities;
@@ -50144,10 +50438,14 @@ class InterpolationManager {
       }
       for (const annotation of annotations) {
         const {
+          interpolationUID,
           data,
           autoGenerated,
           metadata
         } = annotation;
+        if (interpolationUID) {
+          annotation.interpolationCompleted = true;
+        }
         if (!autoGenerated) {
           continue;
         }
@@ -50160,6 +50458,7 @@ class InterpolationManager {
         if (segmentationId && segmentationId !== data.segmentation.segmentationId) {
           continue;
         }
+        addContourSegmentationAnnotation(annotation);
         annotation.autoGenerated = false;
       }
     }
@@ -50171,11 +50470,13 @@ class InterpolationManager {
         return;
       }
       const {
-        toolName
+        toolName,
+        originalToolName
       } = annotation.metadata;
-      if (!this.toolNames.includes(toolName)) {
+      if (!this.toolNames.includes(toolName) && !this.toolNames.includes(originalToolName)) {
         return;
       }
+      console.log('Interpolation annotation', annotation.annotationUID);
       const viewport = getViewportForAnnotation(annotation);
       if (!viewport) {
         console.warn('Unable to find viewport for', annotation);
@@ -50209,11 +50510,21 @@ class InterpolationManager {
         parentKey: annotation => annotation.metadata
       }];
       let interpolationAnnotations = getInterpolationDataCollection(viewportData, filterData);
-      interpolationAnnotations = interpolationAnnotations.filter(interpolationAnnotation => interpolationAnnotation.interpolationUID);
-      if (!annotation.interpolationUID) {
-        annotation.interpolationUID = interpolationAnnotations[0]?.interpolationUID || uuidv4();
-        viewportData.interpolationUID = annotation.interpolationUID;
-      }
+      const {
+        sliceIndex
+      } = annotation.metadata;
+      const skipUIDs = new Set();
+      interpolationAnnotations.forEach(interpolationAnnotation => {
+        if (interpolationAnnotation.interpolationCompleted || interpolationAnnotation.metadata.sliceIndex === sliceIndex) {
+          const {
+            interpolationUID
+          } = interpolationAnnotation;
+          skipUIDs.add(interpolationUID);
+        }
+      });
+      interpolationAnnotations = interpolationAnnotations.filter(interpolationAnnotation => !skipUIDs.has(interpolationAnnotation.interpolationUID));
+      annotation.interpolationUID = interpolationAnnotations[0]?.interpolationUID || uuidv4();
+      viewportData.interpolationUID = annotation.interpolationUID;
       interpolate(viewportData);
     };
   }
@@ -50227,9 +50538,10 @@ class InterpolationManager {
         return;
       }
       const {
-        toolName
+        toolName,
+        originalToolName
       } = annotation.metadata;
-      if (!this.toolNames.includes(toolName) || !ChangeTypesForInterpolation.includes(changeType)) {
+      if (!this.toolNames.includes(toolName) && !this.toolNames.includes(originalToolName) || !ChangeTypesForInterpolation.includes(changeType)) {
         return;
       }
       const viewport = getViewportForAnnotation(annotation);
@@ -50237,7 +50549,10 @@ class InterpolationManager {
         console.warn('Unable to find matching viewport for annotation interpolation', annotation);
         return;
       }
-      annotation.autoGenerated = false;
+      if (annotation.autoGenerated) {
+        addContourSegmentationAnnotation(annotation);
+        annotation.autoGenerated = false;
+      }
       const sliceData = getSliceData(viewport);
       const viewportData = {
         viewport,