@fideus-labs/fidnii 0.1.0 → 0.2.0

package/src/RegionCoalescer.ts

@@ -1,28 +1,29 @@
 // SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
 // SPDX-License-Identifier: MIT
 
-import * as zarr from "zarrita";
-import type { NgffImage } from "@fideus-labs/ngff-zarr";
-import { zarrGet } from "@fideus-labs/ngff-zarr/browser";
+import type { NgffImage } from "@fideus-labs/ngff-zarr"
+import { zarrGet } from "@fideus-labs/ngff-zarr/browser"
+import * as zarr from "zarrita"
+
 import type {
   ChunkCache,
   PixelRegion,
   RegionFetchResult,
   TypedArray,
-} from "./types.js";
+} from "./types.js"
 
 /**
  * Represents a pending request that may have multiple consumers waiting for the result.
  */
 interface PendingRequest {
   /** The promise that resolves when the request completes */
-  promise: Promise<RegionFetchResult>;
+  promise: Promise<RegionFetchResult>
   /** Function to resolve the promise with the result */
-  resolve: (data: RegionFetchResult) => void;
+  resolve: (data: RegionFetchResult) => void
   /** Function to reject the promise with an error */
-  reject: (error: Error) => void;
+  reject: (error: Error) => void
   /** Set of requester IDs waiting for this result */
-  requesters: Set<string>;
+  requesters: Set<string>
 }
 
 /**
@@ -40,10 +41,10 @@ interface PendingRequest {
  * overlapping region requests simultaneously.
  */
 export class RegionCoalescer {
-  private readonly pending: Map<string, PendingRequest> = new Map();
+  private readonly pending: Map<string, PendingRequest> = new Map()
 
   /** Optional decoded-chunk cache forwarded to fizarrita's getWorker. */
-  private readonly _cache: ChunkCache | undefined;
+  private readonly _cache: ChunkCache | undefined
 
   /**
    * @param cache - Optional decoded-chunk cache. When provided, `zarrGet`
@@ -51,7 +52,7 @@ export class RegionCoalescer {
    *   or overlapping reads.
    */
   constructor(cache?: ChunkCache) {
-    this._cache = cache;
+    this._cache = cache
   }
 
   /**
@@ -62,9 +63,9 @@ export class RegionCoalescer {
     levelIndex: number,
     region: PixelRegion,
   ): string {
-    const start = region.start.join(",");
-    const end = region.end.join(",");
-    return `${imagePath}:${levelIndex}:${start}:${end}`;
+    const start = region.start.join(",")
+    const end = region.end.join(",")
+    return `${imagePath}:${levelIndex}:${start}:${end}`
   }
 
   /**
@@ -82,33 +83,33 @@ export class RegionCoalescer {
     region: PixelRegion,
     requesterId: string = "default",
   ): Promise<RegionFetchResult> {
-    const key = this.makeKey(ngffImage.data.path, levelIndex, region);
+    const key = this.makeKey(ngffImage.data.path, levelIndex, region)
 
     // Check if there's already a pending request for this data
-    const existing = this.pending.get(key);
+    const existing = this.pending.get(key)
     if (existing) {
       // Add this requester to the waiters and return the existing promise
-      existing.requesters.add(requesterId);
-      return existing.promise;
+      existing.requesters.add(requesterId)
+      return existing.promise
     }
 
     // Create a new pending request
-    let resolvePromise!: (data: RegionFetchResult) => void;
-    let rejectPromise!: (error: Error) => void;
+    let resolvePromise!: (data: RegionFetchResult) => void
+    let rejectPromise!: (error: Error) => void
 
     const promise = new Promise<RegionFetchResult>((resolve, reject) => {
-      resolvePromise = resolve;
-      rejectPromise = reject;
-    });
+      resolvePromise = resolve
+      rejectPromise = reject
+    })
 
     const pendingRequest: PendingRequest = {
       promise,
       resolve: resolvePromise,
       reject: rejectPromise,
       requesters: new Set([requesterId]),
-    };
+    }
 
-    this.pending.set(key, pendingRequest);
+    this.pending.set(key, pendingRequest)
 
     // Fetch using fizarrita's worker-accelerated zarrGet
     try {
@@ -116,28 +117,28 @@ export class RegionCoalescer {
         zarr.slice(region.start[0], region.end[0]),
         zarr.slice(region.start[1], region.end[1]),
         zarr.slice(region.start[2], region.end[2]),
-      ];
+      ]
       // Pass the chunk cache to fizarrita's getWorker via zarrGet.
       // The `cache` option is available in @fideus-labs/fizarrita >=1.2.0.
       const zarrOpts = this._cache
-        ? { cache: this._cache } as Record<string, unknown>
-        : undefined;
-      const result = await zarrGet(ngffImage.data, selection, zarrOpts);
+        ? ({ cache: this._cache } as Record<string, unknown>)
+        : undefined
+      const result = await zarrGet(ngffImage.data, selection, zarrOpts)
 
       const fetchResult: RegionFetchResult = {
         data: result.data as TypedArray,
         shape: result.shape,
         stride: result.stride,
-      };
+      }
 
-      pendingRequest.resolve(fetchResult);
-      return fetchResult;
+      pendingRequest.resolve(fetchResult)
+      return fetchResult
     } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      pendingRequest.reject(err);
-      throw err;
+      const err = error instanceof Error ? error : new Error(String(error))
+      pendingRequest.reject(err)
+      throw err
     } finally {
-      this.pending.delete(key);
+      this.pending.delete(key)
     }
   }
 
@@ -159,9 +160,9 @@ export class RegionCoalescer {
   ): Promise<RegionFetchResult[]> {
     return Promise.all(
       regions.map((region) =>
-        this.fetchRegion(ngffImage, levelIndex, region, requesterId)
+        this.fetchRegion(ngffImage, levelIndex, region, requesterId),
       ),
-    );
+    )
   }
 
   /**
@@ -172,8 +173,8 @@ export class RegionCoalescer {
     levelIndex: number,
     region: PixelRegion,
   ): boolean {
-    const key = this.makeKey(ngffImage.data.path, levelIndex, region);
-    return this.pending.has(key);
+    const key = this.makeKey(ngffImage.data.path, levelIndex, region)
+    return this.pending.has(key)
   }
 
   /**
@@ -185,8 +186,8 @@ export class RegionCoalescer {
     levelIndex: number,
     region: PixelRegion,
   ): Set<string> | undefined {
-    const key = this.makeKey(ngffImage.data.path, levelIndex, region);
-    return this.pending.get(key)?.requesters;
+    const key = this.makeKey(ngffImage.data.path, levelIndex, region)
+    return this.pending.get(key)?.requesters
   }
 
   /**
@@ -195,16 +196,16 @@ export class RegionCoalescer {
   async onIdle(): Promise<void> {
     // Wait for all in-flight requests to settle
     const promises = Array.from(this.pending.values()).map((p) =>
-      p.promise.catch(() => {})
-    );
-    await Promise.all(promises);
+      p.promise.catch(() => {}),
+    )
+    await Promise.all(promises)
   }
 
   /**
    * Get the number of pending requests (unique region requests).
    */
   get pendingCount(): number {
-    return this.pending.size;
+    return this.pending.size
   }
 
   /**
@@ -212,6 +213,6 @@ export class RegionCoalescer {
    * Note: Does not resolve or reject pending promises.
    */
   clear(): void {
-    this.pending.clear();
+    this.pending.clear()
   }
 }

package/src/ResolutionSelector.ts

@@ -1,20 +1,21 @@
 // SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
 // SPDX-License-Identifier: MIT
 
-import type { Multiscales, NgffImage } from "@fideus-labs/ngff-zarr";
+import type { Multiscales, NgffImage } from "@fideus-labs/ngff-zarr"
+
+import { clipPlanesToPixelRegion } from "./ClipPlanes.js"
 import type {
   ClipPlanes,
   PixelRegion,
   ResolutionSelection,
   VolumeBounds,
-} from "./types.js";
-import { clipPlanesToPixelRegion } from "./ClipPlanes.js";
+} from "./types.js"
 
 /**
  * Orthogonal axis index in [z, y, x] order.
  * 0 = Z (axial view), 1 = Y (coronal view), 2 = X (sagittal view)
  */
-export type OrthogonalAxis = 0 | 1 | 2;
+export type OrthogonalAxis = 0 | 1 | 2
 
 /**
  * Select the appropriate resolution level based on pixel budget and clip planes.
@@ -38,57 +39,57 @@ export function selectResolution(
   volumeBounds: VolumeBounds,
   viewportBounds?: VolumeBounds,
 ): ResolutionSelection {
-  const images = multiscales.images;
+  const images = multiscales.images
 
   // Try each resolution from highest to lowest
   for (let i = 0; i < images.length; i++) {
-    const image = images[i];
+    const image = images[i]
     const region = clipPlanesToPixelRegion(
       clipPlanes,
       volumeBounds,
       image,
       viewportBounds,
-    );
-    const alignedRegion = alignRegionToChunks(region, image);
+    )
+    const alignedRegion = alignRegionToChunks(region, image)
 
     const dimensions: [number, number, number] = [
       alignedRegion.end[0] - alignedRegion.start[0],
       alignedRegion.end[1] - alignedRegion.start[1],
       alignedRegion.end[2] - alignedRegion.start[2],
-    ];
+    ]
 
-    const pixelCount = dimensions[0] * dimensions[1] * dimensions[2];
+    const pixelCount = dimensions[0] * dimensions[1] * dimensions[2]
 
     if (pixelCount <= maxPixels) {
       return {
         levelIndex: i,
         dimensions,
         pixelCount,
-      };
+      }
     }
   }
 
   // Fall back to lowest resolution
-  const lowestImage = images[images.length - 1];
+  const lowestImage = images[images.length - 1]
   const region = clipPlanesToPixelRegion(
     clipPlanes,
     volumeBounds,
     lowestImage,
     viewportBounds,
-  );
-  const alignedRegion = alignRegionToChunks(region, lowestImage);
+  )
+  const alignedRegion = alignRegionToChunks(region, lowestImage)
 
   const dimensions: [number, number, number] = [
     alignedRegion.end[0] - alignedRegion.start[0],
     alignedRegion.end[1] - alignedRegion.start[1],
     alignedRegion.end[2] - alignedRegion.start[2],
-  ];
+  ]
 
   return {
     levelIndex: images.length - 1,
     dimensions,
     pixelCount: dimensions[0] * dimensions[1] * dimensions[2],
-  };
+  }
 }
 
 /**
@@ -98,21 +99,21 @@ export function selectResolution(
  * @returns Chunk shape as [z, y, x]
  */
 export function getChunkShape(ngffImage: NgffImage): [number, number, number] {
-  const chunks = ngffImage.data.chunks;
-  const dims = ngffImage.dims;
+  const chunks = ngffImage.data.chunks
+  const dims = ngffImage.dims
 
   // Find z, y, x indices in dims
-  const zIdx = dims.indexOf("z");
-  const yIdx = dims.indexOf("y");
-  const xIdx = dims.indexOf("x");
+  const zIdx = dims.indexOf("z")
+  const yIdx = dims.indexOf("y")
+  const xIdx = dims.indexOf("x")
 
   if (zIdx === -1 || yIdx === -1 || xIdx === -1) {
     // Fallback: assume last 3 dimensions are z, y, x
-    const n = chunks.length;
-    return [chunks[n - 3] || 1, chunks[n - 2] || 1, chunks[n - 1] || 1];
+    const n = chunks.length
+    return [chunks[n - 3] || 1, chunks[n - 2] || 1, chunks[n - 1] || 1]
   }
 
-  return [chunks[zIdx], chunks[yIdx], chunks[xIdx]];
+  return [chunks[zIdx], chunks[yIdx], chunks[xIdx]]
 }
 
 /**
@@ -122,21 +123,21 @@ export function getChunkShape(ngffImage: NgffImage): [number, number, number] {
  * @returns Shape as [z, y, x]
  */
 export function getVolumeShape(ngffImage: NgffImage): [number, number, number] {
-  const shape = ngffImage.data.shape;
-  const dims = ngffImage.dims;
+  const shape = ngffImage.data.shape
+  const dims = ngffImage.dims
 
   // Find z, y, x indices in dims
-  const zIdx = dims.indexOf("z");
-  const yIdx = dims.indexOf("y");
-  const xIdx = dims.indexOf("x");
+  const zIdx = dims.indexOf("z")
+  const yIdx = dims.indexOf("y")
+  const xIdx = dims.indexOf("x")
 
   if (zIdx === -1 || yIdx === -1 || xIdx === -1) {
     // Fallback: assume last 3 dimensions are z, y, x
-    const n = shape.length;
-    return [shape[n - 3] || 1, shape[n - 2] || 1, shape[n - 1] || 1];
+    const n = shape.length
+    return [shape[n - 3] || 1, shape[n - 2] || 1, shape[n - 1] || 1]
   }
 
-  return [shape[zIdx], shape[yIdx], shape[xIdx]];
+  return [shape[zIdx], shape[yIdx], shape[xIdx]]
 }
 
 /**
@@ -151,15 +152,15 @@ export function alignRegionToChunks(
   region: PixelRegion,
   ngffImage: NgffImage,
 ): PixelRegion {
-  const chunkShape = getChunkShape(ngffImage);
-  const volumeShape = getVolumeShape(ngffImage);
+  const chunkShape = getChunkShape(ngffImage)
+  const volumeShape = getVolumeShape(ngffImage)
 
   // Align start down to chunk boundary
   const alignedStart: [number, number, number] = [
     Math.floor(region.start[0] / chunkShape[0]) * chunkShape[0],
     Math.floor(region.start[1] / chunkShape[1]) * chunkShape[1],
     Math.floor(region.start[2] / chunkShape[2]) * chunkShape[2],
-  ];
+  ]
 
   // Align end up to chunk boundary (but don't exceed volume size)
   const alignedEnd: [number, number, number] = [
@@ -175,12 +176,12 @@ export function alignRegionToChunks(
       Math.ceil(region.end[2] / chunkShape[2]) * chunkShape[2],
       volumeShape[2],
     ),
-  ];
+  ]
 
   return {
     start: alignedStart,
     end: alignedEnd,
-  };
+  }
 }
 
 /**
@@ -190,7 +191,7 @@ export function alignRegionToChunks(
  * @returns Middle resolution level index
  */
 export function getMiddleResolutionIndex(multiscales: Multiscales): number {
-  return Math.floor(multiscales.images.length / 2);
+  return Math.floor(multiscales.images.length / 2)
 }
 
 /**
@@ -206,17 +207,17 @@ export function calculateUpsampleFactor(
   fromLevel: number,
   toLevel: number,
 ): [number, number, number] {
-  const fromImage = multiscales.images[fromLevel];
-  const toImage = multiscales.images[toLevel];
+  const fromImage = multiscales.images[fromLevel]
+  const toImage = multiscales.images[toLevel]
 
-  const fromShape = getVolumeShape(fromImage);
-  const toShape = getVolumeShape(toImage);
+  const fromShape = getVolumeShape(fromImage)
+  const toShape = getVolumeShape(toImage)
 
   return [
     toShape[0] / fromShape[0],
     toShape[1] / fromShape[1],
     toShape[2] / fromShape[2],
-  ];
+  ]
 }
 
 /**
@@ -226,7 +227,7 @@ export function getFullVolumeDimensions(
   multiscales: Multiscales,
   levelIndex: number,
 ): [number, number, number] {
-  return getVolumeShape(multiscales.images[levelIndex]);
+  return getVolumeShape(multiscales.images[levelIndex])
 }
 
 /**
@@ -257,69 +258,67 @@ export function select2DResolution(
   orthogonalAxis: OrthogonalAxis,
   viewportBounds?: VolumeBounds,
 ): ResolutionSelection {
-  const images = multiscales.images;
+  const images = multiscales.images
 
   // Try each resolution from highest to lowest
   for (let i = 0; i < images.length; i++) {
-    const image = images[i];
+    const image = images[i]
     const region = clipPlanesToPixelRegion(
       clipPlanes,
       volumeBounds,
       image,
       viewportBounds,
-    );
-    const alignedRegion = alignRegionToChunks(region, image);
+    )
+    const alignedRegion = alignRegionToChunks(region, image)
 
     const dimensions: [number, number, number] = [
       alignedRegion.end[0] - alignedRegion.start[0],
       alignedRegion.end[1] - alignedRegion.start[1],
       alignedRegion.end[2] - alignedRegion.start[2],
-    ];
+    ]
 
     // Count the full slab volume: in-plane area × chunk depth along the
     // orthogonal axis. The slab is always one chunk thick, so we use the
     // chunk shape rather than the full volume extent in that axis.
-    const chunkShape = getChunkShape(image);
-    const slabDepth = chunkShape[orthogonalAxis];
-    const inPlaneAxes = ([0, 1, 2] as const).filter((a) =>
-      a !== orthogonalAxis
-    );
-    const slabVoxelCount = dimensions[inPlaneAxes[0]] *
-      dimensions[inPlaneAxes[1]] * slabDepth;
+    const chunkShape = getChunkShape(image)
+    const slabDepth = chunkShape[orthogonalAxis]
+    const inPlaneAxes = ([0, 1, 2] as const).filter((a) => a !== orthogonalAxis)
+    const slabVoxelCount =
+      dimensions[inPlaneAxes[0]] * dimensions[inPlaneAxes[1]] * slabDepth
 
     if (slabVoxelCount <= maxPixels) {
       return {
         levelIndex: i,
         dimensions,
         pixelCount: slabVoxelCount,
-      };
+      }
     }
   }
 
   // Fall back to lowest resolution
-  const lowestImage = images[images.length - 1];
+  const lowestImage = images[images.length - 1]
   const region = clipPlanesToPixelRegion(
     clipPlanes,
     volumeBounds,
     lowestImage,
     viewportBounds,
-  );
-  const alignedRegion = alignRegionToChunks(region, lowestImage);
+  )
+  const alignedRegion = alignRegionToChunks(region, lowestImage)
 
   const dimensions: [number, number, number] = [
     alignedRegion.end[0] - alignedRegion.start[0],
     alignedRegion.end[1] - alignedRegion.start[1],
     alignedRegion.end[2] - alignedRegion.start[2],
-  ];
+  ]
 
-  const chunkShape = getChunkShape(lowestImage);
-  const slabDepth = chunkShape[orthogonalAxis];
-  const inPlaneAxes = ([0, 1, 2] as const).filter((a) => a !== orthogonalAxis);
+  const chunkShape = getChunkShape(lowestImage)
+  const slabDepth = chunkShape[orthogonalAxis]
+  const inPlaneAxes = ([0, 1, 2] as const).filter((a) => a !== orthogonalAxis)
 
   return {
     levelIndex: images.length - 1,
     dimensions,
-    pixelCount: dimensions[inPlaneAxes[0]] * dimensions[inPlaneAxes[1]] *
-      slabDepth,
-  };
+    pixelCount:
+      dimensions[inPlaneAxes[0]] * dimensions[inPlaneAxes[1]] * slabDepth,
+  }
 }