@cornerstonejs/tools 1.22.1 → 1.23.1

package/src/tools/displayTools/Surface/surfaceDisplay.ts

@@ -0,0 +1,215 @@
+import {
+  cache,
+  getEnabledElementByIds,
+  Types,
+  utilities,
+  Enums,
+} from '@cornerstonejs/core';
+
+import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import * as SegmentationConfig from '../../../stateManagement/segmentation/config/segmentationConfig';
+import Representations from '../../../enums/SegmentationRepresentations';
+import { getToolGroup } from '../../../store/ToolGroupManager';
+import {
+  RepresentationPublicInput,
+  SegmentationRepresentationConfig,
+  ToolGroupSpecificRepresentation,
+} from '../../../types/SegmentationStateTypes';
+
+import removeSurfaceFromElement from './removeSurfaceFromElement';
+import addSurfaceToElement from './addSurfaceToElement';
+
+/**
+ * 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 = utilities.uuidv4();
+  // Todo: make these configurable during representation input by user
+  const segmentsHidden = new Set() as Set<number>;
+  const colorLUTIndex = 0;
+  const active = true;
+  const toolGroupSpecificRepresentation: ToolGroupSpecificRepresentation = {
+    segmentationId,
+    segmentationRepresentationUID,
+    type: Representations.Surface,
+    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 = utilities.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 {
+  _removeSurfaceFromToolGroupViewports(
+    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 Surface  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 SurfaceData = segmentation.representationData[Representations.Surface];
+  const { geometryId } = SurfaceData;
+
+  if (!geometryId) {
+    console.warn(
+      `No Surfaces found for segmentationId ${segmentationId}. Skipping render.`
+    );
+  }
+
+  const geometry = cache.getGeometry(geometryId);
+  if (!geometry) {
+    throw new Error(`No Surfaces found for geometryId ${geometryId}`);
+  }
+
+  if (geometry.type !== Enums.GeometryType.SURFACE) {
+    // Todo: later we can support converting other geometries to Surfaces
+    throw new Error(
+      `Geometry type ${geometry.type} not supported for rendering.`
+    );
+  }
+
+  if (!geometry.data) {
+    console.warn(
+      `No Surfaces found for geometryId ${geometryId}. Skipping render.`
+    );
+    return;
+  }
+
+  const surface = geometry.data;
+
+  const surfaceUID = `${segmentationRepresentationUID}_${surface.id}}`;
+  _renderSurface(viewport, surface, surfaceUID);
+
+  viewport.resetCamera();
+  viewport.render();
+}
+
+function _renderSurface(
+  viewport: Types.IVolumeViewport,
+  surface: any,
+  surfaceUID: string
+): void {
+  const actorUID = surfaceUID;
+  const actorEntry = viewport.getActor(actorUID);
+
+  if (!actorEntry) {
+    addSurfaceToElement(viewport.element, surface, actorUID);
+  } else {
+    throw new Error('Not implemented yet. (Update surface)');
+  }
+}
+
+function _removeSurfaceFromToolGroupViewports(
+  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
+    );
+    removeSurfaceFromElement(
+      enabledElement.viewport.element,
+      segmentationRepresentationUID
+    );
+  }
+}
+
+export default {
+  render,
+  addSegmentationRepresentation,
+  removeSegmentationRepresentation,
+};

package/src/tools/index.ts

@@ -13,6 +13,7 @@ import MagnifyTool from './MagnifyTool';
 import AdvancedMagnifyTool from './AdvancedMagnifyTool';
 import ReferenceLinesTool from './ReferenceLinesTool';
 import OverlayGridTool from './OverlayGridTool';
+import SegmentationIntersectionTool from './SegmentationIntersectionTool';
 //
 import BidirectionalTool from './annotation/BidirectionalTool';
 import LengthTool from './annotation/LengthTool';
@@ -62,6 +63,7 @@ export {
   CrosshairsTool,
   ReferenceLinesTool,
   OverlayGridTool,
+  SegmentationIntersectionTool,
   BidirectionalTool,
   LengthTool,
   ProbeTool,

package/src/types/SegmentationStateTypes.ts

@@ -9,6 +9,10 @@ import type {
   LabelmapRenderingConfig,
   LabelmapSegmentationData,
 } from './LabelmapTypes';
+import {
+  SurfaceSegmentationData,
+  SurfaceRenderingConfig,
+} from './SurfaceTypes';
 
 /**
  * Four elements RGBA as 0-255
@@ -30,6 +34,8 @@ export type RepresentationConfig = {
   LABELMAP?: LabelmapConfig;
   /** contour configuration */
   CONTOUR?: ContourConfig;
