Skip to content

OME-Zarr metadata — NGFF 0.6.dev4

A preview of the next NGFF release; the model may still change.

Changes from NGFF 0.6.dev3

  • The transform input/output model is overhauled. A CoordinateTransformation's input and output are no longer free-form coordinate-system name strings but a structured Space object (a name and/or a path), and are now recommended fields.
  • Alongside that, the matrix transforms are given concrete shapes: Affine's affine and Rotation's rotation become nested float lists, and path becomes required on Displacements and Coordinates.

abczarr.ome.v0_6dev4.ome

abczarr.ome.v0_6dev4.ome

The top-level metadata attached to an OME-Zarr group.

OME and its subclasses each describe what kind of group carries them, an image, a plate, a well, a scene, a collection of labels, and so on.

Classes

OME 

OME(*, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}), version: Literal['0.6.dev4'] = '0.6.dev4')

Bases: OME

The version-tagged root of an OME-Zarr group's metadata.

Every more specific container, such as OMEImage or OMEPlate, is an OME object that carries one further field identifying what kind of group it describes.

Attributes
version class-attribute instance-attribute 
version: Required[Version] = field(kw_only=True)

The OME-NGFF version the metadata is written against.

Methods:

OMESeries 

OMESeries(series: Iterable[str | bytes] | None = None, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}), version: Literal['0.6.dev4'] = '0.6.dev4')

Bases: OME

Marks an OME-Zarr group that collects other groups as a named series.

Attributes
series class-attribute instance-attribute 
series: list[str] | None = None

The path of each member group, in order, when the group states them explicitly. Optional.

Methods:

OMEImage 

OMEImage(multiscales: Iterable[Multiscale | JsonDict | list[CoordinateSystem]], omero: Omero | JsonDict | list[Channel] = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}), version: Literal['0.6.dev4'] = '0.6.dev4')

Bases: OME

Holds an image group's metadata: its multiscale pyramids and rendering settings.

Attributes
multiscales instance-attribute 
multiscales: Required[list[Multiscale]]

The group's Multiscale pyramids.

omero instance-attribute 
omero: Optional[Omero]

Rendering settings suggesting how to render the pyramids. Optional.

Methods:

OMEImageLabel 

OMEImageLabel(multiscales: Iterable[Multiscale | JsonDict | list[CoordinateSystem]], omero: Omero | JsonDict | list[Channel] = MISSING, image_label: ImageLabel | JsonDict | list[Color], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}), version: Literal['0.6.dev4'] = '0.6.dev4')

Bases: OMEImage

Marks an image group that is itself a segmentation label image.

Extends OMEImage with the metadata describing the segments the image's pixel values name.

Attributes
image_label class-attribute instance-attribute 
image_label: Required[ImageLabel] = field(json='image-label')

The ImageLabel metadata for the segments.

Methods:

OMELabels 

OMELabels(labels: Iterable[str | bytes], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}), version: Literal['0.6.dev4'] = '0.6.dev4')

Bases: OME

Marks a group that collects the label images derived from an intensity image.

Attributes
labels instance-attribute 
labels: Required[list[str]]

The path of each label image group.

Methods:

OMEPlate 

OMEPlate(plate: Plate | JsonDict | list[Acquisition], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}), version: Literal['0.6.dev4'] = '0.6.dev4')

Bases: OME

Holds a high-content screening plate group's metadata.

Attributes
plate instance-attribute 
plate: Required[Plate]

The Plate metadata describing the plate's rows, columns, and wells.

Methods:

OMEWell 

OMEWell(well: Well | JsonDict | list[Image], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}), version: Literal['0.6.dev4'] = '0.6.dev4')

Bases: OME

Holds a well group's metadata: the images acquired at one position of a plate.

Attributes
well instance-attribute 
well: Required[Well]

The Well metadata listing the well's fields of view.

Methods:

OMEScene 

OMEScene(scene: Scene | JsonDict | list[CoordinateTransformation], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}), version: Literal['0.6.dev4'] = '0.6.dev4')

Bases: OME

Marks a group whose metadata is a scene.

Attributes
scene instance-attribute 
scene: Required[Scene]

The Scene the group carries.

Methods:

OMEBioformats2Raw 

