@fideus-labs/ngff-zarr 0.0.1 → 0.1.0

package/esm/io/ngff_image_to_itk_image.js

@@ -0,0 +1,216 @@
+// SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
+// SPDX-License-Identifier: MIT
+/**
+ * Convert NgffImage to ITK-Wasm Image
+ */
+import * as zarr from "zarrita";
+import { NgffImage } from "../types/ngff_image.js";
+/**
+ * Convert the data type from zarr DataType to ITK-Wasm component type
+ */
+function dataTypeToComponentType(dataType) {
+    switch (dataType) {
+        case "uint8":
+            return "uint8";
+        case "int8":
+            return "int8";
+        case "uint16":
+            return "uint16";
+        case "int16":
+            return "int16";
+        case "uint32":
+            return "uint32";
+        case "int32":
+            return "int32";
+        case "uint64":
+            return "uint64";
+        case "int64":
+            return "int64";
+        case "float32":
+            return "float32";
+        case "float64":
+            return "float64";
+        default:
+            throw new Error(`Unsupported data type: ${dataType}`);
+    }
+}
+/**
+ * Move the channel dimension to the end (last position) if it exists
+ * This follows the ITK convention where vector/RGB components are the last dimension
+ */
+function moveChannelDimToLast(ngffImage) {
+    const dims = ngffImage.dims;
+    const cIndex = dims.indexOf("c");
+    if (cIndex === -1 || cIndex === dims.length - 1) {
+        // No channel dimension or already at the end
+        return ngffImage;
+    }
+    // Reorder dimensions to move 'c' to the end
+    const newDims = [...dims];
+    const cDim = newDims.splice(cIndex, 1)[0];
+    newDims.push(cDim);
+    // Note: We would need to transpose the zarr array data here
+    // For now, we'll assume the data is already in the correct order
+    // In a full implementation, you'd transpose the zarr array
+    return new NgffImage({
+        data: ngffImage.data, // TODO: transpose if needed
+        dims: newDims,
+        scale: ngffImage.scale,
+        translation: ngffImage.translation,
+        name: ngffImage.name,
+        axesUnits: ngffImage.axesUnits,
+        axesOrientations: ngffImage.axesOrientations,
+        computedCallbacks: ngffImage.computedCallbacks,
+    });
+}
+/**
+ * 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 async function ngffImageToItkImage(ngffImage, options = {}) {
+    const { tIndex, cIndex } = options;
+    let workingImage = ngffImage;
+    // Extract time slice if requested
+    if (tIndex !== undefined && workingImage.dims.includes("t")) {
+        const tDimIndex = workingImage.dims.indexOf("t");
+        const newDims = workingImage.dims.filter((dim) => dim !== "t");
+        const newScale = Object.fromEntries(Object.entries(workingImage.scale).filter(([dim]) => dim !== "t"));
+        const newTranslation = Object.fromEntries(Object.entries(workingImage.translation).filter(([dim]) => dim !== "t"));
+        // Extract the time slice from zarr array
+        const selection = new Array(workingImage.data.shape.length).fill(null);
+        selection[tDimIndex] = tIndex;
+        const sliceData = await zarr.get(workingImage.data, selection);
+        // Create new zarr array with reduced dimensions
+        const store = new Map();
+        const root = zarr.root(store);
+        const newShape = workingImage.data.shape.filter((_, i) => i !== tDimIndex);
+        const chunkShape = newShape.map((s) => Math.min(s, 256));
+        const newArray = await zarr.create(root.resolve("slice"), {
+            shape: newShape,
+            chunk_shape: chunkShape,
+            data_type: workingImage.data.dtype,
+            fill_value: 0,
+        });
+        // Write the slice data
+        const fullSelection = new Array(newShape.length).fill(null);
+        await zarr.set(newArray, fullSelection, sliceData);
+        workingImage = new NgffImage({
+            data: newArray,
+            dims: newDims,
+            scale: newScale,
+            translation: newTranslation,
+            name: workingImage.name,
+            axesUnits: workingImage.axesUnits
+                ? Object.fromEntries(Object.entries(workingImage.axesUnits).filter(([dim]) => dim !== "t"))
+                : undefined,
+            axesOrientations: workingImage.axesOrientations
+                ? Object.fromEntries(Object.entries(workingImage.axesOrientations).filter(([dim]) => dim !== "t"))
+                : undefined,
+            computedCallbacks: workingImage.computedCallbacks,
+        });
+    }
+    // Extract channel slice if requested
+    if (cIndex !== undefined && workingImage.dims.includes("c")) {
+        const cDimIndex = workingImage.dims.indexOf("c");
+        const newDims = workingImage.dims.filter((dim) => dim !== "c");
+        const newScale = Object.fromEntries(Object.entries(workingImage.scale).filter(([dim]) => dim !== "c"));
+        const newTranslation = Object.fromEntries(Object.entries(workingImage.translation).filter(([dim]) => dim !== "c"));
+        // Extract the channel slice from zarr array
+        const selection = new Array(workingImage.data.shape.length).fill(null);
+        selection[cDimIndex] = cIndex;
+        const sliceData = await zarr.get(workingImage.data, selection);
+        // Create new zarr array with reduced dimensions
+        const store = new Map();
+        const root = zarr.root(store);
+        const newShape = workingImage.data.shape.filter((_, i) => i !== cDimIndex);
+        const chunkShape = newShape.map((s) => Math.min(s, 256));
+        const newArray = await zarr.create(root.resolve("slice"), {
+            shape: newShape,
+            chunk_shape: chunkShape,
+            data_type: workingImage.data.dtype,
+            fill_value: 0,
+        });
+        // Write the slice data
+        const fullSelection = new Array(newShape.length).fill(null);
+        await zarr.set(newArray, fullSelection, sliceData);
+        workingImage = new NgffImage({
+            data: newArray,
+            dims: newDims,
+            scale: newScale,
+            translation: newTranslation,
+            name: workingImage.name,
+            axesUnits: workingImage.axesUnits
+                ? Object.fromEntries(Object.entries(workingImage.axesUnits).filter(([dim]) => dim !== "c"))
+                : undefined,
+            axesOrientations: workingImage.axesOrientations
+                ? Object.fromEntries(Object.entries(workingImage.axesOrientations).filter(([dim]) => dim !== "c"))
+                : undefined,
+            computedCallbacks: workingImage.computedCallbacks,
+        });
+    }
+    // Move channel dimension to last position (ITK convention)
+    workingImage = moveChannelDimToLast(workingImage);
+    const dims = workingImage.dims;
+    const data = workingImage.data;
+    // Identify ITK spatial dimensions
+    const itkDimensionNames = new Set(["x", "y", "z", "t"]);
+    const itkDims = dims.filter((dim) => itkDimensionNames.has(dim));
+    // Sort ITK dimensions: spatial first (x, y, z), then time
+    const sortedItkDims = itkDims.sort((a, b) => {
+        const order = ["x", "y", "z", "t"];
+        return order.indexOf(a) - order.indexOf(b);
+    });
+    // Create ITK spacing, origin, and size arrays
+    const spacing = sortedItkDims.map((dim) => workingImage.scale[dim] || 1.0);
+    const origin = sortedItkDims.map((dim) => workingImage.translation[dim] || 0.0);
+    const size = sortedItkDims.map((dim) => data.shape[dims.indexOf(dim)]);
+    const dimension = sortedItkDims.length;
+    // Determine component type and pixel type
+    const componentType = dataTypeToComponentType(data.dtype);
+    let components = 1;
+    let pixelType = "Scalar";
+    if (dims.includes("c")) {
+        components = data.shape[dims.indexOf("c")];
+        if (components === 3 && componentType === "uint8") {
+            pixelType = "RGB";
+        }
+        else {
+            pixelType =
+                "VariableLengthVector";
+        }
+    }
+    // Create ImageType
+    const imageType = {
+        dimension,
+        componentType,
+        pixelType,
+        components,
+    };
+    // Read all data from zarr array
+    const selection = new Array(data.shape.length).fill(null);
+    const dataChunk = await zarr.get(data, selection);
+    // Create direction matrix (identity for now)
+    const direction = new Float64Array(dimension * dimension);
+    for (let i = 0; i < dimension; i++) {
+        direction[i * dimension + i] = 1.0;
+    }
+    // Create ITK-Wasm Image
+    const itkImage = {
+        imageType,
+        name: workingImage.name || "image",
+        origin,
+        spacing,
+        direction,
+        size,
+        metadata: new Map(),
+        data: dataChunk.data, // Cast to handle zarrita's data type
+    };
+    return itkImage;
+}

package/esm/io/to_multiscales.d.ts

@@ -0,0 +1,18 @@
+import { NgffImage } from "../types/ngff_image.js";
+import { Multiscales } from "../types/multiscales.js";
+import { Methods } from "../types/methods.js";
+export { toNgffImage, type ToNgffImageOptions } from "./to_ngff_image.js";
+export interface ToMultiscalesOptions {
+    scaleFactors?: (Record<string, number> | number)[];
+    method?: Methods;
+    chunks?: number | number[] | Record<string, number>;
+}
+/**
+ * Generate multiple resolution scales for an NgffImage (simplified version for testing)
+ *
+ * @param image - Input NgffImage
+ * @param options - Configuration options
+ * @returns Multiscales object
+ */
+export declare function toMultiscales(image: NgffImage, options?: ToMultiscalesOptions): Promise<Multiscales>;
+//# sourceMappingURL=to_multiscales.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to_multiscales.d.ts","sourceRoot":"","sources":["../../src/io/to_multiscales.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAW9C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE1E,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC;IACnD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrD;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,WAAW,CAAC,CAqEtB"}

