Skip to content

steinbock.utils

matching

match_masks(mask1, mask2)

Source code in steinbock/utils/matching.py 
def match_masks(mask1: np.ndarray, mask2: np.ndarray) -> pd.DataFrame:
    nz1 = mask1 != 0
    nz2 = mask2 != 0
    object_ids1 = []
    object_ids2 = []
    for object_id1 in np.unique(mask1[nz1]):
        for object_id2 in np.unique(mask2[nz2 & (mask1 == object_id1)]):
            object_ids1.append(object_id1)
            object_ids2.append(object_id2)
    for object_id2 in np.unique(mask2[nz2]):
        for object_id1 in np.unique(mask1[nz1 & (mask2 == object_id2)]):
            object_ids1.append(object_id1)
            object_ids2.append(object_id2)
    df = pd.DataFrame(data={"Object1": object_ids1, "Object2": object_ids2})
    df.drop_duplicates(inplace=True, ignore_index=True)
    return df

try_match_masks_from_disk(mask_files1, mask_files2)

Source code in steinbock/utils/matching.py 
def try_match_masks_from_disk(
    mask_files1: Sequence[Union[str, PathLike]],
    mask_files2: Sequence[Union[str, PathLike]],
) -> Generator[Tuple[Path, Path, pd.DataFrame], None, None]:
    for mask_file1, mask_file2 in zip(mask_files1, mask_files2):
        try:
            df = match_masks(
                io.read_mask(mask_file1), io.read_mask(mask_file2)
            )
            yield mask_file1, mask_file2, df
            del df
        except:
            _logger.exception(f"Error matching masks {mask_file1, mask_file2}")

mosaics

TileInfo

try_extract_tiles_from_disk(img_files, tile_size)

Source code in steinbock/utils/mosaics.py 
def try_extract_tiles_from_disk(
    img_files: Sequence[Union[str, PathLike]], tile_size: int
) -> Generator[Tuple[Path, int, int, np.ndarray], None, None]:
    for img_file in img_files:
        try:
            img = io.read_image(img_file, ignore_dtype=True)
            for tile_x in range(0, img.shape[2], tile_size):
                for tile_y in range(0, img.shape[1], tile_size):
                    tile = img[
                        :,
                        tile_y : (tile_y + tile_size),
                        tile_x : (tile_x + tile_size),
                    ]
                    yield Path(img_file), tile_x, tile_y, tile
                    del tile
            del img
        except:
            _logger.exception(f"Error extracting tiles: {img_file}")

try_stitch_tiles_from_disk(img_tile_infos)

Source code in steinbock/utils/mosaics.py 
def try_stitch_tiles_from_disk(
    img_tile_infos: Dict[str, Sequence[TileInfo]]
) -> Generator[Tuple[str, np.ndarray], None, None]:
    for img_stem_name, tile_infos in img_tile_infos.items():
        try:
            tile_file, tile_x, tile_y, tile_width, tile_height = tile_infos[0]
            tile = io.read_image(tile_file, ignore_dtype=True)
            img = np.zeros(
                (
                    tile.shape[0],
                    max(x + w for _, x, y, w, h in tile_infos),
                    max(y + h for _, x, y, w, h in tile_infos),
                ),
                dtype=tile.dtype,
            )
            img[
                :,
                tile_y : (tile_y + tile_height),
                tile_x : (tile_x + tile_width),
            ] = tile
            for (
                tile_file,
                tile_x,
                tile_y,
                tile_width,
                tile_height,
            ) in tile_infos[1:]:
                img[
                    :,
                    tile_y : (tile_y + tile_height),
                    tile_x : (tile_x + tile_width),
                ] = io.read_image(tile_file, ignore_dtype=True)
            yield img_stem_name, img
            del img
        except:
            _logger.exception(f"Error stitching tiles: {img_stem_name}")
Back to top