@fideus-labs/ngff-zarr 0.2.0 → 0.2.2

package/esm/browser-mod.d.ts

@@ -0,0 +1,14 @@
+export * from "./types/units.js";
+export * from "./types/methods.js";
+export * from "./types/array_interface.js";
+export * from "./types/zarr_metadata.js";
+export * from "./types/ngff_image.js";
+export * from "./types/multiscales.js";
+export * from "./schemas/units.js";
+export * from "./schemas/methods.js";
+export * from "./schemas/zarr_metadata.js";
+export * from "./schemas/ngff_image.js";
+export * from "./schemas/multiscales.js";
+export { isValidDimension, isValidUnit, validateMetadata, } from "./utils/validation.js";
+export { createAxis, createDataset, createMetadata, createMultiscales, createNgffImage, } from "./utils/factory.js";
+//# sourceMappingURL=browser-mod.d.ts.map

package/esm/browser-mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-mod.d.ts","sourceRoot":"","sources":["../src/browser-mod.ts"],"names":[],"mappings":"AASA,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AAEvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AAEzC,OAAO,EACL,gBAAgB,EAChB,WAAW,EACX,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,UAAU,EACV,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,eAAe,GAChB,MAAM,oBAAoB,CAAC"}

package/esm/browser-mod.js

@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
+// SPDX-License-Identifier: MIT
+// Browser-compatible module exports
+// This module excludes I/O functionality (from_ngff_zarr, to_ngff_zarr)
+// because those modules depend on Node.js/Deno-specific filesystem APIs
+// that are not available in browser environments.
+//
+// For browser use cases, the schemas, types, and validation utilities
+// are the most commonly needed functionality.
+export * from "./types/units.js";
+export * from "./types/methods.js";
+export * from "./types/array_interface.js";
+export * from "./types/zarr_metadata.js";
+export * from "./types/ngff_image.js";
+export * from "./types/multiscales.js";
+export * from "./schemas/units.js";
+export * from "./schemas/methods.js";
+export * from "./schemas/zarr_metadata.js";
+export * from "./schemas/ngff_image.js";
+export * from "./schemas/multiscales.js";
+export { isValidDimension, isValidUnit, validateMetadata, } from "./utils/validation.js";
+export { createAxis, createDataset, createMetadata, createMultiscales, createNgffImage, } from "./utils/factory.js";
+// Note: Excluding I/O modules for browser compatibility

package/esm/methods/itkwasm-browser.d.ts

@@ -0,0 +1,6 @@
+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/esm/methods/itkwasm-browser.d.ts.map

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

package/esm/methods/itkwasm-browser.js

