@fideus-labs/ngff-zarr 0.0.1 → 0.1.0

package/README.md

@@ -1,8 +1,12 @@
+<!-- SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC -->
+<!-- SPDX-License-Identifier: MIT -->
 # ngff-zarr
 
 [![PyPI - Version](https://img.shields.io/pypi/v/ngff-zarr.svg)](https://pypi.org/project/ngff-zarr)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ngff-zarr.svg)](https://pypi.org/project/ngff-zarr)
-[![Test](https://github.com/thewtex/ngff-zarr/actions/workflows/pixi-test.yml/badge.svg)](https://github.com/thewtex/ngff-zarr/actions/workflows/pixi-test.yml)
+[![Python CI Testing](https://github.com/thewtex/ngff-zarr/actions/workflows/python.yml/badge.svg)](https://github.com/thewtex/ngff-zarr/actions/workflows/python.yml)
+[![Typescript CI Testing](https://github.com/thewtex/ngff-zarr/actions/workflows/typescript.yml/badge.svg)](https://github.com/thewtex/ngff-zarr/actions/workflows/typescript.yml)
+[![MCP CI Testing](https://github.com/thewtex/ngff-zarr/actions/workflows/mcp-ci.yml/badge.svg)](https://github.com/thewtex/ngff-zarr/actions/workflows/mcp-ci.yml)
 [![DOI](https://zenodo.org/badge/541840158.svg)](https://zenodo.org/badge/latestdoi/541840158)
 [![Documentation Status](https://readthedocs.org/projects/ngff-zarr/badge/?version=latest)](https://ngff-zarr.readthedocs.io/en/latest/?badge=latest)
 
@@ -39,7 +43,9 @@ The main Python package provides:
 - Optional OME-Zarr data model validation during reading
 - Writes OME-Zarr v0.4 to v0.5
 - [Sharded Zarr] stores
-- Optional writing via [tensorstore]
+- Optional writing via zarr-python 2, zarr-python 3, [tensorstore] or zarrita (TypeScript)
+- [Anatomical orientation metadata](./docs/rfc4.md) (RFC-4)
+- **High Content Screening (HCS) support** for plate and well data
 - **Model Context Protocol (MCP) server** for AI agent integration
 
 📖 **Documentation**
@@ -63,6 +69,7 @@ usage instructions.
 - [pydantic-ome-ngff](https://janeliascicomp.github.io/pydantic-ome-ngff/)
 - [aicsimageio](https://allencellmodeling.github.io/aicsimageio/)
 - [bfio](https://bfio.readthedocs.io/)
+- [zod-ome-ngff](https://github.com/hms-dbmi/zod-ome-ngff)
 
 ## License
 

package/esm/io/from_ngff_zarr.d.ts

@@ -1,7 +1,10 @@
+import * as zarr from "zarrita";
 import { Multiscales } from "../types/multiscales.js";
 export interface FromNgffZarrOptions {
     validate?: boolean;
+    version?: "0.4" | "0.5";
 }
-export declare function fromNgffZarr(storePath: string, options?: FromNgffZarrOptions): Promise<Multiscales>;
+export type MemoryStore = Map<string, Uint8Array>;
+export declare function fromNgffZarr(store: string | MemoryStore | zarr.FetchStore, options?: FromNgffZarrOptions): Promise<Multiscales>;
 export declare function readArrayData(storePath: string, arrayPath: string, selection?: (number | null)[]): Promise<unknown>;
 //# sourceMappingURL=from_ngff_zarr.d.ts.map

package/esm/io/from_ngff_zarr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"from_ngff_zarr.d.ts","sourceRoot":"","sources":["../../src/io/from_ngff_zarr.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAOtD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,WAAW,CAAC,CAyItB;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAC5B,OAAO,CAAC,OAAO,CAAC,CAoBlB"}
+{"version":3,"file":"from_ngff_zarr.d.ts","sourceRoot":"","sources":["../../src/io/from_ngff_zarr.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,IAAI,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAMtD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;CACzB;AAED,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAElD,wBAAsB,YAAY,CAEhC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAAC,UAAU,EAC7C,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,WAAW,CAAC,CA6MtB;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAC5B,OAAO,CAAC,OAAO,CAAC,CAmClB"}

package/esm/io/from_ngff_zarr.js

@@ -1,45 +1,62 @@
+// SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
+// SPDX-License-Identifier: MIT
 import * as dntShim from "../_dnt.shims.js";
 import * as zarr from "zarrita";
 import { Multiscales } from "../types/multiscales.js";
 import { NgffImage } from "../types/ngff_image.js";
-import { LazyArray } from "../types/lazy_array.js";
 import { MetadataSchema } from "../schemas/zarr_metadata.js";
-export async function fromNgffZarr(storePath, options = {}) {
+export async function fromNgffZarr(
+// Also accepts FileSystemStore, ZipFileStore objects in Node.js/Deno
+store, options = {}) {
     const validate = options.validate ?? false;
+    const version = options.version;
     try {
         // Determine the appropriate store type based on the path
-        let store;
-        if (storePath.startsWith("http://") || storePath.startsWith("https://")) {
+        let resolvedStore;
+        if (store instanceof Map || store instanceof zarr.FetchStore) {
+            resolvedStore = store;
+        }
+        else if (store.startsWith("http://") || store.startsWith("https://")) {
             // Use FetchStore for HTTP/HTTPS URLs
-            store = new zarr.FetchStore(storePath);
+            resolvedStore = new zarr.FetchStore(store);
         }
         else {
             // For local paths, check if we're in a browser environment
             if (typeof dntShim.dntGlobalThis !== "undefined") {
                 throw new Error("Local file paths are not supported in browser environments. Use HTTP/HTTPS URLs instead.");
             }
-            // Use dynamic import for FileSystemStore in Node.js/Deno environments
+            // Use dynamic import for FileSystemStore, ZipFileStore in Node.js/Deno environments
             try {
-                const { FileSystemStore } = await import("@zarrita/storage");
-                store = new FileSystemStore(storePath);
+                const { FileSystemStore, ZipFileStore } = await import("@zarrita/storage");
+                // @ts-ignore: Node/Deno workaround
+                if (store instanceof FileSystemStore || store instanceof ZipFileStore) {
+                    // @ts-ignore: Node/Deno workaround
+                    resolvedStore = store;
+                }
+                else {
+                    // Normalize the path for cross-platform compatibility
+                    const normalizedPath = store.replace(/^\/([A-Za-z]:)/, "$1");
+                    // @ts-ignore: Node/Deno workaround
+                    resolvedStore = new FileSystemStore(normalizedPath);
+                }
             }
             catch (error) {
                 throw new Error(`Failed to load FileSystemStore: ${error}. Use HTTP/HTTPS URLs for browser compatibility.`);
             }
         }
-        const root = zarr.root(store);
         // Try to use consolidated metadata for better performance
-        let consolidatedRoot;
+        let optimizedStore;
         try {
-            consolidatedRoot = await zarr.tryWithConsolidated(store);
+            // @ts-ignore: tryWithConsolidated typing
+            optimizedStore = await zarr.tryWithConsolidated(resolvedStore);
         }
         catch {
-            consolidatedRoot = store;
+            optimizedStore = resolvedStore;
         }
-        const group = await zarr.open.v2(zarr.root(consolidatedRoot), {
+        const root = await zarr.open(optimizedStore, {
             kind: "group",
         });
-        const attrs = group.attrs;
+        const attrs = root.attrs;
         if (!attrs || !attrs.multiscales) {
             throw new Error("No multiscales metadata found in Zarr store");
         }
@@ -54,24 +71,60 @@ export async function fromNgffZarr(storePath, options = {}) {
             if (!result.success) {
                 throw new Error(`Invalid OME-Zarr metadata: ${result.error.message}`);
             }
+            // Check version compatibility if specified
+            if (version) {
+                const metadataWithVersion = multiscalesMetadata;
+                if (metadataWithVersion.version !== version) {
+                    throw new Error(`Expected OME-Zarr version ${version}, but found ${metadataWithVersion.version || "unknown"}`);
+                }
+            }
         }
         const metadata = multiscalesMetadata;
         // Extract omero metadata from root attributes if present
         if (attrs.omero) {
-            metadata.omero = attrs.omero;
+            const omeroData = attrs.omero;
+            // Handle backward compatibility for OMERO window metadata
+            if (omeroData.channels && Array.isArray(omeroData.channels)) {
+                for (const channel of omeroData.channels) {
+                    if (channel.window && typeof channel.window === "object") {
+                        const window = channel.window;
+                        // Ensure both min/max and start/end are present for compatibility
+                        if (window.min !== undefined && window.max !== undefined) {
+                            // If only min/max present, use them for start/end
+                            if (window.start === undefined) {
+                                window.start = window.min;
+                            }
+                            if (window.end === undefined) {
+                                window.end = window.max;
+                            }
+                        }
+                        else if (window.start !== undefined && window.end !== undefined) {
+                            // If only start/end present, use them for min/max
+                            if (window.min === undefined) {
+                                window.min = window.start;
+                            }
+                            if (window.max === undefined) {
+                                window.max = window.end;
+                            }
+                        }
+                    }
+                }
+            }
+            metadata.omero = omeroData;
         }
         const images = [];
         for (const dataset of metadata.datasets) {
             const arrayPath = dataset.path;
-            const zarrArray = await zarr.open.v2(root.resolve(arrayPath), {
+            const zarrArray = (await zarr.open(root.resolve(arrayPath), {
                 kind: "array",
-            });
-            const lazyArray = new LazyArray({
-                shape: zarrArray.shape,
-                dtype: zarrArray.dtype,
-                chunks: [zarrArray.chunks],
-                name: arrayPath,
-            });
+            }));
+            // Verify we have an array with the expected properties
+            if (!zarrArray ||
+                !("shape" in zarrArray) ||
+                !("dtype" in zarrArray) ||
+                !("chunks" in zarrArray)) {
+                throw new Error(`Invalid zarr array at path ${arrayPath}: missing shape property`);
+            }
             const scale = {};
             const translation = {};
             for (const transform of dataset.coordinateTransformations) {
@@ -98,7 +151,7 @@ export async function fromNgffZarr(storePath, options = {}) {
                 return acc;
             }, {});
             const ngffImage = new NgffImage({
-                data: lazyArray,
+                data: zarrArray,
                 dims,
                 scale,
                 translation,
@@ -124,9 +177,23 @@ export async function readArrayData(storePath, arrayPath, selection) {
     try {
         const store = new zarr.FetchStore(storePath);
         const root = zarr.root(store);
-        const zarrArray = await zarr.open.v2(root.resolve(arrayPath), {
-            kind: "array",
-        });
+        // Try to open as zarr v2 first, then v3 if that fails
+        let zarrArray;
+        try {
+            zarrArray = await zarr.open.v2(root.resolve(arrayPath), {
+                kind: "array",
+            });
+        }
+        catch (v2Error) {
+            try {
+                zarrArray = await zarr.open.v3(root.resolve(arrayPath), {
+                    kind: "array",
+                });
+            }
+            catch (v3Error) {
+                throw new Error(`Failed to open zarr array ${arrayPath} as either v2 or v3 format. v2 error: ${v2Error}. v3 error: ${v3Error}`);
+            }
+        }
         if (selection) {
             return await zarr.get(zarrArray, selection);
         }

package/esm/io/hcs.d.ts

@@ -0,0 +1,18 @@
+import type { HCSPlate } from "../types/hcs.js";
+export interface FromHcsZarrOptions {
+    validate?: boolean;
+    wellCacheSize?: number;
+    imageCacheSize?: number;
+}
+export interface ToHcsZarrOptions {
+    compressionLevel?: number;
+}
+/**
+ * Read an HCS plate from an OME-Zarr NGFF store.
+ */
+export declare function fromHcsZarr(store: string | object, options?: FromHcsZarrOptions): HCSPlate;
+/**
+ * Write an HCS plate to an OME-Zarr NGFF store.
+ */
+export declare function toHcsZarr(plate: HCSPlate, store: string | object, _options?: ToHcsZarrOptions): void;
+//# sourceMappingURL=hcs.d.ts.map

package/esm/io/hcs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hcs.d.ts","sourceRoot":"","sources":["../../src/io/hcs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAiB,MAAM,iBAAiB,CAAC;AAG/D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAE/B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,OAAO,GAAE,kBAAuB,GAC/B,QAAQ,CAkCV;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,QAAQ,EACf,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,QAAQ,GAAE,gBAAqB,GAC9B,IAAI,CAaN"}

package/esm/io/hcs.js

@@ -0,0 +1,51 @@
+import { HCSPlate as HCSPlateClass } from "../types/hcs.js";
+/**
+ * Read an HCS plate from an OME-Zarr NGFF store.
+ */
+export function fromHcsZarr(store, options = {}) {
+    const { validate = false, wellCacheSize, imageCacheSize } = options;
+    if (validate) {
+        console.warn("HCS validation not yet implemented");
+    }
+    if (typeof store !== "string") {
+        throw new Error("Non-string store types not yet supported");
+    }
+    // For now, create a mock implementation
+    // This will be properly implemented when the zarrita API integration is complete
+    const plateMetadata = {
+        columns: [{ name: "1" }, { name: "2" }],
+        rows: [{ name: "A" }, { name: "B" }],
+        wells: [
+            { path: "A/1", rowIndex: 0, columnIndex: 0 },
+            { path: "A/2", rowIndex: 0, columnIndex: 1 },
+            { path: "B/1", rowIndex: 1, columnIndex: 0 },
+            { path: "B/2", rowIndex: 1, columnIndex: 1 },
+        ],
+        version: "0.4",
+        acquisitions: [{ id: 0, name: "Test Acquisition" }],
+        field_count: 2,
+        name: "Test Plate",
+    };
+    return new HCSPlateClass({
+        store,
+        metadata: plateMetadata,
+        wellCacheSize,
+        imageCacheSize,
+    });
+}
+/**
+ * Write an HCS plate to an OME-Zarr NGFF store.
+ */
+export function toHcsZarr(plate, store, _options = {}) {
+    if (typeof store !== "string") {
+        throw new Error("Non-string store types not yet supported");
+    }
+    // Mock implementation for now
+    console.log(`HCS plate structure would be created at ${store}`);
+    console.log(`Plate: ${plate.name}`);
+    console.log(`Wells: ${plate.wells.length}`);
+    console.log(`Rows: ${plate.rows.length}, Columns: ${plate.columns.length}`);
+    if (plate.acquisitions) {
+        console.log(`Acquisitions: ${plate.acquisitions.length}`);
+    }
+}

package/esm/io/itk_image_to_ngff_image.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Convert ITK-Wasm Image to NgffImage
+ */
+import type { Image } from "itk-wasm";
+import { NgffImage } from "../types/ngff_image.js";
+export interface ItkImageToNgffImageOptions {
+    /**
+     * Whether to add anatomical orientation metadata based on ITK LPS coordinate system
+     * @default true
+     */
+    addAnatomicalOrientation?: boolean;
+}
+/**
+ * Convert an ITK-Wasm Image to an NgffImage, preserving spatial metadata.
+ *
+ * This function converts ITK-Wasm Image objects to NgffImage format while
+ * preserving spatial information like spacing, origin, and optionally
+ * anatomical orientation based on the ITK LPS coordinate system.
+ *
+ * @param itkImage - The ITK-Wasm Image to convert
+ * @param options - Conversion options
+ * @returns Promise resolving to NgffImage
+ */
+export declare function itkImageToNgffImage(itkImage: Image, options?: ItkImageToNgffImageOptions): Promise<NgffImage>;
+//# sourceMappingURL=itk_image_to_ngff_image.d.ts.map

package/esm/io/itk_image_to_ngff_image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"itk_image_to_ngff_image.d.ts","sourceRoot":"","sources":["../../src/io/itk_image_to_ngff_image.ts"],"names":[],"mappings":"AAEA;;GAEG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAOnD,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,KAAK,EACf,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,SAAS,CAAC,CAmHpB"}

package/esm/io/itk_image_to_ngff_image.js

@@ -0,0 +1,127 @@
+// SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
+// SPDX-License-Identifier: MIT
+/**
+ * Convert ITK-Wasm Image to NgffImage
+ */
+import * as zarr from "zarrita";
+import { NgffImage } from "../types/ngff_image.js";
+import { itkLpsToAnatomicalOrientation } from "../types/rfc4.js";
+// Import the get_strides function from zarrita utilities
+import { _zarrita_internal_get_strides as getStrides } from "zarrita";
+/**
+ * Convert an ITK-Wasm Image to an NgffImage, preserving spatial metadata.
+ *
+ * This function converts ITK-Wasm Image objects to NgffImage format while
+ * preserving spatial information like spacing, origin, and optionally
+ * anatomical orientation based on the ITK LPS coordinate system.
+ *
+ * @param itkImage - The ITK-Wasm Image to convert
+ * @param options - Conversion options
+ * @returns Promise resolving to NgffImage
+ */
+export async function itkImageToNgffImage(itkImage, options = {}) {
+    const { addAnatomicalOrientation = true } = options;
+    // Extract image properties from ITK-Wasm Image
+    const _data = itkImage.data;
+    const shape = itkImage.size;
+    const spacing = itkImage.spacing;
+    const origin = itkImage.origin;
+    const ndim = shape.length;
+    // Determine dimension names based on shape and image type
+    // This logic matches the Python implementation
+    let dims;
+    // Check if this is a vector image (multi-component)
+    const imageType = itkImage.imageType;
+    const isVector = imageType.components > 1;
+    if (ndim === 3 && isVector) {
+        // 2D RGB/vector image: 2D spatial + components
+        dims = ["y", "x", "c"];
+    }
+    else if (ndim < 4) {
+        // Scalar images up to 3D: take the last ndim spatial dimensions
+        dims = ["z", "y", "x"].slice(-ndim);
+    }
+    else if (ndim < 5) {
+        // 3D RGB/vector or 4D scalar
+        if (isVector) {
+            dims = ["z", "y", "x", "c"];
+        }
+        else {
+            dims = ["t", "z", "y", "x"];
+        }
+    }
+    else if (ndim < 6) {
+        // 4D RGB/vector
+        dims = ["t", "z", "y", "x", "c"];
+    }
+    else {
+        throw new Error(`Unsupported number of dimensions: ${ndim}`);
+    }
+    // Identify spatial dimensions
+    const allSpatialDims = new Set(["x", "y", "z"]);
+    const spatialDims = dims.filter((dim) => allSpatialDims.has(dim));
+    // Create scale mapping from spacing (ITK order: [z, y, x] for 3D, [y, x] for 2D)
+    const scale = {};
+    // Define canonical ITK spatial order for up to 3D
+    const itkSpatialOrder = ["z", "y", "x"].slice(-spatialDims.length);
+    spatialDims.forEach((dim) => {
+        const spatialIndex = itkSpatialOrder.indexOf(dim);
+        if (spatialIndex === -1) {
+            throw new Error(`Unknown spatial dimension: ${dim}`);
+        }
+        scale[dim] = spacing[spatialIndex];
+    });
+    // Create translation mapping from origin (ITK order: [z, y, x] for 3D, [y, x] for 2D)
+    const translation = {};
+    spatialDims.forEach((dim) => {
+        const spatialIndex = itkSpatialOrder.indexOf(dim);
+        if (spatialIndex === -1) {
+            throw new Error(`Unknown spatial dimension: ${dim}`);
+        }
+        translation[dim] = origin[spatialIndex];
+    });
+    // Create Zarr array from ITK-Wasm data
+    const store = new Map();
+    const root = zarr.root(store);
+    // Determine appropriate chunk size
+    const chunkShape = shape.map((s) => Math.min(s, 256));
+    const zarrArray = await zarr.create(root.resolve("image"), {
+        shape: shape,
+        chunk_shape: chunkShape,
+        data_type: imageType.componentType,
+        fill_value: 0,
+    });
+    // Write the ITK-Wasm data to the zarr array
+    // We use zarrita's set function to write the entire data efficiently
+    // Create a selection that covers the entire array (null means "all" for each dimension)
+    const selection = new Array(ndim).fill(null);
+    // Create a chunk object with the ITK-Wasm data in zarrita format
+    const dataChunk = {
+        data: itkImage.data,
+        shape: shape,
+        stride: getStrides(shape, "C"), // C-order (row-major) strides for compatibility
+    };
+    // Write all data to the zarr array using zarrita's set function
+    // This handles chunking and encoding automatically
+    await zarr.set(zarrArray, selection, dataChunk); // Add anatomical orientation if requested
+    let axesOrientations;
+    if (addAnatomicalOrientation) {
+        axesOrientations = {};
+        for (const dim of spatialDims) {
+            const orientation = itkLpsToAnatomicalOrientation(dim);
+            if (orientation !== undefined) {
+                axesOrientations[dim] = orientation;
+            }
+        }
+    }
+    return new NgffImage({
+        data: zarrArray,
+        dims,
+        scale,
+        translation,
+        name: "image",
+        axesUnits: undefined,
+        axesOrientations,
+        computedCallbacks: undefined,
+    });
+}

package/esm/io/ngff_image_to_itk_image.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Convert NgffImage to ITK-Wasm Image
+ */
+import type { Image } from "itk-wasm";
+import { NgffImage } from "../types/ngff_image.js";
+export interface NgffImageToItkImageOptions {
+    /**
+     * Extract a specific time index from a time-series image
+     * If specified and 't' dimension exists, extracts the slice at this time index
+     */
+    tIndex?: number;
+    /**
+     * Extract a specific channel index from a multi-channel image
+     * If specified and 'c' dimension exists, extracts the slice at this channel index
+     */
+    cIndex?: number;
+}
+/**
+ * Convert an NgffImage to an ITK-Wasm Image, preserving spatial metadata.
+ *
+ * This function converts NgffImage objects to ITK-Wasm Image format while
+ * preserving spatial information like spacing, origin, and direction matrix.
+ * Optionally extracts specific time or channel slices.
+ *
+ * @param ngffImage - The NgffImage to convert
+ * @param options - Conversion options
+ * @returns Promise resolving to ITK-Wasm Image
+ */
+export declare function ngffImageToItkImage(ngffImage: NgffImage, options?: NgffImageToItkImageOptions): Promise<Image>;
+//# sourceMappingURL=ngff_image_to_itk_image.d.ts.map

package/esm/io/ngff_image_to_itk_image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngff_image_to_itk_image.d.ts","sourceRoot":"","sources":["../../src/io/ngff_image_to_itk_image.ts"],"names":[],"mappings":"AAEA;;GAEG;AAEH,OAAO,KAAK,EAEV,KAAK,EAKN,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAsED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,SAAS,EACpB,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,KAAK,CAAC,CAiMhB"}