ZarrNET Namespace Reference

Classes
class	BloscCodec
	Blosc bytes-to-bytes codec. More...
class	BytesCodec
	The "bytes" array-to-bytes codec (Zarr v3 spec section 3.3.2). Handles endianness conversion when translating between the in-memory array representation and a flat byte sequence. This is always the first codec in a Zarr v3 pipeline. More...
class	ChunkGridConfigurationDocument
class	ChunkGridDocument
class	ChunkKeyEncodingConfigurationDocument
class	ChunkKeyEncodingDocument
class	CodecDocument
class	CodecFactory
	Builds a CodecPipeline from the CodecInfo descriptors stored in ZarrArrayMetadata. This is the only place that knows which codec name maps to which implementation. Handles both Zarr v3 (named pipeline) and Zarr v2 (single compressor, synthesised pipeline).
class	CodecPipeline
	Applies an ordered list of codecs as a pipeline. More...
class	Crc32cCodec
	The "crc32c" bytes-to-bytes codec (Zarr v3 spec). More...
class	DiagnoseChunks
class	DiagnosticHelper
class	GzipCodec
	Gzip bytes-to-bytes codec. Wraps System.IO.Compression — no native dependencies. Configuration mirrors the zarr.json "gzip" codec configuration object. More...
interface	IZarrCodec
	A single step in a Zarr v3 codec pipeline. Codecs are applied in order during encoding (array → bytes → compressed) and reversed during decoding. Each codec is responsible for one transformation only. More...
class	NumpyDtypeParser
	Parses numpy-style dtype strings used in Zarr v2. Format: [byteorder][typecode][size] byteorder: '<' (little), '>' (big), '|' (not applicable) typecode: 'u' (uint), 'i' (int), 'f' (float), 'b' (bool) size: number of bytes (1, 2, 4, 8) Examples: "<u2" → little-endian uint16, ">f4" → big-endian float32, "|u1" → uint8.
class	PlaneHelpers
class	Reader
class	ShardingConfig
	Configuration for a sharding_indexed codec parsed from zarr.json. More...
class	ShardReader
	Reads individual inner chunks from a shard file.
class	SimpleHttpTest
class	ZarrArrayMetadata
	Typed metadata for a Zarr array node. Knows everything needed to read/write chunks — shape, data type, chunk layout, codec pipeline configuration. No OME-Zarr knowledge here. More...
class	ZarrDataType
	Typed representation of a Zarr v3 data type string (e.g. "uint8", "float32"). Resolves element size in bytes and provides type classification used by the codec pipeline for byte-order handling. More...
class	ZarrGroupMetadata
	Typed metadata for a Zarr v3 group node. Groups are pure containers — no data, no shape, just attributes and children. More...
class	ZarrJsonDocument
	Raw deserialisation of a zarr.json node document (Zarr v3 spec). This is the only place we touch raw JSON — all higher layers work with typed metadata objects derived from this. More...
class	ZarrV2ArrayDocument
	Raw deserialization of a .zarray file (Zarr v2). Maps array metadata — shape, chunks, dtype, compression. More...
class	ZarrV2AttrsDocument
	Raw deserialization of a .zattrs file (Zarr v2). This is freeform JSON — OME-Zarr metadata lives here. We just parse it as a raw JsonElement and pass to OmeAttributesParser. More...
class	ZarrV2CompressorDocument
class	ZarrV2GroupDocument
	Raw deserialization of a .zgroup file (Zarr v2). Just contains the format version — no other metadata. More...
class	ZstdCodec
	Zstandard bytes-to-bytes codec. Uses ZstdSharp (managed wrapper around the native zstd library, available as a NuGet package). NuGet: ZstdSharp.Port (pure managed port, no native deps) More...

Enumerations
enum	BloscShuffle { None = 0 , ByteShuffle = 1 , BitShuffle = 2 }
	Shuffle filter mode stored in the Blosc frame header flags byte. More...
enum	ByteOrder { LittleEndian , BigEndian }
enum	ShardIndexLocation { End , Start }

Functions
class	PropertyReferanceGuide ()
record	CodecInfo (string Name, JsonElement? Configuration)
	Lightweight codec descriptor parsed from zarr.json or synthesised from a v2 compressor. The actual IZarrCodec instances are built by CodecFactory from this.

Enumeration Type Documentation

BloscShuffle

enum ZarrNET.BloscShuffle

Shuffle filter mode stored in the Blosc frame header flags byte.

{
    None        = 0,
    ByteShuffle = 1,
    BitShuffle  = 2
}

ByteOrder

enum ZarrNET.ByteOrder

{
    LittleEndian,
    BigEndian
}

ShardIndexLocation

enum ZarrNET.ShardIndexLocation

{
    End,
    Start
}

Function Documentation

PropertyReferanceGuide()

class ZarrNET.PropertyReferanceGuide

