@cornerstonejs/tools 0.56.1 → 0.56.3

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

@@ -0,0 +1,252 @@
+import {
+  cache,
+  Enums,
+  getEnabledElementByIds,
+  Types,
+  utilities as csUtils,
+} from '@cornerstonejs/core';
+
+import Representations from '../../../enums/SegmentationRepresentations';
+import * as SegmentationConfig from '../../../stateManagement/segmentation/config/segmentationConfig';
+import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import { getToolGroup } from '../../../store/ToolGroupManager';
+import {
+  RepresentationPublicInput,
+  SegmentationRepresentationConfig,
+  ToolGroupSpecificRepresentation,
+} from '../../../types/SegmentationStateTypes';
+
+import {
+  addContourSetToElement,
+  addContourToElement,
+} from './addContourToElement';
+import { default as removeContourFromElement } from './removeContourFromElement';
+
+/**
+ * It adds a new segmentation representation to the segmentation state
+ * @param toolGroupId - The id of the toolGroup that the segmentation
+ * belongs to
+ * @param representationInput - RepresentationPublicInput
+ * @param toolGroupSpecificConfig - The configuration that is specific to the toolGroup.
+ * @returns The segmentationRepresentationUID
+ */
+async function addSegmentationRepresentation(
+  toolGroupId: string,
+  representationInput: RepresentationPublicInput,
+  toolGroupSpecificConfig?: SegmentationRepresentationConfig
+): Promise<string> {
+  const { segmentationId } = representationInput;
+  const segmentationRepresentationUID = csUtils.uuidv4();
+  // Todo: make these configurable during representation input by user
+  const segmentsHidden = new Set() as Set<number>;
+  const visibility = true;
+  const colorLUTIndex = 0;
+  const active = true;
+  const toolGroupSpecificRepresentation: ToolGroupSpecificRepresentation = {
+    segmentationId,
+    segmentationRepresentationUID,
+    type: Representations.Contour,
+    segmentsHidden,
+    colorLUTIndex,
+    active,
+    segmentationRepresentationSpecificConfig: {},
+    segmentSpecificConfig: {},
+    config: {},
+  };
+  // Update the toolGroup specific configuration
+  if (toolGroupSpecificConfig) {
+    // Since setting configuration on toolGroup will trigger a segmentationRepresentation
+    // update event, we don't want to trigger the event twice, so we suppress
+    // the first one
+    const currentToolGroupConfig =
+      SegmentationConfig.getToolGroupSpecificConfig(toolGroupId);
+    const mergedConfig = csUtils.deepMerge(
+      currentToolGroupConfig,
+      toolGroupSpecificConfig
+    );
+    SegmentationConfig.setToolGroupSpecificConfig(toolGroupId, {
+      renderInactiveSegmentations:
+        mergedConfig.renderInactiveSegmentations || true,
+      representations: {
+        ...mergedConfig.representations,
+      },
+    });
+  }
+  SegmentationState.addSegmentationRepresentation(
+    toolGroupId,
+    toolGroupSpecificRepresentation
+  );
+  return segmentationRepresentationUID;
+}
+
+/**
+ * It removes a segmentation representation from the tool group's viewports and
+ * from the segmentation state
+ * @param toolGroupId - The toolGroupId of the toolGroup that the
+ * segmentationRepresentation belongs to.
+ * @param segmentationRepresentationUID - This is the unique identifier
+ * for the segmentation representation.
+ * @param renderImmediate - If true, the viewport will be rendered
+ * immediately after the segmentation representation is removed.
+ */
+function removeSegmentationRepresentation(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  renderImmediate = false
+): void {
+  _removeContourFromToolGroupViewports(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+  SegmentationState.removeSegmentationRepresentation(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+
+  if (renderImmediate) {
+    const viewportsInfo = getToolGroup(toolGroupId).getViewportsInfo();
+    viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+      const enabledElement = getEnabledElementByIds(
+        viewportId,
+        renderingEngineId
+      );
+      enabledElement.viewport.render();
+    });
+  }
+}
+
+/**
+ * It renders the contour sets for the given segmentation
+ * @param viewport - The viewport object
+ * @param representation - ToolGroupSpecificRepresentation
+ * @param toolGroupConfig - This is the configuration object for the tool group
+ */
+async function render(
+  viewport: Types.IVolumeViewport,
+  representation: ToolGroupSpecificRepresentation,
+  toolGroupConfig: SegmentationRepresentationConfig
+): Promise<void> {
+  const {
+    colorLUTIndex,
+    active,
+    segmentationId,
+    segmentationRepresentationUID,
+    segmentsHidden,
+  } = representation;
+
+  const segmentation = SegmentationState.getSegmentation(segmentationId);
+  const contourData = segmentation.representationData[Representations.Contour];
+  const { geometryIds } = contourData;
+
+  if (!geometryIds?.length) {
+    console.warn(
+      `No contours found for segmentationId ${segmentationId}. Skipping 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)');
+  }
+}
+
+function _removeContourFromToolGroupViewports(
+  toolGroupId: string,
+  segmentationRepresentationUID: string
+): void {
+  const toolGroup = getToolGroup(toolGroupId);
+
+  if (toolGroup === undefined) {
+    throw new Error(`ToolGroup with ToolGroupId ${toolGroupId} does not exist`);
+  }
+
+  const { viewportsInfo } = toolGroup;
+
+  for (const viewportInfo of viewportsInfo) {
+    const { viewportId, renderingEngineId } = viewportInfo;
+    const enabledElement = getEnabledElementByIds(
+      viewportId,
+      renderingEngineId
+    );
+    removeContourFromElement(
+      enabledElement.viewport.element,
+      segmentationRepresentationUID
+    );
+  }
+}
+
+export default {
+  render,
+  addSegmentationRepresentation,
+  removeSegmentationRepresentation,
+};

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

@@ -0,0 +1,3 @@
+import contourDisplay from './contourDisplay';
+
+export { contourDisplay };

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

@@ -0,0 +1,35 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+
+/**
+ * Remove the contour representation from the viewport's HTML Element.
+ * NOTE: This function should not be called directly.
+ *
+ * @param element - The element that the segmentation is being added to.
+ * @param segmentationRepresentationUID - The UID of the contour representation to remove.
+ * @param removeFromCache - boolean
+ *
+ * @internal
+ */
+function removeContourFromElement(
+  element: HTMLDivElement,
+  segmentationRepresentationUID: string,
+  removeFromCache = false // Todo
+): void {
+  const enabledElement = getEnabledElement(element);
+  const { viewport } = enabledElement;
+
+  const actorEntries = (viewport as Types.IVolumeViewport).getActors();
+
+  // remove actors whose id has the same prefix as the segmentationRepresentationUID
+  const actorUIDsToRemove = actorEntries
+    .map(({ uid }) =>
+      uid.startsWith(segmentationRepresentationUID) ? uid : undefined
+    )
+    .filter(Boolean);
+
+  // @ts-ignore
+  viewport.removeActors(actorUIDsToRemove);
+}
+
+export default removeContourFromElement;

package/src/tools/displayTools/Labelmap/addLabelmapToElement.ts

@@ -0,0 +1,57 @@
+import {
+  getEnabledElement,
+  addVolumesToViewports,
+  Types,
+  Enums,
+} from '@cornerstonejs/core';
+
+/**
+ * It adds a labelmap segmentation representation of the viewport's HTML Element.
+ * NOTE: This function should not be called directly.
+ *
+ * @param element - The element that will be rendered.
+ * @param volumeId - The volume id of the labelmap.
+ * @param segmentationRepresentationUID - The segmentation representation UID.
+ *
+ * @internal
+ */
+async function addLabelmapToElement(
+  element: HTMLDivElement,
+  volumeId: string,
+  segmentationRepresentationUID: string
+): Promise<void> {
+  const enabledElement = getEnabledElement(element);
+  const { renderingEngine, viewport } = enabledElement;
+  const { id: viewportId } = viewport;
+
+  // Default to true since we are setting a new segmentation, however,
+  // in the event listener, we will make other segmentations visible/invisible
+  // based on the config
+  const visibility = true;
+  const immediateRender = false;
+  const suppressEvents = true;
+
+  // Todo: Right now we use MIP blend mode for the labelmap, since the
+  // composite blend mode has a non linear behavior regarding fill and line
+  // opacity. This should be changed to a custom labelmap blendMode which does
+  // what composite does, but with a linear behavior.
+  const volumeInputs: Types.IVolumeInput[] = [
+    {
+      volumeId,
+      actorUID: segmentationRepresentationUID,
+      visibility,
+      blendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
+    },
+  ];
+
+  // Add labelmap volumes to the viewports to be be rendered, but not force the render
+  await addVolumesToViewports(
+    renderingEngine,
+    volumeInputs,
+    [viewportId],
+    immediateRender,
+    suppressEvents
+  );
+}
+
+export default addLabelmapToElement;

package/src/tools/displayTools/Labelmap/index.ts

@@ -0,0 +1,4 @@
+import labelmapDisplay from './labelmapDisplay';
+import labelmapConfig from './labelmapConfig';
+
+export { labelmapDisplay, labelmapConfig };

package/src/tools/displayTools/Labelmap/labelmapConfig.ts

@@ -0,0 +1,37 @@
+import { LabelmapConfig } from '../../../types/LabelmapTypes';
+
+const defaultLabelmapConfig: LabelmapConfig = {
+  renderOutline: true,
+  outlineWidthActive: 3,
+  outlineWidthInactive: 2,
+  renderFill: true,
+  renderFillInactive: true,
+  fillAlpha: 0.7,
+  fillAlphaInactive: 0.65,
+  outlineOpacity: 1,
+  outlineOpacityInactive: 0.85,
+};
+
+function getDefaultLabelmapConfig(): LabelmapConfig {
+  return defaultLabelmapConfig;
+}
+
+// Checks if the labelmap config is valid, which means
+// if all the required fields are present and have the correct type
+function isValidLabelmapConfig(config): boolean {
+  return (
+    config &&
+    typeof config.renderOutline === 'boolean' &&
+    typeof config.outlineWidthActive === 'number' &&
+    typeof config.outlineWidthInactive === 'number' &&
+    typeof config.renderFill === 'boolean' &&
+    typeof config.renderFillInactive === 'boolean' &&
+    typeof config.fillAlpha === 'number' &&
+    typeof config.fillAlphaInactive === 'number' &&
+    typeof config.outlineOpacity === 'number' &&
+    typeof config.outlineOpacityInactive === 'number'
+  );
+}
+
+export default getDefaultLabelmapConfig;
+export { isValidLabelmapConfig };