@cornerstonejs/core 1.22.1 → 1.23.1

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "1.22.1",
+  "version": "1.23.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",
@@ -46,5 +46,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "c7e6f091ac9fc1e38fcaca23599b75d62af605e6"
+  "gitHead": "28ab67ba9ac513970fbd03e95e4b0cfcefca4f66"
 }

package/src/RenderingEngine/BaseVolumeViewport.ts

@@ -46,7 +46,6 @@ import {
   invertRgbTransferFunction,
   triggerEvent,
   colormap as colormapUtils,
-  isImageActor,
 } from '../utilities';
 import { createVolumeActor } from './helpers';
 import volumeNewImageEventDispatcher, {
@@ -565,7 +564,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       this.setVOILUTFunction(VOILUTFunction, volumeId, suppressEvents);
     }
 
-    if (invert !== undefined) {
+    if (invert !== undefined && this.viewportProperties.invert !== invert) {
       this.setInvert(invert, volumeId, suppressEvents);
     }
 
@@ -1033,8 +1032,6 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     // New volume actors implies resetting the inverted flag (i.e. like starting from scratch).
 
     for (let i = 0; i < volumeActorEntries.length; i++) {
-      const volumeId = volumeActorEntries[i].uid;
-
       this.viewportProperties.invert = false;
     }
     this.setActors(volumeActorEntries);

package/src/RenderingEngine/StackViewport.ts

@@ -2197,9 +2197,14 @@ class StackViewport extends Viewport implements IStackViewport {
 
     // Create a VTK Image Slice actor to display the vtkImageData object
     const actor = this.createActorMapper(this._imageData);
-    const actors = [];
-    actors.push({ uid: this.id, actor });
-    this.setActors(actors);
+    const oldActors = this.getActors();
+    if (oldActors.length && oldActors[0].uid === this.id) {
+      oldActors[0].actor = actor;
+    } else {
+      oldActors.unshift({ uid: this.id, actor });
+    }
+    this.setActors(oldActors);
+
     // Adjusting the camera based on slice axis. this is required if stack
     // contains various image orientations (axial ct, sagittal xray)
     const { viewPlaneNormal, viewUp } = this._getCameraOrientation(direction);

package/src/RenderingEngine/Viewport.ts

@@ -12,7 +12,7 @@ import ViewportType from '../enums/ViewportType';
 import renderingEngineCache from './renderingEngineCache';
 import { triggerEvent, planar, isImageActor, actorIsA } from '../utilities';
 import hasNaNValues from '../utilities/hasNaNValues';
-import { RENDERING_DEFAULTS } from '../constants';
+import { EPSILON, RENDERING_DEFAULTS } from '../constants';
 import type {
   ICamera,
   ActorEntry,
@@ -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 = false;
   private _suppressCameraModifiedEvents = false;
   /** A flag representing if viewport methods should fire events or not */
   readonly suppressEvents: boolean;
@@ -481,6 +483,7 @@ class Viewport implements IViewport {
     const renderer = this.getRenderer();
     renderer.addActor(actor);
     this._actors.set(actorUID, Object.assign({}, actorEntry));
+    this.newActorAdded = true;
   }
 
   /**
@@ -1080,20 +1083,36 @@ 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 prevFocalPoint = previousCamera.focalPoint;
+    if (prevFocalPoint && focalPoint) {
+      const currentViewPlaneNormal = <Point3>vtkCamera.getViewPlaneNormal();
+      const deltaCamera = <Point3>[
+        focalPoint[0] - prevFocalPoint[0],
+        focalPoint[1] - prevFocalPoint[1],
+        focalPoint[2] - prevFocalPoint[2],
+      ];
 
-    if (!isImageSlice) {
-      this.updateClippingPlanesForActors(updatedCamera);
-    } else {
-      const renderer = this.getRenderer();
-      renderer.resetCameraClippingRange();
+      const cameraModifiedOutOfPlane =
+        Math.abs(vtkMath.dot(deltaCamera, currentViewPlaneNormal)) > EPSILON;
+
+      // only modify the clipping planes if the camera is modified out of plane
+      // or a new actor is added and we need to update the clipping planes
+      if (cameraModifiedOutOfPlane || this.newActorAdded) {
+        const actorEntry = this.getDefaultActor();
+        if (!actorEntry?.actor) {
+          return;
+        }
+
+        if (!actorIsA(actorEntry, 'vtkActor')) {
+          this.updateClippingPlanesForActors(updatedCamera);
+        }
+
+        if (actorIsA(actorEntry, 'vtkImageSlice')) {
+          const renderer = this.getRenderer();
+          renderer.resetCameraClippingRange();
+        }
+      }
     }
 
     if (storeAsInitialCamera) {
@@ -1133,9 +1152,11 @@ 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
+  ): Promise<void> {
     const actorEntries = this.getActors();
-    actorEntries.forEach((actorEntry) => {
+    const allPromises = actorEntries.map(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 +1165,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 === 0 && actorEntry?.clippingFilter) {
+        vtkPlanes = [vtkPlane.newInstance(), vtkPlane.newInstance()];
+      }
 
       let slabThickness = RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
       if (actorEntry.slabThickness) {
@@ -1159,7 +1186,20 @@ class Viewport implements IViewport {
         viewPlaneNormal,
         focalPoint
       );
+      triggerEvent(this.element, Events.CLIPPING_PLANES_UPDATED, {
+        actorEntry,
+        focalPoint,
+        vtkPlanes,
+        viewport: this,
+      });
     });
+
+    await Promise.all(allPromises);
+    this.posProcessNewActors();
+  }
+
+  protected posProcessNewActors(): void {
+    this.newActorAdded = false;
   }
 
   public setOrientationOfClippingPlanes(

package/src/RenderingEngine/VolumeViewport.ts

@@ -17,6 +17,7 @@ import type { ViewportInput } from '../types/IViewport';
 import {
   actorIsA,
   getClosestImageId,
+  getSpacingInNormalDirection,
   isImageActor,
   triggerEvent,
 } from '../utilities';
@@ -244,7 +245,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];
@@ -305,21 +306,18 @@ class VolumeViewport extends BaseVolumeViewport {
 
   /**
    * Uses the origin and focalPoint to calculate the slice index.
-   * Todo: This only works if the imageIds are properly sorted
    *
-   * @returns The slice index
+   * @returns The slice index in the direction of the view
    */
-  public getCurrentImageIdIndex = (): number | undefined => {
+  public getCurrentImageIdIndex = (volumeId?: string): number => {
     const { viewPlaneNormal, focalPoint } = this.getCamera();
 
-    // Todo: handle scenario of fusion of multiple volumes
-    // we cannot only check number of actors, because we might have
-    // segmentations ...
-    const { origin, spacing } = this.getImageData();
+    const { origin, direction, spacing } = this.getImageData(volumeId);
 
-    // how many steps are from the origin to the focal point in the
-    // normal direction
-    const spacingInNormal = spacing[2];
+    const spacingInNormal = getSpacingInNormalDirection(
+      { direction, spacing },
+      viewPlaneNormal
+    );
     const sub = vec3.create();
     vec3.sub(sub, focalPoint, origin);
     const distance = vec3.dot(sub, viewPlaneNormal);

package/src/RenderingEngine/VolumeViewport3D.ts

@@ -46,6 +46,14 @@ class VolumeViewport3D extends BaseVolumeViewport {
     return null;
   };
 
+  posProcessNewActors(): void {
+    if (this.newActorAdded) {
+      const renderer = this.getRenderer();
+      renderer.resetCameraClippingRange();
+    }
+    super.posProcessNewActors();
+  }
+
   setSlabThickness(
     slabThickness: number,
     filterActorUIDs?: Array<string>

package/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;
+  }
+}

package/src/enums/Events.ts

@@ -209,6 +209,11 @@ enum Events {
    * This is usually for signaling that the user may want a different volume for partially loaded volumes which is meant to optimize memory.
    */
   VOLUME_SCROLL_OUT_OF_BOUNDS = 'CORNERSTONE_VOLUME_SCROLL_OUT_OF_BOUNDS',
+
+  /**
+   * Triggers when the clipping planes has been updated
+   */
+  CLIPPING_PLANES_UPDATED = 'CORNERSTONE_CLIPPING_PLANES_UPDATED',
   // IMAGE_CACHE_FULL = 'CORNERSTONE_IMAGE_CACHE_FULL',
   // PRE_RENDER = 'CORNERSTONE_PRE_RENDER',
   // ELEMENT_RESIZED = 'CORNERSTONE_ELEMENT_RESIZED',

package/src/enums/GeometryType.ts

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

package/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');
   }
@@ -47,63 +56,4 @@ async function createAndCacheGeometry(
   return geometry;
 }
 
-// Todo: this should be moved
-function _createContourSet(
-  geometryId: string,
-  contourSetData: PublicContourSetData
-) {
-  // validate the data to make sure it is a valid contour set
-  if (!contourSetData || contourSetData.data.length === 0) {
-    throw new Error(
-      'Invalid contour set data, see publicContourSetData type for more info'
-    );
-  }
-
-  // make sure it each has id, and each has data of type Point3[]
-  if (!contourSetData.id) {
-    throw new Error(
-      'Invalid contour set data, each contour set must have an id'
-    );
-  }
-
-  if (!contourSetData.data || !Array.isArray(contourSetData.data)) {
-    throw new Error(
-      'Invalid contour set data, each contour set must have an array of contours'
-    );
-  }
-
-  contourSetData.data.forEach((contourData) => {
-    if (!contourData.points || !Array.isArray(contourData.points)) {
-      throw new Error(
-        'Invalid contour set data, each contour must have an array of points'
-      );
-    }
-
-    contourData.points.forEach((point) => {
-      if (!point || !Array.isArray(point) || point.length !== 3) {
-        throw new Error(
-          'Invalid contour set data, each point must be an array of length 3'
-        );
-      }
-    });
-  });
-
-  const contourSet = new ContourSet({
-    id: contourSetData.id,
-    data: contourSetData.data,
-    color: contourSetData.color,
-    frameOfReferenceUID: contourSetData.frameOfReferenceUID,
-    segmentIndex: contourSetData.segmentIndex,
-  });
-
-  const geometry: IGeometry = {
-    id: geometryId,
-    type: GeometryType.CONTOUR,
-    data: contourSet,
-    sizeInBytes: contourSet.getSizeInBytes(),
-  };
-
-  return geometry;
-}
-
 export { createAndCacheGeometry };

package/src/loaders/utils/contourSet/createContourSet.ts

@@ -0,0 +1,29 @@
+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,
+    segmentIndex: 1,
+  });
+
+  const geometry: IGeometry = {
+    id: geometryId,
+    type: GeometryType.CONTOUR,
+    data: contourSet,
+    sizeInBytes: contourSet.getSizeInBytes(),
+  };
+
+  return geometry;
+}

package/src/loaders/utils/contourSet/validateContourSet.ts

@@ -0,0 +1,38 @@
+import { PublicContourSetData } from '../../../types';
+
+export function validateContourSet(contourSetData: PublicContourSetData) {
+  if (!contourSetData || contourSetData.data.length === 0) {
+    throw new Error(
+      'Invalid contour set data, see publicContourSetData type for more info'
+    );
+  }
+
+  // make sure it each has id, and each has data of type Point3[]
+  if (!contourSetData.id) {
+    throw new Error(
+      'Invalid contour set data, each contour set must have an id'
+    );
+  }
+
+  if (!contourSetData.data || !Array.isArray(contourSetData.data)) {
+    throw new Error(
+      'Invalid contour set data, each contour set must have an array of contours'
+    );
+  }
+
+  contourSetData.data.forEach((contourData) => {
+    if (!contourData.points || !Array.isArray(contourData.points)) {
+      throw new Error(
+        'Invalid contour set data, each contour must have an array of points'
+      );
+    }
+
+    contourData.points.forEach((point) => {
+      if (!point || !Array.isArray(point) || point.length !== 3) {
+        throw new Error(
+          'Invalid contour set data, each point must be an array of length 3'
+        );
+      }
+    });
+  });
+}

package/src/loaders/utils/surface/createSurface.ts

@@ -0,0 +1,31 @@
+import { IGeometry, PublicSurfaceData } from '../../../types';
+import { GeometryType } from '../../../enums';
+import { validateSurface } from './validateSurface';
+import { Surface } from '../../../cache/classes/Surface';
+
+export function createSurface(
+  geometryId: string,
+  SurfaceData: PublicSurfaceData
+) {
+  // validate the data to make sure it is a valid contour set
+  validateSurface(SurfaceData);
+
+  const surface = new Surface({
+    id: SurfaceData.id,
+    color: SurfaceData.color,
+    frameOfReferenceUID: SurfaceData.frameOfReferenceUID,
+    data: {
+      points: SurfaceData.data.points,
+      polys: SurfaceData.data.polys,
+    },
+  });
+
+  const geometry: IGeometry = {
+    id: geometryId,
+    type: GeometryType.SURFACE,
+    data: surface,
+    sizeInBytes: surface.getSizeInBytes(),
+  };
+
+  return geometry;
+}

package/src/loaders/utils/surface/validateSurface.ts

@@ -0,0 +1,9 @@
+import { PublicSurfaceData } from '../../../types';
+
+export function validateSurface(contourSetData: PublicSurfaceData) {
+  const { data } = contourSetData;
+
+  if (!data.points || !data.polys) {
+    throw new Error('Invalid surface data');
+  }
+}

package/src/types/IActor.ts

@@ -20,4 +20,6 @@ export type ActorEntry = {
   referenceId?: string;
   /** slab thickness for the actor */
   slabThickness?: number;
+  /** clipping filter applied to actor surfaces*/
+  clippingFilter?: any;
 };

package/src/types/IGeometry.ts

@@ -1,3 +1,4 @@
+import { Surface } from '../cache/classes/Surface';
 import { GeometryType } from '../enums';
 import { IContourSet } from './IContourSet';
 
@@ -5,7 +6,7 @@ import { IContourSet } from './IContourSet';
 interface IGeometry {
   id: string;
   type: GeometryType;
-  data: IContourSet; // | Array<IClosedSurface> , etc
+  data: IContourSet | Surface;
   sizeInBytes: number;
 }
 

package/src/types/SurfaceData.ts

@@ -0,0 +1,15 @@
+import Point3 from './Point3';
+
+type PublicSurfaceData = {
+  id: string;
+  data: SurfaceData;
+  frameOfReferenceUID: string;
+  color?: Point3;
+};
+
+type SurfaceData = {
+  points: number[];
+  polys: number[];
+};
+
+export type { PublicSurfaceData, SurfaceData };

package/src/types/index.ts

@@ -72,6 +72,7 @@ import type {
   ContourSetData,
   ContourData,
 } from './ContourData';
+import type { PublicSurfaceData, SurfaceData } from './SurfaceData';
 import type ICachedGeometry from './ICachedGeometry';
 import type { IContourSet } from './IContourSet';
 import type { IContour } from './IContour';
@@ -166,6 +167,9 @@ export type {
   ContourData,
   IContourSet,
   IContour,
+  // Surface
+  PublicSurfaceData,
+  SurfaceData,
   // Color
   RGB,
   ColormapPublic,

package/src/utilities/getSpacingInNormalDirection.ts

@@ -1,4 +1,4 @@
-import { vec3 } from 'gl-matrix';
+import { mat3, vec3 } from 'gl-matrix';
 import { IImageVolume, Point3 } from '../types';
 
 /**
@@ -13,7 +13,7 @@ import { IImageVolume, Point3 } from '../types';
  * @returns
  */
 export default function getSpacingInNormalDirection(
-  imageVolume: IImageVolume,
+  imageVolume: IImageVolume | { direction: mat3; spacing: Point3 },
   viewPlaneNormal: Point3
 ): number {
   const { direction, spacing } = imageVolume;