+  /** surface configuration */
+  SURFACE?: any;
 };
 
 export type SegmentationRepresentationConfig = {
@@ -42,6 +48,7 @@ export type SegmentationRepresentationConfig = {
 export type SegmentationRepresentationData = {
   LABELMAP?: LabelmapSegmentationData;
   CONTOUR?: ContourSegmentationData;
+  SURFACE?: SurfaceSegmentationData;
 };
 
 /**
@@ -132,6 +139,13 @@ export type ToolGroupSpecificContourRepresentation =
     segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
   };
 
+export type ToolGroupSpecificSurfaceRepresentation =
+  ToolGroupSpecificRepresentationState & {
+    config: SurfaceRenderingConfig;
+    segmentationRepresentationSpecificConfig?: RepresentationConfig;
+    segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
+  };
+
 export type ToolGroupSpecificRepresentation =
   | ToolGroupSpecificLabelmapRepresentation
   | ToolGroupSpecificContourRepresentation;
@@ -252,7 +266,10 @@ export type SegmentationPublicInput = {
   segmentationId: string;
   representation: {
     type: Enums.SegmentationRepresentations;
-    data: LabelmapSegmentationData | ContourSegmentationData;
+    data:
+      | LabelmapSegmentationData
+      | ContourSegmentationData
+      | SurfaceSegmentationData;
   };
 };
 

package/src/types/SurfaceTypes.ts

@@ -0,0 +1,10 @@
+/**
+ * Labelmap representation type
+ */
+export type SurfaceRenderingConfig = {
+  // not much here yet
+};
+
+export type SurfaceSegmentationData = {
+  geometryId: string;
+};

package/src/utilities/index.ts

@@ -17,6 +17,7 @@ import pointInShapeCallback from './pointInShapeCallback';
 import pointInSurroundingSphereCallback from './pointInSurroundingSphereCallback';
 import scroll from './scroll';
 import roundNumber from './roundNumber';
+import { pointToString } from './pointToString';
 
 // name spaces
 import * as segmentation from './segmentation';
@@ -33,6 +34,7 @@ import { stackPrefetch, stackContextPrefetch } from './stackPrefetch';
 import * as viewport from './viewport';
 import * as touch from './touch';
 import * as dynamicVolume from './dynamicVolume';
+import * as polyDataUtils from './polyData/utils';
 
 // Events
 import { triggerEvent } from '@cornerstonejs/core';
@@ -68,4 +70,6 @@ export {
   stackContextPrefetch,
   scroll,
   roundNumber,
+  pointToString,
+  polyDataUtils,
 };

package/src/utilities/math/point/distanceToPoint.ts

@@ -1,22 +1,23 @@
 import type { Types } from '@cornerstonejs/core';
 
+type Point = Types.Point2 | Types.Point3;
+
 /**
  * Calculates the distance of a point to another point
  *
- * @param p1 - x,y of the point
- * @param p2 - x,y of the point
+ * @param p1 - x,y or x,y,z of the point
+ * @param p2 - x,y or x,y,z of the point
  * @returns distance
  */
-export default function distanceToPoint(
-  p1: Types.Point2,
-  p2: Types.Point2
-): number {
-  if (p1?.length !== 2 || p2?.length !== 2) {
-    throw Error('points should have 2 elements of [x, y]');
+export default function distanceToPoint(p1: Point, p2: Point): number {
+  if (p1.length !== p2.length) {
+    throw Error('Both points should have the same dimensionality');
   }
 
-  const [x1, y1] = p1;
-  const [x2, y2] = p2;
+  const [x1, y1, z1 = 0] = p1;
+  const [x2, y2, z2 = 0] = p2;
 
-  return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
+  return Math.sqrt(
+    Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2) + Math.pow(z1 - z2, 2)
+  );
 }

package/src/utilities/pointToString.ts

@@ -0,0 +1,10 @@
+export function pointToString(point, decimals = 5) {
+  return (
+    parseFloat(point[0]).toFixed(decimals) +
+    ',' +
+    parseFloat(point[1]).toFixed(decimals) +
+    ',' +
+    parseFloat(point[2]).toFixed(decimals) +
+    ','
+  );
+}

package/src/utilities/polyData/utils.ts

@@ -0,0 +1,82 @@
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+
+/**
+ * Gets a point from an array of numbers given its index
+ * @param points array of number, each point defined by three consecutive numbers
+ * @param idx index of the point to retrieve
+ * @returns
+ */
+export function getPoint(points, idx) {
+  if (idx < points.length / 3) {
+    return [points[idx * 3], points[idx * 3 + 1], points[idx * 3 + 2]];
+  }
+}
+
+/**
+ * Extract contour point sets from the outline of a poly data actor
+ * @param polyData - vtk polyData
+ * @returns
+ */
+export function getPolyDataPointIndexes(polyData: vtkPolyData) {
+  const linesData = polyData.getLines().getData();
+  let idx = 0;
+  const lineSegments = new Map<number, number[]>();
+
+  // Populate lineSegments map
+  while (idx < linesData.length) {
+    const segmentSize = linesData[idx++];
+    const segment = [];
+    for (let i = 0; i < segmentSize; i++) {
+      segment.push(linesData[idx + i]);
+    }
+    lineSegments.set(segment[0], segment);
+    idx += segmentSize;
+  }
+
+  const contours = [];
+
+  // Function to find an available starting point
+  const findStartingPoint = (map) => {
+    for (const [key, value] of map.entries()) {
+      if (value !== undefined) {
+        return key;
+      }
+    }
+    return -1;
+  };
+
+  // Build contours
+  let startPoint = findStartingPoint(lineSegments);
+  while (startPoint !== -1) {
+    const contour = [startPoint];
+    while (lineSegments.has(startPoint)) {
+      const nextPoint = lineSegments.get(startPoint)[1];
+      if (lineSegments.has(nextPoint)) {
+        contour.push(nextPoint);
+      }
+      lineSegments.delete(startPoint);
+      startPoint = nextPoint;
+    }
+    contours.push(contour);
+    startPoint = findStartingPoint(lineSegments);
+  }
+
+  return contours.length ? contours : undefined;
+}
+
+/**
+ * Extract contour points from a poly data object
+ * @param polyData - vtk polyData
+ * @returns
+ */
+export function getPolyDataPoints(polyData: vtkPolyData) {
+  const contoursIndexes = getPolyDataPointIndexes(polyData);
+  if (!contoursIndexes) {
+    return;
+  }
+
+  const rawPointsData = polyData.getPoints().getData();
+  return contoursIndexes.map((contourIndexes) =>
+    contourIndexes.map((index) => getPoint(rawPointsData, index))
+  );
+}