package/esm/io/to_multiscales.js

@@ -0,0 +1,62 @@
+import { Methods } from "../types/methods.js";
+import { createAxis, createDataset, createMetadata, createMultiscales, } from "../utils/factory.js";
+import { getMethodMetadata } from "../utils/method_metadata.js";
+import { downsampleItkWasm } from "../methods/itkwasm.js";
+// Re-export for convenience
+export { toNgffImage } from "./to_ngff_image.js";
+/**
+ * Generate multiple resolution scales for an NgffImage (simplified version for testing)
+ *
+ * @param image - Input NgffImage
+ * @param options - Configuration options
+ * @returns Multiscales object
+ */
+export async function toMultiscales(image, options = {}) {
+    const { scaleFactors = [2, 4], method = Methods.ITKWASM_GAUSSIAN, chunks: _chunks, } = options;
+    let images;
+    // Check if we should perform actual downsampling
+    if (method === Methods.ITKWASM_GAUSSIAN ||
+        method === Methods.ITKWASM_BIN_SHRINK ||
+        method === Methods.ITKWASM_LABEL_IMAGE) {
+        // Perform actual downsampling using ITK-Wasm
+        const smoothing = method === Methods.ITKWASM_GAUSSIAN
+            ? "gaussian"
+            : method === Methods.ITKWASM_BIN_SHRINK
+                ? "bin_shrink"
+                : "label_image";
+        images = await downsampleItkWasm(image, scaleFactors, smoothing);
+    }
+    else {
+        // Fallback: create only the base image (no actual downsampling)
+        images = [image];
+    }
+    // Create axes from image dimensions
+    const axes = image.dims.map((dim) => {
+        if (dim === "x" || dim === "y" || dim === "z") {
+            return createAxis(dim, "space", image.axesUnits?.[dim]);
+        }
+        else if (dim === "c") {
+            return createAxis(dim, "channel");
+        }
+        else if (dim === "t") {
+            return createAxis(dim, "time");
+        }
+        else {
+            throw new Error(`Unsupported dimension: ${dim}`);
+        }
+    });
+    // Create datasets for all images
+    const datasets = images.map((img, index) => {
+        return createDataset(`${index}`, img.dims.map((dim) => img.scale[dim]), img.dims.map((dim) => img.translation[dim]));
+    });
+    // Create metadata with method information
+    const methodMetadata = getMethodMetadata(method);
+    const metadata = createMetadata(axes, datasets, image.name);
+    // The 'type' field, part of the OME-Zarr specification, in metadata is used here to
+    // record the downsampling method applied to generate multiscale images for provenance.
+    metadata.type = method;
+    if (methodMetadata) {
+        metadata.metadata = methodMetadata;
+    }
+    return createMultiscales(images, metadata, scaleFactors, method);
+}