OMEBioformats2Raw(bioformats2raw_layout: Literal[3] = 3, plate: Plate | JsonDict | list[Acquisition], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}), version: Literal['0.6.dev4'] = '0.6.dev4')

Bases: OME

The root group of a Bio-Formats2Raw-layout conversion.

Attributes
bioformats2raw_layout class-attribute instance-attribute 
bioformats2raw_layout: Required[Literal[3]] = field(json='bioformats2raw.layout')

Marks the layout version. Its value is always 3.

plate instance-attribute 
plate: Required[Plate]

The Plate metadata for the screening plate the converted data belongs to.

Methods:

abczarr.ome.v0_6dev4.images

abczarr.ome.v0_6dev4.images

The multiscale image pyramid.

Multiscale describes a pyramid of progressively downsampled resolution levels, placed within one or more named coordinate systems. Each level is a Dataset, naming a Zarr array and how it maps into those coordinate systems.

Classes

Dataset 

Dataset(path: str | bytes, coordinateTransformations: Iterable[CoordinateTransformation | JsonDict | str], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

One resolution level of a multiscale pyramid.

Attributes
path class-attribute instance-attribute 
path: Required[str] = field(factory=False)

The name of the Zarr array holding this level, relative to the image group.

coordinateTransformations instance-attribute 
coordinateTransformations: Required[list[CoordinateTransformation]]

One or more transformations that map this level's own coordinate system into another coordinate system of the pyramid.

Methods:

Multiscale 

Multiscale(coordinateSystems: Iterable[CoordinateSystem | JsonDict | str], datasets: Iterable[Dataset | JsonDict | str], coordinateTransformations: Iterable[CoordinateTransformation | JsonDict | str] = MISSING, name: str | bytes = MISSING, type: str | bytes = MISSING, metadata: Metadata | JsonDict | str = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

An image pyramid: its coordinate systems and its resolution levels.

Attributes
coordinateSystems instance-attribute 
coordinateSystems: Required[list[CoordinateSystem]]

Every CoordinateSystem that a Dataset or a transformation in coordinateTransformations can refer to.

datasets instance-attribute 
datasets: Required[list[Dataset]]

The pyramid's resolution levels, from full resolution down.

coordinateTransformations instance-attribute 
coordinateTransformations: Recommended[list[CoordinateTransformation]]

Transformations applied to every level, after that level's own transformations have run. A level's own transformations map that level from its own coordinate system into a coordinate system the pyramid shares. These transformations then map that shared coordinate system into the pyramid's world coordinate system. Recommended.

name instance-attribute 
name: Recommended[str]

A name for the multiscale image. Recommended.

type instance-attribute 
type: Recommended[str]

The method used to generate the lower resolutions, such as "gaussian". Recommended.

metadata instance-attribute 
metadata: Recommended[Metadata]

Further, free-form detail about how the lower resolutions were generated. Recommended.

Classes
Metadata 
Metadata(method: str | bytes = MISSING, version: str | bytes = MISSING, args: Any = MISSING, kwargs: Iterable[tuple[str | bytes, Any]] | Mapping[str | bytes, Any] = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

Free-form detail about how a pyramid's lower resolutions were generated.

Attributes
method instance-attribute 
method: Optional[str]

The name of the downsampling function. Optional.

version instance-attribute 
version: Optional[str]

The version of the software that ran method. Optional.

args instance-attribute 
args: Optional[Json]

The positional arguments method was called with. Optional.

kwargs instance-attribute 
kwargs: Optional[dict[str, Json]]

The keyword arguments method was called with. Optional.

Methods:
Methods:

abczarr.ome.v0_6dev4.systems

abczarr.ome.v0_6dev4.systems

Coordinate systems: the named axes a transformation maps between.

Attributes

AxisType module-attribute 

AxisType = tx.Literal['array', 'space', 'time', 'channel', 'coordinate', 'displacement']

SpaceUnit module-attribute 

SpaceUnit = tx.Literal['angstrom', 'attometer', 'centimeter', 'decimeter', 'exameter', 'femtometer', 'foot', 'gigameter', 'hectometer', 'inch', 'kilometer', 'megameter', 'meter', 'micrometer', 'mile', 'millimeter', 'nanometer', 'parsec', 'petameter', 'picometer', 'terameter', 'yard', 'yoctometer', 'yottameter', 'zeptometer', 'zettameter']

TimeUnit module-attribute 

TimeUnit = tx.Literal['attosecond', 'centisecond', 'day', 'decisecond', 'exasecond', 'femtosecond', 'gigasecond', 'hectosecond', 'hour', 'kilosecond', 'megasecond', 'microsecond', 'millisecond', 'minute', 'nanosecond', 'petasecond', 'picosecond', 'second', 'terasecond', 'yoctosecond', 'yottasecond', 'zeptosecond', 'zettasecond']

Unit module-attribute 

Unit = SpaceUnit | TimeUnit

Classes

Axis 

Axis(name: str | bytes, type: str | bytes = MISSING, discrete: bool | int | str = MISSING, unit: str | bytes = MISSING, longName: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

Describes one dimension of a CoordinateSystem.

Constructing an Axis with a recognized type returns the matching subclass, such as SpaceAxis.

Attributes
name class-attribute instance-attribute 
name: Required[str] = field(factory=False)

The axis's label, such as "x" or "channel".

type instance-attribute 
type: Recommended[AxisType | str]

What kind of axis this is: "space", "time", "channel", "array", "displacement", or "coordinate". Recommended.

discrete instance-attribute 
discrete: Optional[bool]

Marks an axis whose values are integer indices rather than continuous coordinates. Optional.

unit instance-attribute 
unit: Recommended[Unit | str]

The axis's physical unit, when it has one. Recommended.

longName instance-attribute 
longName: Optional[str]

A human-readable label for the axis, beyond name. Optional.

Methods:

SpaceAxis 

SpaceAxis(name: str | bytes, type: str | bytes = MISSING, discrete: bool | int | str = MISSING, unit: str | bytes = MISSING, longName: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: Axis

A spatial axis, such as x, y, or z, with a length unit.

Attributes
type instance-attribute 
type: Recommended[Literal['space']]
unit instance-attribute 
unit: Recommended[SpaceUnit]

The axis's physical length unit, such as "micrometer". Recommended.

Methods:

TimeAxis 

TimeAxis(name: str | bytes, type: str | bytes = MISSING, discrete: bool | int | str = MISSING, unit: str | bytes = MISSING, longName: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: Axis

A temporal axis, with a duration unit.

Attributes
type instance-attribute 
type: Recommended[Literal['time']]
unit instance-attribute 
unit: Recommended[TimeUnit]

The axis's physical duration unit, such as "second". Recommended.

Methods:

ChannelAxis 

ChannelAxis(name: str | bytes, type: str | bytes = MISSING, discrete: bool | int | str = MISSING, unit: str | bytes = MISSING, longName: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: Axis

Indexes an image's channels, carrying no physical unit.

Attributes
type instance-attribute 
type: Recommended[Literal['channel']]
unit instance-attribute 
unit: NotRecommended[Unit]
Methods:

ArrayAxis 

ArrayAxis(name: str | bytes, type: str | bytes = MISSING, discrete: bool | int | str = MISSING, unit: str | bytes = MISSING, longName: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: Axis

A discrete axis of an array's own coordinate system.

The axis's values are raw pixel or voxel indices, before any transformation into a physical or temporal coordinate system.

Attributes
type instance-attribute 
type: Required[Literal['array']]
unit instance-attribute 
unit: NotRecommended[Unit]
Methods:

DisplacementAxis 

DisplacementAxis(name: str | bytes, type: str | bytes = MISSING, discrete: bool | int | str = MISSING, unit: str | bytes = MISSING, longName: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: Axis

An axis whose values are the components of a displacement vector.

The axis labels a dimension of the array that a Displacements transformation reads its offsets from.

Attributes
type instance-attribute 
type: Required[Literal['displacement']]
unit instance-attribute 
unit: NotRecommended[Unit]
Methods:

CoordinateAxis 

CoordinateAxis(name: str | bytes, type: str | bytes = MISSING, discrete: bool | int | str = MISSING, unit: str | bytes = MISSING, longName: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: Axis

An axis whose values are the components of a coordinate vector.

The axis labels a dimension of the array that a Coordinates transformation reads its positions from.

Attributes
type instance-attribute 
type: Required[Literal['coordinate']]
unit instance-attribute 
unit: NotRecommended[Unit]
Methods:

CoordinateSystem 

CoordinateSystem(name: str | bytes, axes: Iterable[Axis | JsonDict | str], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

A named set of axes.

A coordinate system is a space that data and transformations refer to by name. A Dataset or a CoordinateTransformation names a CoordinateSystem by its name as its input or output.

Attributes
name class-attribute instance-attribute 
name: Required[str] = field(factory=False)

The coordinate system's name.

axes instance-attribute 
axes: Required[list[Axis]]

The system's Axis objects, in order. That order is the order every coordinate tuple in this coordinate system uses.

Methods:

abczarr.ome.v0_6dev4.transformations

abczarr.ome.v0_6dev4.transformations

Coordinate transformations: how one coordinate system maps to another.

Classes

Space 

Space(name: str | bytes = MISSING, path: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

Identifies a CoordinateSystem that a transformation maps to or from.

Attributes
name instance-attribute 
name: Optional[str]

Identifies the coordinate system directly. Optional.

path instance-attribute 
path: Optional[str]

Locates the coordinate system in another group, for one defined outside the transformation's own group. Optional.

Methods:

CoordinateTransformation 

CoordinateTransformation(type: str | bytes, output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

Maps coordinates from one coordinate system to another.

Constructing a CoordinateTransformation with a recognized type returns the matching subclass, such as Scale.

Attributes
type class-attribute instance-attribute 
type: Required[str] = field(factory=False)

Which kind of transformation this is.

output instance-attribute 
output: Recommended[Space]

The Space identifying the coordinate system the transformation maps to. Recommended.

input instance-attribute 
input: Recommended[Space]

The Space identifying the coordinate system the transformation maps from. Recommended.

name instance-attribute 
name: Optional[str]

A label for the transformation itself. Optional.

Methods:

Identity 

Identity(type: Literal['identity'] = 'identity', output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: CoordinateTransformation

Leaves coordinates unchanged.

States that input and output are the same coordinate system, or that no numeric adjustment is needed between them.

Attributes
type instance-attribute 
type: Required[Literal['identity']]
Methods:

MapAxis 

MapAxis(type: Literal['mapAxis'] = 'mapAxis', output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, mapAxis: Iterable[Integral | integer | bool], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: CoordinateTransformation

Permutes axes without changing any coordinate values.

Attributes
type instance-attribute 
type: Required[Literal['mapAxis']]
mapAxis instance-attribute 
mapAxis: Required[list[int]]

One entry per output axis, giving the index of the input axis whose values that output axis carries.

Methods:

Translation 

Translation(type: Literal['translation'] = 'translation', output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, translation: Iterable[Real | floating | bool] = MISSING, path: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: CoordinateTransformation

Adds a fixed offset to every coordinate, one value per axis.

Attributes
type instance-attribute 
type: Required[Literal['translation']]
translation instance-attribute 
translation: Optional[list[float]]

The offset, given inline, one number per axis. Optional.

path instance-attribute 
path: Optional[str]

The path of an array to read the offset from instead, for a translation that varies from point to point rather than staying constant. Optional.

Methods:

Scale 

Scale(type: Literal['scale'] = 'scale', output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, scale: Iterable[Real | floating | bool] = MISSING, path: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: CoordinateTransformation

Multiplies every coordinate by a per-axis factor.

Attributes
type instance-attribute 
type: Required[Literal['scale']]
scale instance-attribute 
scale: Optional[list[float]]

The factor, given inline, one number per axis. Optional.

path instance-attribute 
path: Optional[str]

The path of an array to read the factor from instead, for a scale that varies from point to point rather than staying constant. Optional.

Methods:

Affine 

Affine(type: Literal['affine'] = 'affine', output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, affine: Iterable[Iterable[Real | floating | bool]] = MISSING, path: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: CoordinateTransformation

Applies a linear map and a translation, given as a matrix.

Attributes
type instance-attribute 
type: Required[Literal['affine']]
affine instance-attribute 
affine: Optional[list[list[float]]]

The matrix, given inline. Optional.

path instance-attribute 
path: Optional[str]

The path of an array to read the matrix from instead. Optional.

Methods:

Rotation 

Rotation(type: Literal['rotation'] = 'rotation', output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, rotation: Iterable[Iterable[Real | floating | bool]] = MISSING, path: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: CoordinateTransformation

Rotates coordinates, given as a matrix.

Attributes
type instance-attribute 
type: Required[Literal['rotation']]
rotation instance-attribute 
rotation: Optional[list[list[float]]]

The matrix, given inline. Optional.

path instance-attribute 
path: Optional[str]

The path of an array to read the matrix from instead. Optional.

Methods:

Sequence 

Sequence(type: Literal['sequence'] = 'sequence', output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, transformations: Iterable[CoordinateTransformation | JsonDict | str], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: CoordinateTransformation

Composes several transformations into one, applied in order.

Each transformation's output feeds into the next transformation as its input.

Attributes
type instance-attribute 
type: Required[Literal['sequence']]
transformations instance-attribute 
transformations: Required[list[CoordinateTransformation]]

The transformations to compose, from input to output.

Methods:

Displacements 

Displacements(type: Literal['displacements'] = 'displacements', output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, path: str | bytes, interpolation: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: CoordinateTransformation

Defined by a displacement field.

The vector read for each point is added to the input coordinate to produce the output coordinate.

Attributes
type instance-attribute 
type: Required[Literal['displacements']]
path instance-attribute 
path: Required[str]

The path of an array that gives a displacement vector for each point.

interpolation instance-attribute 
interpolation: Optional[Interpolation]

How to sample the array between its own points. Optional.

Methods:

Coordinates 

Coordinates(type: Literal['coordinates'] = 'coordinates', output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, path: str | bytes, interpolation: str | bytes = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: CoordinateTransformation

Defined by an explicit coordinate lookup.

Attributes
type instance-attribute 
type: Required[Literal['coordinates']]
path instance-attribute 
path: Required[str]

The path of an array that gives the output coordinate for each point directly.

interpolation instance-attribute 
interpolation: Optional[Interpolation]

How to sample the array between its own points. Optional.

Methods:

Bijection 

Bijection(type: Literal['bijection'] = 'bijection', output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, forward: CoordinateTransformation | JsonDict | str, inverse: CoordinateTransformation | JsonDict | str, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: CoordinateTransformation

An explicit forward and inverse pair of transformations.

Used when a transformation's inverse cannot be derived automatically from its forward direction.

Attributes
type instance-attribute 
type: Required[Literal['bijection']]
forward instance-attribute 
forward: Required[CoordinateTransformation]

The transformation from input to output.

inverse instance-attribute 
inverse: Required[CoordinateTransformation]

The transformation from output back to input.

Methods:

ByDimension 

ByDimension(type: Literal['byDimension'] = 'byDimension', output: Space | JsonDict | str = MISSING, input: Space | JsonDict | str = MISSING, name: str | bytes = MISSING, transformations: Iterable[Transformation | JsonDict | CoordinateTransformation], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: CoordinateTransformation

Combines several transformations, each acting on its own subset of axes.

Together, the entries in transformations write every axis of the output coordinate system exactly once.

Attributes
type instance-attribute 
type: Required[Literal['byDimension']]
transformations instance-attribute 
transformations: Required[list[Transformation]]

The transformations to combine.

Classes
Transformation 
Transformation(transformation: CoordinateTransformation | JsonDict | str = MISSING, input_axes: Iterable[Integral | integer | bool] = MISSING, output_axes: Iterable[Integral | integer | bool] = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

One transformation of a ByDimension, and the axes it applies to.

Attributes
transformation instance-attribute 
transformation: Optional[CoordinateTransformation]

The transformation to apply. Optional.

input_axes instance-attribute 
input_axes: Optional[list[int]]

The indices, into the enclosing ByDimension's input coordinate system, of the axes transformation reads from. Optional.

output_axes instance-attribute 
output_axes: Optional[list[int]]

The indices, into the enclosing ByDimension's output coordinate system, of the axes transformation writes to. Optional.

Methods:
Methods:

abczarr.ome.v0_6dev4.scenes

abczarr.ome.v0_6dev4.scenes

A scene: coordinate transformations attached to a group directly.

Classes

Scene 

Scene(coordinateTransformations: Iterable[CoordinateTransformation | JsonDict | str], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

A set of coordinate transformations attached to a group, independent of any single image or pyramid.

Attributes
coordinateTransformations instance-attribute 
coordinateTransformations: Required[list[CoordinateTransformation]]

The transformations the scene carries.

Methods:

abczarr.ome.v0_6dev4.plates

abczarr.ome.v0_6dev4.plates

A high-content screening plate: its rows, columns, wells, and acquisitions.

Classes

Plate 

Plate(acquisitions: Iterable[Acquisition | JsonDict | int] = MISSING, columns: Iterable[Column | JsonDict | str], field_count: Integral | integer | bool = MISSING, name: str | bytes = MISSING, rows: Iterable[Row | JsonDict | str], wells: Iterable[Well | JsonDict | str], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

Describes a high-content screening plate.

rows and columns name the plate's grid, such as "A", "B", and so on for rows, and "1", "2", and so on for columns.

Attributes
acquisitions instance-attribute 
acquisitions: Optional[list[Acquisition]]

The imaging runs the wells' images belong to, when the screen ran more than one. Optional.

columns instance-attribute 
columns: Required[list[Column]]

The plate's columns, in grid order.

field_count instance-attribute 
field_count: Recommended[NonNegativeInt]

The largest number of fields of view acquired for any well of the plate. Recommended.

name instance-attribute 
name: Recommended[str]

A name for the plate. Recommended.

rows instance-attribute 
rows: Required[list[Row]]

The plate's rows, in grid order.

wells instance-attribute 
wells: Required[list[Well]]

Every well of the plate, each placed in the grid and pointing at the group holding its images.

Classes
Acquisition 
Acquisition(id: Integral | integer | bool, name: str | bytes = MISSING, maximumfieldcount: Integral | integer | bool = MISSING, description: str | bytes = MISSING, starttime: Integral | integer | bool = MISSING, endtime: Integral | integer | bool = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

One imaging run over some or all of the plate's wells.

Attributes
id class-attribute instance-attribute 
id: Required[NonNegativeInt] = field(factory=False)

A non-negative integer identifying the acquisition. A Well.Image refers to this run by this value.

name instance-attribute 
name: Recommended[str]

A name for the acquisition. Recommended.

maximumfieldcount instance-attribute 
maximumfieldcount: Recommended[NonNegativeInt]

The largest number of fields of view acquired for any well in this run. Recommended.

description instance-attribute 
description: Optional[str]

A description of the acquisition. Optional.

starttime instance-attribute 
starttime: Optional[int]

The time the acquisition started, in Unix epoch milliseconds. Optional.

endtime instance-attribute 
endtime: Optional[int]

The time the acquisition ended, in Unix epoch milliseconds. Optional.

Methods:
Column 
Column(name: str | bytes, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

One column of the plate's grid, named as it is labeled.

Attributes
name class-attribute instance-attribute 
name: Required[AlphaNumeric] = field(factory=False)

The column's label, made of letters and digits only.

Methods:
Row 
Row(name: str | bytes, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

One row of the plate's grid, named as it is labeled.

Attributes
name class-attribute instance-attribute 
name: Required[AlphaNumeric] = field(factory=False)

The row's label, made of letters and digits only.

Methods:
Well 
Well(path: str | bytes, rowIndex: Integral | integer | bool, columnIndex: Integral | integer | bool, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

One well's position in the plate, and the group holding it.

Attributes
path class-attribute instance-attribute 
path: Required[WellPath] = field(factory=False)

The well's group, relative to the plate group, spelled as "<row>/<column>".

rowIndex instance-attribute 
rowIndex: Required[NonNegativeInt]

The well's row, as an index into Plate.rows.

columnIndex instance-attribute 
columnIndex: Required[NonNegativeInt]

The well's column, as an index into Plate.columns.

Methods:
Methods:

abczarr.ome.v0_6dev4.wells

abczarr.ome.v0_6dev4.wells

A well: the images acquired at one position of a screening plate.

Classes

Well 

Well(images: Iterable[Image | JsonDict | str], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

Lists a well's images: one field of view per acquisition run.

A well group holds one subgroup per field of view.

Attributes
images instance-attribute 
images: Required[list[Image]]

The well's fields of view, each naming its subgroup and, when the plate ran more than one acquisition, which acquisition it belongs to.

Classes
Image 
Image(path: str | bytes, acquisition: Integral | integer | bool = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

One field of view within a well.

Attributes
path class-attribute instance-attribute 
path: Required[str] = field(factory=False)

The image's group, relative to the well group.

acquisition instance-attribute 
acquisition: Recommended[int]

The id of the Plate.Acquisition this field of view was captured in, when the plate ran more than one acquisition. Recommended.

Methods:
Methods:

abczarr.ome.v0_6dev4.labels

abczarr.ome.v0_6dev4.labels

A segmentation label image: display colors and per-label properties.

Classes

ImageLabel 

ImageLabel(colors: Iterable[Color | JsonDict | int] = MISSING, properties: Iterable[Property | JsonDict | int] = MISSING, source: Source | JsonDict | str = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

Describes a segmentation label image: an array whose integer values name segments.

Attach one of these to a label image group alongside its own Multiscale.

Attributes
colors instance-attribute 
colors: Recommended[list[Color]]

The display color for each labeled integer value. Recommended.

properties instance-attribute 
properties: Optional[list[Property]]

Further, application-defined attributes for each labeled value. Optional.

source instance-attribute 
source: Optional[Source]

Where the label image was derived from. Optional.

Classes
Color 
Color(label_value: Integral | integer | bool = MISSING, rgba: tuple[Integral | integer | bool, Integral | integer | bool, Integral | integer | bool, Integral | integer | bool] = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

The display color for one label value.

Attributes
label_value class-attribute instance-attribute 
label_value: Optional[int] = field(json='label-value')

The integer value this color applies to. Optional.

rgba instance-attribute 
rgba: Optional[tuple[UInt8, UInt8, UInt8, UInt8]]

The color as red, green, blue, and alpha components, each from 0 to 255. Optional.

Methods:
Property 
Property(label_value: Integral | integer | bool = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

Extra, application-defined attributes for one label value.

Any key beyond label_value is carried through as extra data. See OMEMetadata.

Attributes
label_value class-attribute instance-attribute 
label_value: Optional[int] = field(json='label-value')

The integer value these properties apply to. Optional.

Methods:
Source 
Source(image: str | bytes = None, label_value: Integral | integer | bool = MISSING, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

Where a label image was derived from.

Attributes
image class-attribute instance-attribute 
image: Optional[str] = None

The path of the intensity image this label was derived from, relative to the label image group. Optional.

label_value class-attribute instance-attribute 
label_value: Optional[int] = field(json='label-value')

The single labeled value this source applies to, when the source differs per label. Optional.

Methods:
Methods:

abczarr.ome.v0_6dev4.omero

abczarr.ome.v0_6dev4.omero

Rendering settings: how to display an image's channels.

Classes

Channel 

Channel(color: str | bytes, window: Window | JsonDict | float, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

Specifies how to render one channel of a multi-channel image.

Attributes
color instance-attribute 
color: Required[str]

The channel's display color, as a hex RGB string such as "FF0000" for red.

window instance-attribute 
window: Required[Window]

The intensity range mapped onto that color.

Classes
Window 
Window(min: Real | floating | bool, max: Real | floating | bool, start: Real | floating | bool, end: Real | floating | bool, *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

The intensity range a channel's color is mapped over.

Attributes
min instance-attribute 
min: Required[float]

The lowest value the channel's data can take.

max instance-attribute 
max: Required[float]

The highest value the channel's data can take.

start instance-attribute 
start: Required[float]

The value a viewer should render at zero intensity. This may narrow the range min and max bound.

end instance-attribute 
end: Required[float]

The value a viewer should render at full intensity. This may narrow the range min and max bound.

Methods:
Methods:

Omero 

Omero(channels: Iterable[Channel | JsonDict | str], *, extra_items: Iterable[tuple[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None]] | Mapping[str | bytes, Real | floating | bool | bool | int | str | bytes | Iterable[()] | None] = FrozenDict({}))

Bases: OMEMetadata

Holds rendering settings for an image, one entry per channel.

Attach one of these to an image group, alongside its Multiscale, to suggest how a viewer should display it.

Attributes
channels instance-attribute 
channels: Required[list[Channel]]

A Channel for each channel of the image, in the image's channel order.

Methods:

abczarr.ome.v0_6dev4.version

abczarr.ome.v0_6dev4.version

Attributes

Version module-attribute 

Version = tx.Literal['0.6.dev4']

VERSION module-attribute 

VERSION = '0.6.dev4'