@@ -0,0 +1,462 @@
+// SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
+// SPDX-License-Identifier: MIT
+/**
+ * Browser-compatible ITK-Wasm downsampling support
+ * Uses WebWorker-based implementations from @itk-wasm/downsample
+ */
+import { downsample, downsampleBinShrink, downsampleLabelImage, } from "@itk-wasm/downsample";
+import * as zarr from "zarrita";
+import { NgffImage } from "../types/ngff_image.js";
+import { dimScaleFactors, itkImageToZarr, nextScaleMetadata, SPATIAL_DIMS, updatePreviousDimFactors, zarrToItkImage, } from "./itkwasm-shared.js";
+/**
+ * Perform Gaussian downsampling using ITK-Wasm (browser version)
+ */
+async function downsampleGaussian(image, dimFactors, spatialDims) {
+    // Handle time dimension by processing each time slice independently
+    if (image.dims.includes("t")) {
+        const tDimIndex = image.dims.indexOf("t");
+        const tSize = image.data.shape[tDimIndex];
+        const newDims = image.dims.filter((dim) => dim !== "t");
+        // Downsample each time slice
+        const downsampledSlices = [];
+        for (let t = 0; t < tSize; t++) {
+            // Extract time slice
+            const selection = new Array(image.data.shape.length).fill(null);
+            selection[tDimIndex] = t;
+            const sliceData = await zarr.get(image.data, selection);
+            // Create temporary zarr array for this slice
+            const sliceStore = new Map();
+            const sliceRoot = zarr.root(sliceStore);
+            const sliceShape = image.data.shape.filter((_, i) => i !== tDimIndex);
+            const sliceChunkShape = sliceShape.map((s) => Math.min(s, 256));
+            const sliceArray = await zarr.create(sliceRoot.resolve("slice"), {
+                shape: sliceShape,
+                chunk_shape: sliceChunkShape,
+                data_type: image.data.dtype,
+                fill_value: 0,
+            });
+            const fullSelection = new Array(sliceShape.length).fill(null);
+            await zarr.set(sliceArray, fullSelection, sliceData);
+            // Create NgffImage for this slice (without 't' dimension)
+            const sliceImage = new NgffImage({
+                data: sliceArray,
+                dims: newDims,
+                scale: Object.fromEntries(Object.entries(image.scale).filter(([dim]) => dim !== "t")),
+                translation: Object.fromEntries(Object.entries(image.translation).filter(([dim]) => dim !== "t")),
+                name: image.name,
+                axesUnits: image.axesUnits
+                    ? Object.fromEntries(Object.entries(image.axesUnits).filter(([dim]) => dim !== "t"))
+                    : undefined,
+                computedCallbacks: image.computedCallbacks,
+            });
+            // Recursively downsample this slice (without 't', so no infinite loop)
+            const downsampledSlice = await downsampleGaussian(sliceImage, dimFactors, spatialDims);
+            downsampledSlices.push(downsampledSlice.data);
+        }
+        // Combine downsampled slices back into a single array with 't' dimension
+        const firstSlice = downsampledSlices[0];
+        const combinedShape = [...image.data.shape];
+        combinedShape[tDimIndex] = tSize;
+        // Update spatial dimensions based on downsampled size
+        for (let i = 0; i < image.dims.length; i++) {
+            if (i !== tDimIndex) {
+                const sliceIndex = i < tDimIndex ? i : i - 1;
+                combinedShape[i] = firstSlice.shape[sliceIndex];
+            }
+        }
+        // Create combined array
+        const combinedStore = new Map();
+        const combinedRoot = zarr.root(combinedStore);
+        const combinedArray = await zarr.create(combinedRoot.resolve("combined"), {
+            shape: combinedShape,
+            chunk_shape: combinedShape.map((s) => Math.min(s, 256)),
+            data_type: image.data.dtype,
+            fill_value: 0,
+        });
+        // Copy each downsampled slice into the combined array
+        for (let t = 0; t < tSize; t++) {
+            const sliceData = await zarr.get(downsampledSlices[t]);
+            const targetSelection = new Array(combinedShape.length).fill(null);
+            targetSelection[tDimIndex] = t;
+            await zarr.set(combinedArray, targetSelection, sliceData);
+        }
+        // Compute new metadata (time dimension unchanged, spatial dimensions downsampled)
+        const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+        return new NgffImage({
+            data: combinedArray,
+            dims: image.dims,
+            scale: { ...image.scale, ...scale },
+            translation: { ...image.translation, ...translation },
+            name: image.name,
+            axesUnits: image.axesUnits,
+            computedCallbacks: image.computedCallbacks,
+        });
+    }
+    const isVector = image.dims.includes("c");
+    // Convert to ITK-Wasm format
+    const itkImage = await zarrToItkImage(image.data, image.dims, isVector);
+    // Prepare shrink factors - need to be for ALL dimensions in ITK order (reversed)
+    const shrinkFactors = [];
+    for (let i = image.dims.length - 1; i >= 0; i--) {
+        const dim = image.dims[i];
+        if (SPATIAL_DIMS.includes(dim)) {
+            shrinkFactors.push(dimFactors[dim] || 1);
+        }
+    }
+    // Use all zeros for cropRadius
+    const cropRadius = new Array(shrinkFactors.length).fill(0);
+    // Perform downsampling using browser-compatible function
+    const { downsampled } = await downsample(itkImage, {
+        shrinkFactors,
+        cropRadius: cropRadius,
+    });
+    // Compute new metadata
+    const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+    // Convert back to zarr array in a new in-memory store
+    const store = new Map();
+    const chunkShape = downsampled.size.map((s) => Math.min(s, 256)).reverse();
+    const array = await itkImageToZarr(downsampled, store, "image", chunkShape, image.dims);
+    return new NgffImage({
+        data: array,
+        dims: image.dims,
+        scale,
+        translation,
+        name: image.name,
+        axesUnits: image.axesUnits,
+        computedCallbacks: image.computedCallbacks,
+    });
+}
+/**
+ * Perform bin shrink downsampling using ITK-Wasm (browser version)
+ */
+async function downsampleBinShrinkImpl(image, dimFactors, spatialDims) {
+    // Handle time dimension by processing each time slice independently
+    if (image.dims.includes("t")) {
+        const tDimIndex = image.dims.indexOf("t");
+        const tSize = image.data.shape[tDimIndex];
+        const newDims = image.dims.filter((dim) => dim !== "t");
+        // Downsample each time slice
+        const downsampledSlices = [];
+        for (let t = 0; t < tSize; t++) {
+            // Extract time slice
+            const selection = new Array(image.data.shape.length).fill(null);
+            selection[tDimIndex] = t;
+            const sliceData = await zarr.get(image.data, selection);
+            // Create temporary zarr array for this slice
+            const sliceStore = new Map();
+            const sliceRoot = zarr.root(sliceStore);
+            const sliceShape = image.data.shape.filter((_, i) => i !== tDimIndex);
+            const sliceChunkShape = sliceShape.map((s) => Math.min(s, 256));
+            const sliceArray = await zarr.create(sliceRoot.resolve("slice"), {
+                shape: sliceShape,
+                chunk_shape: sliceChunkShape,
+                data_type: image.data.dtype,
+                fill_value: 0,
+            });
+            const fullSelection = new Array(sliceShape.length).fill(null);
+            await zarr.set(sliceArray, fullSelection, sliceData);
+            // Create NgffImage for this slice (without 't' dimension)
+            const sliceImage = new NgffImage({
+                data: sliceArray,
+                dims: newDims,
+                scale: Object.fromEntries(Object.entries(image.scale).filter(([dim]) => dim !== "t")),
+                translation: Object.fromEntries(Object.entries(image.translation).filter(([dim]) => dim !== "t")),
+                name: image.name,
+                axesUnits: image.axesUnits
+                    ? Object.fromEntries(Object.entries(image.axesUnits).filter(([dim]) => dim !== "t"))
+                    : undefined,
+                computedCallbacks: image.computedCallbacks,
+            });
+            // Recursively downsample this slice
+            const downsampledSlice = await downsampleBinShrinkImpl(sliceImage, dimFactors, spatialDims);
+            downsampledSlices.push(downsampledSlice.data);
+        }
+        // Combine downsampled slices back into a single array with 't' dimension
+        const firstSlice = downsampledSlices[0];
+        const combinedShape = [...image.data.shape];
+        combinedShape[tDimIndex] = tSize;
+        // Update spatial dimensions based on downsampled size
+        for (let i = 0; i < image.dims.length; i++) {
+            if (i !== tDimIndex) {
+                const sliceIndex = i < tDimIndex ? i : i - 1;
+                combinedShape[i] = firstSlice.shape[sliceIndex];
+            }
+        }
+        // Create combined array
+        const combinedStore = new Map();
+        const combinedRoot = zarr.root(combinedStore);
+        const combinedArray = await zarr.create(combinedRoot.resolve("combined"), {
+            shape: combinedShape,
+            chunk_shape: combinedShape.map((s) => Math.min(s, 256)),
+            data_type: image.data.dtype,
+            fill_value: 0,
+        });
+        // Copy each downsampled slice into the combined array
+        for (let t = 0; t < tSize; t++) {
+            const sliceData = await zarr.get(downsampledSlices[t]);
+            const targetSelection = new Array(combinedShape.length).fill(null);
+            targetSelection[tDimIndex] = t;
+            await zarr.set(combinedArray, targetSelection, sliceData);
+        }
+        // Compute new metadata
+        const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+        return new NgffImage({
+            data: combinedArray,
+            dims: image.dims,
+            scale: { ...image.scale, ...scale },
+            translation: { ...image.translation, ...translation },
+            name: image.name,
+            axesUnits: image.axesUnits,
+            computedCallbacks: image.computedCallbacks,
+        });
+    }
+    const isVector = image.dims.includes("c");
+    // Convert to ITK-Wasm format
+    const itkImage = await zarrToItkImage(image.data, image.dims, isVector);
+    // Prepare shrink factors - only for spatial dimensions in ITK order (reversed)
+    const shrinkFactors = [];
+    for (let i = image.dims.length - 1; i >= 0; i--) {
+        const dim = image.dims[i];
+        if (SPATIAL_DIMS.includes(dim)) {
+            shrinkFactors.push(dimFactors[dim] || 1);
+        }
+    }
+    // Perform downsampling using browser-compatible function
+    const { downsampled } = await downsampleBinShrink(itkImage, {
+        shrinkFactors,
+    });
+    // Compute new metadata
+    const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+    // Convert back to zarr array in a new in-memory store
+    const store = new Map();
+    const chunkShape = downsampled.size.map((s) => Math.min(s, 256)).reverse();
+    const array = await itkImageToZarr(downsampled, store, "image", chunkShape, image.dims);
+    return new NgffImage({
+        data: array,
+        dims: image.dims,
+        scale,
+        translation,
+        name: image.name,
+        axesUnits: image.axesUnits,
+        computedCallbacks: image.computedCallbacks,
+    });
+}
+/**
+ * Perform label image downsampling using ITK-Wasm (browser version)
+ */
+async function downsampleLabelImageImpl(image, dimFactors, spatialDims) {
+    // Handle time dimension by processing each time slice independently
+    if (image.dims.includes("t")) {
+        const tDimIndex = image.dims.indexOf("t");
+        const tSize = image.data.shape[tDimIndex];
+        const newDims = image.dims.filter((dim) => dim !== "t");
+        // Downsample each time slice
+        const downsampledSlices = [];
+        for (let t = 0; t < tSize; t++) {
+            // Extract time slice
+            const selection = new Array(image.data.shape.length).fill(null);
+            selection[tDimIndex] = t;
+            const sliceData = await zarr.get(image.data, selection);
+            // Create temporary zarr array for this slice
+            const sliceStore = new Map();
+            const sliceRoot = zarr.root(sliceStore);
+            const sliceShape = image.data.shape.filter((_, i) => i !== tDimIndex);
+            const sliceChunkShape = sliceShape.map((s) => Math.min(s, 256));
+            const sliceArray = await zarr.create(sliceRoot.resolve("slice"), {
+                shape: sliceShape,
+                chunk_shape: sliceChunkShape,
+                data_type: image.data.dtype,
+                fill_value: 0,
+            });
+            const fullSelection = new Array(sliceShape.length).fill(null);
+            await zarr.set(sliceArray, fullSelection, sliceData);
+            // Create NgffImage for this slice (without 't' dimension)
+            const sliceImage = new NgffImage({
+                data: sliceArray,
+                dims: newDims,
+                scale: Object.fromEntries(Object.entries(image.scale).filter(([dim]) => dim !== "t")),
+                translation: Object.fromEntries(Object.entries(image.translation).filter(([dim]) => dim !== "t")),
+                name: image.name,
+                axesUnits: image.axesUnits
+                    ? Object.fromEntries(Object.entries(image.axesUnits).filter(([dim]) => dim !== "t"))
+                    : undefined,
+                computedCallbacks: image.computedCallbacks,
+            });
+            // Recursively downsample this slice
+            const downsampledSlice = await downsampleLabelImageImpl(sliceImage, dimFactors, spatialDims);
+            downsampledSlices.push(downsampledSlice.data);
+        }
+        // Combine downsampled slices back into a single array with 't' dimension
+        const firstSlice = downsampledSlices[0];
+        const combinedShape = [...image.data.shape];
+        combinedShape[tDimIndex] = tSize;
+        // Update spatial dimensions based on downsampled size
+        for (let i = 0; i < image.dims.length; i++) {
+            if (i !== tDimIndex) {
+                const sliceIndex = i < tDimIndex ? i : i - 1;
+                combinedShape[i] = firstSlice.shape[sliceIndex];
+            }
+        }
+        // Create combined array
+        const combinedStore = new Map();
+        const combinedRoot = zarr.root(combinedStore);
+        const combinedArray = await zarr.create(combinedRoot.resolve("combined"), {
+            shape: combinedShape,
+            chunk_shape: combinedShape.map((s) => Math.min(s, 256)),
+            data_type: image.data.dtype,
+            fill_value: 0,
+        });
+        // Copy each downsampled slice into the combined array
+        for (let t = 0; t < tSize; t++) {
+            const sliceData = await zarr.get(downsampledSlices[t]);
+            const targetSelection = new Array(combinedShape.length).fill(null);
+            targetSelection[tDimIndex] = t;
+            await zarr.set(combinedArray, targetSelection, sliceData);
+        }
+        // Compute new metadata
+        const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+        return new NgffImage({
+            data: combinedArray,
+            dims: image.dims,
+            scale: { ...image.scale, ...scale },
+            translation: { ...image.translation, ...translation },
+            name: image.name,
+            axesUnits: image.axesUnits,
+            computedCallbacks: image.computedCallbacks,
+        });
+    }
+    const isVector = image.dims.includes("c");
+    // Convert to ITK-Wasm format
+    const itkImage = await zarrToItkImage(image.data, image.dims, isVector);
+    // Prepare shrink factors - need to be for ALL dimensions in ITK order (reversed)
+    const shrinkFactors = [];
+    for (let i = image.dims.length - 1; i >= 0; i--) {
+        const dim = image.dims[i];
+        if (SPATIAL_DIMS.includes(dim)) {
+            shrinkFactors.push(dimFactors[dim] || 1);
+        }
+        else {
+            shrinkFactors.push(1); // Non-spatial dimensions don't shrink
+        }
+    }
+    // Use all zeros for cropRadius
+    const cropRadius = new Array(shrinkFactors.length).fill(0);
+    // Perform downsampling using browser-compatible function
+    const { downsampled } = await downsampleLabelImage(itkImage, {
+        shrinkFactors,
+        cropRadius: cropRadius,
+    });
+    // Compute new metadata
+    const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+    // Convert back to zarr array in a new in-memory store
+    const store = new Map();
+    const chunkShape = downsampled.size.map((s) => Math.min(s, 256)).reverse();
+    const array = await itkImageToZarr(downsampled, store, "image", chunkShape, image.dims);
+    return new NgffImage({
+        data: array,
+        dims: image.dims,
+        scale,
+        translation,
+        name: image.name,
+        axesUnits: image.axesUnits,
+        computedCallbacks: image.computedCallbacks,
+    });
+}
+/**
+ * Main downsampling function for ITK-Wasm (browser version)
+ */
+export async function downsampleItkWasm(ngffImage, scaleFactors, smoothing) {
+    const multiscales = [ngffImage];
+    const dims = ngffImage.dims;
+    const spatialDims = dims.filter((dim) => SPATIAL_DIMS.includes(dim));
+    let previousImage = ngffImage;
+    let previousDimFactors = {};
+    for (const dim of dims)
+        previousDimFactors[dim] = 1;
+    for (let i = 0; i < scaleFactors.length; i++) {
+        const scaleFactor = scaleFactors[i];
+        let sourceImage;
+        let sourceDimFactors;
+        if (smoothing === "bin_shrink") {
+            // Purely incremental: scaleFactor is the shrink for this step
+            sourceImage = previousImage;
+            sourceDimFactors = {};
+            if (typeof scaleFactor === "number") {
+                for (const dim of spatialDims)
+                    sourceDimFactors[dim] = scaleFactor;
+            }
+            else {
+                for (const dim of spatialDims) {
+                    sourceDimFactors[dim] = scaleFactor[dim] || 1;
+                }
+            }
+            for (const dim of dims) {
+                if (!(dim in sourceDimFactors))
+                    sourceDimFactors[dim] = 1;
+            }
+        }
+        else {
+            // Hybrid absolute strategy
+            const dimFactors = dimScaleFactors(dims, scaleFactor, previousDimFactors, ngffImage, previousImage);
+            let canDownsampleIncrementally = true;
+            for (const dim of Object.keys(dimFactors)) {
+                const dimIndex = ngffImage.dims.indexOf(dim);
+                if (dimIndex >= 0) {
+                    const originalSize = ngffImage.data.shape[dimIndex];
+                    const targetSize = Math.floor(originalSize /
+                        (typeof scaleFactor === "number"
+                            ? scaleFactor
+                            : scaleFactor[dim]));
+                    const prevDimIndex = previousImage.dims.indexOf(dim);
+                    const previousSize = previousImage.data.shape[prevDimIndex];
+                    if (Math.floor(previousSize / dimFactors[dim]) !== targetSize) {
+                        canDownsampleIncrementally = false;
+                        break;
+                    }
+                }
+            }
+            if (canDownsampleIncrementally) {
+                sourceImage = previousImage;
+                sourceDimFactors = dimFactors;
+            }
+            else {
+                sourceImage = ngffImage;
+                const originalDimFactors = {};
+                for (const dim of dims)
+                    originalDimFactors[dim] = 1;
+                sourceDimFactors = dimScaleFactors(dims, scaleFactor, originalDimFactors);
+            }
+        }
+        let downsampled;
+        if (smoothing === "gaussian") {
+            downsampled = await downsampleGaussian(sourceImage, sourceDimFactors, spatialDims);
+        }
+        else if (smoothing === "bin_shrink") {
+            downsampled = await downsampleBinShrinkImpl(sourceImage, sourceDimFactors, spatialDims);
+        }
+        else if (smoothing === "label_image") {
+            downsampled = await downsampleLabelImageImpl(sourceImage, sourceDimFactors, spatialDims);
+        }
+        else {
+            throw new Error(`Unknown smoothing method: ${smoothing}`);
+        }
+        multiscales.push(downsampled);
+        previousImage = downsampled;
+        if (smoothing === "bin_shrink") {
+            if (typeof scaleFactor === "number") {
+                for (const dim of spatialDims) {
+                    previousDimFactors[dim] *= scaleFactor;
+                }
+            }
+            else {
+                for (const dim of spatialDims) {
+                    previousDimFactors[dim] *= scaleFactor[dim] || 1;
+                }
+            }
+        }
+        else {
+            previousDimFactors = updatePreviousDimFactors(scaleFactor, spatialDims, previousDimFactors);
+        }
+    }
+    return multiscales;
+}

package/esm/methods/itkwasm-node.d.ts

@@ -0,0 +1,6 @@
+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-node.d.ts.map

package/esm/methods/itkwasm-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"itkwasm-node.d.ts","sourceRoot":"","sources":["../../src/methods/itkwasm-node.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"}