def build_image(
fovs: Sequence[int],
rounds: Sequence[int],
chs: Sequence[int],
zplanes: Sequence[int],
image_fetcher: TileFetcher,
default_shape: Optional[Mapping[Axes, int]]=None,
axes_order: Sequence[Axes]=DEFAULT_DIMENSION_ORDER,
) -> Collection:
"""
Build and returns an image set with the following characteristics:
Parameters
----------
fovs : Sequence[int]
Sequence of field of view ids in this image set.
rounds : Sequence[int]
Sequence of the round numbers in this image set.
chs : Sequence[int]
Sequence of the ch numbers in this image set.
zplanes : Sequence[int]
Sequence of the zplane numbers in this image set.
image_fetcher : TileFetcher
Instance of TileFetcher that provides the data for the tile.
default_shape : Optional[Tuple[int, int]]
Default shape of the individual tiles in this image set.
axes_order : Sequence[Axes]
Ordering for which axes vary, in order of the slowest changing axis to the fastest. For
instance, if the order is (ROUND, Z, CH) and each dimension has size 2, then the sequence
is:
(ROUND=0, CH=0, Z=0)
(ROUND=0, CH=1, Z=0)
(ROUND=0, CH=0, Z=1)
(ROUND=0, CH=1, Z=1)
(ROUND=1, CH=0, Z=0)
(ROUND=1, CH=1, Z=0)
(ROUND=1, CH=0, Z=1)
(ROUND=1, CH=1, Z=1)
(default = (Axes.Z, Axes.ROUND, Axes.CH))
Returns
-------
The slicedimage collection representing the image.
"""
axes_sizes = join_axes_labels(
axes_order, rounds=rounds, chs=chs, zplanes=zplanes)
collection = Collection()
for fov_id in fovs:
fov_images = TileSet(
[
Coordinates.X,
Coordinates.Y,
Coordinates.Z,
Axes.ZPLANE,
Axes.ROUND,
Axes.CH,
Axes.X,
Axes.Y,
],
{Axes.ROUND: len(rounds), Axes.CH: len(chs), Axes.ZPLANE: len(zplanes)},
default_shape,
ImageFormat.TIFF,
)
for selector in ordered_iterator(axes_sizes):
image = image_fetcher.get_tile(
fov_id,
selector[Axes.ROUND],
selector[Axes.CH],
selector[Axes.ZPLANE])
tile = Tile(
image.coordinates,
{
Axes.ZPLANE: (selector[Axes.ZPLANE]),
Axes.ROUND: (selector[Axes.ROUND]),
Axes.CH: (selector[Axes.CH]),
},
image.shape,
extras=image.extras,
)
tile.set_numpy_array_future(image.tile_data)
fov_images.add_tile(tile)
collection.add_partition("fov_{:03}".format(fov_id), fov_images)
return collection
def build_irregular_image(
tile_identifiers: Iterable[TileIdentifier],
image_fetcher: TileFetcher,
default_shape: Optional[Mapping[Axes, int]] = None,
) -> Collection:
"""
Build and returns an image set that can potentially be irregular (i.e., the cardinality of the
dimensions are not always consistent). It can also build a regular image.
Parameters
----------
tile_identifiers : Iterable[TileIdentifier]
Iterable of all the TileIdentifier that are valid in the image.
image_fetcher : TileFetcher
Instance of TileFetcher that provides the data for the tile.
default_shape : Optional[Tuple[int, int]]
Default shape of the individual tiles in this image set.
Returns
-------
The slicedimage collection representing the image.
"""
def reducer_to_sets(
accumulated: Sequence[MutableSet[int]], update: TileIdentifier,
) -> Sequence[MutableSet[int]]:
"""Reduces to a list of sets of tile identifiers, in the order of FOV, round, ch, and
zplane."""
result: MutableSequence[MutableSet[int]] = list()
for accumulated_elem, update_elem in zip(accumulated, astuple(update)):
accumulated_elem.add(update_elem)
result.append(accumulated_elem)
return result
initial_value: Sequence[MutableSet[int]] = tuple(set() for _ in range(4))
fovs, rounds, chs, zplanes = functools.reduce(
reducer_to_sets, tile_identifiers, initial_value)
collection = Collection()
for expected_fov in fovs:
fov_images = TileSet(
[
Coordinates.X,
Coordinates.Y,
Coordinates.Z,
Axes.ZPLANE,
Axes.ROUND,
Axes.CH,
Axes.X,
Axes.Y,
],
{Axes.ROUND: len(rounds), Axes.CH: len(chs), Axes.ZPLANE: len(zplanes)},
default_shape,
ImageFormat.TIFF,
)
for tile_identifier in tile_identifiers:
current_fov, current_round, current_ch, current_zplane = astuple(tile_identifier)
# filter out the fovs that are not the one we are currently processing
if expected_fov != current_fov:
continue
image = image_fetcher.get_tile(
current_fov,
current_round,
current_ch,
current_zplane
)
tile = Tile(
image.coordinates,
{
Axes.ZPLANE: current_zplane,
Axes.ROUND: current_round,
Axes.CH: current_ch,
},
image.shape,
extras=image.extras,
)
tile.set_numpy_array_future(image.tile_data)
# Astute readers might wonder why we set this variable. This is to support in-place
# experiment construction. We monkey-patch slicedimage's Tile class such that checksum
# computation is done by finding the FetchedTile object, which allows us to calculate
# the checksum of the original file.
tile.provider = image
fov_images.add_tile(tile)
collection.add_partition("fov_{:03}".format(expected_fov), fov_images)
return collection
def build_image(
fov_count: int,
round_count: int,
ch_count: int,
z_count: int,
image_fetcher: TileFetcher,
default_shape: Optional[Tuple[int, int]] = None,
dimension_order: Sequence[Indices] = DEFAULT_DIMENSION_ORDER,
) -> Collection:
"""
Build and returns an image set with the following characteristics:
Parameters
----------
fov_count : int
Number of fields of view in this image set.
round_count : int
Number for rounds in this image set.
ch_count : int
Number for channels in this image set.
z_count : int
Number of z-layers in this image set.
image_fetcher : TileFetcher
Instance of TileFetcher that provides the data for the tile.
default_shape : Optional[Tuple[int, int]]
Default shape of the individual tiles in this image set.
dimension_order : Sequence[Indices]
Ordering for which dimensions vary, in order of the slowest changing dimension to the
fastest. For instance, if the order is (ROUND, Z, CH) and each dimension has size 2, then
the sequence is:
(ROUND=0, CH=0, Z=0)
(ROUND=0, CH=1, Z=0)
(ROUND=0, CH=0, Z=1)
(ROUND=0, CH=1, Z=1)
(ROUND=1, CH=0, Z=0)
(ROUND=1, CH=1, Z=0)
(ROUND=1, CH=0, Z=1)
(ROUND=1, CH=1, Z=1)
(default = (Indices.Z, Indices.ROUND, Indices.CH))
Returns
-------
The slicedimage collection representing the image.
"""
dimension_sizes = join_dimension_sizes(
dimension_order,
size_for_round=round_count,
size_for_ch=ch_count,
size_for_z=z_count,
)
collection = Collection()
for fov_ix in range(fov_count):
fov_images = TileSet(
[
Coordinates.X,
Coordinates.Y,
Coordinates.Z,
Indices.Z,
Indices.ROUND,
Indices.CH,
Indices.X,
Indices.Y,
],
{
Indices.ROUND: round_count,
Indices.CH: ch_count,
Indices.Z: z_count
},
default_shape,
ImageFormat.TIFF,
)
for dimension_indices in ordered_iterator(dimension_sizes):
image = image_fetcher.get_tile(fov_ix,
dimension_indices[Indices.ROUND],
dimension_indices[Indices.CH],
dimension_indices[Indices.Z])
tile = Tile(
image.coordinates,
{
Indices.Z: (dimension_indices[Indices.Z]),
Indices.ROUND: (dimension_indices[Indices.ROUND]),
Indices.CH: (dimension_indices[Indices.CH]),
},
image.shape,
extras=image.extras,
)
tile.set_numpy_array_future(image.tile_data)
fov_images.add_tile(tile)
collection.add_partition("fov_{:03}".format(fov_ix), fov_images)
return collection
def build_image(
fov_count: int,
round_count: int,
ch_count: int,
z_count: int,
image_fetcher: TileFetcher,
default_shape: Optional[Tuple[int, int]] = None,
) -> Collection:
"""
Build and returns an image set with the following characteristics:
Parameters
----------
fov_count : int
Number of fields of view in this image set.
round_count : int
Number for rounds in this image set.
ch_count : int
Number for channels in this image set.
z_count : int
Number of z-layers in this image set.
image_fetcher : TileFetcher
Instance of TileFetcher that provides the data for the tile.
default_shape : Optional[Tuple[int, int]]
Default shape of the individual tiles in this image set.
Returns
-------
The slicedimage collection representing the image.
"""
collection = Collection()
for fov_ix in range(fov_count):
fov_images = TileSet(
[
Coordinates.X,
Coordinates.Y,
Coordinates.Z,
Indices.Z,
Indices.ROUND,
Indices.CH,
Indices.X,
Indices.Y,
],
{
Indices.ROUND: round_count,
Indices.CH: ch_count,
Indices.Z: z_count
},
default_shape,
ImageFormat.TIFF,
)
for z_ix in range(z_count):
for round_ix in range(round_count):
for ch_ix in range(ch_count):
image = image_fetcher.get_tile(fov_ix, round_ix, ch_ix,
z_ix)
tile = Tile(
image.coordinates,
{
Indices.Z: z_ix,
Indices.ROUND: round_ix,
Indices.CH: ch_ix,
},
image.shape,
extras=image.extras,
)
tile.set_numpy_array_future(image.tile_data)
fov_images.add_tile(tile)
collection.add_partition("fov_{:03}".format(fov_ix), fov_images)
return collection