Data¶

Assign a field, announcing the change when it is a data field.

A class-level hook rather than a connection to self.events made in model_post_init: model_copy(deep=True) -- which to_model and from_model use -- runs no model_post_init, so a connection would silently go missing on every copy. Construction assigns through __dict__ and announces nothing.

Announce that the store's data changed.

Reassigning a data field announces itself; call this after an in-place write, which nothing can see -- store.data[...] = v or store.positions[:] = p.

Parameters:

Raises:

Check the systems passed at construction and install their transforms.

Stores that open array handles in their own model_post_init call this after opening them: the level count and rank it checks against are read off the handles.

Install the store's coordinate systems and level transforms.

Assignment rather than construction because the systems are sometimes derived from the scene the store is added to, which the store cannot see at construction time.

Parameters:

Raises:

Describe the array: shape, dtype, value range and footprint.

The value range is a full pass over the array, affordable only because the data is already resident in RAM. The zarr-backed stores deliberately omit it (see their dataset_info).

Return the requested sub-region as a float32 array.

Interprets request.axis_selections generically:

• int entry → sliced axis; the integer index is applied and the axis is dropped from the output.
• (start, stop) tuple → displayed axis; a slice is applied and the axis is kept in the output.

Out-of-bounds coordinates are clamped to array extents and zero-padded on the output side so the returned shape always matches what the caller requested.

Parameters:

Returns:

Set a field, reopening the handles when the cache settings change.

cache_pool_bytes, request_concurrency and file_io_concurrency rebuild the pool on a new context. recheck_cached_data reopens on the same context. Every other field is set as usual. Assigning the value a field already has is a no-op, so a redundant write does not throw away a warm cache.

Raises:

Announce that the store's data changed.

Reassigning a data field announces itself; call this after an in-place write, which nothing can see -- store.data[...] = v or store.positions[:] = p.

Parameters:

Raises:

Install the store's coordinate systems and level transforms.

Assignment rather than construction because the systems are sometimes derived from the scene the store is added to, which the store cannot see at construction time.

Parameters:

Raises:

Record the paint write buffer currently open on this store.

Held weakly: a controller that is dropped without tearing down does not leave the store permanently locked.

The first registration reopens the handles with rechecks on, on the same context, so a write from outside this store is not masked by the cache while painting. Registering again while registered (a fresh buffer after an autosave) only swaps the reference. A transaction already open on the old handle is unaffected: it shares the context, so its staged and committed writes are visible through the new handles.

Parameters:

Forget the paint write buffer, undoing :meth:register_paint_writer.

Reopens the handles with rechecks off again, unless recheck_cached_data keeps them on.

Revalidate every cached chunk once, on its next read.

Reopens the handles on the same context with recheck_cached_data="open": chunks cached before now are checked against the kvstore when next read (unchanged ones cost a 304, changed ones are refetched), then trusted again. Called for every announced change (:meth:_invalidate_caches), so a store another process writes to shows the new data after notify_changed.

A no-op while rechecks are on, since every read revalidates then, and before the handles are opened.

Open all tensorstore handles.

Called automatically by pydantic after __init__. Must run before QtAsyncio.run() starts the event loop.

Construct from per-level scale and translation vectors.

Parameters:

Describe the pyramid: path, dtype, and the per-level geometry.

No value range: unlike the in-memory stores, computing one here would mean reading every level-0 chunk off disk or over the network.

The per-level scale rows are derived from level_scales rather than asserted -- the examples used to hardcode strings like "2x isotropic" that no longer matched an anisotropic pyramid.

Read a single padded brick, returning a zero-padded float32 array.

Interprets request.axis_selections generically: displayed axes (tuple ranges) become slice dimensions in the output; sliced axes (int values) become point selections.

Parameters:

Returns:

Set a field, reopening the handles when the cache settings change.

cache_pool_bytes, request_concurrency and file_io_concurrency rebuild the pool on a new context. recheck_cached_data reopens on the same context. Every other field is set as usual. Assigning the value a field already has is a no-op, so a redundant write does not throw away a warm cache.

Raises:

Announce that the store's data changed.

Reassigning a data field announces itself; call this after an in-place write, which nothing can see -- store.data[...] = v or store.positions[:] = p.

Parameters:

Raises:

Install the store's coordinate systems and level transforms.

Assignment rather than construction because the systems are sometimes derived from the scene the store is added to, which the store cannot see at construction time.

Parameters:

Raises:

Record the paint write buffer currently open on this store.

Held weakly: a controller that is dropped without tearing down does not leave the store permanently locked.

The first registration reopens the handles with rechecks on, on the same context, so a write from outside this store is not masked by the cache while painting. Registering again while registered (a fresh buffer after an autosave) only swaps the reference. A transaction already open on the old handle is unaffected: it shares the context, so its staged and committed writes are visible through the new handles.

Parameters:

Forget the paint write buffer, undoing :meth:register_paint_writer.

