@cornerstonejs/tools 0.56.6 → 0.57.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "0.56.6",
+  "version": "0.57.0",
   "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.36.5",
+    "@cornerstonejs/core": "^0.37.0",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
   },
@@ -52,5 +52,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "ea1b62924f0e481d137460808f72caa95236d105"
+  "gitHead": "1e40104275742f14a7a48b076f244610f90e8657"
 }

package/src/stateManagement/segmentation/SegmentationStateManager.ts

@@ -1,29 +1,32 @@
-import cloneDeep from 'lodash.clonedeep';
 import { utilities as csUtils } from '@cornerstonejs/core';
+import cloneDeep from 'lodash.clonedeep';
 
 import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
 
+import { SegmentationRepresentations } from '../../enums';
+import getDefaultContourConfig from '../../tools/displayTools/Contour/contourConfig';
+import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
 import type {
-  SegmentationState,
   ColorLUT,
+  RepresentationConfig,
   Segmentation,
-  ToolGroupSpecificRepresentation,
   SegmentationRepresentationConfig,
-  ToolGroupSpecificRepresentations,
-  RepresentationConfig,
+  SegmentationState,
   SegmentSpecificRepresentationConfig,
+  ToolGroupSpecificRepresentation,
+  ToolGroupSpecificRepresentations,
 } from '../../types/SegmentationStateTypes';
-import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
-import { SegmentationRepresentations } from '../../enums';
 
 // Initialize the default configuration
 // Note: when we get other representations, we should set their default representations too.
 const defaultLabelmapConfig = getDefaultLabelmapConfig();
+const defaultContourConfig = getDefaultContourConfig();
 
 const newGlobalConfig: SegmentationRepresentationConfig = {
   renderInactiveSegmentations: true,
   representations: {
     [SegmentationRepresentations.Labelmap]: defaultLabelmapConfig,
+    [SegmentationRepresentations.Contour]: defaultContourConfig,
   },
 };
 

package/src/stateManagement/segmentation/config/segmentationColor.ts

@@ -3,6 +3,7 @@ import * as SegmentationState from '../../../stateManagement/segmentation/segmen
 import { Color } from '../../../types/SegmentationStateTypes';
 import { ColorLUT } from '../../../types/SegmentationStateTypes';
 import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