package/esm/io/to_ngff_image.d.ts

@@ -0,0 +1,17 @@
+import { NgffImage } from "../types/ngff_image.js";
+export interface ToNgffImageOptions {
+    dims?: string[];
+    scale?: Record<string, number>;
+    translation?: Record<string, number>;
+    name?: string;
+    shape?: number[];
+}
+/**
+ * Convert array data to NgffImage
+ *
+ * @param data - Input data as typed array or regular array
+ * @param options - Configuration options for NgffImage creation
+ * @returns NgffImage instance
+ */
+export declare function toNgffImage(data: ArrayLike<number> | number[][] | number[][][], options?: ToNgffImageOptions): Promise<NgffImage>;
+//# sourceMappingURL=to_ngff_image.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to_ngff_image.d.ts","sourceRoot":"","sources":["../../src/io/to_ngff_image.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGnD,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,EAAE,EACnD,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,SAAS,CAAC,CAqIpB"}

package/esm/io/to_ngff_image.js

@@ -0,0 +1,136 @@
+import * as zarr from "zarrita";
+import { NgffImage } from "../types/ngff_image.js";
+/**
+ * Convert array data to NgffImage
+ *
+ * @param data - Input data as typed array or regular array
+ * @param options - Configuration options for NgffImage creation
+ * @returns NgffImage instance
+ */
+export async function toNgffImage(data, options = {}) {
+    const { dims = ["y", "x"], scale = {}, translation = {}, name = "image", shape: explicitShape, } = options;
+    // Determine data shape and create typed array
+    let typedData;
+    let shape;
+    if (Array.isArray(data)) {
+        // Handle multi-dimensional arrays
+        if (Array.isArray(data[0])) {
+            if (Array.isArray(data[0][0])) {
+                // 3D array
+                const d3 = data;
+                shape = [d3.length, d3[0].length, d3[0][0].length];
+                typedData = new Float32Array(shape[0] * shape[1] * shape[2]);
+                let idx = 0;
+                for (let i = 0; i < shape[0]; i++) {
+                    for (let j = 0; j < shape[1]; j++) {
+                        for (let k = 0; k < shape[2]; k++) {
+                            typedData[idx++] = d3[i][j][k];
+                        }
+                    }
+                }
+            }
+            else {
+                // 2D array
+                const d2 = data;
+                shape = [d2.length, d2[0].length];
+                typedData = new Float32Array(shape[0] * shape[1]);
+                let idx = 0;
+                for (let i = 0; i < shape[0]; i++) {
+                    for (let j = 0; j < shape[1]; j++) {
+                        typedData[idx++] = d2[i][j];
+                    }
+                }
+            }
+        }
+        else {
+            // 1D array
+            const d1 = data;
+            shape = [d1.length];
+            typedData = new Float32Array(d1);
+        }
+    }
+    else {
+        // ArrayLike (already a typed array)
+        // Use explicit shape if provided, otherwise infer from data length and dims
+        if (explicitShape) {
+            shape = [...explicitShape];
+        }
+        else {
+            // Try to infer shape - this is a best guess
+            shape = [data.length];
+        }
+        // Preserve the original typed array type
+        if (data instanceof Uint8Array) {
+            typedData = data;
+        }
+        else if (data instanceof Uint16Array) {
+            typedData = data;
+        }
+        else {
+            typedData = new Float32Array(data);
+        }
+    }
+    // Adjust shape to match dims length if not explicitly provided
+    if (!explicitShape) {
+        while (shape.length < dims.length) {
+            shape.unshift(1);
+        }
+    }
+    if (shape.length !== dims.length) {
+        throw new Error(`Shape dimensionality (${shape.length}) must match dims length (${dims.length})`);
+    }
+    // Create in-memory zarr store and array
+    const store = new Map();
+    const root = zarr.root(store);
+    // Calculate appropriate chunk size
+    const chunkShape = shape.map((dim) => Math.min(dim, 256));
+    const zarrArray = await zarr.create(root.resolve("data"), {
+        shape,
+        chunk_shape: chunkShape,
+        data_type: "float32",
+        fill_value: 0,
+    });
+    // Write data to zarr array
+    await zarr.set(zarrArray, [], {
+        data: typedData,
+        shape,
+        stride: calculateStride(shape),
+    });
+    // Create scale and translation records with defaults
+    const fullScale = {};
+    const fullTranslation = {};
+    const spatialDims = new Set(["x", "y", "z"]);
+    for (const dim of dims) {
+        // Only set defaults for spatial dimensions
+        if (spatialDims.has(dim)) {
+            fullScale[dim] = scale[dim] ?? 1.0;
+            fullTranslation[dim] = translation[dim] ?? 0.0;
+        }
+        else {
+            // For non-spatial dimensions, only include if explicitly provided
+            if (scale[dim] !== undefined) {
+                fullScale[dim] = scale[dim];
+            }
+            if (translation[dim] !== undefined) {
+                fullTranslation[dim] = translation[dim];
+            }
+        }
+    }
+    return new NgffImage({
+        data: zarrArray,
+        dims,
+        scale: fullScale,
+        translation: fullTranslation,
+        name,
+        axesUnits: undefined,
+        computedCallbacks: undefined,
+    });
+}
+function calculateStride(shape) {
+    const stride = new Array(shape.length);
+    stride[shape.length - 1] = 1;
+    for (let i = shape.length - 2; i >= 0; i--) {
+        stride[i] = stride[i + 1] * shape[i + 1];
+    }
+    return stride;
+}

