@fideus-labs/fidnii 0.1.0 → 0.2.0

package/src/ViewportBounds.ts

@@ -1,9 +1,10 @@
 // SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
 // SPDX-License-Identifier: MIT
 
-import type { Niivue } from "@niivue/niivue";
-import { SLICE_TYPE } from "@niivue/niivue";
-import type { VolumeBounds } from "./types.js";
+import type { Niivue } from "@niivue/niivue"
+import { SLICE_TYPE } from "@niivue/niivue"
+
+import type { VolumeBounds } from "./types.js"
 
 /**
  * Intersect two axis-aligned bounding boxes.
@@ -17,12 +18,12 @@ export function intersectBounds(
     Math.max(a.min[0], b.min[0]),
     Math.max(a.min[1], b.min[1]),
     Math.max(a.min[2], b.min[2]),
-  ];
+  ]
   const max: [number, number, number] = [
     Math.min(a.max[0], b.max[0]),
     Math.min(a.max[1], b.max[1]),
     Math.min(a.max[2], b.max[2]),
-  ];
+  ]
   // Ensure valid bounds (max >= min)
   return {
     min: [
@@ -35,7 +36,7 @@ export function intersectBounds(
       Math.max(min[1], max[1]),
       Math.max(min[2], max[2]),
     ],
-  };
+  }
 }
 
 /**
@@ -56,40 +57,40 @@ export function computeViewportBounds3D(
   volumeBounds: VolumeBounds,
 ): VolumeBounds {
   // Get scene extents: [min, max, range]
-  const extents = nv.sceneExtentsMinMax(true);
-  const mn = extents[0]; // vec3
-  const mx = extents[1]; // vec3
-  const range = extents[2]; // vec3
+  const extents = nv.sceneExtentsMinMax(true)
+  const mn = extents[0] // vec3
+  const mx = extents[1] // vec3
+  const range = extents[2] // vec3
 
   // Pivot = center of scene
-  const pivotX = (mn[0] + mx[0]) * 0.5;
-  const pivotY = (mn[1] + mx[1]) * 0.5;
-  const pivotZ = (mn[2] + mx[2]) * 0.5;
+  const pivotX = (mn[0] + mx[0]) * 0.5
+  const pivotY = (mn[1] + mx[1]) * 0.5
+  const pivotZ = (mn[2] + mx[2]) * 0.5
 
   // furthestFromPivot = half-diagonal of bounding box
-  const furthest = Math.sqrt(
-    range[0] * range[0] + range[1] * range[1] + range[2] * range[2],
-  ) * 0.5;
+  const furthest =
+    Math.sqrt(range[0] * range[0] + range[1] * range[1] + range[2] * range[2]) *
+    0.5
 
   // NiiVue's orthographic scale (matches calculateMvpMatrix)
-  const scale = (0.8 * furthest) / (nv.scene.volScaleMultiplier || 1);
+  const scale = (0.8 * furthest) / (nv.scene.volScaleMultiplier || 1)
 
   // Canvas aspect ratio
-  const canvas = nv.canvas;
-  const canvasW = canvas?.width ?? 1;
-  const canvasH = canvas?.height ?? 1;
-  const whratio = canvasW / canvasH;
+  const canvas = nv.canvas
+  const canvasW = canvas?.width ?? 1
+  const canvasH = canvas?.height ?? 1
+  const whratio = canvasW / canvasH
 
   // Ortho extents in view space (before rotation)
-  let halfW: number, halfH: number;
+  let halfW: number, halfH: number
   if (whratio < 1) {
     // Portrait
-    halfW = scale;
-    halfH = scale / whratio;
+    halfW = scale
+    halfH = scale / whratio
   } else {
     // Landscape
-    halfW = scale * whratio;
-    halfH = scale;
+    halfW = scale * whratio
+    halfH = scale
   }
   // For viewport-aware resolution, we need the world-space extent that is
   // visible on screen. Rather than rotating a full 3D frustum box (whose depth
@@ -105,15 +106,15 @@ export function computeViewportBounds3D(
   // NiiVue applies: rotateX(270 - elevation) then rotateZ(azimuth - 180)
   // Also mirrors X (modelMatrix[0] = -1).
   // We need the inverse rotation to go from view space back to world space.
-  const azimuth = nv.scene.renderAzimuth ?? 0;
-  const elevation = nv.scene.renderElevation ?? 0;
-  const azRad = ((azimuth - 180) * Math.PI) / 180;
-  const elRad = ((270 - elevation) * Math.PI) / 180;
+  const azimuth = nv.scene.renderAzimuth ?? 0
+  const elevation = nv.scene.renderElevation ?? 0
+  const azRad = ((azimuth - 180) * Math.PI) / 180
+  const elRad = ((270 - elevation) * Math.PI) / 180
 
-  const cosAz = Math.cos(azRad);
-  const sinAz = Math.sin(azRad);
-  const cosEl = Math.cos(elRad);
-  const sinEl = Math.sin(elRad);
+  const cosAz = Math.cos(azRad)
+  const sinAz = Math.sin(azRad)
+  const cosEl = Math.cos(elRad)
+  const sinEl = Math.sin(elRad)
 
   // Compute inverse rotation of unit view-space axes to world space.
   // Inverse: un-mirror X, then rotateZ(-azRad), then rotateX(-elRad).
@@ -123,28 +124,29 @@ export function computeViewportBounds3D(
     -cosAz, // wx
     sinAz * cosEl, // wy
     -sinAz * sinEl, // wz
-  ];
+  ]
   // View Y axis (0, 1, 0) — no mirror effect
   const viewYinWorld: [number, number, number] = [
     sinAz, // wx
     cosAz * cosEl, // wy
     -cosAz * sinEl, // wz
-  ];
+  ]
   // View Z axis (0, 0, 1) — no mirror effect
   const viewZinWorld: [number, number, number] = [
     0, // wx
     sinEl, // wy
     cosEl, // wz
-  ];
+  ]
 
   // For each world axis, the visible half-extent is:
   //   halfW * |viewXinWorld[axis]| + halfH * |viewYinWorld[axis]|
   //   + furthest * |viewZinWorld[axis]|  (full volume depth along view Z)
-  const worldHalfExtent: [number, number, number] = [0, 0, 0];
+  const worldHalfExtent: [number, number, number] = [0, 0, 0]
   for (let axis = 0; axis < 3; axis++) {
-    worldHalfExtent[axis] = halfW * Math.abs(viewXinWorld[axis]) +
+    worldHalfExtent[axis] =
+      halfW * Math.abs(viewXinWorld[axis]) +
       halfH * Math.abs(viewYinWorld[axis]) +
-      furthest * Math.abs(viewZinWorld[axis]);
+      furthest * Math.abs(viewZinWorld[axis])
   }
 
   const frustumBounds: VolumeBounds = {
@@ -158,9 +160,9 @@ export function computeViewportBounds3D(
       pivotY + worldHalfExtent[1],
       pivotZ + worldHalfExtent[2],
     ],
-  };
+  }
 
-  return intersectBounds(frustumBounds, volumeBounds);
+  return intersectBounds(frustumBounds, volumeBounds)
 }
 
 /**
@@ -203,97 +205,97 @@ export function computeViewportBounds2D(
     volumeBounds.min[0] * normalizationScale,
     volumeBounds.min[1] * normalizationScale,
     volumeBounds.min[2] * normalizationScale,
-  ];
+  ]
   const normMax: [number, number, number] = [
     volumeBounds.max[0] * normalizationScale,
     volumeBounds.max[1] * normalizationScale,
     volumeBounds.max[2] * normalizationScale,
-  ];
+  ]
 
   // Swizzle to screen axes (same mapping as NiiVue's swizzleVec3MM):
   //   AXIAL:    screen X = mm X, screen Y = mm Y
   //   CORONAL:  screen X = mm X, screen Y = mm Z
   //   SAGITTAL: screen X = mm Y, screen Y = mm Z
-  let mnMM0: number, mxMM0: number, mnMM1: number, mxMM1: number;
+  let mnMM0: number, mxMM0: number, mnMM1: number, mxMM1: number
   switch (sliceType) {
     case SLICE_TYPE.CORONAL:
-      mnMM0 = normMin[0];
-      mxMM0 = normMax[0]; // screen X = mm X
-      mnMM1 = normMin[2];
-      mxMM1 = normMax[2]; // screen Y = mm Z
-      break;
+      mnMM0 = normMin[0]
+      mxMM0 = normMax[0] // screen X = mm X
+      mnMM1 = normMin[2]
+      mxMM1 = normMax[2] // screen Y = mm Z
+      break
     case SLICE_TYPE.SAGITTAL:
-      mnMM0 = normMin[1];
-      mxMM0 = normMax[1]; // screen X = mm Y
-      mnMM1 = normMin[2];
-      mxMM1 = normMax[2]; // screen Y = mm Z
-      break;
+      mnMM0 = normMin[1]
+      mxMM0 = normMax[1] // screen X = mm Y
+      mnMM1 = normMin[2]
+      mxMM1 = normMax[2] // screen Y = mm Z
+      break
     default: // AXIAL
-      mnMM0 = normMin[0];
-      mxMM0 = normMax[0]; // screen X = mm X
-      mnMM1 = normMin[1];
-      mxMM1 = normMax[1]; // screen Y = mm Y
-      break;
+      mnMM0 = normMin[0]
+      mxMM0 = normMax[0] // screen X = mm X
+      mnMM1 = normMin[1]
+      mxMM1 = normMax[1] // screen Y = mm Y
+      break
   }
 
   // Account for canvas aspect ratio stretching (matches draw2DMain logic)
   // NiiVue stretches the FOV to fill the canvas while preserving aspect ratio
-  const canvas = nv.canvas;
+  const canvas = nv.canvas
   if (canvas) {
-    const canvasW = canvas.width || 1;
-    const canvasH = canvas.height || 1;
-    const fovW = Math.abs(mxMM0 - mnMM0);
-    const fovH = Math.abs(mxMM1 - mnMM1);
+    const canvasW = canvas.width || 1
+    const canvasH = canvas.height || 1
+    const fovW = Math.abs(mxMM0 - mnMM0)
+    const fovH = Math.abs(mxMM1 - mnMM1)
     if (fovW > 0 && fovH > 0) {
-      const canvasAspect = canvasW / canvasH;
-      const fovAspect = fovW / fovH;
+      const canvasAspect = canvasW / canvasH
+      const fovAspect = fovW / fovH
       if (canvasAspect > fovAspect) {
         // Canvas is wider than FOV: expand X
-        const midX = (mnMM0 + mxMM0) * 0.5;
-        const newHalfW = (fovH * canvasAspect) * 0.5;
-        mnMM0 = midX - newHalfW;
-        mxMM0 = midX + newHalfW;
+        const midX = (mnMM0 + mxMM0) * 0.5
+        const newHalfW = fovH * canvasAspect * 0.5
+        mnMM0 = midX - newHalfW
+        mxMM0 = midX + newHalfW
       } else {
         // Canvas is taller than FOV: expand Y
-        const midY = (mnMM1 + mxMM1) * 0.5;
-        const newHalfH = (fovW / canvasAspect) * 0.5;
-        mnMM1 = midY - newHalfH;
-        mxMM1 = midY + newHalfH;
+        const midY = (mnMM1 + mxMM1) * 0.5
+        const newHalfH = (fovW / canvasAspect) * 0.5
+        mnMM1 = midY - newHalfH
+        mxMM1 = midY + newHalfH
       }
     }
   }
 
   // Apply pan and zoom (matching NiiVue's draw2DMain logic)
-  const pan = nv.scene.pan2Dxyzmm; // vec4: [panX, panY, panZ, zoom]
+  const pan = nv.scene.pan2Dxyzmm // vec4: [panX, panY, panZ, zoom]
   // Swizzle the pan vector to match the current orientation
   const panSwizzled = nv.swizzleVec3MM(
     [pan[0], pan[1], pan[2]] as unknown as import("gl-matrix").vec3,
     sliceType,
-  );
-  const zoom = pan[3] || 1;
+  )
+  const zoom = pan[3] || 1
 
   // Apply pan: shift visible window
-  mnMM0 -= panSwizzled[0];
-  mxMM0 -= panSwizzled[0];
-  mnMM1 -= panSwizzled[1];
-  mxMM1 -= panSwizzled[1];
+  mnMM0 -= panSwizzled[0]
+  mxMM0 -= panSwizzled[0]
+  mnMM1 -= panSwizzled[1]
+  mxMM1 -= panSwizzled[1]
 
   // Apply zoom: divide by zoom factor (zoom > 1 = zoomed in = smaller FOV)
-  mnMM0 /= zoom;
-  mxMM0 /= zoom;
-  mnMM1 /= zoom;
-  mxMM1 /= zoom;
+  mnMM0 /= zoom
+  mxMM0 /= zoom
+  mnMM1 /= zoom
+  mxMM1 /= zoom
 
   // Convert from NiiVue's mm space back to physical world coordinates.
   // If the slab affine was normalized (multiplied by normalizationScale),
   // NiiVue's mm values are world * normalizationScale. Dividing by the
   // normalization scale recovers physical coordinates.
   if (normalizationScale !== 1.0 && normalizationScale > 0) {
-    const invNorm = 1.0 / normalizationScale;
-    mnMM0 *= invNorm;
-    mxMM0 *= invNorm;
-    mnMM1 *= invNorm;
-    mxMM1 *= invNorm;
+    const invNorm = 1.0 / normalizationScale
+    mnMM0 *= invNorm
+    mxMM0 *= invNorm
+    mnMM1 *= invNorm
+    mxMM1 *= invNorm
   }
 
   // Now un-swizzle back to RAS world coordinates.
@@ -306,42 +308,42 @@ export function computeViewportBounds2D(
   const result: VolumeBounds = {
     min: [...volumeBounds.min],
     max: [...volumeBounds.max],
-  };
+  }
 
   // Ensure min < max for each swizzled axis
-  const visMin0 = Math.min(mnMM0, mxMM0);
-  const visMax0 = Math.max(mnMM0, mxMM0);
-  const visMin1 = Math.min(mnMM1, mxMM1);
-  const visMax1 = Math.max(mnMM1, mxMM1);
+  const visMin0 = Math.min(mnMM0, mxMM0)
+  const visMax0 = Math.max(mnMM0, mxMM0)
+  const visMin1 = Math.min(mnMM1, mxMM1)
+  const visMax1 = Math.max(mnMM1, mxMM1)
 
   switch (sliceType) {
     case SLICE_TYPE.AXIAL:
       // screen X = world X (R/L), screen Y = world Y (A/P)
-      result.min[0] = visMin0;
-      result.max[0] = visMax0;
-      result.min[1] = visMin1;
-      result.max[1] = visMax1;
+      result.min[0] = visMin0
+      result.max[0] = visMax0
+      result.min[1] = visMin1
+      result.max[1] = visMax1
       // Z (S/I) = full extent (orthogonal axis)
-      break;
+      break
     case SLICE_TYPE.CORONAL:
       // screen X = world X (R/L), screen Y = world Z (S/I)
-      result.min[0] = visMin0;
-      result.max[0] = visMax0;
-      result.min[2] = visMin1;
-      result.max[2] = visMax1;
+      result.min[0] = visMin0
+      result.max[0] = visMax0
+      result.min[2] = visMin1
+      result.max[2] = visMax1
       // Y (A/P) = full extent (orthogonal axis)
-      break;
+      break
     case SLICE_TYPE.SAGITTAL:
       // screen X = world Y (A/P), screen Y = world Z (S/I)
-      result.min[1] = visMin0;
-      result.max[1] = visMax0;
-      result.min[2] = visMin1;
-      result.max[2] = visMax1;
+      result.min[1] = visMin0
+      result.max[1] = visMax0
+      result.min[2] = visMin1
+      result.max[2] = visMax1
       // X (R/L) = full extent (orthogonal axis)
-      break;
+      break
   }
 
-  return intersectBounds(result, volumeBounds);
+  return intersectBounds(result, volumeBounds)
 }
 
 /**
@@ -358,12 +360,12 @@ export function boundsApproxEqual(
   tolerance: number = 0.01,
 ): boolean {
   for (let i = 0; i < 3; i++) {
-    const rangeA = a.max[i] - a.min[i];
-    const rangeB = b.max[i] - b.min[i];
-    const maxRange = Math.max(Math.abs(rangeA), Math.abs(rangeB), 1e-10);
+    const rangeA = a.max[i] - a.min[i]
+    const rangeB = b.max[i] - b.min[i]
+    const maxRange = Math.max(Math.abs(rangeA), Math.abs(rangeB), 1e-10)
 
-    if (Math.abs(a.min[i] - b.min[i]) / maxRange > tolerance) return false;
-    if (Math.abs(a.max[i] - b.max[i]) / maxRange > tolerance) return false;
+    if (Math.abs(a.min[i] - b.min[i]) / maxRange > tolerance) return false
+    if (Math.abs(a.max[i] - b.max[i]) / maxRange > tolerance) return false
   }
-  return true;
+  return true
 }

package/src/events.ts

@@ -1,8 +1,9 @@
 // SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
 // SPDX-License-Identifier: MIT
 
-import type { SLICE_TYPE } from "@niivue/niivue";
-import type { ClipPlanes } from "./types.js";
+import type { SLICE_TYPE } from "@niivue/niivue"
+
+import type { ClipPlanes } from "./types.js"
 
 /**
  * Identifies what triggered a volume population.
@@ -12,7 +13,7 @@ export type PopulateTrigger =
   | "initial" // First load or reload with new settings
   | "clipPlanesChanged" // Clip planes were modified
   | "sliceChanged" // Slice position changed (slab reload)
-  | "viewportChanged"; // Viewport pan/zoom/rotation changed
+  | "viewportChanged" // Viewport pan/zoom/rotation changed
 
 /**
  * Type-safe event map for OMEZarrNVImage events.
@@ -43,15 +44,15 @@ export type PopulateTrigger =
 export interface OMEZarrNVImageEventMap {
   /** Fired when loading starts for a resolution level */
   loadingStart: {
-    levelIndex: number;
-    trigger: PopulateTrigger;
-  };
+    levelIndex: number
+    trigger: PopulateTrigger
+  }
 
   /** Fired when loading completes for a resolution level */
   loadingComplete: {
-    levelIndex: number;
-    trigger: PopulateTrigger;
-  };
+    levelIndex: number
+    trigger: PopulateTrigger
+  }
 
   /**
    * Fired when resolution level changes.
@@ -59,27 +60,27 @@ export interface OMEZarrNVImageEventMap {
    * cause a resolution change.
    */
   resolutionChange: {
-    currentLevel: number;
-    targetLevel: number;
-    previousLevel: number;
-    trigger: PopulateTrigger;
-  };
+    currentLevel: number
+    targetLevel: number
+    previousLevel: number
+    trigger: PopulateTrigger
+  }
 
   /**
    * Fired when clip planes are updated (after debounce).
    * This is emitted after the debounce delay, not on every slider movement.
    */
