@cornerstonejs/core 2.0.0-beta.1 → 2.0.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.3",
   "description": "",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -46,5 +46,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "8cb0ace8dd10393a32f88507ef911ce823b0069d"
+  "gitHead": "d78cf780d4383a61ea0a9762bafa4104666757a4"
 }

package/src/RenderingEngine/BaseVolumeViewport.ts

@@ -12,6 +12,7 @@ import {
 import {
   BlendModes,
   Events,
+  InterpolationType,
   OrientationAxis,
   ViewportStatus,
   VOILUTFunctionType,
@@ -367,6 +368,23 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     return newRGBTransferFunction;
   }
 
+  private setInterpolationType(
+    interpolationType: InterpolationType,
+    volumeId?: string
+  ) {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+
+    if (!applicableVolumeActorInfo) {
+      return;
+    }
+
+    const { volumeActor } = applicableVolumeActorInfo;
+    const volumeProperty = volumeActor.getProperty();
+
+    // @ts-ignore
+    volumeProperty.setInterpolationType(interpolationType);
+  }
+
   /**
    * Sets the properties for the volume viewport on the volume
    * (if fusion, it sets it for the first volume in the fusion)
@@ -449,6 +467,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       invert,
       colormap,
       preset,
+      interpolationType,
     }: VolumeViewportProperties = {},
     volumeId?: string,
     suppressEvents = false
@@ -467,6 +486,10 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       this.setVOI(voiRange, volumeId, suppressEvents);
     }
 
+    if (typeof interpolationType !== 'undefined') {
+      this.setInterpolationType(interpolationType);
+    }
+
     if (VOILUTFunction !== undefined) {
       this.setVOILUTFunction(VOILUTFunction, volumeId, suppressEvents);
     }
@@ -519,7 +542,9 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
         const volumeActor = actorEntry.actor as vtkVolume;
         const volumeId = actorEntry.uid;
         const volume = cache.getVolume(volumeId);
-        if (!volume) return null;
+        if (!volume) {
+          return null;
+        }
         const cfun = volumeActor.getProperty().getRGBTransferFunction(0);
         const [lower, upper] =
           this.VOILUTFunction === 'SIGMOID'
@@ -847,6 +872,8 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
    *
    */
   private _setVolumeActors(volumeActorEntries: Array<ActorEntry>): void {
+    // New volume actors implies resetting the inverted flag (i.e. like starting from scratch).
+    this.inverted = false;
     this.setActors(volumeActorEntries);
   }
 
@@ -1078,6 +1105,31 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     return volume.getScalarData()[voxelIndex];
   }
 
+  /**
+   * Returns the list of image Ids for the current viewport
+   *
+   * @param volumeId - volumeId
+   * @returns list of strings for image Ids
+   */
+  public getImageIds = (volumeId?: string): Array<string> => {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+
+    if (!applicableVolumeActorInfo) {
+      throw new Error(`No actor found for the given volumeId: ${volumeId}`);
+    }
+
+    const volumeIdToUse = applicableVolumeActorInfo.volumeId;
+
+    const imageVolume = cache.getVolume(volumeIdToUse);
+    if (!imageVolume) {
+      throw new Error(
+        `imageVolume with id: ${volumeIdToUse} does not exist in cache`
+      );
+    }
+
+    return imageVolume.imageIds;
+  };
+
   abstract getCurrentImageIdIndex(): number;
 
   abstract getCurrentImageId(): string;
@@ -1092,6 +1144,8 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     slabThickness: number,
     filterActorUIDs?: Array<string>
   ): void;
+
+  abstract resetProperties(volumeId?: string): void;
 }
 
 export default BaseVolumeViewport;

package/src/RenderingEngine/RenderingEngine.ts

@@ -54,6 +54,7 @@ const VIEWPORT_MIN_SIZE = 2;
  * trigger a render on a specific viewport(s). Each viewport also has a `.render` method which can be used to trigger a render on that
  * viewport.
  *
+ *
  * Rendering engine uses `detect-gpu` external library to detect if GPU is available and
  * it has minimum requirement to be able to render a volume with vtk.js. If GPU is not available
  * RenderingEngine will throw an error if you try to render a volume; however, for StackViewports

package/src/RenderingEngine/StackViewport.ts

@@ -130,6 +130,8 @@ class StackViewport extends Viewport implements IStackViewport {
   private VOILUTFunction: VOILUTFunctionType;
   //
   private invert = false;
+  // The initial invert of the image loaded as opposed to the invert status of the viewport itself (see above).
+  private initialInvert = false;
   private interpolationType: InterpolationType;
 
   // Helpers
@@ -606,7 +608,9 @@ class StackViewport extends Viewport implements IStackViewport {
     this.hasPixelSpacing = scale > 0 || imagePlaneModule.rowPixelSpacing > 0;
     imagePlaneModule.calibration = calibration;
 
-    if (!isUpdated) return imagePlaneModule;
+    if (!isUpdated) {
+      return imagePlaneModule;
+    }
 
     this.calibration = calibration;
     this._publishCalibratedEvent = true;
@@ -728,7 +732,7 @@ class StackViewport extends Viewport implements IStackViewport {
       this.setRotation(0);
     }
     this.setInterpolationType(InterpolationType.LINEAR);
-    this.setInvertColor(false);
+    this.setInvertColor(this.initialInvert);
   }
 
   private _setPropertiesFromCache(): void {
@@ -1013,7 +1017,7 @@ class StackViewport extends Viewport implements IStackViewport {
       ? vec3.negate(vec3.create(), this.initialViewUp)
       : this.initialViewUp;
 
-    this.setCamera({
+    this.setCameraNoEvent({
       viewUp: initialViewUp as Point3,
     });
 
@@ -1755,10 +1759,17 @@ class StackViewport extends Viewport implements IStackViewport {
           return;
         }
 
-        //If Photometric Interpretation is not the same for the next image we are trying to load, invalidate the stack to recreate the VTK imageData
+        // If Photometric Interpretation is not the same for the next image we are trying to load
+        // invalidate the stack to recreate the VTK imageData
+        const csImgFrame = this.csImage?.imageFrame;
+        const imgFrame = image?.imageFrame;
+
+        // if a volume is decached into images then the imageFrame will be undefined
         if (
-          this.csImage?.imageFrame.photometricInterpretation !==
-          image?.imageFrame?.photometricInterpretation
+          csImgFrame?.photometricInterpretation !==
+            imgFrame?.photometricInterpretation ||
+          this.csImage?.photometricInterpretation !==
+            image?.photometricInterpretation
         ) {
           this.stackInvalidated = true;
         }
@@ -2057,8 +2068,10 @@ class StackViewport extends Viewport implements IStackViewport {
       forceRecreateLUTFunction: !!monochrome1,
     });
 
+    this.initialInvert = !!monochrome1;
+
     // should carry over the invert color from the previous image if has been applied
-    this.setInvertColor(this.invert || !!monochrome1);
+    this.setInvertColor(this.invert || this.initialInvert);
 
     // Saving position of camera on render, to cache the panning
     this.cameraFocalPointOnRender = this.getCamera().focalPoint;
@@ -2142,6 +2155,7 @@ class StackViewport extends Viewport implements IStackViewport {
     // Update the state of the viewport to the new imageIdIndex;
     this.currentImageIdIndex = imageIdIndex;
     this.hasPixelSpacing = true;
+    this.viewportStatus = ViewportStatus.PRE_RENDER;
 
     // Todo: trigger an event to allow applications to hook into START of loading state
     // Currently we use loadHandlerManagers for this
@@ -2225,7 +2239,7 @@ class StackViewport extends Viewport implements IStackViewport {
 
     const targetImageId = imageIds[newTargetImageIdIndex];
 
-    const imageAlreadyLoaded = cache.isImageIdCached(targetImageId);
+    const imageAlreadyLoaded = cache.isLoaded(targetImageId);
 
     // If image is already cached we want to scroll right away; however, if it is
     // not cached, we can debounce the scroll event to avoid firing multiple scroll
@@ -2564,7 +2578,9 @@ class StackViewport extends Viewport implements IStackViewport {
   public hasImageURI = (imageURI: string): boolean => {
     const imageIds = this.imageIds;
     for (let i = 0; i < imageIds.length; i++) {
-      if (imageIdToURI(imageIds[i]) === imageURI) return true;
+      if (imageIdToURI(imageIds[i]) === imageURI) {
+        return true;
+      }
     }
 
     return false;

package/src/RenderingEngine/Viewport.ts

@@ -126,7 +126,7 @@ class Viewport implements IViewport {
 
   /**
    * Indicate that the image has been rendered.
-   * This will set hte viewportStatus to RENDERED if there is image data
+   * This will set the viewportStatus to RENDERED if there is image data
    * available to actually be rendered - otherwise, the rendering simply showed
    * the background image.
    */

package/src/RenderingEngine/VolumeViewport.ts

@@ -1,9 +1,11 @@
 import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
+import vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
+
 import { vec3 } from 'gl-matrix';
 
 import cache from '../cache';
 import { MPR_CAMERA_VALUES, RENDERING_DEFAULTS } from '../constants';
-import { BlendModes, OrientationAxis } from '../enums';
+import { BlendModes, OrientationAxis, Events } from '../enums';
 import type {
   ActorEntry,
   IImageVolume,
@@ -12,8 +14,9 @@ import type {
   Point3,
 } from '../types';
 import type { ViewportInput } from '../types/IViewport';
-import { actorIsA, getClosestImageId } from '../utilities';
+import { actorIsA, getClosestImageId, triggerEvent } from '../utilities';
 import BaseVolumeViewport from './BaseVolumeViewport';
+import setDefaultVolumeVOI from './helpers/setDefaultVolumeVOI';
 
 /**
  * An object representing a VolumeViewport. VolumeViewports are used to render
@@ -350,6 +353,54 @@ class VolumeViewport extends BaseVolumeViewport {
   };
 
   getRotation = (): number => 0;
+
+  /**
+   * Reset the viewport properties to the default values
+   *
+
+   * @param volumeId - Optional volume ID to specify which volume properties to reset.
+   * If not provided, it will reset the properties of the default actor.
+   *
+   * @returns void
+   */
+  public resetProperties(volumeId?: string): void {
+    this._resetProperties(volumeId);
+  }
+
+  private _resetProperties(volumeId?: string) {
+    // Get the actor based on the volumeId if provided, otherwise use the default actor.
+    const volumeActor = volumeId
+      ? this.getActor(volumeId)
+      : this.getDefaultActor();
+
+    if (!volumeActor) {
+      throw new Error(`No actor found for the given volumeId: ${volumeId}`);
+    }
+
+    const imageVolume = cache.getVolume(volumeActor.uid);
+    if (!imageVolume) {
+      throw new Error(
+        `imageVolume with id: ${volumeActor.uid} does not exist in cache`
+      );
+    }
+    setDefaultVolumeVOI(volumeActor.actor as vtkVolume, imageVolume, false);
+
+    const range = (volumeActor.actor as vtkVolume)
+      .getProperty()
+      .getRGBTransferFunction(0)
+      .getMappingRange();
+
+    const eventDetails = {
+      viewportId: volumeActor.uid,
+      range: {
+        lower: range[0],
+        upper: range[1],
+      },
+      volumeId: volumeActor.uid,
+    };
+
+    triggerEvent(this.element, Events.VOI_MODIFIED, eventDetails);
+  }
 }
 
 export default VolumeViewport;

package/src/RenderingEngine/VolumeViewport3D.ts

@@ -60,6 +60,10 @@ class VolumeViewport3D extends BaseVolumeViewport {
   ): void {
     return null;
   }
+
+  resetProperties(volumeId?: string): void {
+    return null;
+  }
 }
 
 export default VolumeViewport3D;

package/src/RenderingEngine/helpers/cpuFallback/rendering/getVOILut.ts

@@ -15,6 +15,11 @@
  */
 
 /**
+ * Generates the linear VOI LUT function.
+ * From the DICOM standard:
+ * https://dicom.nema.org/medical/dicom/current/output/html/part03.html#sect_C.11.2.1.2.1
+ * ((x - (c - 0.5)) / (w-1) + 0.5) * (ymax- ymin) + ymin
+ * clipped to the ymin...ymax range
  *
  * @param {Number} windowWidth Window Width
  * @param {Number} windowCenter Window Center
@@ -23,7 +28,10 @@
  */
 function generateLinearVOILUT(windowWidth: number, windowCenter: number) {
   return function (modalityLutValue) {
-    return ((modalityLutValue - windowCenter) / windowWidth + 0.5) * 255.0;
+    const value =
+      ((modalityLutValue - (windowCenter - 0.5)) / (windowWidth - 1) + 0.5) *
+      255.0;
+    return Math.min(Math.max(value, 0), 255);
   };
 }
 

package/src/RenderingEngine/helpers/cpuFallback/rendering/renderColorImage.ts

@@ -72,10 +72,12 @@ function getRenderCanvas(
   const renderCanvas = enabledElement.renderingTools.renderCanvas;
 
   // The ww/wc is identity and not inverted - get a canvas with the image rendered into it for
-  // Fast drawing
+  // Fast drawing.  Note that this is 256/128, and NOT 255/127, per the DICOM
+  // standard, but allow either.
+  const { windowWidth, windowCenter } = enabledElement.viewport.voi;
   if (
-    enabledElement.viewport.voi.windowWidth === 255 &&
-    enabledElement.viewport.voi.windowCenter === 127 &&
+    (windowWidth === 256 || windowWidth === 255) &&
+    (windowCenter === 128 || windowCenter === 127) &&
     enabledElement.viewport.invert === false &&
     image.getCanvas &&
     image.getCanvas()

package/src/RenderingEngine/helpers/setVolumesForViewports.ts

@@ -34,7 +34,9 @@ async function setVolumesForViewports(
 
     // if not instance of BaseVolumeViewport, throw
     if (!(viewport instanceof BaseVolumeViewport)) {
-      throw new Error('setVolumesForViewports only supports VolumeViewport and VolumeViewport3D');
+      throw new Error(
+        'setVolumesForViewports only supports VolumeViewport and VolumeViewport3D'
+      );
     }
   });
 

package/src/Settings.ts

@@ -250,10 +250,14 @@ function get(dictionary: Record<string, unknown>, key: string): unknown {
  */
 function isValidKey(key: string): boolean {
   let last: number, current: number, previous: number;
-  if (typeof key !== 'string' || (last = key.length - 1) < 0) return false;
+  if (typeof key !== 'string' || (last = key.length - 1) < 0) {
+    return false;
+  }
   previous = -1;
   while ((current = key.indexOf('.', previous + 1)) >= 0) {
-    if (current - previous < 2 || current === last) return false;
+    if (current - previous < 2 || current === last) {
+      return false;
+    }
     previous = current;
   }
   return true;

package/src/cache/cache.ts

@@ -15,34 +15,40 @@ import { triggerEvent, imageIdToURI } from '../utilities';
 import eventTarget from '../eventTarget';
 import Events from '../enums/Events';
 
-const MAX_CACHE_SIZE_1GB = 1073741824;
+const ONE_GB = 1073741824;
 
+/**
+ * Stores images, volumes and geometry.
+ * There are two sizes - the max cache size, that controls the overal maximum
+ * size, and the instance size, which controls how big any single object can
+ * be.  Defaults are 3 GB and 2 GB - 8 bytes (just enough to allow allocating it
+ * without crashing).
+ * The 3 gb is tuned to the chromium garbage collection cycle to allow image volumes
+ * to be used/discarded.
+ */
 class Cache implements ICache {
-  private readonly _imageCache: Map<string, ICachedImage>; // volatile space
-  private readonly _volumeCache: Map<string, ICachedVolume>; // non-volatile space
+  // used to store image data (2d)
+  private readonly _imageCache = new Map<string, ICachedImage>(); // volatile space
+  // used to store volume data (3d)
+  private readonly _volumeCache = new Map<string, ICachedVolume>(); // non-volatile space
   // Todo: contour for now, but will be used for surface, etc.
   private readonly _geometryCache: Map<string, ICachedGeometry>;
-  private _imageCacheSize: number;
-  private _volumeCacheSize: number;
-  private _maxCacheSize: number;
+
+  private _imageCacheSize = 0;
+  private _volumeCacheSize = 0;
+  private _maxCacheSize = 3 * ONE_GB;
+  private _maxInstanceSize = 2 * ONE_GB - 8;
 
   constructor() {
-    // used to store image data (2d)
-    this._imageCache = new Map();
-    // used to store volume data (3d)
-    this._volumeCache = new Map();
     // used to store object data (contour, surface, etc.)
     this._geometryCache = new Map();
-    this._imageCacheSize = 0;
-    this._volumeCacheSize = 0;
-    this._maxCacheSize = MAX_CACHE_SIZE_1GB; // Default 1GB
   }
 
   /**
    * Set the maximum cache Size
    *
-   * Maximum cache size should be set before adding the data; otherwise, it
-   * will throw an error.
+   * Maximum cache size should be set before adding the data.  If set after,
+   * and it is smaller than the current size, will cause issues.
    *
    * @param newMaxCacheSize -  new maximum cache size
    *
@@ -59,7 +65,7 @@ class Cache implements ICache {
   /**
    * Checks if there is enough space in the cache for requested byte size
    *
-   * It throws error, if the sum of volatile (image) cache and unallocated cache
+   * It returns false, if the sum of volatile (image) cache and unallocated cache
    * is less than the requested byteLength
    *
    * @param byteLength - byte length of requested byte size
@@ -67,6 +73,9 @@ class Cache implements ICache {
    * @returns - boolean indicating if there is enough space in the cache
    */
   public isCacheable = (byteLength: number): boolean => {
+    if (byteLength > this._maxInstanceSize) {
+      return false;
+    }
     const unallocatedSpace = this.getBytesAvailable();
     const imageCacheSize = this._imageCacheSize;
     const availableSpace = unallocatedSpace + imageCacheSize;
@@ -81,6 +90,13 @@ class Cache implements ICache {
    */
   public getMaxCacheSize = (): number => this._maxCacheSize;
 
+  /**
+   * Returns maximum size of a single instance (volume or single image)
+   *
+   * @returns maximum instance size
+   */
+  public getMaxInstanceSize = (): number => this._maxInstanceSize;
+
   /**
    * Returns current size of the cache
    *
@@ -384,7 +400,6 @@ class Cache implements ICache {
         cachedImage.image = image;
         cachedImage.sizeInBytes = image.sizeInBytes;
         this._incrementImageCacheSize(cachedImage.sizeInBytes);
-
         const eventDetails: EventTypes.ImageCacheImageAddedEventDetail = {
           image: cachedImage,
         };
@@ -429,7 +444,7 @@ class Cache implements ICache {
    * @param imageId - image Id to check
    * @returns boolean
    */
-  public isImageIdCached(imageId: string): boolean {
+  public isLoaded(imageId: string): boolean {
     const cachedImage = this._imageCache.get(imageId);
 
     if (!cachedImage) {

package/src/cache/classes/ImageVolume.ts

@@ -151,12 +151,12 @@ export class ImageVolume implements IImageVolume {
    */
   destroy(): void {
     // TODO: GPU memory associated with volume is not cleared.
-    this.vtkOpenGLTexture.releaseGraphicsResources();
-    this.vtkOpenGLTexture.destroyTexture();
-    this.vtkOpenGLTexture.delete();
     this.imageData.delete();
     this.imageData = null;
     this.scalarData = null;
+
+    this.vtkOpenGLTexture.releaseGraphicsResources();
+    this.vtkOpenGLTexture.delete();
   }
 }
 

package/src/init.ts

@@ -100,7 +100,7 @@ function hasSharedArrayBuffer() {
  * @returns A promise that resolves to true cornerstone has been initialized successfully.
  * @category Initialization
  */
-async function init(configuration = {}): Promise<boolean> {
+async function init(configuration = config): Promise<boolean> {
   if (csRenderInitialized) {
     return csRenderInitialized;
   }

package/src/loaders/volumeLoader.ts

@@ -132,7 +132,7 @@ let unknownVolumeLoader;
  */
 function loadVolumeFromVolumeLoader(
   volumeId: string,
-  options: VolumeLoaderOptions
+  options?: VolumeLoaderOptions
 ): Types.IVolumeLoadObject {
   const colonIndex = volumeId.indexOf(':');
   const scheme = volumeId.substring(0, colonIndex);
@@ -210,7 +210,7 @@ export function loadVolume(
  */
 export async function createAndCacheVolume(
   volumeId: string,
-  options: VolumeLoaderOptions
+  options?: VolumeLoaderOptions
 ): Promise<Record<string, any>> {
   if (volumeId === undefined) {
     throw new Error(

package/src/requestPool/requestPoolManager.ts

@@ -307,7 +307,7 @@ class RequestPoolManager {
     const priorities = Object.keys(this.requestPool[type])
       .map(Number)
       .filter((priority) => this.requestPool[type][priority].length)
-      .sort();
+      .sort((a, b) => a - b);
     return priorities;
   }
 

package/src/types/AffineMatrix.ts

@@ -0,0 +1,8 @@
+type AffineMatrix = [
+  [number, number, number, number],
+  [number, number, number, number],
+  [number, number, number, number],
+  [number, number, number, number]
+];
+
+export type { AffineMatrix };

package/src/types/IImage.ts

@@ -72,6 +72,8 @@ interface IImage {
   sliceThickness?: number;
   /** whether image pixels are inverted in color */
   invert: boolean;
+  /** image photometric interpretation */
+  photometricInterpretation?: string;
   /** image size in number of bytes */
   sizeInBytes: number;
   /** CPU: custom modality LUT for image  */
@@ -91,6 +93,8 @@ interface IImage {
       suvbwToSuvbsa?: number;
     };
   };
+  loadTimeInMS?: number;
+  decodeTimeInMS?: number;
   /** CPU: image statistics for rendering */
   stats?: {
     lastStoredPixelDataToCanvasImageDataTime?: number;

package/src/types/IVolumeViewport.ts

@@ -28,6 +28,10 @@ export default interface IVolumeViewport extends IViewport {
    * projected onto the `Viewport`'s `canvas`.
    */
   worldToCanvas: (worldPos: Point3) => Point2;
+  /**
+   * Returns the list of image Ids for the current viewport
+   */
+  getImageIds: (volumeId?: string) => string[];
   /**
    * Uses viewport camera and volume actor to decide if the viewport
    * is looking at the volume in the direction of acquisition (imageIds).
@@ -138,4 +142,8 @@ export default interface IVolumeViewport extends IViewport {
   getImageData(volumeId?: string): IImageData | undefined;
 
   setOrientation(orientation: OrientationAxis): void;
+  /**
+   * Reset the viewport properties to the default values
+   */
+  resetProperties(volumeId?: string): void;
 }

package/src/types/Mat3.ts

@@ -1,16 +1,8 @@
 /**
  * This represents a 3x3 matrix of numbers
  */
-type Mat3 = [
-  number,
-  number,
-  number,
-  number,
-  number,
-  number,
-  number,
-  number,
-  number
-];
+type Mat3 =
+  | [number, number, number, number, number, number, number, number, number]
+  | Float32Array;
 
 export default Mat3;

package/src/types/ViewportProperties.ts

@@ -1,4 +1,4 @@
-import { VOILUTFunctionType } from '../enums';
+import { InterpolationType, VOILUTFunctionType } from '../enums';
 import { VOIRange } from './voi';
 
 /**
@@ -11,6 +11,8 @@ type ViewportProperties = {
   VOILUTFunction?: VOILUTFunctionType;
   /** invert flag - whether the image is inverted */
   invert?: boolean;
+  /** interpolation type */
+  interpolationType?: InterpolationType;
 };
 
 export type { ViewportProperties };

package/src/types/index.ts

@@ -81,6 +81,7 @@ import type { ViewportProperties } from './ViewportProperties';
 import type { PixelDataTypedArray } from './PixelDataTypedArray';
 import type { ImagePixelModule } from './ImagePixelModule';
 import type { ImagePlaneModule } from './ImagePlaneModule';
+import type { AffineMatrix } from './AffineMatrix';
 
 export type {
   // config
@@ -173,4 +174,5 @@ export type {
   PixelDataTypedArray,
   ImagePixelModule,
   ImagePlaneModule,
+  AffineMatrix,
 };