Reopens the handles with rechecks off again, unless recheck_cached_data keeps them on.

Revalidate every cached chunk once, on its next read.

Reopens the handles on the same context with recheck_cached_data="open": chunks cached before now are checked against the kvstore when next read (unchanged ones cost a 304, changed ones are refetched), then trusted again. Called for every announced change (:meth:_invalidate_caches), so a store another process writes to shows the new data after notify_changed.

A no-op while rechecks are on, since every read revalidates then, and before the handles are opened.

Open all TensorStore handles (synchronous, before QtAsyncio).

Construct from an OME-Zarr v0.5 URI.

Supports both standard Image stores and Bf2Raw (bioformats2raw) multi-series containers. For Bf2Raw stores the series_index selects which child image to open.

Parameters:

Raises:

Describe the store from metadata it already holds.

Reads only fields parsed at construction plus the open tensorstore handles' shapes and dtype -- it never re-opens the group, which for an s3:// store would mean a network round trip every time an appearance panel is built.

No value range, for the same reason: it would be a full read of level 0.

Read a single padded brick, returning a zero-padded float32 array.

Interprets request.axis_selections generically: displayed axes (tuple ranges) become slice dimensions in the output; sliced axes (int values) become point selections.

Parameters:

Returns:

Assign a field, announcing the change when it is a data field.

A class-level hook rather than a connection to self.events made in model_post_init: model_copy(deep=True) -- which to_model and from_model use -- runs no model_post_init, so a connection would silently go missing on every copy. Construction assigns through __dict__ and announces nothing.

Announce that the store's data changed.

Reassigning a data field announces itself; call this after an in-place write, which nothing can see -- store.data[...] = v or store.positions[:] = p.

Parameters:

Raises:

Check the systems passed at construction and install their transforms.

Stores that open array handles in their own model_post_init call this after opening them: the level count and rank it checks against are read off the handles.

Install the store's coordinate systems and level transforms.

Assignment rather than construction because the systems are sometimes derived from the scene the store is added to, which the store cannot see at construction time.

Parameters:

Raises:

Describe the array, including how many distinct labels it holds.

The label count is a full pass over the array (np.unique), which is affordable only because the data is already resident in RAM. OMEZarrLabelDataStore deliberately omits it: there the same row would mean reading every chunk off disk.

Return the requested sub-region as an int32 array.

Interprets request.axis_selections generically: - int entry → sliced axis (dropped from output) - (start, stop) tuple → displayed axis (kept in output)

Out-of-bounds coordinates are clamped and zero-padded. Always returns int32 regardless of source dtype.

Set a field, reopening the handles when the cache settings change.

cache_pool_bytes, request_concurrency and file_io_concurrency rebuild the pool on a new context. recheck_cached_data reopens on the same context. Every other field is set as usual. Assigning the value a field already has is a no-op, so a redundant write does not throw away a warm cache.

Raises:

Announce that the store's data changed.

Reassigning a data field announces itself; call this after an in-place write, which nothing can see -- store.data[...] = v or store.positions[:] = p.

Parameters:

Raises:

Install the store's coordinate systems and level transforms.

Assignment rather than construction because the systems are sometimes derived from the scene the store is added to, which the store cannot see at construction time.

Parameters:

Raises:

Record the paint write buffer currently open on this store.

Held weakly: a controller that is dropped without tearing down does not leave the store permanently locked.

The first registration reopens the handles with rechecks on, on the same context, so a write from outside this store is not masked by the cache while painting. Registering again while registered (a fresh buffer after an autosave) only swaps the reference. A transaction already open on the old handle is unaffected: it shares the context, so its staged and committed writes are visible through the new handles.

Parameters:

Forget the paint write buffer, undoing :meth:register_paint_writer.

Reopens the handles with rechecks off again, unless recheck_cached_data keeps them on.

Revalidate every cached chunk once, on its next read.

Reopens the handles on the same context with recheck_cached_data="open": chunks cached before now are checked against the kvstore when next read (unchanged ones cost a 304, changed ones are refetched), then trusted again. Called for every announced change (:meth:_invalidate_caches), so a store another process writes to shows the new data after notify_changed.

A no-op while rechecks are on, since every read revalidates then, and before the handles are opened.

Open all TensorStore handles (synchronous, before QtAsyncio).

Construct from a URI pointing directly at an OME-NGFF label group.

The URI must point at a zarr group that carries ome.multiscales metadata (i.e. the label sub-group itself, not the root OME-Zarr).

Parameters:

Describe the store from metadata it already holds.

Like the image store, this never re-opens the group and never reads array data -- so no label count, which would require a full pass over level 0. LabelMemoryStore reports one because its data is already in RAM.

The Data type row names the on-disk dtype and the int32 the store hands out, which differ whenever the source is int8 or int16.

Read a padded brick, returning int32 (zero-padded for out-of-bounds).

Parameters:

Returns:

Assign a field, announcing the change when it is a data field.

