@cornerstonejs/core 1.36.3 → 1.37.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "1.36.3",
+  "version": "1.37.1",
   "description": "",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -47,5 +47,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "b6b6f9273ca4cff849336005d199c4b1b1570815"
+  "gitHead": "81e281d066bc2d92c2b7eb7cebbaae49da439fa8"
 }

package/src/RenderingEngine/StackViewport.ts

@@ -1193,6 +1193,8 @@ class StackViewport extends Viewport implements IStackViewport, IImagesLoader {
   }
 
   private setRotationGPU(rotation: number): void {
+    const pan = this.getPan();
+    this.setPan([0, 0]);
     const { flipVertical } = this.getCamera();
 
     // Moving back to zero rotation, for new scrolled slice rotation is 0 after camera reset
@@ -1206,6 +1208,7 @@ class StackViewport extends Viewport implements IStackViewport, IImagesLoader {
 
     // rotating camera to the new value
     this.getVtkActiveCamera().roll(-rotation);
+    this.setPan(pan);
   }
 
   private setInterpolationTypeGPU(interpolationType: InterpolationType): void {

package/src/RenderingEngine/Viewport.ts

@@ -55,6 +55,11 @@ class Viewport implements IViewport {
   readonly renderingEngineId: string;
   /** Type of viewport */
   readonly type: ViewportType;
+  /**
+   * The amount by which the images are inset in a viewport by default.
+   */
+  protected insetImageMultiplier = 1.1;
+
   protected flipHorizontal = false;
   protected flipVertical = false;
   public isDisabled: boolean;
@@ -584,14 +589,15 @@ class Viewport implements IViewport {
     const { storeAsInitialCamera } = displayArea;
 
     // make calculations relative to the fitToCanvasCamera view
-    this.setCamera(this.fitToCanvasCamera, false);
+    this.setCamera(this.fitToCanvasCamera, storeAsInitialCamera);
 
     const { imageArea, imageCanvasPoint } = displayArea;
 
+    let zoom = 1;
     if (imageArea) {
       const [areaX, areaY] = imageArea;
-      const zoom = Math.min(this.getZoom() / areaX, this.getZoom() / areaY);
-      this.setZoom(zoom, storeAsInitialCamera);
+      zoom = Math.min(this.getZoom() / areaX, this.getZoom() / areaY);
+      this.setZoom(this.insetImageMultiplier * zoom, storeAsInitialCamera);
     }
 
     // getting the image info
@@ -604,18 +610,22 @@ class Viewport implements IViewport {
       const validateCanvasPanY = this.sHeight / devicePixelRatio;
       const canvasPanX = validateCanvasPanX * (canvasX - 0.5);
       const canvasPanY = validateCanvasPanY * (canvasY - 0.5);
-
       const dimensions = imageData.getDimensions();
       const canvasZero = this.worldToCanvas([0, 0, 0]);
-      const canvasEdge = this.worldToCanvas(dimensions);
+      const canvasEdge = this.worldToCanvas([
+        dimensions[0] - 1,
+        dimensions[1] - 1,
+        dimensions[2],
+      ]);
       const canvasImage = [
         canvasEdge[0] - canvasZero[0],
         canvasEdge[1] - canvasZero[1],
       ];
       const [imgWidth, imgHeight] = canvasImage;
       const [imageX, imageY] = imagePoint;
-      const imagePanX = imgWidth * (0.5 - imageX);
-      const imagePanY = imgHeight * (0.5 - imageY);
+      const imagePanX =
+        (zoom * imgWidth * (0.5 - imageX) * validateCanvasPanY) / imgHeight;
+      const imagePanY = zoom * validateCanvasPanY * (0.5 - imageY);
 
       const newPositionX = imagePanX + canvasPanX;
       const newPositionY = imagePanY + canvasPanY;
@@ -727,7 +737,7 @@ class Viewport implements IViewport {
     }
 
     //const angle = vtkMath.radiansFromDegrees(activeCamera.getViewAngle())
-    const parallelScale = 1.1 * radius;
+    const parallelScale = this.insetImageMultiplier * radius;
 
     let w1 = bounds[1] - bounds[0];
     let w2 = bounds[3] - bounds[2];
@@ -743,7 +753,7 @@ class Viewport implements IViewport {
     // compute the radius of the enclosing sphere
     radius = Math.sqrt(radius) * 0.5;
 
-    const distance = 1.1 * radius;
+    const distance = this.insetImageMultiplier * radius;
 
     const viewUpToSet: Point3 =
       Math.abs(vtkMath.dot(viewUp, viewPlaneNormal)) > 0.999

package/src/types/BoundsIJK.ts

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

package/src/types/index.ts

@@ -105,6 +105,7 @@ import type {
   InternalVideoCamera,
   VideoViewportInput,
 } from './VideoViewportTypes';
+import type BoundsIJK from './BoundsIJK';
 
 export type {
   // config
@@ -212,6 +213,7 @@ export type {
   // video
   InternalVideoCamera,
   VideoViewportInput,
+  BoundsIJK,
   Color,
   ColorLUT,
 };

package/src/utilities/VoxelManager.ts

@@ -0,0 +1,296 @@
+import type { BoundsIJK, Point3, VolumeScalarData } from '../types';
+
+/**
+ * This is a simple, standard interface to values associated with a voxel.
+ */
+export default class VoxelManager<T> {
+  public modifiedSlices = new Set<number>();
+  public boundsIJK = [
+    [Infinity, -Infinity],
+    [Infinity, -Infinity],
+    [Infinity, -Infinity],
+  ] as BoundsIJK;
+
+  // Provide direct access to the underlying data, if any
+  public scalarData: VolumeScalarData;
+  public map: Map<number, T>;
+  public sourceVoxelManager: VoxelManager<T>;
+  public isInObject: (pointIPS, pointIJK) => boolean;
+  public readonly dimensions: Point3;
+
+  points: Set<number>;
+  width: number;
+  frameSize: number;
+  _get: (index: number) => T;
+  _set: (index: number, v: T) => boolean | void;
+
+  /**
+   * Creates a generic voxel value accessor, with access to the values
+   * provided by the _get and optionally _set values.
+   * @param dimensions - for the voxel volume
+   * @param _get - called to get a value by index
+   * @param _set  - called when setting a value
+   */
+  constructor(
+    dimensions,
+    _get: (index: number) => T,
+    _set?: (index: number, v: T) => boolean | void
+  ) {
+    this.dimensions = dimensions;
+    this.width = dimensions[0];
+    this.frameSize = this.width * dimensions[1];
+    this._get = _get;
+    this._set = _set;
+  }
+
+  /**
+   * Gets the voxel value at position i,j,k.
+   */
+  public getAtIJK = (i, j, k) => {
+    const index = i + j * this.width + k * this.frameSize;
+    return this._get(index);
+  };
+
+  /**
+   * Sets the voxel value at position i,j,k and records the slice
+   * that was modified.
+   */
+  public setAtIJK = (i: number, j: number, k: number, v) => {
+    const index = i + j * this.width + k * this.frameSize;
+    if (this._set(index, v) !== false) {
+      this.modifiedSlices.add(k);
+      VoxelManager.addBounds(this.boundsIJK, [i, j, k]);
+    }
+  };
+
+  /**
+   * Adds a point as an array or an index value to the set of points
+   * associated with this voxel value.
+   * Can be used for tracking clicked points or other modified values.
+   */
+  public addPoint(point: Point3 | number) {
+    const index = Array.isArray(point)
+      ? point[0] + this.width * point[1] + this.frameSize * point[2]
+      : point;
+    if (!this.points) {
+      this.points = new Set<number>();
+    }
+    this.points.add(index);
+  }
+
+  /**
+   * Gets the list of added points as an array of Point3 values
+   */
+  public getPoints(): Point3[] {
+    return this.points
+      ? [...this.points].map((index) => this.toIJK(index))
+      : [];
+  }
+
+  /**
+   * Gets the points added using addPoint as an array of indices.
+   */
+  public getPointIndices(): number[] {
+    return this.points ? [...this.points] : [];
+  }
+
+  /**
+   * Gets the voxel value at the given Point3 location.
+   */
+  public getAtIJKPoint = ([i, j, k]) => this.getAtIJK(i, j, k);
+
+  /**
+   * Sets the voxel value at the given point3 location to the specified value.
+   * Records the z index modified.
+   * Will record the index value if the VoxelManager is backed by a map.
+   */
+  public setAtIJKPoint = ([i, j, k], v) => this.setAtIJK(i, j, k, v);
+
+  /**
+   * Gets the value at the given index.
+   */
+  public getAtIndex = (index) => this._get(index);
+
+  /**
+   * Sets the value at the given index
+   */
+  public setAtIndex = (index, v) => {
+    if (this._set(index, v) !== false) {
+      const pointIJK = this.toIJK(index);
+      this.modifiedSlices.add(pointIJK[2]);
+      VoxelManager.addBounds(this.boundsIJK, pointIJK);
+    }
+  };
+
+  /**
+   * Converts an index value to a Point3 IJK value
+   */
+  public toIJK(index: number): Point3 {
+    return [
+      index % this.width,
+      Math.floor((index % this.frameSize) / this.width),
+      Math.floor(index / this.frameSize),
+    ];
+  }
+
+  /**
+   * Converts an IJK Point3 value to an index value
+   */
+  public toIndex(ijk: Point3) {
+    return ijk[0] + ijk[1] * this.width + ijk[2] * this.frameSize;
+  }
+
+  /**
+   * Gets the bounds for the modified set of values.
+   */
+  public getBoundsIJK(): BoundsIJK {
+    if (this.boundsIJK[0][0] < this.dimensions[0]) {
+      return this.boundsIJK;
+    }
+    return this.dimensions.map((dimension) => [0, dimension - 1]) as BoundsIJK;
+  }
+
+  /**
+   * Iterate over the points within the bounds, or the modified points if recorded.
+   */
+  public forEach = (callback, options?) => {
+    const boundsIJK = options?.boundsIJK || this.getBoundsIJK();
+    const { isWithinObject } = options || {};
+    if (this.map) {
+      // Optimize this for only values in the map
+      for (const index of this.map.keys()) {
+        const pointIJK = this.toIJK(index);
+        const value = this._get(index);
+        const callbackArguments = { value, index, pointIJK };
+        if (isWithinObject?.(callbackArguments) === false) {
+          continue;
+        }
+        callback(callbackArguments);
+      }
+    } else {
+      for (let k = boundsIJK[2][0]; k <= boundsIJK[2][1]; k++) {
+        const kIndex = k * this.frameSize;
+        for (let j = boundsIJK[1][0]; j <= boundsIJK[1][1]; j++) {
+          const jIndex = kIndex + j * this.width;
+          for (
+            let i = boundsIJK[0][0], index = jIndex + i;
+            i <= boundsIJK[0][1];
+            i++, index++
+          ) {
+            const value = this.getAtIndex(index);
+            const callbackArguments = { value, index, pointIJK: [i, j, k] };
+            if (isWithinObject?.(callbackArguments) === false) {
+              continue;
+            }
+            callback(callbackArguments);
+          }
+        }
+      }
+    }
+  };
+
+  /**
+   * Clears any map specific data, as wellas the modified slices, points and
+   * bounds.
+   */
+  public clear() {
+    if (this.map) {
+      this.map.clear();
+    }
+    this.boundsIJK.map((bound) => {
+      bound[0] = Infinity;
+      bound[1] = -Infinity;
+    });
+    this.modifiedSlices.clear();
+    this.points?.clear();
+  }
+
+  /**
+   * @returns The array of modified k indices
+   */
+  public getArrayOfSlices(): number[] {
+    return Array.from(this.modifiedSlices);
+  }
+
+  /**
+   * 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]);
+    });
+  }
+
+  /**
+   *  Creates a volume value accessor, based on a volume scalar data instance.
+   * This also works for image value accessors for single plane (k=0) accessors.
+   */
+  public static createVolumeVoxelManager(
+    dimensions: Point3,
+    scalarData
+  ): VoxelManager<number> {
+    const voxels = new VoxelManager(
+      dimensions,
+      (index) => scalarData[index],
+      (index, v) => {
+        const isChanged = scalarData[index] !== v;
+        scalarData[index] = v;
+        return isChanged;
+      }
+    );
+    voxels.scalarData = scalarData;
+    return voxels;
+  }
+
+  /**
+   * Creates a volume map value accessor.  This is initially empty and
+   * the map stores the index to value instances.
+   * This is useful for sparse matrices containing pixel data.
+   */
+  public static createMapVoxelManager<T>(dimension: Point3): VoxelManager<T> {
+    const map = new Map<number, T>();
+    const voxelManager = new VoxelManager(
+      dimension,
+      map.get.bind(map),
+      (index, v) => map.set(index, v) && true
+    );
+    voxelManager.map = map;
+    return voxelManager;
+  }
+
+  /**
+   * Creates a history remembering voxel manager.
+   * This will remember the original values in the voxels, and will apply the
+   * update to the underlying source voxel manager.
+   */
+  public static createHistoryVoxelManager<T>(
+    sourceVoxelManager: VoxelManager<T>
+  ): VoxelManager<T> {
+    const map = new Map<number, T>();
+    const { dimensions } = sourceVoxelManager;
+    const voxelManager = new VoxelManager(
+      dimensions,
+      (index) => map.get(index),
+      function (index, v) {
+        if (!map.has(index)) {
+          const oldV = this.sourceVoxelManager.getAtIndex(index);
+          if (oldV === v) {
+            // No-op
+            return false;
+          }
+          map.set(index, oldV);
+        } else if (v === map.get(index)) {
+          map.delete(index);
+        }
+        this.sourceVoxelManager.setAtIndex(index, v);
+      }
+    );
+    voxelManager.map = map;
+    voxelManager.scalarData = sourceVoxelManager.scalarData;
+    voxelManager.sourceVoxelManager = sourceVoxelManager;
+    return voxelManager;
+  }
+}
+
+export type { VoxelManager };

package/src/utilities/index.ts

@@ -59,6 +59,7 @@ import decimate from './decimate';
 import imageRetrieveMetadataProvider from './imageRetrieveMetadataProvider';
 import isVideoTransferSyntax from './isVideoTransferSyntax';
 import { getBufferConfiguration } from './getBufferConfiguration';
+import VoxelManager from './VoxelManager';
 
 // name spaces
 import * as planar from './planar';
@@ -133,4 +134,5 @@ export {
   genericMetadataProvider,
   isVideoTransferSyntax,
   getBufferConfiguration,
+  VoxelManager,
 };