@cornerstonejs/tools 0.60.2 → 0.61.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "0.60.2",
+  "version": "0.61.1",
   "description": "Cornerstone3D Tools",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -26,7 +26,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^0.40.1",
+    "@cornerstonejs/core": "^0.41.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
   },
@@ -52,5 +52,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "ebbb555ff9032600b1f7d6fecde9303e5c79571f"
+  "gitHead": "8e8c4693642dab1c46c38381f66730b40b187e79"
 }

package/src/stateManagement/segmentation/removeSegmentationsFromToolGroup.ts

@@ -1,5 +1,6 @@
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 import { labelmapDisplay } from '../../tools/displayTools/Labelmap';
+import { contourDisplay } from '../../tools/displayTools/Contour';
 
 import {
   getSegmentationRepresentations,
@@ -76,7 +77,11 @@ function _removeSegmentation(
       immediate
     );
   } else if (type === SegmentationRepresentations.Contour) {
-    console.debug('Contour representation is not supported yet, ignoring...');
+    contourDisplay.removeSegmentationRepresentation(
+      toolGroupId,
+      segmentationRepresentationUID,
+      immediate
+    );
   } else {
     throw new Error(`The representation ${type} is not supported yet`);
   }

package/src/tools/displayTools/Contour/contourConfig.ts