(

)

    {
        public static MultiscaleNode image;
        // =============================================================================
        // ResolutionLevelNode - Array-level properties
        // =============================================================================
        public static async Task Start(MultiscaleNode node)
        {
            await using var reader = await OmeZarrReader.OpenAsync("path/to/data.zarr");
            image = reader.AsMultiscaleImage();
            var level = await image.OpenResolutionLevelAsync(0);
 
            // ✓ CORRECT - Available on ResolutionLevelNode:
            long[] shape = level.Shape;              // [t, c, z, y, x] - full array dimensions
            string dtype = level.DataType;           // "uint16", "float32", etc.
            int rank = level.Rank;                   // Number of dimensions (e.g., 5 for t,c,z,y,x)
            double[] pixelSize = level.GetPixelSize(); // Physical size per pixel [µm, µm, µm...]
 
            // Example: Get width and height from Shape
            var axes = level.Multiscale.Axes;
            var yIndex = Array.FindIndex(axes, a => a.Name.Equals("y", StringComparison.OrdinalIgnoreCase));
            var xIndex = Array.FindIndex(axes, a => a.Name.Equals("x", StringComparison.OrdinalIgnoreCase));
            long arrayHeight = level.Shape[yIndex];  // Full array height
            long arrayWidth = level.Shape[xIndex];   // Full array width
 
            // ✗ WRONG - These don't exist on ResolutionLevelNode:
            // int width = level.Width;    // ❌ Compile error
            // int height = level.Height;  // ❌ Compile error
 
            // =============================================================================
            // PlaneResult - 2D plane properties (after reading)
            // =============================================================================
 
            var plane = await level.ReadPlaneAsync(t: 0, c: 0, z: 0);
 
            // ✓ CORRECT - Available on PlaneResult:
            int width = plane.Width;                 // Width of the read plane (x dimension)
            int height = plane.Height;               // Height of the read plane (y dimension)
                                                     //byte[] data = plane.Data;                // Raw bytes
                                                     //int[] shape = plane.Shape;               // Shape of the read region
                                                     //string dtype = plane.DataType;           // Data type string
 
            // Extract data:
            ushort[,] pixels2D = plane.As2DArray<ushort>();
            ushort[] pixels1D = plane.As1DArray<ushort>();
            byte[] bytes = plane.ToBytes<ushort>(ZarrNET.Core.Helpers.PixelFormat.Gray8);
 
            // =============================================================================
            // RegionResult - Multi-dimensional region (may not be 2D)
            // =============================================================================
 
            var roi = new PhysicalROI(
                origin: [0, 0, 0, 0, 0],
                size: [5, 4, 10, 100, 100]  // Multiple timepoints, channels, z-slices
            );
            var result = await level.ReadRegionAsync(roi);
 
            // ✓ CORRECT - Available on RegionResult:
            var data = result.Data;               // Raw bytes
            shape = result.Shape;              // [5, 4, 10, 100, 100] in this case
            dtype = result.DataType;          // Data type
            rank = result.Rank;                  // Number of dimensions
            var elementCount = result.ElementCount; // Total elements
 
            // ✗ WRONG - Width/Height only exist if it's a 2D plane:
            // int width = result.Width;    // ❌ Not available on RegionResult
            // int height = result.Height;  // ❌ Not available on RegionResult
        }
        // =============================================================================
        // Common Patterns
        // =============================================================================
 
        // Pattern 1: Get full array dimensions
        public static async Task GetArrayDimensions()
        {
            var level = await image.OpenResolutionLevelAsync(0);
 
            // Method 1: From Shape with axis names
            var axes = level.Multiscale.Axes;
            for (int i = 0; i < axes.Length; i++)
            {
                Console.WriteLine($"{axes[i].Name}: {level.Shape[i]}");
            }
 
            // Method 2: Direct indexing (if you know the layout)
            // Typical 5D: [t, c, z, y, x]
            if (level.Rank == 5)
            {
                long t = level.Shape[0];
                long c = level.Shape[1];
                long z = level.Shape[2];
                long y = level.Shape[3];
                long x = level.Shape[4];
                Console.WriteLine($"Array: {t}t x {c}c x {z}z x {y}y x {x}x");
            }
        }
 
        // Pattern 2: Get plane dimensions after reading
        public static async Task GetPlaneDimensions()
        {
            var level = await image.OpenResolutionLevelAsync(0);
            var plane = await level.ReadPlaneAsync(t: 0, c: 0, z: 0);
 
            // ✓ CORRECT - plane has Width and Height
            Console.WriteLine($"Plane: {plane.Width} x {plane.Height}");
 
            // Also available:
            Console.WriteLine($"Shape: [{string.Join(", ", plane.Shape)}]");
        }
 
        // Pattern 3: Validate dimensions before processing
        public async static Task ValidateDimensions()
        {
            var level = await image.OpenResolutionLevelAsync(0);
 
            // Check if it's a 5D dataset
            if (level.Rank != 5)
            {
                throw new InvalidOperationException(
                    $"Expected 5D data (t,c,z,y,x), got {level.Rank}D");
            }
 
            // Check spatial dimensions
            var yIndex = Array.FindIndex(level.Multiscale.Axes,
                a => a.Name.Equals("y", StringComparison.OrdinalIgnoreCase));
            var xIndex = Array.FindIndex(level.Multiscale.Axes,
                a => a.Name.Equals("x", StringComparison.OrdinalIgnoreCase));
 
            long height = level.Shape[yIndex];
            long width = level.Shape[xIndex];
 
            Console.WriteLine($"Spatial dimensions: {width} x {height}");
        }
 
        // Pattern 4: Read and process plane data
        public async static Task ProcessPlane()
        {
            var level = await image.OpenResolutionLevelAsync(0);
            var plane = await level.ReadPlaneAsync(t: 0, c: 0, z: 0);
 
            // Get dimensions from the plane result
            int w = plane.Width;
            int h = plane.Height;
 
            // Process the data
            var pixels = plane.As2DArray<ushort>();
            for (int y = 0; y < h; y++)
            {
                for (int x = 0; x < w; x++)
                {
                    ushort value = pixels[y, x];
                    // Process pixel...
                }
            }
        }
    }