A class-level hook rather than a connection to self.events made in model_post_init: model_copy(deep=True) -- which to_model and from_model use -- runs no model_post_init, so a connection would silently go missing on every copy. Construction assigns through __dict__ and announces nothing.

Announce that the store's data changed.

Reassigning a data field announces itself; call this after an in-place write, which nothing can see -- store.data[...] = v or store.positions[:] = p.

Parameters:

Raises:

Check the systems passed at construction and install their transforms.

Stores that open array handles in their own model_post_init call this after opening them: the level count and rank it checks against are read off the handles.

Install the store's coordinate systems and level transforms.

Assignment rather than construction because the systems are sometimes derived from the scene the store is added to, which the store cannot see at construction time.

Parameters:

Raises:

Describe the point cloud: count, dimensionality, extent, footprint.

color_mode and size_mode are deliberately absent: they describe how the points are drawn, not what the store holds, and the appearance model is where a reader should look for that.

Return proximity-filtered point data for request.

Parameters:

Returns:

Assign a field, announcing the change when it is a data field.

A class-level hook rather than a connection to self.events made in model_post_init: model_copy(deep=True) -- which to_model and from_model use -- runs no model_post_init, so a connection would silently go missing on every copy. Construction assigns through __dict__ and announces nothing.

Announce that the store's data changed.

Reassigning a data field announces itself; call this after an in-place write, which nothing can see -- store.data[...] = v or store.positions[:] = p.

Parameters:

Raises:

Check the systems passed at construction and install their transforms.

Stores that open array handles in their own model_post_init call this after opening them: the level count and rank it checks against are read off the handles.

Install the store's coordinate systems and level transforms.

Assignment rather than construction because the systems are sometimes derived from the scene the store is added to, which the store cannot see at construction time.

Parameters:

Raises:

Describe the segments: count, dimensionality, extent, footprint.

The vertex count is spelled out beside the segment count to make the two-vertices-per-segment layout visible; a reader comparing this block against the raw array would otherwise see twice what they expect. color_mode is absent -- it is a display property.

Return slab-filtered segment data for request.

Parameters:

Returns:

Assign a field, announcing the change when it is a data field.

A class-level hook rather than a connection to self.events made in model_post_init: model_copy(deep=True) -- which to_model and from_model use -- runs no model_post_init, so a connection would silently go missing on every copy. Construction assigns through __dict__ and announces nothing.

Announce that the store's data changed.

Reassigning a data field announces itself; call this after an in-place write, which nothing can see -- store.data[...] = v or store.positions[:] = p.

Parameters:

Raises:

Check the systems passed at construction and install their transforms.

Stores that open array handles in their own model_post_init call this after opening them: the level count and rank it checks against are read off the handles.

Install the store's coordinate systems and level transforms.

Assignment rather than construction because the systems are sometimes derived from the scene the store is added to, which the store cannot see at construction time.

Parameters:

Raises:

Describe the mesh: vertex and face counts, extent, footprint.

colors_mode is deliberately absent: it describes how the mesh is drawn, not what the store holds.

Closed says whether the surface is watertight, which decides whether a 2D section of it can be filled: an open surface draws its outline only. It is worked out by the first 2D section read, so it reads "not computed" before one.

The arrays of level; this store has level 0 only.

What the reads of level share (normals, bounds indexes).

Return slab-filtered, reindexed, upload-ready mesh data.

The work runs in an executor thread (:func:~cellier.data.mesh._mesh_slicing.slice_mesh), so the event loop stays free. There are no cancellation checkpoints: the chunk scheduler, which issues these reads, never cancels one.

Parameters:

Returns:

Assign a field, announcing the change when it is a data field.

A class-level hook rather than a connection to self.events made in model_post_init: model_copy(deep=True) -- which to_model and from_model use -- runs no model_post_init, so a connection would silently go missing on every copy. Construction assigns through __dict__ and announces nothing.

Announce that the store's data changed.

Reassigning a data field announces itself; call this after an in-place write, which nothing can see -- store.data[...] = v or store.positions[:] = p.

Parameters:

Raises:

Check the systems passed at construction and install their transforms.

Stores that open array handles in their own model_post_init call this after opening them: the level count and rank it checks against are read off the handles.

Install the store's coordinate systems and level transforms.

Assignment rather than construction because the systems are sometimes derived from the scene the store is added to, which the store cannot see at construction time.

Parameters:

Raises:

Describe the mesh: its levels, extent and footprint.

Closed says, per level, whether the surface is watertight, which decides whether a 2D section of that level can be filled. It is worked out by the level's first 2D section read.

The arrays of level (0 is the finest).

What the reads of level share (normals, bounds indexes).

Return one level, sliced and upload-ready.

The same read as :meth:MeshMemoryStore.get_data, on the level the request names (scale_index, 0 the finest). It runs in an executor thread, with no cancellation checkpoints.

Parameters:

Returns: