@cornerstonejs/core 1.4.6 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "1.4.6",
+  "version": "1.6.0",
   "description": "",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -44,5 +44,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "611a684e4c3674d12cc66b749cf19d0f1b5698da"
+  "gitHead": "cfde297ad3a3ef5f1976751654c847ea63610749"
 }

package/src/RenderingEngine/BaseVolumeViewport.ts

@@ -13,6 +13,7 @@ import {
   BlendModes,
   Events,
   OrientationAxis,
+  ViewportStatus,
   VOILUTFunctionType,
 } from '../enums';
 import ViewportType from '../enums/ViewportType';
@@ -591,6 +592,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     }
 
     this._setVolumeActors(volumeActors);
+    this.viewportStatus = ViewportStatus.PRE_RENDER;
 
     triggerEvent(this.element, Events.VOLUME_VIEWPORT_NEW_VOLUME, {
       viewportId: this.id,

package/src/RenderingEngine/RenderingEngine.ts

@@ -20,7 +20,7 @@ import type {
   InternalViewportInput,
   NormalizedViewportInput,
 } from '../types/IViewport';
-import { OrientationAxis } from '../enums';
+import { OrientationAxis, ViewportStatus } from '../enums';
 import VolumeViewport3D from './VolumeViewport3D';
 
 type ViewportDisplayCoords = {
@@ -1107,6 +1107,7 @@ class RenderingEngine implements IRenderingEngine {
         const eventDetail =
           this.renderViewportUsingCustomOrVtkPipeline(viewport);
         eventDetailArray.push(eventDetail);
+        viewport.setRendered();
 
         // This viewport has been rendered, we can remove it from the set
         this._needsRender.delete(viewport.id);
@@ -1251,6 +1252,7 @@ class RenderingEngine implements IRenderingEngine {
       suppressEvents,
       viewportId,
       renderingEngineId,
+      viewportStatus: viewport.viewportStatus,
     };
   }
 

package/src/RenderingEngine/StackViewport.ts

@@ -10,7 +10,6 @@ import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransf
 import * as metaData from '../metaData';
 import Viewport from './Viewport';
 import eventTarget from '../eventTarget';
-import Events from '../enums/Events';
 import {
   triggerEvent,
   isEqual,
@@ -41,6 +40,7 @@ import {
   VolumeActor,
   Mat3,
   ColormapRegistration,
+  IImageCalibration,
 } from '../types';
 import { ViewportInput } from '../types/IViewport';
 import drawImageSync from './helpers/cpuFallback/drawImageSync';
@@ -48,8 +48,13 @@ import { getColormap } from './helpers/cpuFallback/colors/index';
 
 import { loadAndCacheImage } from '../loaders/imageLoader';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
-import InterpolationType from '../enums/InterpolationType';
-import VOILUTFunctionType from '../enums/VOILUTFunctionType';
+import {
+  InterpolationType,
+  RequestType,
+  Events,
+  CalibrationTypes,
+  VOILUTFunctionType,
+} from '../enums';
 import canvasToPixel from './helpers/cpuFallback/rendering/canvasToPixel';
 import pixelToCanvas from './helpers/cpuFallback/rendering/pixelToCanvas';
 import getDefaultViewport from './helpers/cpuFallback/rendering/getDefaultViewport';
@@ -59,7 +64,6 @@ import resize from './helpers/cpuFallback/rendering/resize';
 import resetCamera from './helpers/cpuFallback/rendering/resetCamera';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
 import { getConfiguration, getShouldUseCPURendering } from '../init';
-import RequestType from '../enums/RequestType';
 import {
   StackViewportNewStackEventDetail,
   StackViewportScrollEventDetail,
@@ -74,6 +78,7 @@ import {
   ImagePixelModule,
   ImagePlaneModule,
 } from '../types';
+import ViewportStatus from '../enums/ViewportStatus';
 
 const EPSILON = 1; // Slice Thickness
 
@@ -90,8 +95,10 @@ interface ImageDataMetaData {
 }
 // TODO This needs to be exposed as its published to consumers.
 type CalibrationEvent = {
-  rowScale: number;
-  columnScale: number;
+  rowScale?: number;
+  columnScale?: number;
+  scale: number;
+  calibration: IImageCalibration;
 };
 
 type SetVOIOptions = {
@@ -410,6 +417,7 @@ class StackViewport extends Viewport implements IStackViewport {
       metadata: { Modality: this.modality },
       scaling: this.scaling,
       hasPixelSpacing: this.hasPixelSpacing,
+      calibration: this.calibration,
       preScale: {
         ...this.csImage.preScale,
       },
@@ -451,6 +459,7 @@ class StackViewport extends Viewport implements IStackViewport {
       },
       scalarData: this.cpuImagePixelData,
       hasPixelSpacing: this.hasPixelSpacing,
+      calibration: this.calibration,
       preScale: {
         ...this.csImage.preScale,
       },
@@ -557,6 +566,7 @@ class StackViewport extends Viewport implements IStackViewport {
     const voiLUTFunctionEnum = this._getValidVOILUTFunction(voiLUTFunction);
     this.VOILUTFunction = voiLUTFunctionEnum;
 
+    this.calibration = null;
     let imagePlaneModule = this._getImagePlaneModule(imageId);
 
     if (!this.useCPURendering) {
@@ -590,89 +600,19 @@ class StackViewport extends Viewport implements IStackViewport {
    * @returns modified imagePlaneModule with the calibrated spacings
    */
   private calibrateIfNecessary(imageId, imagePlaneModule) {
-    const calibratedPixelSpacing = metaData.get(
-      'calibratedPixelSpacing',
-      imageId
-    );
-
-    if (!calibratedPixelSpacing) {
-      return imagePlaneModule;
-    }
-
-    const {
-      rowPixelSpacing: calibratedRowSpacing,
-      columnPixelSpacing: calibratedColumnSpacing,
-    } = calibratedPixelSpacing;
+    const calibration = metaData.get('calibratedPixelSpacing', imageId);
+    const isUpdated = this.calibration !== calibration;
+    const { scale } = calibration || {};
+    this.hasPixelSpacing = scale > 0 || imagePlaneModule.rowPixelSpacing > 0;
+    imagePlaneModule.calibration = calibration;
 
-    // Todo: This is necessary in general, but breaks an edge case when an image
-    // is calibrated to some other spacing, and it gets calibrated BACK to the
-    // original spacing.
-    if (
-      imagePlaneModule.rowPixelSpacing === calibratedRowSpacing &&
-      imagePlaneModule.columnPixelSpacing === calibratedColumnSpacing
-    ) {
-      return imagePlaneModule;
-    }
+    if (!isUpdated) return imagePlaneModule;
 
-    // Check if there is already an actor
-    const imageDataMetadata = this.getImageData();
-
-    // If no actor (first load) and calibration matches the dicom header
-    if (
-      !imageDataMetadata &&
-      imagePlaneModule.rowPixelSpacing === calibratedRowSpacing &&
-      imagePlaneModule.columnPixelSpacing === calibratedColumnSpacing
-    ) {
-      return imagePlaneModule;
-    }
-
-    // If no actor (first load) and calibration doesn't match headers
-    // -> needs calibration
-    if (
-      !imageDataMetadata &&
-      (imagePlaneModule.rowPixelSpacing !== calibratedRowSpacing ||
-        imagePlaneModule.columnPixelSpacing !== calibratedColumnSpacing)
-    ) {
-      this._publishCalibratedEvent = true;
-
-      this._calibrationEvent = <CalibrationEvent>{
-        rowScale: calibratedRowSpacing / imagePlaneModule.rowPixelSpacing,
-        columnScale:
-          calibratedColumnSpacing / imagePlaneModule.columnPixelSpacing,
-      };
-
-      // modify the calibration object to store the actual updated values applied
-      calibratedPixelSpacing.appliedSpacing = calibratedPixelSpacing;
-      // This updates the render copy
-      imagePlaneModule.rowPixelSpacing = calibratedRowSpacing;
-      imagePlaneModule.columnPixelSpacing = calibratedColumnSpacing;
-      return imagePlaneModule;
-    }
-
-    // If there is already an actor, check if calibration is needed for the current actor
-    const { imageData } = imageDataMetadata;
-    const [columnPixelSpacing, rowPixelSpacing] = imageData.getSpacing();
-
-    // modify the calibration object to store the actual updated values applied
-    calibratedPixelSpacing.appliedSpacing = calibratedPixelSpacing;
-    imagePlaneModule.rowPixelSpacing = calibratedRowSpacing;
-    imagePlaneModule.columnPixelSpacing = calibratedColumnSpacing;
-
-    // If current actor spacing matches the calibrated spacing
-    if (
-      rowPixelSpacing === calibratedRowSpacing &&
-      columnPixelSpacing === calibratedPixelSpacing
-    ) {
-      // No calibration is required
-      return imagePlaneModule;
-    }
-
-    // Calibration is required
+    this.calibration = calibration;
     this._publishCalibratedEvent = true;
-
     this._calibrationEvent = <CalibrationEvent>{
-      rowScale: calibratedRowSpacing / rowPixelSpacing,
-      columnScale: calibratedColumnSpacing / columnPixelSpacing,
+      scale,
+      calibration,
     };
 
     return imagePlaneModule;
@@ -696,6 +636,9 @@ class StackViewport extends Viewport implements IStackViewport {
     }: StackViewportProperties = {},
     suppressEvents = false
   ): void {
+    this.viewportStatus = this.csImage
+      ? ViewportStatus.PRE_RENDER
+      : ViewportStatus.LOADING;
     // if voi is not applied for the first time, run the setVOI function
     // which will apply the default voi based on the range
     if (typeof voiRange !== 'undefined') {
@@ -753,6 +696,7 @@ class StackViewport extends Viewport implements IStackViewport {
   public resetProperties(): void {
     this.cpuRenderingInvalidated = true;
     this.voiUpdatedWithSetProperties = false;
+    this.viewportStatus = ViewportStatus.PRE_RENDER;
 
     this.fillWithBackgroundColor();
 
@@ -1494,6 +1438,7 @@ class StackViewport extends Viewport implements IStackViewport {
     this.voiRange = null;
     this.interpolationType = InterpolationType.LINEAR;
     this.invert = false;
+    this.viewportStatus = ViewportStatus.LOADING;
 
     this.fillWithBackgroundColor();
 
@@ -1715,6 +1660,7 @@ class StackViewport extends Viewport implements IStackViewport {
         }
 
         this._setCSImage(image);
+        this.viewportStatus = ViewportStatus.PRE_RENDER;
 
         const eventDetail: EventTypes.StackNewImageEventDetail = {
           image,
@@ -2648,6 +2594,7 @@ class StackViewport extends Viewport implements IStackViewport {
       element: this.element,
       viewportId: this.id,
       renderingEngineId: this.renderingEngineId,
+      viewportStatus: this.viewportStatus,
     };
   };
 
@@ -2709,28 +2656,20 @@ class StackViewport extends Viewport implements IStackViewport {
       imageId
     );
 
+    this.calibration ||= imagePlaneModule.calibration;
+
     const newImagePlaneModule: ImagePlaneModule = {
       ...imagePlaneModule,
     };
 
-    if (calibratedPixelSpacing?.appliedSpacing) {
-      // Over-ride the image plane module spacing, as the measurement data
-      // has already been created with the calibrated spacing provided from
-      // down below inside calibrateIfNecessary
-      const { rowPixelSpacing, columnPixelSpacing } =
-        calibratedPixelSpacing.appliedSpacing;
-      newImagePlaneModule.rowPixelSpacing = rowPixelSpacing;
-      newImagePlaneModule.columnPixelSpacing = columnPixelSpacing;
-    }
-
     if (!newImagePlaneModule.columnPixelSpacing) {
       newImagePlaneModule.columnPixelSpacing = 1;
-      this.hasPixelSpacing = false;
+      this.hasPixelSpacing = this.calibration?.scale > 0;
     }
 
     if (!newImagePlaneModule.rowPixelSpacing) {
       newImagePlaneModule.rowPixelSpacing = 1;
-      this.hasPixelSpacing = false;
+      this.hasPixelSpacing = this.calibration?.scale > 0;
     }
 
     if (!newImagePlaneModule.columnCosines) {

package/src/RenderingEngine/Viewport.ts

@@ -7,6 +7,7 @@ import { vec2, vec3 } from 'gl-matrix';
 import _cloneDeep from 'lodash.clonedeep';
 
 import Events from '../enums/Events';
+import ViewportStatus from '../enums/ViewportStatus';
 import ViewportType from '../enums/ViewportType';
 import renderingEngineCache from './renderingEngineCache';
 import { triggerEvent, planar, isImageActor, actorIsA } from '../utilities';
@@ -26,6 +27,7 @@ import type {
 import type { ViewportInput, IViewport } from '../types/IViewport';
 import type { vtkSlabCamera } from './vtkClasses/vtkSlabCamera';
 import { getConfiguration } from '../init';
+import IImageCalibration from '../types/IImageCalibration';
 
 /**
  * An object representing a single viewport, which is a camera
@@ -50,6 +52,10 @@ class Viewport implements IViewport {
   protected flipHorizontal = false;
   protected flipVertical = false;
   public isDisabled: boolean;
+  /** Record the renddering 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;
 
   /** sx of viewport on the offscreen canvas */
   sx: number;
@@ -69,6 +75,7 @@ class Viewport implements IViewport {
   /** A flag representing if viewport methods should fire events or not */
   readonly suppressEvents: boolean;
   protected hasPixelSpacing = true;
+  protected calibration: IImageCalibration;
   /** The camera that is initially defined on the reset for
    * the relative pan/zoom
    */
@@ -117,6 +124,22 @@ class Viewport implements IViewport {
     return false;
   }
 
+  /**
+   * Indicate that the image has been rendered.
+   * This will set hte viewportStatus to RENDERED if there is image data
+   * available to actually be rendered - otherwise, the rendering simply showed
+   * the background image.
+   */
+  public setRendered() {
+    if (
+      this.viewportStatus === ViewportStatus.NO_DATA ||
+      this.viewportStatus === ViewportStatus.LOADING
+    ) {
+      return;
+    }
+    this.viewportStatus = ViewportStatus.RENDERED;
+  }
+
   /**
    * Returns the rendering engine driving the `Viewport`.
    *

package/src/enums/CalibrationTypes.ts

@@ -0,0 +1,55 @@
+/**
+ * Defines the calibration types available.  These define how the units
+ * for measurements are specified.
+ */
+export enum CalibrationTypes {
+  /**
+   * Not applicable means the units are directly defind by the underlying
+   * hardware, such as CT and MR volumetric displays, so no special handling
+   * or notification is required.
+   */
+  NOT_APPLICABLE = '',
+  /**
+   * ERMF is estimated radiographic magnification factor.  This defines how
+   * much the image is magnified at the detector as opposed to the location in
+   * the body of interest.  This occurs because the radiation beam is expanding
+   * and effectively magnifies the image on the detector compared to where the
+   * point of interest in the body is.
+   * This suggests that measurements can be partially trusted, but the user
+   * still needs to be aware that different depths within the body have differing
+   * ERMF values, so precise measurements would still need to be manually calibrated.
+   */
+  ERMF = 'ERMF',
+  /**
+   * User calibration means that the user has provided a custom calibration
+   * specifying how large the image data is.  This type can occur on
+   * volumetric images, eg for scout images that might have invalid spacing
+   * tags.
+   */
+  USER = 'User',
+  /**
+   * A projection calibration means the raw detector size, without any
+   * ERMF applied, meaning that the size in the body cannot be trusted and
+   * that a calibration should be applied.
+   * This is different from Error in that there is simply no magnification
+   * factor applied as opposed to having multiple, inconsistent magnification
+   * factors.
+   */
+  PROJECTION = 'Proj',
+  /**
+   * A region calibration is used for other types of images, typically
+   * ultrasouunds where the distance in the image may mean something other than
+   * physical distance, such as mV or Hz or some other measurement values.
+   */
+  REGION = 'Region',
+  /**
+   * Error is used to define mismatches between various units, such as when
+   * there are two different ERMF values specified.  This is an indication to
+   * NOT trust the measurement values but to manually calibrate.
+   */
+  ERROR = 'Error',
+  /** Uncalibrated image */
+  UNCALIBRATED = 'Uncalibrated',
+}
+
+export default CalibrationTypes;

package/src/enums/ViewportStatus.ts

@@ -0,0 +1,14 @@
+enum ViewportStatus {
+  /** Initial state before any volumes or stacks are available*/
+  NO_DATA = 'noData',
+  /** Stack/volumes are available but are in progress */
+  LOADING = 'loading',
+  /** Ready to be rendered */
+  PRE_RENDER = 'preRender',
+  /** In the midst of a resize */
+  RESIZE = 'resize',
+  /** Rendered image data */
+  RENDERED = 'rendered',
+}
+
+export default ViewportStatus;

package/src/enums/index.ts

@@ -9,10 +9,13 @@ import GeometryType from './GeometryType';
 import ContourType from './ContourType';
 import VOILUTFunctionType from './VOILUTFunctionType';
 import DynamicOperatorType from './DynamicOperatorType';
+import CalibrationTypes from './CalibrationTypes';
+import ViewportStatus from './ViewportStatus';
 
 export {
   Events,
   BlendModes,
+  CalibrationTypes,
   InterpolationType,
   RequestType,
   ViewportType,
@@ -22,4 +25,5 @@ export {
   ContourType,
   VOILUTFunctionType,
   DynamicOperatorType,
+  ViewportStatus,
 };

package/src/types/CPUIImageData.ts

@@ -1,4 +1,5 @@
 import { Point3, Scaling, Mat3, PixelDataTypedArray } from '../types';
+import IImageCalibration from './IImageCalibration';
 
 type CPUImageData = {
   worldToIndex?: (point: Point3) => Point3;
@@ -24,6 +25,8 @@ type CPUIImageData = {
   scaling: Scaling;
   /** whether the image has pixel spacing and it is not undefined */
   hasPixelSpacing?: boolean;
+  calibration?: IImageCalibration;
+
   /** preScale object */
   preScale?: {
     /** boolean flag to indicate whether the image has been scaled */

package/src/types/EventTypes.ts

@@ -8,7 +8,9 @@ import type IImage from './IImage';
 import type IImageVolume from './IImageVolume';
 import type { VOIRange } from './voi';
 import type VOILUTFunctionType from '../enums/VOILUTFunctionType';
+import type ViewportStatus from '../enums/ViewportStatus';
 import type DisplayArea from './displayArea';
+import IImageCalibration from './IImageCalibration';
 
 /**
  * CAMERA_MODIFIED Event's data
@@ -96,6 +98,8 @@ type ImageRenderedEventDetail = {
   renderingEngineId: string;
   /** Whether to suppress the event */
   suppressEvents?: boolean;
+  /** Include information on whether this is a real rendering or just background */
+  viewportStatus: ViewportStatus;
 };
 /**
  * IMAGE_VOLUME_MODIFIED Event's data
@@ -225,8 +229,8 @@ type ImageSpacingCalibratedEventDetail = {
   viewportId: string;
   renderingEngineId: string;
   imageId: string;
-  rowScale: number;
-  columnScale: number;
+  /** calibration contains the scaling information as well as other calibration info */
+  calibration: IImageCalibration;
   imageData: vtkImageData;
   worldToIndex: mat4;
 };

package/src/types/IImageCalibration.ts

@@ -0,0 +1,41 @@
+import CalibrationTypes from '../enums/CalibrationTypes';
+
+/**
+ * IImageCalibration is an object that stores information about the type
+ * of image calibration.
+ */
+export interface IImageCalibration {
+  /**
+   * The pixel spacing for the image, in mm between pixel centers
+   * These are not required, and are deprecated in favour of getting the original
+   * image spacing and then applying the transforms.  The values here should
+   * be identical to original spacing.
+   */
+  rowPixelSpacing?: number;
+  columnPixelSpacing?: number;
+  /** The scaling of measurement values relative to the base pixel spacing (1 if not specified) */
+  scale?: number;
+  /**
+   * The calibration aspect ratio for non-square calibrations.
+   * This is the aspect ratio similar to the scale above that applies when
+   * the viewport is displaying non-square image pixels as square screen pixels.
+   *
+   * Defaults to 1 if not specified, and is also 1 if the Viewport has squared
+   * up the image pixels so that they are displayed as a square.
+   * Not well handled currently as this needs to be incorporated into
+   * tools when doing calculations.
+   */
+  aspect?: number;
+  /** The type of the pixel spacing, distinguishing between various
+   * types projection (CR/DX/MG) spacing and volumetric spacing (the type is
+   * an empty string as it doesn't get a suffix, but this distinguishes it
+   * from other types)
+   */
+  type: CalibrationTypes;
+  /** A tooltip which can be used to explain the calibration information */
+  tooltip?: string;
+  /** The DICOM defined ultrasound regions.  Used for non-distance spacing units. */
+  sequenceOfUltrasoundRegions?: Record<string, unknown>[];
+}
+
+export default IImageCalibration;

package/src/types/IImageData.ts

@@ -1,5 +1,6 @@
 import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
 import { Point3, Scaling, Mat3 } from '../types';
+import IImageCalibration from './IImageCalibration';
 
 /**
  * IImageData of an image, which stores actual scalarData and metaData about the image.
@@ -24,6 +25,9 @@ interface IImageData {
   scaling?: Scaling;
   /** whether the image has pixel spacing and it is not undefined */
   hasPixelSpacing?: boolean;
+
+  calibration?: IImageCalibration;
+
   /** preScale object */
   preScale?: {
     /** boolean flag to indicate whether the image has been scaled */

package/src/types/IViewport.ts

@@ -4,6 +4,7 @@ import Point3 from './Point3';
 import ViewportInputOptions from './ViewportInputOptions';
 import { ActorEntry } from './IActor';
 import ViewportType from '../enums/ViewportType';
+import ViewportStatus from '../enums/ViewportStatus';
 import DisplayArea from './displayArea';
 
 /**
@@ -38,6 +39,8 @@ interface IViewport {
   suppressEvents: boolean;
   /** if the viewport has been disabled */
   isDisabled: boolean;
+  /** The rendering state of this viewport */
+  viewportStatus: ViewportStatus;
   /** the rotation applied to the view */
   getRotation: () => number;
   /** frameOfReferenceUID the viewport's default actor is rendering */
@@ -88,6 +91,8 @@ interface IViewport {
   getCanvas(): HTMLCanvasElement;
   /** returns camera object */
   getCamera(): ICamera;
+  /** Sets the rendered state to rendered if the render actually showed image data */
+  setRendered(): void;
   /** returns the parallel zoom relative to the default (eg returns 1 after reset) */
   getZoom(): number;
   /** Sets the relative zoom - set to 1 to reset it */

package/src/types/index.ts

@@ -30,6 +30,7 @@ import type Plane from './Plane';
 import type IStreamingImageVolume from './IStreamingImageVolume';
 import type ViewportInputOptions from './ViewportInputOptions';
 import type IImageData from './IImageData';
+import type IImageCalibration from './IImageCalibration';
 import type CPUIImageData from './CPUIImageData';
 import type { CPUImageData } from './CPUIImageData';
 import type IImage from './IImage';
@@ -102,6 +103,7 @@ export type {
   IStreamingImageVolume,
   IImage,
   IImageData,
+  IImageCalibration,
   CPUIImageData,
   CPUImageData,
   EventTypes,

package/src/utilities/calibratedPixelSpacingMetadataProvider.ts

@@ -1,13 +1,7 @@
 import imageIdToURI from './imageIdToURI';
+import { IImageCalibration } from '../types';
 
-export type CalibratedPixelValue = {
-  rowPixelSpacing: number;
-  columnPixelSpacing: number;
-  // These values get updated by the viewport after the change to record the applied value
-  appliedSpacing?: CalibratedPixelValue;
-};
-
-const state: Record<string, CalibratedPixelValue> = {}; // Calibrated pixel spacing per imageId
+const state: Record<string, IImageCalibration> = {}; // Calibrated pixel spacing per imageId
 
 /**
  * Simple metadataProvider object to store metadata for calibrated spacings.
@@ -20,7 +14,7 @@ const metadataProvider = {
    * @param imageId - the imageId for the metadata to store
    * @param payload - the payload composed of new calibrated pixel spacings
    */
-  add: (imageId: string, payload: CalibratedPixelValue): void => {
+  add: (imageId: string, payload: IImageCalibration): void => {
     const imageURI = imageIdToURI(imageId);
     state[imageURI] = payload;
   },
@@ -31,7 +25,7 @@ const metadataProvider = {
    * @param imageId - the imageId to enquire about
    * @returns the calibrated pixel spacings for the imageId if it exists, otherwise undefined
    */
-  get: (type: string, imageId: string): CalibratedPixelValue => {
+  get: (type: string, imageId: string): IImageCalibration => {
     if (type === 'calibratedPixelSpacing') {
       const imageURI = imageIdToURI(imageId);
       return state[imageURI];

package/src/utilities/imageToWorldCoords.ts

@@ -23,12 +23,15 @@ export default function imageToWorldCoords(
 
   const {
     columnCosines,
-    columnPixelSpacing,
     rowCosines,
-    rowPixelSpacing,
     imagePositionPatient: origin,
   } = imagePlaneModule;
 
+  let { columnPixelSpacing, rowPixelSpacing } = imagePlaneModule;
+  // Use ||= to convert null and 0 as well as undefined to 1
+  columnPixelSpacing ||= 1;
+  rowPixelSpacing ||= 1;
+
   // calculate the image coordinates in the world space
   const imageCoordsInWorld = vec3.create();