fix: more generic viewport push for parity with legacy (#2766)

Author: sedghi

packages/core/src/RenderingEngine/ContextPoolRenderingEngine.ts

@@ -25,6 +25,7 @@ import type {
   VtkOffscreenMultiRenderWindow,
 } from '../types';
 import { getViewportClassForInput } from './helpers/viewportTypeToViewportClass';
+import { isGenericViewport } from '../utilities/viewportCapabilities';
 
 /**
  * ContextPoolRenderingEngine extends BaseRenderingEngine to provide parallel rendering
@@ -198,6 +199,31 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine {
     }
   }
 
+  /**
+   * Returns the displayed size (in device pixels) of a viewport's container.
+   *
+   * For native Generic ("next") viewports the on-screen canvas returned by
+   * getOrCreateCanvas (the .cornerstone-canvas / VTK target) can report
+   * clientWidth/Height === 0 when the CPU render path is active and that canvas
+   * is hidden in favor of the CPU canvas. Measuring from the viewport element
+   * instead always reflects the real container size, so native viewports are
+   * detected on container resize and their resize() (which refits the active
+   * CPU/VTK canvas) actually runs. Legacy viewports keep measuring their canvas.
+   */
+  private _getDisplayedSize(vp: IViewport): {
+    displayedWidth: number;
+    displayedHeight: number;
+  } {
+    const devicePixelRatio = window.devicePixelRatio || 1;
+    const sizeSource = isGenericViewport(vp)
+      ? vp.element
+      : getOrCreateCanvas(vp.element);
+    return {
+      displayedWidth: Math.round(sizeSource.clientWidth * devicePixelRatio),
+      displayedHeight: Math.round(sizeSource.clientHeight * devicePixelRatio),
+    };
+  }
+
   /**
    * Resizes viewports that use VTK.js for rendering.
    * Only updates the VTK offscreen size when the displayed size (canvas client size in device pixels)
@@ -211,16 +237,11 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine {
     keepCamera = true,
     immediate = true
   ) {
-    const devicePixelRatio = window.devicePixelRatio || 1;
-
     // Compute target display size (pixels the canvas is actually displayed at) for each viewport
     const viewportsNeedingResize: (IStackViewport | IVolumeViewport)[] = [];
     for (const vp of vtkDrivenViewports) {
       const canvas = getOrCreateCanvas(vp.element);
-      const displayedWidth = Math.round(canvas.clientWidth * devicePixelRatio);
-      const displayedHeight = Math.round(
-        canvas.clientHeight * devicePixelRatio
-      );
+      const { displayedWidth, displayedHeight } = this._getDisplayedSize(vp);
 
       if (displayedWidth === 0 || displayedHeight === 0) {
         continue;
@@ -242,11 +263,7 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine {
     }
 
     for (const vp of viewportsNeedingResize) {
-      const canvas = getOrCreateCanvas(vp.element);
-      const displayedWidth = Math.round(canvas.clientWidth * devicePixelRatio);
-      const displayedHeight = Math.round(
-        canvas.clientHeight * devicePixelRatio
-      );
+      const { displayedWidth, displayedHeight } = this._getDisplayedSize(vp);
       const targetWidth = Math.max(VIEWPORT_MIN_SIZE, displayedWidth);
       const targetHeight = Math.max(VIEWPORT_MIN_SIZE, displayedHeight);
 
@@ -265,6 +282,14 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine {
     vtkDrivenViewports.forEach((vp) => {
       vp.resize?.();
 
+      if (isGenericViewport(vp)) {
+        // Generic ("next") viewports (PlanarViewport / PLANAR_NEXT) refit
+        // inside their own resize() (recompute fitScale + reapply presentation
+        // with scaleMode 'fit') and do NOT expose the legacy getCamera/setCamera/
+        // setViewPresentation surface. Skip the legacy snapshot/restore dance.
+        return;
+      }
+
       const prevCamera = vp.getCamera();
       const rotation = vp.getRotation?.() ?? 0;
       const { flipHorizontal } = prevCamera;

packages/core/src/RenderingEngine/GenericViewport/GenericViewport.ts

@@ -1,9 +1,11 @@
 import type * as EventTypes from '../../types/EventTypes';
 import type ICamera from '../../types/ICamera';
-import type { Point2, Point3 } from '../../types';
+import type { Point2, Point3, ViewportContentMode } from '../../types';
 import Events from '../../enums/Events';
 import ViewportStatus from '../../enums/ViewportStatus';
 import triggerEvent from '../../utilities/triggerEvent';
+import renderingEngineCache from '../renderingEngineCache';
+import type { IRenderingEngine } from '../../types';
 import type {
   BaseViewportRenderContext,
   BindingRole,
@@ -210,6 +212,22 @@ abstract class GenericViewport<
     return this.getDataPresentationState(displaySetId);
   }
 
+  /**
+   * Content-true classification of the currently bound source data.
+   *
+   * The duck-typing capability guards (`viewportSupportsImageSlices`,
+   * `viewportSupportsVolumeId`, ...) report which methods a viewport exposes,
+   * not what it is showing, so a single generic viewport reports support for
+   * both stack and volume operations regardless of its bound content. This
+   * method answers the content question instead, derived from the mounted
+   * source binding. The base implementation only distinguishes "has bound data"
+   * from "empty"; concrete viewport families override it to report `stack`,
+   * `volume`, `volume3d`, etc. See {@link ViewportContentMode}.
+   */
+  getCurrentMode(): ViewportContentMode {
+    return this.getSourceBinding() ? 'unknown' : 'empty';
+  }
+
   /**
    * Returns a spatial reference for the current viewport state.
    */
@@ -260,6 +278,16 @@ abstract class GenericViewport<
     );
   }
 
