@fideus-labs/ngff-zarr 0.2.3 → 0.2.5

package/script/io/to_ngff_image.js

@@ -1,162 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toNgffImage = toNgffImage;
-const zarr = __importStar(require("zarrita"));
-const ngff_image_js_1 = require("../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
- */
-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 ngff_image_js_1.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/script/io/to_ngff_zarr.d.ts

@@ -1,10 +0,0 @@
-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";
-    chunksPerShard?: number | number[] | Record<string, number>;
-}
-export declare function toNgffZarr(store: string | MemoryStore | zarr.FetchStore, multiscales: Multiscales, options?: ToNgffZarrOptions): Promise<void>;
-//# sourceMappingURL=to_ngff_zarr.d.ts.map

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

@@ -1 +0,0 @@
-{"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"}

package/script/io/to_ngff_zarr.js

@@ -1,346 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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"));
-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 {
-        // 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);
-        // 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: zarrDataType,
-            chunk_shape: chunks,
-            fill_value: 0,
-        });
-        await _writeArrayData(zarrArray, image);
-    }
-    catch (error) {
-        throw new Error(`Failed to write image array: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-function getChunksFromImage(image) {
-    // 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));
-}
-async function _writeArrayData(zarrArray, image) {
-    try {
-        // 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);
-    // Validate chunk data size
-    const expectedSize = chunkShape.reduce((a, b) => a * b, 1);
-    const actualSize = chunkTargetData.byteLength /
-        (chunkTargetData
-            .BYTES_PER_ELEMENT || 1);
-    if (actualSize !== expectedSize) {
-        console.error(`[writeChunkWithGet] Chunk data size mismatch!`);
-        console.error(`  Image shape:`, shape);
-        console.error(`  Chunk index:`, chunkIndex);
-        console.error(`  Chunk start:`, chunkStart);
-        console.error(`  Chunk end:`, chunkEnd);
-        console.error(`  Chunk shape:`, chunkShape);
-        console.error(`  Expected size:`, expectedSize);
-        console.error(`  Actual size:`, actualSize);
-        throw new Error(`Chunk data size mismatch: expected ${expectedSize} elements, got ${actualSize}`);
-    }
-    // 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-browser.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"itkwasm-browser.d.ts","sourceRoot":"","sources":["../../src/methods/itkwasm-browser.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AA2fnD;;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,CAsHtB"}