+import { SegmentationRepresentations } from '../../../enums';
 
 /**
  * addColorLUT - Adds a new color LUT to the state at the given colorLUTIndex.

package/src/stateManagement/segmentation/config/segmentationVisibility.ts

@@ -1,16 +1,34 @@
-import { cache } from '@cornerstonejs/core';
+import { cache, Types } from '@cornerstonejs/core';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import { getSegmentationRepresentations } from '../../../stateManagement/segmentation/segmentationState';
 import { ToolGroupSpecificRepresentation } from '../../../types/SegmentationStateTypes';
 import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
+import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
 
 function getSegmentationIndices(segmentationId) {
-  const volume = cache.getVolume(segmentationId);
-  const scalarData = volume.getScalarData();
-
-  const keySet = {};
-  scalarData.forEach((it) => (keySet[it] = it));
-  return Object.keys(keySet).map((it) => parseInt(it, 10));
+  const segmentation = SegmentationState.getSegmentation(segmentationId);
+
+  if (segmentation.type === SegmentationRepresentations.Labelmap) {
+    const volume = cache.getVolume(segmentationId);
+    const scalarData = volume.getScalarData();
+
+    const keySet = {};
+    scalarData.forEach((it) => (keySet[it] = it));
+    return Object.keys(keySet).map((it) => parseInt(it, 10));
+  } else if (segmentation.type === SegmentationRepresentations.Contour) {
+    const geometryIds = segmentation.representationData.CONTOUR?.geometryIds;
+
+    if (!geometryIds) {
+      throw new Error(
+        `No geometryIds found for segmentationId ${segmentationId}`
+      );
+    }
+
+    return geometryIds.map((geometryId) => {
+      const geometry = cache.getGeometry(geometryId) as Types.IGeometry;
+      return (geometry.data as Types.IContourSet).getSegmentIndex();
+    });
+  }
 }
 
 /**

package/src/stateManagement/segmentation/segmentationState.ts

@@ -1,10 +1,3 @@
-import { defaultSegmentationStateManager } from './SegmentationStateManager';
-import {
-  triggerSegmentationRepresentationModified,
-  triggerSegmentationModified,
-  triggerSegmentationRepresentationRemoved,
-  triggerSegmentationRemoved,
-} from './triggerSegmentationEvents';
 import type {
   ColorLUT,
   RepresentationConfig,
@@ -15,10 +8,15 @@ import type {
   ToolGroupSpecificRepresentation,
   ToolGroupSpecificRepresentations,
 } from '../../types/SegmentationStateTypes';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import {
+  triggerSegmentationModified,
+  triggerSegmentationRemoved,
+  triggerSegmentationRepresentationModified,
+  triggerSegmentationRepresentationRemoved,
+} from './triggerSegmentationEvents';
 
 import normalizeSegmentationInput from './helpers/normalizeSegmentationInput';
-import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
-import { SegmentationRepresentations } from '../../enums';
 
 /**
  * It returns the defaultSegmentationStateManager.
@@ -385,21 +383,7 @@ function addColorLUT(colorLUT: ColorLUT, index: number): void {
   // Todo: trigger event color LUT added
 }
 
-// Initialize the default configuration
-// Note: when we get other representations, we should set their default representations too.
-const defaultLabelmapConfig = getDefaultLabelmapConfig();
-
-const newGlobalConfig: SegmentationRepresentationConfig = {
-  renderInactiveSegmentations: true,
-  representations: {
-    [SegmentationRepresentations.Labelmap]: defaultLabelmapConfig,
-  },
-};
-
-setGlobalConfig(newGlobalConfig, true);
-
 export {
-  // state manager
   getDefaultSegmentationStateManager,
   // Segmentation
   getSegmentation,

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

@@ -0,0 +1,110 @@
+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 vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
+
+import {
+  getPolyData,
+  getSegmentSpecificConfig,
+  validateGeometry,
+} from './utils';
+
+import {
+  SegmentationRepresentationConfig,
+  ToolGroupSpecificContourRepresentation,
+} from '../../../types';
+import { getConfigCache, setConfigCache } from './contourConfigCache';
+
+export function addContourSetsToElement(
+  viewport: Types.IVolumeViewport,
+  geometryIds: string[],
+  contourRepresentation: ToolGroupSpecificContourRepresentation,
+  contourRepresentationConfig: SegmentationRepresentationConfig,
+  contourActorUID: string
+) {
+  const { segmentationRepresentationUID, segmentsHidden } =
+    contourRepresentation;
+  const appendPolyData = vtkAppendPolyData.newInstance();
+
+  const scalarToColorMap = new Map();
+  const segmentSpecificMap = new Map();
+
+  geometryIds.forEach((geometryId) => {
+    const geometry = cache.getGeometry(geometryId);
+
+    if (!geometry) {
+      console.warn(
+        `No geometry found for geometryId ${geometryId}. Skipping render.`
+      );
+      return;
+    }
+
+    const segmentIndex = (geometry.data as Types.IContourSet).getSegmentIndex();
+
+    validateGeometry(geometry);
+
+    const segmentSpecificConfig = getSegmentSpecificConfig(
+      contourRepresentation,
+      geometryId,
+      segmentIndex
+    );
+
+    const contourSet = geometry.data;
+    const polyData = getPolyData(contourSet);
+    const color = contourSet.getColor();
+
+    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, 255]);
+    }
+    polyData.getPointData().setScalars(scalars);
+
+    if (segmentSpecificConfig) {
+      segmentSpecificMap.set(segmentIndex, segmentSpecificConfig);
+    }
+
+    scalarToColorMap.set(segmentIndex, [
+      ...color,
+      segmentsHidden.has(segmentIndex) ? 0 : 255,
+    ]);
+
+    segmentIndex === 0
+      ? appendPolyData.setInputData(polyData)
+      : appendPolyData.addInputData(polyData);
+  });
+
+  const polyDataOutput = appendPolyData.getOutputData();
+
+  const outlineWidthActive =
+    contourRepresentationConfig.representations.CONTOUR.outlineWidthActive;
+
+  const mapper = vtkMapper.newInstance();
+  mapper.setInputData(polyDataOutput);
+
+  const actor = vtkActor.newInstance();
+  actor.setMapper(mapper);
+  actor.getProperty().setLineWidth(outlineWidthActive);
+
+  // set the config cache for later update of the contour
+  setConfigCache(
+    segmentationRepresentationUID,
+    Object.assign({}, getConfigCache(segmentationRepresentationUID), {
+      segmentsHidden: new Set(segmentsHidden),
+      segmentSpecificMap,
+      outlineWidthActive,
+    })
+  );
+
+  actor.setForceOpaque(true);
+
+  viewport.addActor({ uid: contourActorUID, actor });
+  viewport.resetCamera();
+  viewport.render();
+}

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

@@ -0,0 +1,28 @@
+import { Types } from '@cornerstonejs/core';
+
+import {
+  SegmentationRepresentationConfig,
+  ToolGroupSpecificContourRepresentation,
+} from '../../../types';
+import { addContourSetsToElement } from './addContourSetsToElement';
+import { updateContourSets } from './updateContourSets';
+
+export function addOrUpdateContourSets(
+  viewport: Types.IVolumeViewport,
+  geometryIds: string[],
+  contourRepresentation: ToolGroupSpecificContourRepresentation,
+  contourRepresentationConfig: SegmentationRepresentationConfig
+) {
+  const { segmentationRepresentationUID } = contourRepresentation;
+  const actorUID = `CONTOUR_${segmentationRepresentationUID}`;
+  const actor = viewport.getActor(actorUID);
+
+  const addOrUpdateFn = actor ? updateContourSets : addContourSetsToElement;
+  addOrUpdateFn(
+    viewport,
+    geometryIds,
+    contourRepresentation,
+    contourRepresentationConfig,
+    actorUID
+  );
+}

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

@@ -0,0 +1,15 @@
+import { ContourConfig } from '../../../types/ContourTypes';
+
+const defaultContourConfig: ContourConfig = {
+  renderOutline: true,
+  outlineWidthActive: 2,
+  outlineWidthInactive: 2,
+  outlineOpacity: 1,
+  outlineOpacityInactive: 0.85,
+};
+
+function getDefaultContourConfig(): ContourConfig {
+  return defaultContourConfig;
+}
+
+export default getDefaultContourConfig;

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

@@ -0,0 +1,37 @@
+type ConfigCache = {
+  segmentsHidden: Set<number>;
+  outlineWidthActive: number;
+  visibility: boolean;
+};
+
+/**
+ * Config cache is used to store the config for a given segmentation
+ * representation. This is used to avoid having to recompute the config
+ * every time the user changes the active segment, and also for performance
+ * reasons.
+ */
+const configCachePerSegmentationRepresentationUID = new Map();
+
+export function getConfigCache(
+  segmentationRepresentationUID: string
+): ConfigCache {
+  return configCachePerSegmentationRepresentationUID.get(
+    segmentationRepresentationUID
+  );
+}
+
+export function setConfigCache(
+  segmentationRepresentationUID: string,
+  config: ConfigCache
+) {
+  configCachePerSegmentationRepresentationUID.set(
+    segmentationRepresentationUID,
+    config
+  );
+}
+
+export function deleteConfigCache(segmentationRepresentationUID: string) {
+  configCachePerSegmentationRepresentationUID.delete(
+    segmentationRepresentationUID
+  );
+}

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