+  /**
+   * Returns the rendering engine that owns this viewport. Tools and utilities
+   * rely on this method existing on every viewport (legacy Viewport provides
+   * it); without it, calls like `viewport.getRenderingEngine()` threw on native
+   * generic viewports.
+   */
+  getRenderingEngine(): IRenderingEngine {
+    return renderingEngineCache.get(this.renderingEngineId);
+  }
+
   // ====================================================================
   // Public API -- coordinate transforms
   // ====================================================================
@@ -647,9 +675,30 @@ abstract class GenericViewport<
 
     this.setDataPresentationState(displaySetId, nextPresentation);
 
+    // Notify only when the change targets a mounted dataset so that listeners
+    // (VOI/colormap UI, synchronizers) react to applied presentation changes.
+    if (this.bindings.has(displaySetId)) {
+      this.notifyDataPresentationModified(displaySetId, props);
+    }
+
     return nextPresentation;
   }
 
+  /**
+   * Hook invoked after a per-display-set presentation update is applied through
+   * the public `setDisplaySetPresentation` path and the target display set is
+   * mounted. Concrete viewport families override this to emit their
+   * presentation-modified events (e.g. `VOI_MODIFIED`, `COLORMAP_MODIFIED`) so
+   * application UI and synchronizers can react to programmatic and tool-driven
+   * presentation changes. The base implementation is intentionally a no-op.
+   */
+  protected notifyDataPresentationModified(
+    _displaySetId: DisplaySetId,
+    _props: Partial<TDataPresentation>
+  ): void {
+    // Subclasses emit presentation-modified events; base viewports do not.
+  }
+
   // ====================================================================
   // Protected -- view state
   // ====================================================================
@@ -765,6 +814,22 @@ abstract class GenericViewport<
     return this.bindings.values().next().value;
   }
 