package/esm/io/to_ngff_zarr.d.ts

@@ -1,9 +1,10 @@
+import * as zarr from "zarrita";
 import type { Multiscales } from "../types/multiscales.js";
+import type { MemoryStore } from "./from_ngff_zarr.js";
 export interface ToNgffZarrOptions {
     overwrite?: boolean;
     version?: "0.4" | "0.5";
-    useTensorstore?: boolean;
     chunksPerShard?: number | number[] | Record<string, number>;
 }
-export declare function toNgffZarr(_storePath: string, _multiscales: Multiscales, options?: ToNgffZarrOptions): Promise<void>;
+export declare function toNgffZarr(store: string | MemoryStore | zarr.FetchStore, multiscales: Multiscales, options?: ToNgffZarrOptions): Promise<void>;
 //# sourceMappingURL=to_ngff_zarr.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"to_ngff_zarr.d.ts","sourceRoot":"","sources":["../../src/io/to_ngff_zarr.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAG3D,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7D;AAED,wBAAgB,UAAU,CACxB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,WAAW,EACzB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAuBf"}
+{"version":3,"file":"to_ngff_zarr.d.ts","sourceRoot":"","sources":["../../src/io/to_ngff_zarr.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,IAAI,MAAM,SAAS,CAAC;AAChC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGvD,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7D;AAED,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAAC,UAAU,EAC7C,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,IAAI,CAAC,CA0Ff"}