@@ -1,6 +1,4 @@
 import {
-  cache,
-  Enums,
   getEnabledElementByIds,
   Types,
   utilities as csUtils,
@@ -15,12 +13,8 @@ import {
   SegmentationRepresentationConfig,
   ToolGroupSpecificRepresentation,
 } from '../../../types/SegmentationStateTypes';
-
-import {
-  addContourSetToElement,
-  addContourToElement,
-} from './addContourToElement';
-import { default as removeContourFromElement } from './removeContourFromElement';
+import { addOrUpdateContourSets } from './addOrUpdateContourSets';
+import removeContourFromElement from './removeContourFromElement';
 
 /**
  * It adds a new segmentation representation to the segmentation state
@@ -123,17 +117,10 @@ function removeSegmentationRepresentation(
  */
 async function render(
   viewport: Types.IVolumeViewport,
-  representation: ToolGroupSpecificRepresentation,
+  representationConfig: ToolGroupSpecificRepresentation,
   toolGroupConfig: SegmentationRepresentationConfig
 ): Promise<void> {
-  const {
-    colorLUTIndex,
-    active,
-    segmentationId,
-    segmentationRepresentationUID,
-    segmentsHidden,
-  } = representation;
-
+  const { segmentationId } = representationConfig;
   const segmentation = SegmentationState.getSegmentation(segmentationId);
   const contourData = segmentation.representationData[Representations.Contour];
   const { geometryIds } = contourData;
@@ -144,80 +131,13 @@ async function render(
     );
   }
 
-  _renderContourSets(viewport, geometryIds, segmentationRepresentationUID);
-}
-
-function _renderContourSets(
-  viewport,
-  geometryIds,
-  segmentationRepresentationUID
-) {
-  geometryIds.forEach((geometryId) => {
-    const geometry = cache.getGeometry(geometryId);
-    if (!geometry) {
-      throw new Error(`No contours found for geometryId ${geometryId}`);
-    }
-
-    if (geometry.type !== Enums.GeometryType.CONTOUR) {
-      // Todo: later we can support converting other geometries to contours
-      throw new Error(
-        `Geometry type ${geometry.type} not supported for rendering.`
-      );
-    }
-
-    if (!geometry.data) {
-      console.warn(
-        `No contours found for geometryId ${geometryId}. Skipping render.`
-      );
-      return;
-    }
-
-    const contourSet = geometry.data;
-
-    _renderContourSet(viewport, contourSet, segmentationRepresentationUID);
-  });
-}
-
-function _renderContourSet(
-  viewport: Types.IVolumeViewport,
-  contourSet: Types.IContourSet,
-  segmentationRepresentationUID: string,
-  separated = false
-): void {
-  if (separated) {
-    contourSet.getContours().forEach((contour: Types.IContour, index) => {
-      const contourUID = `${segmentationRepresentationUID}_${contourSet.id}_${index}}`;
-      _renderContour(viewport, contour, contourUID);
-    });
-  } else {
-    const contourUID = `${segmentationRepresentationUID}_${contourSet.id}`;
-    const actorUID = contourUID;
-    const actorEntry = viewport.getActor(actorUID);
-
-    if (!actorEntry) {
-      addContourSetToElement(viewport.element, contourSet, actorUID);
-    } else {
-      throw new Error('Not implemented yet. (Update contour)');
-    }
-  }
-
-  viewport.resetCamera();
-  viewport.render();
-}
-
-function _renderContour(
-  viewport: Types.IVolumeViewport,
-  contour: Types.IContour,
-  contourUID: string
-): void {
-  const actorUID = contourUID;
-  const actorEntry = viewport.getActor(actorUID);
-
-  if (!actorEntry) {
-    addContourToElement(viewport.element, contour, actorUID);
-  } else {
-    throw new Error('Not implemented yet. (Update contour)');
-  }
+  // add the contour sets to the viewport
+  addOrUpdateContourSets(
+    viewport,
+    geometryIds,
+    representationConfig,
+    toolGroupConfig
+  );
 }
 
 function _removeContourFromToolGroupViewports(

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

@@ -0,0 +1,111 @@
+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 {
+  SegmentationRepresentationConfig,
+  ToolGroupSpecificContourRepresentation,
+} from '../../../types';
+import { getConfigCache, setConfigCache } from './contourConfigCache';
+import { getPolyData } from './utils';
+
+export function updateContourSets(
+  viewport: Types.IVolumeViewport,
+  geometryIds: string[],
+  contourRepresentation: ToolGroupSpecificContourRepresentation,
+  contourRepresentationConfig: SegmentationRepresentationConfig,
+  contourActorUID: string
+) {
+  const { segmentationRepresentationUID, segmentsHidden } =
+    contourRepresentation;
+  const newContourConfig = contourRepresentationConfig.representations.CONTOUR;
+  const cachedConfig = getConfigCache(segmentationRepresentationUID);
+
+  const contourSetsActor = viewport.getActor(contourActorUID);
+
+  if (!contourSetsActor) {
+    console.warn(
+      `No contour actor found for actorUID ${contourActorUID}. Skipping render.`
+    );
+    return;
+  }
+
+  const { actor } = contourSetsActor;
+
+  const newOutlineWithActive = newContourConfig.outlineWidthActive;
+
+  if (cachedConfig?.outlineWidthActive !== newOutlineWithActive) {
+    (actor as vtkActor).getProperty().setLineWidth(newOutlineWithActive);
+
+    setConfigCache(
+      segmentationRepresentationUID,
+      Object.assign({}, cachedConfig, {
+        outlineWidthActive: newOutlineWithActive,
+      })
+    );
+  }
+
+  const mapper = (actor as vtkActor).getMapper();
+  const lut = mapper.getLookupTable();
+
+  const segmentsToSetToInvisible = [];
+  const segmentsToSetToVisible = [];
+
+  for (const segmentIndex of segmentsHidden) {
+    if (!cachedConfig?.segmentsHidden.has(segmentIndex)) {
+      segmentsToSetToInvisible.push(segmentIndex);
+    }
+  }
+
+  // the other way around
+  for (const segmentIndex of cachedConfig.segmentsHidden) {
+    if (!segmentsHidden.has(segmentIndex)) {
+      segmentsToSetToVisible.push(segmentIndex);
+    }
+  }
+  if (segmentsToSetToInvisible.length || segmentsToSetToVisible.length) {
+    const appendPolyData = vtkAppendPolyData.newInstance();
+
+    geometryIds.forEach((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]);
+      }
+      polyData.getPointData().setScalars(scalars);
+
+      segmentIndex === 0
+        ? appendPolyData.setInputData(polyData)
+        : appendPolyData.addInputData(polyData);
+    });
+
+    const polyDataOutput = appendPolyData.getOutputData();
+    mapper.setInputData(polyDataOutput);
+
+    setConfigCache(
+      segmentationRepresentationUID,
+      Object.assign({}, cachedConfig, {
+        segmentsHidden: new Set(segmentsHidden),
+      })
+    );
+
+    mapper.setLookupTable(lut);
+  }
+
+  viewport.render();
+}