Skip to content

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)

data

Measurement

MAX

MEAN

MEDIAN

MIN

STD

SUM

VAR

measure_intensites(img, mask, channel_names, measurement)

Source code in steinbock/measurement/data.py 
def measure_intensites(
    img: np.ndarray,
    mask: np.ndarray,
    channel_names: Sequence[str],
    measurement: Measurement,
) -> pd.DataFrame:
    object_ids = np.unique(mask[mask != 0])
    data = {
        channel_name: measurement.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, measurement)

Source code in steinbock/measurement/data.py 
def measure_intensities_from_disk(
    img_files: Sequence[Union[str, PathLike]],
    mask_files: Sequence[Union[str, PathLike]],
    channel_names: Sequence[str],
    measurement: Measurement,
) -> 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,
            measurement,
        )
        yield Path(img_file), Path(mask_file), intensities
        del intensities

measure_regionprops(img, mask, skimage_regionprops)

Source code in steinbock/measurement/data.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/data.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

distances

measure_centroid_distances(mask, metric)

Source code in steinbock/measurement/distances.py 
def measure_centroid_distances(mask: np.ndarray, metric: str) -> pd.DataFrame:
    properties = regionprops(mask)
    object_ids = np.array([p.label for p in properties])
    object_centroids = np.array([p.centroid for p in properties])
    return pd.DataFrame(
        data=squareform(pdist(object_centroids, metric=metric), checks=False),
        index=pd.Index(object_ids, dtype=io.mask_dtype, name="Object"),
        columns=pd.Index(object_ids, dtype=io.mask_dtype, name="Object"),
    )

measure_centroid_distances_from_disk(mask_files, metric)

Source code in steinbock/measurement/distances.py 
def measure_centroid_distances_from_disk(
    mask_files: Sequence[Union[str, PathLike]], metric: str
) -> Generator[Tuple[Path, pd.DataFrame], None, None]:
    for mask_file in mask_files:
        dists = measure_centroid_distances(io.read_mask(mask_file), metric)
        yield Path(mask_file), dists
        del dists

measure_euclidean_border_distances(mask)

Source code in steinbock/measurement/distances.py 
def measure_euclidean_border_distances(mask: np.ndarray) -> pd.DataFrame:
    object_ids = np.unique(mask[mask != 0])
    data = np.zeros((len(object_ids), len(object_ids)))
    for i, object_id in enumerate(object_ids):
        dist_img = distance_transform_edt(mask != object_id)
        data[i, i + 1 :] = data[i + 1 :, i] = [
            np.amin(dist_img[mask == neighbor_object_id])
            for neighbor_object_id in object_ids[i + 1 :]
        ]
    return pd.DataFrame(
        data=data,
        index=pd.Index(object_ids, dtype=io.mask_dtype, name="Object"),
        columns=pd.Index(object_ids, dtype=io.mask_dtype, name="Object"),
    )

measure_euclidean_border_distances_from_disk(mask_files)

Source code in steinbock/measurement/distances.py 
def measure_euclidean_border_distances_from_disk(
    mask_files: Sequence[Union[str, PathLike]]
) -> Generator[Tuple[Path, pd.DataFrame], None, None]:
    for mask_file in mask_files:
        dists = measure_euclidean_border_distances(io.read_mask(mask_file))
        yield Path(mask_file), dists
        del dists

graphs

construct_graph(dists, dmax=None, kmax=None)

Source code in steinbock/measurement/graphs.py 
def construct_graph(
    dists: pd.DataFrame,
    dmax: Optional[float] = None,
    kmax: Optional[float] = None,
) -> pd.DataFrame:
    source_object_ids = []
    target_object_ids = []
    for i, source_object_id in enumerate(dists.index.values):
        neighbor_dists = dists.loc[source_object_id, :].values
        neighbor_mask = np.ones(len(dists.columns), dtype=bool)
        neighbor_mask[i] = False
        if dmax is not None:
            neighbor_mask &= neighbor_dists <= dmax
        n = np.count_nonzero(neighbor_mask)
        if kmax is not None and n > 0:
            k = min(kmax, n)
            p = np.argpartition(neighbor_dists[neighbor_mask], k - 1)[:k]
            neighbor_indices = np.flatnonzero(neighbor_mask)[p]
            neighbor_mask = np.zeros_like(neighbor_mask)
            neighbor_mask[neighbor_indices] = True
        for target_object_id in dists.columns.values[neighbor_mask]:
            source_object_ids.append(source_object_id)
            target_object_ids.append(target_object_id)
    return pd.DataFrame(
        data={
            "Object1": np.asarray(source_object_ids, dtype=io.mask_dtype),
            "Object2": np.asarray(target_object_ids, dtype=io.mask_dtype),
        }
    )

construct_graphs_from_disk(dists_files, dmax=None, kmax=None)

Source code in steinbock/measurement/graphs.py 
def construct_graphs_from_disk(
    dists_files: Sequence[Union[str, PathLike]],
    dmax: Optional[float] = None,
    kmax: Optional[float] = None,
) -> Generator[Tuple[Path, pd.DataFrame], None, None]:
    for dists_file in dists_files:
        graph = construct_graph(
            io.read_distances(dists_file), dmax=dmax, kmax=kmax
        )
        yield Path(dists_file), graph
        del graph
Back to top