@cornerstonejs/core 1.42.1 → 1.43.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "1.42.1",
+  "version": "1.43.1",
   "description": "",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -30,7 +30,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@kitware/vtk.js": "27.3.1",
+    "@kitware/vtk.js": "29.3.0",
     "comlink": "^4.4.1",
     "detect-gpu": "^5.0.22",
     "gl-matrix": "^3.4.3",
@@ -47,5 +47,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "14a1bff3ba983b6664529e8e829a655cc4ffda89"
+  "gitHead": "ebb1c8fd94162c195ddae365ab20c2007da13800"
 }

package/src/RenderingEngine/BaseVolumeViewport.ts

@@ -1000,6 +1000,10 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       ? vec3.negate(vec3.create(), this.initialViewUp)
       : this.initialViewUp;
 
+    if (!initialViewUp) {
+      return 0;
+    }
+
     // The angle between the initial and current view up vectors.
     // TODO: check with VTK about rounding errors here.
     const initialToCurrentViewUpAngle =

package/src/RenderingEngine/Viewport.ts

@@ -63,7 +63,7 @@ class Viewport implements IViewport {
   protected flipHorizontal = false;
   protected flipVertical = false;
   public isDisabled: boolean;
-  /** Record the renddering status, mostly for testing purposes, but can also
+  /** Record the rendering status, mostly for testing purposes, but can also
    * be useful for knowing things like whether the viewport is initialized
    */
   public viewportStatus: ViewportStatus = ViewportStatus.NO_DATA;
@@ -373,6 +373,14 @@ class Viewport implements IViewport {
     return Array.from(this._actors.values());
   }
 
+  /**
+   * Returns an array of unique identifiers for all the actors in the viewport.
+   * @returns An array of strings
+   */
+  public getActorUIDs(): Array<string> {
+    return Array.from(this._actors.keys());
+  }
+
   /**
    * Get an actor by its UID
    * @param actorUID - The unique ID of the actor.

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLVolumeMapper.js

@@ -1,4 +1,3 @@
-import { mat3, mat4, vec3 } from 'gl-matrix';
 import macro from '@kitware/vtk.js/macros';
 import vtkOpenGLVolumeMapper from '@kitware/vtk.js/Rendering/OpenGL/VolumeMapper';
 import { Filter } from '@kitware/vtk.js/Rendering/OpenGL/Texture/Constants';
@@ -6,9 +5,8 @@ import { VtkDataTypes } from '@kitware/vtk.js/Common/Core/DataArray/Constants';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import { Representation } from '@kitware/vtk.js/Rendering/Core/Property/Constants';
 
-const { vtkWarningMacro } = macro;
 /**
- * vtkStreamingOpenGLVolumeMapper - A dervied class of the core vtkOpenGLVolumeMapper class.
+ * vtkStreamingOpenGLVolumeMapper - A derived class of the core vtkOpenGLVolumeMapper class.
  * This class  replaces the buildBufferObjects function so that we progressively upload our textures
  * into GPU memory using the new methods on vtkStreamingOpenGLTexture.
  *
@@ -155,6 +153,8 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
       model.colorTextureString = toString;
     }
 
+    publicAPI.updateLabelOutlineThicknessTexture(actor);
+
     // rebuild the scalarTexture if the data has changed
     toString = `${image.getMTime()}`;
 
@@ -246,29 +246,6 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
     model.VBOBuildTime.modified();
   };
 
-  // publicAPI.getRenderTargetSize = () => {
-  //   // https://github.com/Kitware/vtk-js/blob/master/Sources/Rendering/OpenGL/VolumeMapper/index.js#L952
-  //   if (model.lastXYF > 1.43) {
-  //     const sz = model.framebuffer.getSize()
-  //     return [model.fvp[0] * sz[0], model.fvp[1] * sz[1]]
-  //   }
-
-  //   // This seems wrong, it assumes the renderWindow only has one renderer
-  //   // but I don't know if this stuff is correct...
-
-  //   const { usize, vsize } = model.openGLRenderer.getTiledSizeAndOrigin()
-
-  //   return [usize, vsize]
-  // }
-
-  // publicAPI.getRenderTargetSize = () => {
-  //   if (model._useSmallViewport) {
-  //     return [model._smallViewportWidth, model._smallViewportHeight]
-  //   }
-
-  //   return model._openGLRenderWindow.getFramebufferSize()
-  // }
-
   publicAPI.getRenderTargetSize = () => {
     if (model._useSmallViewport) {
       return [model._smallViewportWidth, model._smallViewportHeight];

package/src/init.ts

@@ -124,7 +124,7 @@ async function init(configuration = config): Promise<boolean> {
       'CornerstoneRender: Using detect-gpu to get the GPU benchmark:',
       config.gpuTier
     );
-    if (config.gpuTier.tier < 1) {
+    if (config.gpuTier?.tier < 1) {
       console.log(
         'CornerstoneRender: GPU is not powerful enough, using CPU rendering'
       );

package/src/loaders/imageLoader.ts

@@ -289,11 +289,16 @@ export function createAndCacheDerivedImage(
  * Load and cache a list of imageIds
  *
  * @param referencedImageIds - list of imageIds
- * @param getDerivedImageId - optional function to generate derived imageId name however you want
+ * @param options
+ * @param options.getDerivedImageId - function to get the derived imageId
+ * @param options.targetBufferType - target buffer type
  */
 export function createAndCacheDerivedImages(
   referencedImageIds: Array<string>,
-  getDerivedImageId?: (referencedImageId: string) => string
+  options: {
+    getDerivedImageId?: (referencedImageId: string) => string;
+    targetBufferType?: PixelDataTypedArrayString;
+  } = {}
 ): DerivedImages {
   if (referencedImageIds?.length === 0) {
     throw new Error(
@@ -302,14 +307,15 @@ export function createAndCacheDerivedImages(
   }
 
   const derivedImageIds = [];
-  const allPromises = referencedImageIds.map((referencedImageId, index) => {
-    const options: DerivedImageOptions = {
-      imageId: getDerivedImageId
-        ? getDerivedImageId(referencedImageId)
+  const allPromises = referencedImageIds.map((referencedImageId) => {
+    const newOptions: DerivedImageOptions = {
+      imageId: options.getDerivedImageId
+        ? options.getDerivedImageId(referencedImageId)
         : `derived:${uuidv4()}`,
+      ...options,
     };
-    derivedImageIds.push(options.imageId);
-    return createAndCacheDerivedImage(referencedImageId, options);
+    derivedImageIds.push(newOptions.imageId);
+    return createAndCacheDerivedImage(referencedImageId, newOptions);
   });
 
   return { imageIds: derivedImageIds, promises: allPromises };
@@ -501,3 +507,41 @@ export function unregisterAllImageLoaders(): void {
   );
   unknownImageLoader = undefined;
 }
+
+/**
+ * Creates and caches derived segmentation images based on the referenced imageIds, this
+ * is a helper function, we don't have segmentation concept in the cornerstone core; however,
+ * this helper would make it clear that the segmentation images SHOULD be Uint8Array type
+ * always until we have a better solution.
+ *
+ * @param referencedImageIds - An array of referenced image IDs.
+ * @param options - The options for creating the derived images (default: { targetBufferType: 'Uint8Array' }).
+ * @returns The derived images.
+ */
+export function createAndCacheDerivedSegmentationImages(
+  referencedImageIds: Array<string>,
+  options: DerivedImageOptions = {
+    targetBufferType: 'Uint8Array',
+  }
+): DerivedImages {
+  return createAndCacheDerivedImages(referencedImageIds, options);
+}
+
+/**
+ * Creates and caches a derived segmentation image based on the referenced image ID.
+ * this is a helper function, we don't have segmentation concept in the cornerstone core; however,
+ * this helper would make it clear that the segmentation images SHOULD be Uint8Array type
+ * always until we have a better solution.
+ *
+ * @param referencedImageId The ID of the referenced image.
+ * @param options The options for creating the derived image (default: { targetBufferType: 'Uint8Array' }).
+ * @returns A promise that resolves to the created derived segmentation image.
+ */
+export function createAndCacheDerivedSegmentationImage(
+  referencedImageId: string,
+  options: DerivedImageOptions = {
+    targetBufferType: 'Uint8Array',
+  }
+): Promise<IImage> {
+  return createAndCacheDerivedImage(referencedImageId, options);
+}

package/src/loaders/volumeLoader.ts

@@ -561,3 +561,24 @@ export function registerUnknownVolumeLoader(
 export function getUnknownVolumeLoaderSchema(): string {
   return unknownVolumeLoader.name;
 }
+
+/**
+ * Creates and caches a derived segmentation volume based on a referenced volume.
+ * This is basically a utility method since for the segmentations we have to specify
+ * Uint8Array as the targetBuffer type for now until we support other types.
+ *
+ * @param referencedVolumeId - The ID of the referenced volume.
+ * @param options - The options for creating the derived volume.
+ * @returns A promise that resolves to the created derived segmentation volume.
+ */
+export async function createAndCacheDerivedSegmentationVolume(
+  referencedVolumeId: string,
+  options: DerivedVolumeOptions
+): Promise<IImageVolume> {
+  return createAndCacheDerivedVolume(referencedVolumeId, {
+    ...options,
+    targetBuffer: {
+      type: 'Uint8Array',
+    },
+  });
+}

package/src/types/BoundsLPS.ts

@@ -0,0 +1,5 @@
+import type Point2 from './Point3';
+
+type BoundsLPS = [Point2, Point2, Point2];
+
+export default BoundsLPS;

package/src/types/IViewport.ts

@@ -6,7 +6,6 @@ import { ActorEntry } from './IActor';
 import ViewportType from '../enums/ViewportType';
 import ViewportStatus from '../enums/ViewportStatus';
 import DisplayArea from './displayArea';
-import { IRetrieveConfiguration } from './IRetrieveConfiguration';
 
 /**
  * Viewport interface for cornerstone viewports
@@ -66,6 +65,8 @@ interface IViewport {
   addActors(actors: Array<ActorEntry>): void;
   /** add one actor */
   addActor(actorEntry: ActorEntry): void;
+  /** get actor UIDs */
+  getActorUIDs(): Array<string>;
   /** remove all actors from the viewport */
   removeAllActors(): void;
   /** remove array of uids */

package/src/types/index.ts

@@ -108,6 +108,7 @@ import type {
 import type BoundsIJK from './BoundsIJK';
 import type { ImageVolumeProps } from './ImageVolumeProps';
 import type { VolumeProps } from './VolumeProps';
+import type BoundsLPS from './BoundsLPS';
 
 export type {
   // config
@@ -216,6 +217,7 @@ export type {
   InternalVideoCamera,
   VideoViewportInput,
   BoundsIJK,
+  BoundsLPS,
   Color,
   ColorLUT,
   VolumeProps,

package/src/utilities/VoxelManager.ts

@@ -216,10 +216,21 @@ export default class VoxelManager<T> {
    * Extends the bounds of this object to include the specified point
    */
   public static addBounds(bounds: BoundsIJK, point: Point3) {
-    bounds.forEach((bound, index) => {
-      bound[0] = Math.min(point[index], bound[0]);
-      bound[1] = Math.max(point[index], bound[1]);
-    });
+    if (!bounds) {
+      bounds = [
+        [Infinity, -Infinity],
+        [Infinity, -Infinity],
+        [Infinity, -Infinity],
+      ];
+    }
+
+    // Directly update the bounds for each axis
+    bounds[0][0] = Math.min(point[0], bounds[0][0]);
+    bounds[0][1] = Math.max(point[0], bounds[0][1]);
+    bounds[1][0] = Math.min(point[1], bounds[1][0]);
+    bounds[1][1] = Math.max(point[1], bounds[1][1]);
+    bounds[2][0] = Math.min(point[2], bounds[2][0]);
+    bounds[2][1] = Math.max(point[2], bounds[2][1]);
   }
 
   /**

package/src/utilities/planar.ts

@@ -28,11 +28,22 @@ function linePlaneIntersection(p0: Point3, p1: Point3, plane: Plane): Point3 {
  * It returns the plane equation defined by a point and a normal vector.
  * @param normal - normal vector
  * @param point - a point on the plane
+ * @param normalized - if true, the values of the plane equation will be normalized
  * @returns - [A, B,C, D] of plane equation A*X + B*Y + C*Z = D
  */
-function planeEquation(normal: Point3, point: Point3 | vec3): Plane {
+function planeEquation(
+  normal: Point3,
+  point: Point3 | vec3,
+  normalized = false
+): Plane {
   const [A, B, C] = normal;
   const D = A * point[0] + B * point[1] + C * point[2];
+
+  if (normalized) {
+    const length = Math.sqrt(A * A + B * B + C * C);
+    return [A / length, B / length, C / length, D / length];
+  }
+
   return [A, B, C, D];
 }