steinbock.measurement

cellprofiler special

cellprofiler

create_and_save_measurement_pipeline(measurement_pipeline_file, num_channels)

Source code in steinbock/measurement/cellprofiler/cellprofiler.py

def create_and_save_measurement_pipeline(
    measurement_pipeline_file: Union[str, PathLike], num_channels: int
):
    with _measurement_pipeline_file_template.open(mode="r") as f:
        s = f.read()
    s = s.replace("{{NUM_CHANNELS}}", str(num_channels))
    with Path(measurement_pipeline_file).open(mode="w") as f:
        f.write(s)

run_object_measurement(cellprofiler_binary, measurement_pipeline_file, input_dir, output_dir, cellprofiler_plugin_dir=None)

Source code in steinbock/measurement/cellprofiler/cellprofiler.py

def run_object_measurement(
    cellprofiler_binary: str,
    measurement_pipeline_file: Union[str, PathLike],
    input_dir: Union[str, PathLike],
    output_dir: Union[str, PathLike],
    cellprofiler_plugin_dir: Union[str, PathLike, None] = None,
):
    args = [
        cellprofiler_binary,
        "-c",
        "-r",
        "-p",
        str(measurement_pipeline_file),
        "-i",
        str(input_dir),
        "-o",
        str(output_dir),
    ]
    if cellprofiler_plugin_dir is not None:
        args.append("--plugins-directory")
        args.append(str(cellprofiler_plugin_dir))
    return run_captured(args)

intensities

IntensityAggregation

MAX

MEAN

MEDIAN

MIN

STD

SUM

VAR

measure_intensites(img, mask, channel_names, intensity_aggregation)

Source code in steinbock/measurement/intensities.py

def measure_intensites(
    img: np.ndarray,
    mask: np.ndarray,
    channel_names: Sequence[str],
    intensity_aggregation: IntensityAggregation,
) -> pd.DataFrame:
    object_ids = np.unique(mask[mask != 0])
    data = {
        channel_name: intensity_aggregation.value(
            img[i], labels=mask, index=object_ids
        )
        for i, channel_name in enumerate(channel_names)
    }
    return pd.DataFrame(
        data=data,
        index=pd.Index(object_ids, dtype=io.mask_dtype, name="Object"),
    )

measure_intensities_from_disk(img_files, mask_files, channel_names, intensity_aggregation)

Source code in steinbock/measurement/intensities.py

def measure_intensities_from_disk(
    img_files: Sequence[Union[str, PathLike]],
    mask_files: Sequence[Union[str, PathLike]],
    channel_names: Sequence[str],
    intensity_aggregation: IntensityAggregation,
) -> Generator[Tuple[Path, Path, pd.DataFrame], None, None]:
    for img_file, mask_file in zip(img_files, mask_files):
        intensities = measure_intensites(
            io.read_image(img_file),
            io.read_mask(mask_file),
            channel_names,
            intensity_aggregation,
        )
        yield Path(img_file), Path(mask_file), intensities
        del intensities

neighbors

NeighborhoodType

CENTROID_DISTANCE

EUCLIDEAN_BORDER_DISTANCE

EUCLIDEAN_PIXEL_EXPANSION

measure_neighbors(mask, neighborhood_type, metric=None, dmax=None, kmax=None)

Source code in steinbock/measurement/neighbors.py

def measure_neighbors(
    mask: np.ndarray,
    neighborhood_type: NeighborhoodType,
    metric: Optional[str] = None,
    dmax: Optional[float] = None,
    kmax: Optional[int] = None,
) -> pd.DataFrame:
    return neighborhood_type.value(mask, metric=metric, dmax=dmax, kmax=kmax)

measure_neighbors_from_disk(mask_files, neighborhood_type, metric=None, dmax=None, kmax=None)

Source code in steinbock/measurement/neighbors.py

def measure_neighbors_from_disk(
    mask_files: Sequence[Union[str, PathLike]],
    neighborhood_type: NeighborhoodType,
    metric: Optional[str] = None,
    dmax: Optional[float] = None,
    kmax: Optional[int] = None,
) -> Generator[Tuple[Path, pd.DataFrame], None, None]:
    for mask_file in mask_files:
        mask = io.read_mask(mask_file)
        neighbors = measure_neighbors(
            mask,
            neighborhood_type,
            metric=metric,
            dmax=dmax,
            kmax=kmax,
        )
        yield Path(mask_file), neighbors
        del neighbors

regionprops

measure_regionprops(img, mask, skimage_regionprops)

Source code in steinbock/measurement/regionprops.py

def measure_regionprops(
    img: np.ndarray, mask: np.ndarray, skimage_regionprops: Sequence[str]
) -> pd.DataFrame:
    data = regionprops_table(
        mask,
        intensity_image=np.moveaxis(img, 0, -1),
        properties=skimage_regionprops,
    )
    object_ids = data.pop("label")
    return pd.DataFrame(
        data=data,
        index=pd.Index(object_ids, dtype=io.mask_dtype, name="Object"),
    )

measure_regionprops_from_disk(img_files, mask_files, skimage_regionprops)

Source code in steinbock/measurement/regionprops.py

def measure_regionprops_from_disk(
    img_files: Sequence[Union[str, PathLike]],
    mask_files: Sequence[Union[str, PathLike]],
    skimage_regionprops: Sequence[str],
) -> Generator[Tuple[Path, Path, pd.DataFrame], None, None]:
    skimage_regionprops = list(skimage_regionprops)
    if "label" not in skimage_regionprops:
        skimage_regionprops.insert(0, "label")
    for img_file, mask_file in zip(img_files, mask_files):
        regionprops = measure_regionprops(
            io.read_image(img_file),
            io.read_mask(mask_file),
            skimage_regionprops,
        )
        yield Path(img_file), Path(mask_file), regionprops
        del regionprops