@@ -6,6 +6,9 @@ const defaultContourConfig: ContourConfig = {
   outlineWidthInactive: 2,
   outlineOpacity: 1,
   outlineOpacityInactive: 0.85,
+  renderFill: true,
+  fillAlpha: 1,
+  fillAlphaInactive: 0,
 };
 
 function getDefaultContourConfig(): ContourConfig {

package/src/tools/displayTools/Contour/contourDisplay.ts

@@ -15,6 +15,7 @@ import {
 } from '../../../types/SegmentationStateTypes';
 import { addOrUpdateContourSets } from './addOrUpdateContourSets';
 import removeContourFromElement from './removeContourFromElement';
+import { deleteConfigCache } from './contourConfigCache';
 
 /**
  * It adds a new segmentation representation to the segmentation state
@@ -97,6 +98,8 @@ function removeSegmentationRepresentation(
     segmentationRepresentationUID
   );
 
+  deleteConfigCache(segmentationRepresentationUID);
+
   if (renderImmediate) {
     const viewportsInfo = getToolGroup(toolGroupId).getViewportsInfo();
     viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {

package/src/tools/displayTools/Contour/updateContourSets.ts

@@ -1,6 +1,4 @@
 import { cache, Types } from '@cornerstonejs/core';
-import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
-import vtkAppendPolyData from '@kitware/vtk.js/Filters/General/AppendPolyData';
 import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
 
 import {
@@ -8,7 +6,7 @@ import {
   ToolGroupSpecificContourRepresentation,
 } from '../../../types';
 import { getConfigCache, setConfigCache } from './contourConfigCache';
-import { getPolyData } from './utils';
+import { getSegmentSpecificConfig } from './utils';
 
 export function updateContourSets(
   viewport: Types.IVolumeViewport,
@@ -53,7 +51,7 @@ export function updateContourSets(
   const segmentsToSetToVisible = [];
 
   for (const segmentIndex of segmentsHidden) {
-    if (!cachedConfig?.segmentsHidden.has(segmentIndex)) {
+    if (!cachedConfig.segmentsHidden.has(segmentIndex)) {
       segmentsToSetToInvisible.push(segmentIndex);
     }
   }
@@ -64,38 +62,82 @@ export function updateContourSets(
       segmentsToSetToVisible.push(segmentIndex);
     }
   }
-  if (segmentsToSetToInvisible.length || segmentsToSetToVisible.length) {
-    const appendPolyData = vtkAppendPolyData.newInstance();
 
-    geometryIds.forEach((geometryId) => {
+  const mergedInvisibleSegments = Array.from(cachedConfig.segmentsHidden)
+    .filter((segmentIndex) => !segmentsToSetToVisible.includes(segmentIndex))
+    .concat(segmentsToSetToInvisible);
+
+  const { contourSets, segmentSpecificConfigs } = geometryIds.reduce(
+    (acc, geometryId) => {
       const geometry = cache.getGeometry(geometryId);
       const { data: contourSet } = geometry;
       const segmentIndex = (contourSet as Types.IContourSet).getSegmentIndex();
-      const color = contourSet.getColor();
-      const visibility = segmentsToSetToInvisible.includes(segmentIndex)
-        ? 0
-        : 255;
-      const polyData = getPolyData(contourSet);
-
-      const size = polyData.getPoints().getNumberOfPoints();
-
-      const scalars = vtkDataArray.newInstance({
-        size: size * 4,
-        numberOfComponents: 4,
-        dataType: 'Uint8Array',
-      });
-      for (let i = 0; i < size; ++i) {
-        scalars.setTuple(i, [...color, visibility]);
+      const segmentSpecificConfig = getSegmentSpecificConfig(
+        contourRepresentation,
+        geometryId,
+        segmentIndex
+      );
+
+      acc.contourSets.push(contourSet);
+      acc.segmentSpecificConfigs[segmentIndex] = segmentSpecificConfig ?? {};
+
+      return acc;
+    },
+    { contourSets: [], segmentSpecificConfigs: {} }
+  );
+
+  const affectedSegments = [
+    ...mergedInvisibleSegments,
+    ...segmentsToSetToVisible,
+  ];
+
+  const hasCustomSegmentSpecificConfig = Object.values(
+    segmentSpecificConfigs
+  ).some((config) => Object.keys(config).length > 0);
+
+  let polyDataModified = false;
+
+  if (affectedSegments.length || hasCustomSegmentSpecificConfig) {
+    const appendPolyData = mapper.getInputData();
+    const appendScalars = appendPolyData.getPointData().getScalars();
+    const appendScalarsData = appendScalars.getData();
+    // below we will only manipulate the polyData of the contourSets that are affected
+    // by picking the correct offset in the scalarData array
+    let offset = 0;
+    contourSets.forEach((contourSet) => {
+      const segmentIndex = (contourSet as Types.IContourSet).getSegmentIndex();
+      const size = contourSet.getTotalNumberOfPoints();
+
+      if (
+        affectedSegments.includes(segmentIndex) ||
+        segmentSpecificConfigs[segmentIndex]?.fillAlpha // Todo: add others
+      ) {
+        const color = contourSet.getColor();
+        let visibility = mergedInvisibleSegments.includes(segmentIndex)
+          ? 0
+          : 255;
+
+        const segmentConfig = segmentSpecificConfigs[segmentIndex];
+        if (segmentConfig.fillAlpha !== undefined) {
+          visibility = segmentConfig.fillAlpha * 255;
+        }
+
+        for (let i = 0; i < size; ++i) {
+          appendScalarsData[offset + i * 4] = color[0];
+          appendScalarsData[offset + i * 4 + 1] = color[1];
+          appendScalarsData[offset + i * 4 + 2] = color[2];
+          appendScalarsData[offset + i * 4 + 3] = visibility;
+        }
+
+        polyDataModified = true;
       }
-      polyData.getPointData().setScalars(scalars);
 
-      segmentIndex === 0
-        ? appendPolyData.setInputData(polyData)
-        : appendPolyData.addInputData(polyData);
+      offset = offset + size * 4;
     });
 
-    const polyDataOutput = appendPolyData.getOutputData();
-    mapper.setInputData(polyDataOutput);
+    if (polyDataModified) {
+      appendPolyData.modified();
+    }
 
     setConfigCache(
       segmentationRepresentationUID,

package/src/tools/displayTools/Contour/utils.ts

@@ -1,6 +1,5 @@
 import { Enums, Types } from '@cornerstonejs/core';
 import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
-import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkPoints from '@kitware/vtk.js/Common/Core/Points';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
 import { ToolGroupSpecificContourRepresentation } from '../../../types';

package/src/types/ContourTypes.ts

@@ -12,6 +12,12 @@ export type ContourConfig = {
   outlineOpacityInactive?: number;
   /** outline visibility */
   renderOutline?: boolean;
+  /** render fill */
+  renderFill?: boolean;
+  /** fill alpha */
+  fillAlpha?: number;
+  /** fillAlphaInactive */
+  fillAlphaInactive?: number;
 };
 
 /**