feat(surface rendering): Add surface rendering as segmentation representation

common/reviews/api/core.api.md

@@ -764,7 +764,9 @@ export { geometryLoader }
 // @public (undocumented)
 enum GeometryType {
     // (undocumented)
-    CONTOUR = "contour"
+    CONTOUR = "contour",
+    // (undocumented)
+    SURFACE = "Surface"
 }
 
 // @public (undocumented)
@@ -2076,6 +2078,14 @@ type PTScaling = {
 // @public (undocumented)
 type PublicContourSetData = ContourSetData;
 
+// @public (undocumented)
+type PublicSurfaceData = {
+    id: string;
+    data: SurfaceData;
+    frameOfReferenceUID: string;
+    color?: Point3;
+};
+
 // @public (undocumented)
 type PublicViewportInput = {
     element: HTMLDivElement;
@@ -2399,6 +2409,12 @@ type StackViewportScrollEventDetail = {
     direction: number;
 };
 
+// @public (undocumented)
+type SurfaceData = {
+    points: number[];
+    polys: number[];
+};
+
 // @public (undocumented)
 function threePlaneIntersection(firstPlane: Plane, secondPlane: Plane, thirdPlane: Plane): Point3;
 

common/reviews/api/streaming-image-volume-loader.api.md

@@ -1442,6 +1442,14 @@ type PTScaling = {
 // @public (undocumented)
 type PublicContourSetData = ContourSetData;
 
+// @public (undocumented)
+type PublicSurfaceData = {
+    id: string;
+    data: SurfaceData;
+    frameOfReferenceUID: string;
+    color?: Point3;
+};
+
 // @public
 type PublicViewportInput = {
     element: HTMLDivElement;

common/reviews/api/tools.api.md

@@ -4043,6 +4043,14 @@ type PTScaling = {
 // @public (undocumented)
 type PublicContourSetData = ContourSetData;
 
+// @public (undocumented)
+type PublicSurfaceData = {
+    id: string;
+    data: SurfaceData;
+    frameOfReferenceUID: string;
+    color?: Point3;
+};
+
 // @public (undocumented)
 type PublicToolProps = SharedToolProp & {
     name?: string;
@@ -4500,6 +4508,7 @@ export function removeTool(ToolClass: any): void;
 type RepresentationConfig = {
     LABELMAP?: LabelmapConfig;
     CONTOUR?: ContourConfig;
+    SURFACE?: any;
 };
 
 // @public (undocumented)
@@ -4720,6 +4729,7 @@ type SegmentationRepresentationConfig = {
 type SegmentationRepresentationData = {
     LABELMAP?: LabelmapSegmentationData;
     CONTOUR?: ContourSegmentationData;
+    SURFACE?: SurfaceSegmentationData;
 };
 
 // @public (undocumented)
@@ -4745,7 +4755,9 @@ enum SegmentationRepresentations {
     // (undocumented)
     Contour = "CONTOUR",
     // (undocumented)
-    Labelmap = "LABELMAP"
+    Labelmap = "LABELMAP",
+    // (undocumented)
+    Surface = "SURFACE"
 }
 
 // @public (undocumented)
@@ -5082,6 +5094,12 @@ type StyleSpecifier = {
     annotationUID?: string;
 };
 
+// @public (undocumented)
+type SurfaceData = {
+    points: number[];
+    polys: number[];
+};
+
 // @public (undocumented)
 type SVGCursorDescriptor = {
     iconContent: string;

packages/core/examples/volumeBasic/index.ts

@@ -44,10 +44,10 @@ async function run() {
   // Get Cornerstone imageIds and fetch metadata into RAM
   const imageIds = await createImageIdsAndCacheMetaData({
     StudyInstanceUID:
-      '1.3.6.1.4.1.14519.5.2.1.7009.2403.334240657131972136850343327463',
+      '1.2.276.0.7230010.3.1.2.531406877.716565.1673190654.866619',
     SeriesInstanceUID:
-      '1.3.6.1.4.1.14519.5.2.1.7009.2403.226151125820845824875394858561',
-    wadoRsRoot: 'https://d3t6nz73ql33tx.cloudfront.net/dicomweb',
+      '1.2.276.0.7230010.3.1.3.531406877.716565.1673190655.866747',
+    wadoRsRoot: 'http://localhost/dicom-web
   });
 
   // Instantiate a rendering engine

packages/core/package.json

@@ -2,7 +2,7 @@
   "name": "@cornerstonejs/core",
   "version": "1.19.1",
   "description": "",
-  "main": "dist/umd/index.js",
+  "main": "src/index.ts",
   "types": "dist/esm/index.d.ts",
   "module": "dist/esm/index.js",
   "repository": "https://github.com/cornerstonejs/cornerstone3D",

packages/core/src/RenderingEngine/Viewport.ts

@@ -71,6 +71,8 @@ class Viewport implements IViewport {
   readonly defaultOptions: any;
   /** options for the viewport which includes orientation axis, backgroundColor and displayArea */
   options: ViewportInputOptions;
+  /** informs if a new actor was added before a resetCameraClippingRange phase */
+  protected newActorAdded;
   private _suppressCameraModifiedEvents = false;
   /** A flag representing if viewport methods should fire events or not */
   readonly suppressEvents: boolean;
@@ -109,6 +111,7 @@ class Viewport implements IViewport {
       : false;
     this.options = _cloneDeep(props.defaultOptions);
     this.isDisabled = false;
+    this.newActorAdded = false;
   }
 
   getRotation: () => number;
@@ -481,6 +484,7 @@ class Viewport implements IViewport {
     const renderer = this.getRenderer();
     renderer.addActor(actor);
     this._actors.set(actorUID, Object.assign({}, actorEntry));
+    this.newActorAdded = true;
   }
 
   /**
@@ -1080,20 +1084,34 @@ class Viewport implements IViewport {
       vtkCamera.setClippingRange(clippingRange);
     }
 
-    // update clippingPlanes if volume viewports
-    const actorEntry = this.getDefaultActor();
-
-    if (!actorEntry || !actorEntry.actor) {
-      return;
-    }
-
-    const isImageSlice = actorIsA(actorEntry, 'vtkImageSlice');
+    // update clipping range only if focal point changed of a new actor is added
+    const oldCamera = previousCamera;
+    const oldFocalPoint = oldCamera.focalPoint;
+    if (oldFocalPoint && focalPoint) {
+      const currentViewPlaneNormal = <Point3>vtkCamera.getViewPlaneNormal();
+      const deltaCamera = <Point3>[
+        focalPoint[0] - oldFocalPoint[0],
+        focalPoint[1] - oldFocalPoint[1],
+        focalPoint[2] - oldFocalPoint[2],
+      ];
 
-    if (!isImageSlice) {
-      this.updateClippingPlanesForActors(updatedCamera);
-    } else {
-      const renderer = this.getRenderer();
-      renderer.resetCameraClippingRange();
+      const cameraModifiedInPlane =
+        Math.abs(vtkMath.dot(deltaCamera, currentViewPlaneNormal)) > 1e-2;
+
+      if (cameraModifiedInPlane || this.newActorAdded) {
+        const actorEntry = this.getDefaultActor();
+        if (!actorEntry || !actorEntry.actor) {
+          return;
+        }
+
+        const isImageSlice = actorIsA(actorEntry, 'vtkImageSlice');
+        if (!isImageSlice) {
+          this.updateClippingPlanesForActors(updatedCamera);
+        } else {
+          const renderer = this.getRenderer();
+          renderer.resetCameraClippingRange();
+        }
+      }
     }
 
     if (storeAsInitialCamera) {
@@ -1133,9 +1151,9 @@ class Viewport implements IViewport {
    * Updates the actors clipping planes orientation from the camera properties
    * @param updatedCamera - ICamera
    */
-  protected updateClippingPlanesForActors(updatedCamera: ICamera): void {
+  protected async updateClippingPlanesForActors(updatedCamera: ICamera): void {
     const actorEntries = this.getActors();
-    actorEntries.forEach((actorEntry) => {
+    await actorEntries.forEach(async (actorEntry) => {
       // we assume that the first two clipping plane of the mapper are always
       // the 'camera' clipping. Update clipping planes only if the actor is
       // a vtkVolume
@@ -1144,7 +1162,13 @@ class Viewport implements IViewport {
       }
 
       const mapper = actorEntry.actor.getMapper();
-      const vtkPlanes = mapper.getClippingPlanes();
+      let vtkPlanes = actorEntry?.clippingFilter
+        ? actorEntry.clippingFilter.getClippingPlanes()
+        : mapper.getClippingPlanes();
+
+      if (!vtkPlanes?.length) {
+        vtkPlanes = [vtkPlane.newInstance(), vtkPlane.newInstance()];
+      }
 
       let slabThickness = RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
       if (actorEntry.slabThickness) {
@@ -1159,7 +1183,19 @@ class Viewport implements IViewport {
         viewPlaneNormal,
         focalPoint
       );
+      if (actorEntry?.clippingFilter) {
+        const clippingFilter = actorEntry.clippingFilter;
+        clippingFilter.setClippingPlanes(vtkPlanes);
+        clippingFilter.update();
+        const filteredData = clippingFilter.getOutputData();
+        mapper.setInputData(filteredData);
+      }
     });
+    if (this.newActorAdded) {
+      const renderer = this.getRenderer();
+      renderer.resetCameraClippingRange();
+      this.newActorAdded = false;
+    }
   }
 
   public setOrientationOfClippingPlanes(

packages/core/src/RenderingEngine/VolumeViewport.ts

@@ -236,7 +236,7 @@ class VolumeViewport extends BaseVolumeViewport {
       const mapper = actorEntry.actor.getMapper();
       const vtkPlanes = mapper.getClippingPlanes();
 
-      if (vtkPlanes.length === 0) {
+      if (vtkPlanes.length === 0 && !actorEntry?.clippingFilter) {
         const clipPlane1 = vtkPlane.newInstance();
         const clipPlane2 = vtkPlane.newInstance();
         const newVtkPlanes = [clipPlane1, clipPlane2];

packages/core/src/cache/classes/Surface.ts

@@ -0,0 +1,49 @@
+import { SurfaceData, Point3 } from '../../types';
+
+type SurfaceProps = {
+  id: string;
+  data: SurfaceData;
+  frameOfReferenceUID: string;
+  color?: Point3;
+};
+
+/**
+ * Surface class for storing surface data
+ */
+export class Surface {
+  readonly id: string;
+  readonly sizeInBytes: number;
+  readonly frameOfReferenceUID: string;
+  private color: Point3 = [200, 0, 0]; // default color
+  private points: number[];
+  private polys: number[];
+
+  constructor(props: SurfaceProps) {
+    this.id = props.id;
+    this.points = props.data.points;
+    this.polys = props.data.polys;
+    this.color = props.color ?? this.color;
+    this.frameOfReferenceUID = props.frameOfReferenceUID;
+    this.sizeInBytes = this._getSizeInBytes();
+  }
+
+  _getSizeInBytes(): number {
+    return this.points.length * 4 + this.polys.length * 4;
+  }
+
+  public getColor(): Point3 {
+    return this.color;
+  }
+
+  public getPoints(): number[] {
+    return this.points;
+  }
+
+  public getPolys(): number[] {
+    return this.polys;
+  }
+
+  public getSizeInBytes(): number {
+    return this.sizeInBytes;
+  }
+}

packages/core/src/enums/GeometryType.ts

@@ -1,5 +1,6 @@
 enum GeometryType {
   CONTOUR = 'contour',
+  SURFACE = 'Surface',
 }
 
 export default GeometryType;

packages/core/src/loaders/geometryLoader.ts

@@ -1,13 +1,14 @@
 import '@kitware/vtk.js/Rendering/Profiles/Geometry';
 
 import cache from '../cache';
-import { ContourSet } from '../cache/classes/ContourSet';
 import { GeometryType } from '../enums';
-import { IGeometry, PublicContourSetData } from '../types';
+import { IGeometry, PublicContourSetData, PublicSurfaceData } from '../types';
+import { createContourSet } from './utils/contourSet/createContourSet';
+import { createSurface } from './utils/surface/createSurface';
 
 type GeometryOptions = {
   type: GeometryType;
-  geometryData: PublicContourSetData; // | PublicClosedSurfaceData, ...
+  geometryData: PublicContourSetData | PublicSurfaceData;
 };
 
 /**
@@ -33,7 +34,15 @@ async function createAndCacheGeometry(
   }
 
   if (options.type === GeometryType.CONTOUR) {
-    geometry = _createContourSet(geometryId, options.geometryData);
+    geometry = createContourSet(
+      geometryId,
+      options.geometryData as PublicContourSetData
+    );
+  } else if (options.type === GeometryType.SURFACE) {
+    geometry = createSurface(
+      geometryId,
+      options.geometryData as PublicSurfaceData
+    );
   } else {
     throw new Error('Unknown geometry type, Only CONTOUR is supported');
   }

packages/core/src/loaders/utils/contourSet/createContourSet.ts

@@ -0,0 +1,28 @@
+import { IGeometry, PublicContourSetData } from '../../../types';
+import { GeometryType } from '../../../enums';
+import { validateContourSet } from './validateContourSet';
+import { ContourSet } from '../../../cache/classes/ContourSet';
+
+export function createContourSet(
+  geometryId: string,
+  contourSetData: PublicContourSetData
+) {
+  // validate the data to make sure it is a valid contour set
+  validateContourSet(contourSetData);
+
+  const contourSet = new ContourSet({
+    id: contourSetData.id,
+    data: contourSetData.data,
+    color: contourSetData.color,
+    frameOfReferenceUID: contourSetData.frameOfReferenceUID,
+  });
+
+  const geometry: IGeometry = {
+    id: geometryId,
+    type: GeometryType.CONTOUR,
+    data: contourSet,
+    sizeInBytes: contourSet.getSizeInBytes(),
+  };
+
+  return geometry;
+}