@fideus-labs/ngff-zarr 0.0.1 → 0.1.0

package/script/io/to_ngff_zarr.js

@@ -24,60 +24,307 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toNgffZarr = toNgffZarr;
+// SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
+// SPDX-License-Identifier: MIT
+const dntShim = __importStar(require("../_dnt.shims.js"));
 const zarr = __importStar(require("zarrita"));
-function toNgffZarr(_storePath, _multiscales, options = {}) {
+const create_queue_js_1 = require("../utils/create_queue.js");
+async function toNgffZarr(store, multiscales, options = {}) {
     const _overwrite = options.overwrite ?? true;
     const _version = options.version ?? "0.4";
     try {
-        // TODO: Implement using zarrita v0.5.2 API
-        // Example implementation would be:
-        // 1. Create a writable store (e.g., FileSystemStore for local files)
-        // 2. Use zarr.root(store) to create a Location
-        // 3. Use zarr.create(root, { attributes: { multiscales: [...] } }) to create group
-        // 4. For each image, use zarr.create(root.resolve(path), { shape, data_type, chunk_shape })
-        // 5. Use zarr.set() to write actual data
-        throw new Error("Writing OME-Zarr files is not yet fully implemented with zarrita v0.5.2");
+        // Determine the appropriate store type based on the path
+        let _resolvedStore; // Use unknown for FileSystemStore since we import it dynamically
+        if (store instanceof Map) {
+            _resolvedStore = store;
+        }
+        else if (store instanceof zarr.FetchStore) {
+            throw new Error("FetchStore is read-only and cannot be used for writing. Use a local file path or MemoryStore instead.");
+        }
+        else if (store.startsWith("http://") || store.startsWith("https://")) {
+            throw new Error("HTTP/HTTPS URLs are read-only and cannot be used for writing. Use a local file path instead.");
+        }
+        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 a MemoryStore instead.");
+            }
+            // Use dynamic import for FileSystemStore in Node.js/Deno environments
+            try {
+                const { FileSystemStore } = await Promise.resolve().then(() => __importStar(require("@zarrita/storage")));
+                // Normalize the path for cross-platform compatibility
+                const normalizedPath = store.replace(/^\/([A-Za-z]:)/, "$1");
+                _resolvedStore = new FileSystemStore(normalizedPath);
+            }
+            catch (error) {
+                throw new Error(`Failed to load FileSystemStore: ${error}. Use MemoryStore for browser compatibility.`);
+            }
+        }
+        // Create root location and group with zarrita v0.5.2 API
+        const root = zarr.root(_resolvedStore);
+        // Create the root group with OME-Zarr metadata
+        const rootGroup = await zarr.create(root, {
+            attributes: {
+                multiscales: [
+                    {
+                        version: _version,
+                        name: multiscales.metadata.name,
+                        axes: multiscales.metadata.axes,
+                        datasets: multiscales.metadata.datasets,
+                        ...(multiscales.metadata.coordinateTransformations && {
+                            coordinateTransformations: multiscales.metadata.coordinateTransformations,
+                        }),
+                        ...(multiscales.metadata.type && {
+                            type: multiscales.metadata.type,
+                        }),
+                        ...(multiscales.metadata.metadata && {
+                            metadata: multiscales.metadata.metadata,
+                        }),
+                    },
+                ],
+                ...(multiscales.metadata.omero && {
+                    omero: multiscales.metadata.omero,
+                }),
+            },
+        });
+        // Write each image in the multiscales
+        for (let i = 0; i < multiscales.images.length; i++) {
+            const image = multiscales.images[i];
+            const dataset = multiscales.metadata.datasets[i];
+            if (!dataset) {
+                throw new Error(`No dataset configuration found for image ${i}`);
+            }
+            await _writeImage(rootGroup, image, dataset.path);
+        }
     }
     catch (error) {
         throw new Error(`Failed to write OME-Zarr: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+function _convertDtypeToZarrType(dtype) {
+    // Map common numpy/LazyArray dtypes to zarrita data types
+    const dtypeMap = {
+        int8: "int8",
+        int16: "int16",
+        int32: "int32",
+        int64: "int64",
+        uint8: "uint8",
+        uint16: "uint16",
+        uint32: "uint32",
+        uint64: "uint64",
+        float32: "float32",
+        float64: "float64",
+        bool: "bool",
+        // Handle some alternative formats
+        i1: "int8",
+        i2: "int16",
+        i4: "int32",
+        i8: "int64",
+        u1: "uint8",
+        u2: "uint16",
+        u4: "uint32",
+        u8: "uint64",
+        f4: "float32",
+        f8: "float64",
+    };
+    if (dtype in dtypeMap) {
+        return dtypeMap[dtype];
+    }
+    else {
+        throw new Error(`Unsupported data type: ${dtype}`);
+    }
+}
+function getTypedArrayConstructor(dtype) {
+    // Map zarrita data types to TypedArray constructors
+    const constructorMap = {
+        int8: Int8Array,
+        int16: Int16Array,
+        int32: Int32Array,
+        int64: BigInt64Array,
+        uint8: Uint8Array,
+        uint16: Uint16Array,
+        uint32: Uint32Array,
+        uint64: BigUint64Array,
+        float32: Float32Array,
+        float64: Float64Array,
+        bool: Uint8Array, // Use Uint8Array for boolean, where 0 represents false and 1 represents true
+        // Note: float16 and "v2:object" not supported by standard TypedArrays
+    };
+    const constructor = constructorMap[dtype];
+    if (constructor) {
+        return constructor;
+    }
+    else {
+        throw new Error(`Unsupported data type for typed array: ${dtype}`);
+    }
+}
 async function _writeImage(group, image, arrayPath) {
     try {
         const chunks = getChunksFromImage(image);
-        // TODO: Update to use zarrita v0.5.2 API properly
-        // The new API would use:
-        // const location = (group as { resolve: (path: string) => Location }).resolve(arrayPath);
-        // const zarrArray = await zarr.create(location, { ... });
-        // Then use zarr.set(zarrArray, data, selection) to write data
-        const resolvedPath = group.resolve(arrayPath);
-        // @ts-ignore - zarrita API types are complex, this is a temporary workaround
-        const _zarrArray = await zarr.create(resolvedPath, {
+        // Convert LazyArray dtype to zarrita DataType
+        const zarrDataType = _convertDtypeToZarrType(image.data.dtype);
+        // Create array location
+        const arrayLocation = group.resolve(arrayPath);
+        // Create the zarr array with proper configuration
+        const zarrArray = await zarr.create(arrayLocation, {
             shape: image.data.shape,
-            data_type: image.data.dtype,
+            data_type: zarrDataType,
             chunk_shape: chunks,
             fill_value: 0,
         });
-        // Note: With zarrita v0.5.2, attributes can be set during creation
-        // or updated using the store's set method for metadata files
+        await _writeArrayData(zarrArray, image);
     }
     catch (error) {
         throw new Error(`Failed to write image array: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
 function getChunksFromImage(image) {
-    if (image.data.chunks.length > 0 && image.data.chunks[0].length > 0) {
-        return image.data.chunks[0];
+    // zarr.Array.chunks is a number[] representing chunk shape
+    if (image.data.chunks && image.data.chunks.length > 0) {
+        return image.data.chunks;
     }
     return image.data.shape.map((dim) => Math.min(dim, 1024));
 }
-function _writeArrayData(_storePath, _arrayPath, _data, _selection) {
+async function _writeArrayData(zarrArray, image) {
     try {
-        // Note: zarrita doesn't have a direct set method for arrays
-        // This would need to be implemented differently
-        throw new Error("Writing array data not yet implemented with zarrita");
+        // Get array shape for chunk calculation - we don't need the full data here
+        const shape = image.data.shape;
+        // Calculate chunk indices for parallel writing
+        const chunkIndices = calculateChunkIndices(shape, zarrArray.chunks);
+        // Create a queue for parallel chunk writing
+        const writeQueue = (0, create_queue_js_1.createQueue)();
+        // Queue all chunks for writing
+        for (const chunkIndex of chunkIndices) {
+            writeQueue.add(async () => {
+                await writeChunkWithGet(zarrArray, image, chunkIndex);
+            });
+        }
+        // Wait for all chunks to be written
+        await writeQueue.onIdle();
     }
     catch (error) {
         throw new Error(`Failed to write array data: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+async function writeChunkWithGet(zarrArray, image, chunkIndex) {
+    // Calculate the chunk bounds
+    const shape = image.data.shape;
+    const chunkStart = chunkIndex.map((idx, dim) => idx * zarrArray.chunks[dim]);
+    const chunkEnd = chunkStart.map((start, dim) => Math.min(start + zarrArray.chunks[dim], shape[dim]));
+    // Calculate chunk shape
+    const chunkShape = chunkEnd.map((end, dim) => end - chunkStart[dim]);
+    // Create selection for this chunk from the source data
+    const sourceSelection = chunkStart.map((start, dim) => zarr.slice(start, chunkEnd[dim]));
+    // Get only the chunk data we need from the source
+    const { data: chunkSourceData } = await zarr.get(image.data, sourceSelection);
+    // Convert chunk data to target type
+    const targetTypedArrayConstructor = getTypedArrayConstructor(zarrArray.dtype);
+    const chunkTargetData = convertChunkToTargetType(chunkSourceData, zarrArray.dtype, targetTypedArrayConstructor);
+    // Create the selection for writing to the target zarr array
+    const targetSelection = chunkStart.map((start, dim) => zarr.slice(start, chunkEnd[dim]));
+    // Write the chunk using zarrita's set function
+    await zarr.set(zarrArray, targetSelection, {
+        data: chunkTargetData,
+        shape: chunkShape,
+        stride: calculateChunkStride(chunkShape),
+    });
+}
+function convertChunkToTargetType(chunkData, targetDtype, targetTypedArrayConstructor) {
+    // Handle different source data types
+    if (chunkData instanceof BigInt64Array ||
+        chunkData instanceof BigUint64Array) {
+        // Handle BigInt arrays separately
+        if (chunkData.constructor === targetTypedArrayConstructor) {
+            return chunkData;
+        }
+        else if (targetDtype === "int64" || targetDtype === "uint64") {
+            // BigInt to BigInt conversion
+            const bigIntArray = new targetTypedArrayConstructor(chunkData.length);
+            for (let i = 0; i < chunkData.length; i++) {
+                bigIntArray[i] = chunkData[i];
+            }
+            return bigIntArray;
+        }
+        else {
+            // BigInt to regular number conversion
+            const numberArray = new targetTypedArrayConstructor(chunkData.length);
+            for (let i = 0; i < chunkData.length; i++) {
+                numberArray[i] = Number(chunkData[i]);
+            }
+            return numberArray;
+        }
+    }
+    else if (chunkData instanceof Uint8Array ||
+        chunkData instanceof Int8Array ||
+        chunkData instanceof Uint16Array ||
+        chunkData instanceof Int16Array ||
+        chunkData instanceof Uint32Array ||
+        chunkData instanceof Int32Array ||
+        chunkData instanceof Float32Array ||
+        chunkData instanceof Float64Array) {
+        // Handle regular typed arrays
+        if (chunkData.constructor === targetTypedArrayConstructor) {
+            return chunkData;
+        }
+        else {
+            // Convert between typed arrays
+            if (targetDtype === "int64" || targetDtype === "uint64") {
+                // Regular number to BigInt conversion
+                const bigIntArray = new targetTypedArrayConstructor(chunkData.length);
+                for (let i = 0; i < chunkData.length; i++) {
+                    bigIntArray[i] = BigInt(chunkData[i]);
+                }
+                return bigIntArray;
+            }
+            else {
+                // Standard numeric conversion - use typed conversion
+                const typedArrayMap = new Map([
+                    [Uint8Array, (data) => new Uint8Array(Array.from(data))],
+                    [Int8Array, (data) => new Int8Array(Array.from(data))],
+                    [Uint16Array, (data) => new Uint16Array(Array.from(data))],
+                    [Int16Array, (data) => new Int16Array(Array.from(data))],
+                    [Uint32Array, (data) => new Uint32Array(Array.from(data))],
+                    [Int32Array, (data) => new Int32Array(Array.from(data))],
+                    [Float32Array, (data) => new Float32Array(Array.from(data))],
+                    [Float64Array, (data) => new Float64Array(Array.from(data))],
+                ]);
+                const createTypedArray = typedArrayMap.get(targetTypedArrayConstructor);
+                if (createTypedArray) {
+                    return createTypedArray(chunkData);
+                }
+                else {
+                    throw new Error(`Unsupported target constructor: ${targetTypedArrayConstructor.name}`);
+                }
+            }
+        }
+    }
+    else {
+        // Handle other types (fallback)
+        throw new Error(`Unsupported source data type: ${chunkData.constructor.name}`);
+    }
+}
+function calculateChunkIndices(shape, chunks) {
+    const indices = [];
+    function generateIndices(dimIndex, currentIndex) {
+        if (dimIndex === shape.length) {
+            indices.push([...currentIndex]);
+            return;
+        }
+        const chunkSize = chunks[dimIndex];
+        const dimSize = shape[dimIndex];
+        for (let i = 0; i < Math.ceil(dimSize / chunkSize); i++) {
+            currentIndex[dimIndex] = i;
+            generateIndices(dimIndex + 1, currentIndex);
+        }
+    }
+    generateIndices(0, new Array(shape.length));
+    return indices;
+}
+function calculateChunkStride(chunkShape) {
+    const stride = new Array(chunkShape.length);
+    stride[chunkShape.length - 1] = 1;
+    for (let i = chunkShape.length - 2; i >= 0; i--) {
+        stride[i] = stride[i + 1] * chunkShape[i + 1];
+    }
+    return stride;
+}

package/script/methods/itkwasm.d.ts

@@ -0,0 +1,6 @@
+import { NgffImage } from "../types/ngff_image.js";
+/**
+ * Main downsampling function for ITK-Wasm
+ */
+export declare function downsampleItkWasm(ngffImage: NgffImage, scaleFactors: (Record<string, number> | number)[], smoothing: "gaussian" | "bin_shrink" | "label_image"): Promise<NgffImage[]>;
+//# sourceMappingURL=itkwasm.d.ts.map

package/script/methods/itkwasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"itkwasm.d.ts","sourceRoot":"","sources":["../../src/methods/itkwasm.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAohCnD;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,EAAE,EACjD,SAAS,EAAE,UAAU,GAAG,YAAY,GAAG,aAAa,GACnD,OAAO,CAAC,SAAS,EAAE,CAAC,CA+CtB"}