+  /**
+   * Returns the active source binding (the dataset that defines the view),
+   * falling back to the first mounted binding when no explicit `source` role is
+   * present. Used for content-mode classification and source-scoped queries.
+   */
+  protected getSourceBinding():
+    | ViewportDataBinding<TDataPresentation>
+    | undefined {
+    for (const binding of this.bindings.values()) {
+      if (binding.role === 'source') {
+        return binding;
+      }
+    }
+    return this.getFirstBinding();
+  }
+
   /**
    * Returns the binding used for generic transform and frame-of-reference
    * queries when a viewport family does not override the selection logic.

packages/core/src/RenderingEngine/GenericViewport/Planar/CpuImageSliceRenderPath.ts

@@ -78,6 +78,7 @@ export class CpuImageSliceRenderPath
     ctx.display.activateRenderMode(ActorRenderMode.CPU_IMAGE);
 
     let rendering: PlanarCpuImageRendering;
+    markCpuImagePreScaled(payload.image);
     const compatibilityActor = new CanvasActor(
       {
         getImageData: () => this.getImageData(rendering),
@@ -107,7 +108,7 @@ export class CpuImageSliceRenderPath
       actorEntryUID: uuidv4(),
       enabledElement,
       compatibilityActor,
-      currentImageIdIndex: payload.initialImageIdIndex,
+      currentImageIdIndex: payload.initialImageIdIndex ?? 0,
       defaultVOIRange: getDefaultImageVOIRange(payload.image),
       dataPresentation: undefined,
       fitScale: getCPUFallbackScalarScale(enabledElement.viewport.scale),
@@ -117,7 +118,7 @@ export class CpuImageSliceRenderPath
 
     triggerPlanarNewImage(ctx, {
       image: payload.image,
-      imageIdIndex: payload.initialImageIdIndex,
+      imageIdIndex: payload.initialImageIdIndex ?? 0,
     });
 
     return {
@@ -576,13 +577,38 @@ function worldToCPUImageDrawPoint(
   ];
 }
 
+/**
+ * Mirror legacy StackViewport._setCSImage: when the cached image's pixel data is
+ * already pre-scaled (modality rescale baked in), flag it so the CPUFallback
+ * renderer skips the modality LUT. Without this the renderer
+ * (generateLut/getDefaultViewport/renderGrayscaleImage all branch on
+ * image.isPreScaled) re-applies slope/intercept on top of already-scaled data,
+ * shifting every pixel down by the rescale intercept — e.g. a CT renders far too
+ * dark, with only the densest bone surviving the window.
+ */
+function markCpuImagePreScaled(image: IImage): void {
+  image.isPreScaled = image.preScale?.scaled;
+}
+
 export function buildPlanarImageData(
   image: IImage,
   frameOfReferenceUID?: string
 ): CPUIImageData {
   const metadata = getImageDataMetadata(image);
-  const { calibration, dimensions, direction, modality, origin, spacing } =
-    metadata;
+  const { dimensions, direction, modality, origin, spacing } = metadata;
+  // getImageDataMetadata().calibration is the DICOM calibration module; the USER
+  // calibration (CalibrationLine -> calibratedPixelSpacing provider) is stored
+  // separately, so merge it on top — mirroring legacy StackViewport.getImageData()
+  // (`calibration: { ...csImage.calibration, ...this.calibration }`). Without this,
+  // native getImageData().calibration ignores user calibration and length tools never
+  // rescale after calibrateImageSpacing().
+  const userCalibration = metaData.get(
+    'calibratedPixelSpacing',
+    image.imageId
+  ) as Record<string, unknown> | undefined;
+  const calibration = userCalibration
+    ? { ...metadata.calibration, ...userCalibration }
+    : metadata.calibration;
   const rowVector = direction.slice(0, 3) as Point3;
   const columnVector = direction.slice(3, 6) as Point3;
   const scalarData =
@@ -681,6 +707,7 @@ async function updateRenderedImage(args: {
 }): Promise<void> {
   const { ctx, dataId, image, imageIdIndex, props, rendering } = args;
   const enabledElement = rendering.enabledElement;
+  markCpuImagePreScaled(image);
   const camera = ctx.viewport.getViewState();
   const defaultViewport = getDefaultViewport(ctx.cpu.canvas, image);
   const previousViewport = enabledElement.viewport;

packages/core/src/RenderingEngine/GenericViewport/Planar/CpuVolumeSliceRenderPath.ts

@@ -84,7 +84,7 @@ export class CpuVolumeSliceRenderPath
         ctx.cpu.canvas.width,
         ctx.cpu.canvas.height
       ),
-      currentImageIdIndex: payload.initialImageIdIndex,
+      currentImageIdIndex: payload.initialImageIdIndex ?? 0,
       maxImageIdIndex: payload.imageIds.length - 1,
       defaultVOIRange,
       renderingInvalidated: true,
@@ -219,6 +219,7 @@ export class CpuVolumeSliceRenderPath
       acquisitionOrientation: rendering.acquisitionOrientation,
       imageIds: rendering.imageIds,
       imageIdIndex: rendering.currentImageIdIndex,
+      maxImageIdIndex: rendering.maxImageIdIndex,
     });
 
     return {
@@ -538,6 +539,7 @@ export class CpuVolumeSliceRenderPath
         acquisitionOrientation: rendering.acquisitionOrientation,
         imageIds: rendering.imageIds,
         imageIdIndex: rendering.currentImageIdIndex,
+        maxImageIdIndex: rendering.maxImageIdIndex,
       });
     }
   }

packages/core/src/RenderingEngine/GenericViewport/Planar/DefaultPlanarDataProvider.ts

@@ -34,10 +34,18 @@ export class DefaultPlanarDataProvider implements PlanarDataProvider {
       throw new Error('[PlanarViewport] Cannot load an empty planar dataset');
     }
 
+    // A concrete, clamped index is always needed to load a single image below.
     const clampedImageIdIndex = Math.min(
       Math.max(0, dataSet.initialImageIdIndex ?? 0),
       dataSet.imageIds.length - 1
     );
+    // But preserve "no slice requested" (undefined) in the payload so the volume
+    // acquisition view can center instead of pinning to slice 0; an explicit
+    // index (including 0) is clamped and honored downstream.
+    const initialImageIdIndex =
+      dataSet.initialImageIdIndex === undefined
+        ? undefined
+        : clampedImageIdIndex;
 
     if (
       options.renderMode === ActorRenderMode.VTK_VOLUME_SLICE ||
@@ -56,7 +64,7 @@ export class DefaultPlanarDataProvider implements PlanarDataProvider {
         id: dataId,
         type: 'image',
         imageIds,
-        initialImageIdIndex: clampedImageIdIndex,
+        initialImageIdIndex,
         acquisitionOrientation: options.acquisitionOrientation,
         imageData: dataSet.imageData,
         imageVolume,
@@ -79,7 +87,7 @@ export class DefaultPlanarDataProvider implements PlanarDataProvider {
       imageIds: dataSet.imageIds,
       image,
       imageData: dataSet.imageData,
-      initialImageIdIndex: clampedImageIdIndex,
+      initialImageIdIndex,
       acquisitionOrientation: options.acquisitionOrientation,
       reference: dataSet.reference,
       renderMode: options.renderMode,