-  clipPlanesChange: { clipPlanes: ClipPlanes };
+  clipPlanesChange: { clipPlanes: ClipPlanes }
 
   /**
    * Fired when populateVolume() completes and no more requests are queued.
    * This is the final event after all loading is done.
    */
   populateComplete: {
-    currentLevel: number;
-    targetLevel: number;
-    trigger: PopulateTrigger;
-  };
+    currentLevel: number
+    targetLevel: number
+    trigger: PopulateTrigger
+  }
 
   /**
    * Fired when a queued load request is replaced by a newer one.
@@ -87,30 +88,30 @@ export interface OMEZarrNVImageEventMap {
    * the first request is queued.
    */
   loadingSkipped: {
-    reason: "queued-replaced";
-    trigger: PopulateTrigger;
-  };
+    reason: "queued-replaced"
+    trigger: PopulateTrigger
+  }
 
   /**
    * Fired when a slab (2D slice buffer) finishes loading.
    * This event is specific to slab-based loading for 2D slice views.
    */
   slabLoadingComplete: {
-    sliceType: SLICE_TYPE;
-    levelIndex: number;
-    slabStart: number;
-    slabEnd: number;
-    trigger: PopulateTrigger;
-  };
+    sliceType: SLICE_TYPE
+    levelIndex: number
+    slabStart: number
+    slabEnd: number
+    trigger: PopulateTrigger
+  }
 
   /**
    * Fired when a slab starts loading.
    */
   slabLoadingStart: {
-    sliceType: SLICE_TYPE;
-    levelIndex: number;
-    trigger: PopulateTrigger;
-  };
+    sliceType: SLICE_TYPE
+    levelIndex: number
+    trigger: PopulateTrigger
+  }
 }
 
 /**
@@ -121,7 +122,7 @@ export class OMEZarrNVImageEvent<
   K extends keyof OMEZarrNVImageEventMap,
 > extends CustomEvent<OMEZarrNVImageEventMap[K]> {
   constructor(type: K, detail: OMEZarrNVImageEventMap[K]) {
-    super(type, { detail });
+    super(type, { detail })
   }
 }
 
@@ -131,7 +132,7 @@ export class OMEZarrNVImageEvent<
  */
 export type OMEZarrNVImageEventListener<
   K extends keyof OMEZarrNVImageEventMap,
-> = (event: OMEZarrNVImageEvent<K>) => void | Promise<void>;
+> = (event: OMEZarrNVImageEvent<K>) => void | Promise<void>
 
 /**
  * Options for addEventListener/removeEventListener.
@@ -143,4 +144,4 @@ export type OMEZarrNVImageEventListener<
  */
 export type OMEZarrNVImageEventListenerOptions =
   | boolean
-  | AddEventListenerOptions;
+  | AddEventListenerOptions