6898444902

Committed 17 Nov 2023 12:59AM UTC coverage: 93.541% (-0.2%) from 93.746%

Build # 6898444902

Build Type

Pull #958

github

Committed by

web-flow

Commit Message

Merge 42eee930b into bfc53b7d6

Pull Request Pull Request #958: ezSegmentation

Run Details

2031 of 2274 branches covered (0.0%)

Branch coverage included in aggregate %.

334 of 344 new or added lines in 7 files covered. (97.09%)

1 existing line in 1 file now uncovered.

3936 of 4105 relevant lines covered (95.88%)

5.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.04

/src/ark/segmentation/ez_seg/ez_seg_display.py

import pathlib
from typing import Union
from matplotlib.axes import Axes
from skimage.io import imread
from skimage import feature, color, filters
from skimage.util import img_as_ubyte
import numpy as np
import matplotlib.pyplot as plt
import os
from matplotlib.figure import Figure
from matplotlib import gridspec
from alpineer import io_utils


def display_channel_image(
    base_image_path: Union[str, pathlib.Path],
    sub_folder_name: str,
    test_fov_name: str,
    channel_name: str,
    composite: bool = False,
) -> None:
    """
    Displays a channel or a composite image.

    Args:
        base_image_path (Union[str, pathlib.Path]): The path to the image.
        sub_folder_name (str): If a subfolder name for the channel data exists.
        test_fov_name (str): The name of the fov you wish to display.
        channel_name (str): The name of the channel you wish to display.
        composite (bool): Whether the image to be viewed is a composite image.
    """
    # Show test composite image
    if composite or (sub_folder_name is None):
        sub_folder_name = ""

    image_path = (
        pathlib.Path(base_image_path)
        / test_fov_name
        / sub_folder_name
        / f"{channel_name}.tiff"
    )

    if isinstance(image_path, str):
        image_path = pathlib.Path(image_path)
    io_utils.validate_paths(image_path)

    base_image: np.ndarray = imread(image_path, as_gray=True)

    base_image_scaled = img_as_ubyte(base_image)

    # Plot
    fig: Figure = plt.figure(dpi=300, figsize=(6, 6))
    fig.set_layout_engine(layout="constrained")
    gs = gridspec.GridSpec(1, 1, figure=fig)
    fig.suptitle(f"{image_path.name}")

    ax: Axes = fig.add_subplot(gs[0, 0])
    ax.imshow(base_image_scaled)
    ax.axis("off")


# for displaying segmentation masks overlaid upon a base channel or composite
def overlay_mask_outlines(
    fov: str,
    channel: str,
    image_dir: Union[str, os.PathLike],
    sub_folder_name: str,
    mask_name: str,
    mask_dir: Union[str, os.PathLike],
) -> None:
    """
    Displays a segmentation mask overlaid on a base image (channel or composite).

    Args:
        fov (str): name of fov to be viewed
        channel (str): name of channel to view
        image_dir (Union[str, os.PathLike]): The Path to channel for viewing.
        sub_folder_name (str): If a subfolder name for the channel data exists.
        mask_name (str): The name of mask to view
        mask_dir (Union[str, os.PathLike]): The path to the directory containing the mask.
    """
    if sub_folder_name is None:
        sub_folder_name = ""

    if isinstance(image_dir, str):
        image_dir = pathlib.Path(image_dir)
    if isinstance(mask_dir, str):
        mask_dir = pathlib.Path(mask_dir)

    image_dir = image_dir / sub_folder_name

    io_utils.validate_paths([image_dir, mask_dir])

    # Get ezseg and channel image paths
    channel_image_path = pathlib.Path(image_dir) / fov / f"{channel}.tiff"
    mask_image_path = pathlib.Path(mask_dir) / f"{fov}_{mask_name}.tiff"

    # Validate paths
    io_utils.validate_paths(paths=[channel_image_path, mask_image_path])

    # Load the base image and mask image
    # Autoscale the base image
    channel_image: np.ndarray = imread(channel_image_path, as_gray=True)
    mask_image: np.ndarray = imread(mask_image_path, as_gray=True)

    # Auto-scale the base image
    channel_image_scaled = img_as_ubyte(channel_image)

    # Apply Canny edge detection to extract outlines
    edges: np.ndarray = feature.canny(
        image=mask_image, low_threshold=30, high_threshold=100
    )

    # Set the outline color to red
    outline_color = (255, 0, 0)

    # Convert the base image to RGB
    rgb_channel_image_scaled = color.gray2rgb(channel_image_scaled)

    # Overlay the outlines on the copy of the base image
    rgb_channel_image_scaled[edges != 0] = outline_color

    # Create a new figure
    fig: Figure = plt.figure(dpi=300, figsize=(6, 6))
    fig.set_layout_engine(layout="constrained")
    gs = gridspec.GridSpec(1, 1, figure=fig)
    fig.suptitle(f"Mask: {mask_name}")
    ax: Axes = fig.add_subplot(gs[0, 0])
    ax.imshow(channel_image)
    # Display color mask with transparency
    ax.imshow(rgb_channel_image_scaled, alpha=0.3)
    ax.axis("off")


def multiple_mask_display(
    fov: str,
    mask_name: str,
    object_mask_dir: Union[str, os.PathLike],
    cell_mask_dir: Union[str, os.PathLike],
    merged_mask_dir: Union[str, os.PathLike],
) -> None:
    """
    Create a grid to display the object, cell, and merged masks for a given fov.

    Args:
        fov (str): Name of the fov to view
        mask_name (str): Name of mask to view
        object_mask_dir (Union[str, os.PathLike]): Directory where the object masks are stored.
        cell_mask_dir (Union[str, os.PathLike]): Directory where the cell masks are stored.
        merged_mask_dir (Union[str, os.PathLike]): Directory where the merged masks are stored.
    """
    if isinstance(object_mask_dir, str):
        object_mask_dir = pathlib.Path(object_mask_dir)
    if isinstance(cell_mask_dir, str):
        cell_mask_dir = pathlib.Path(cell_mask_dir)
    if isinstance(merged_mask_dir, str):
        merged_mask_dir = pathlib.Path(merged_mask_dir)
    io_utils.validate_paths([object_mask_dir, cell_mask_dir, merged_mask_dir])

    modified_overlay_mask: np.ndarray = create_overlap_and_merge_visual(
        fov, mask_name, object_mask_dir, cell_mask_dir, merged_mask_dir
    )

    # Create a new figure
    fig: Figure = plt.figure(dpi=300, figsize=(6, 6))
    fig.set_layout_engine(layout="constrained")
    gs = gridspec.GridSpec(1, 1, figure=fig)
    fig.suptitle(f"Merged Mask: {mask_name}")
    ax: Axes = fig.add_subplot(gs[0, 0])
    # Display color mask with transparency
    ax.imshow(modified_overlay_mask)
    ax.axis("off")


def create_overlap_and_merge_visual(
    fov: str,
    mask_name: str,
    object_mask_dir: pathlib.Path,
    cell_mask_dir: pathlib.Path,
    merged_mask_dir: pathlib.Path,
) -> np.ndarray:
    """
    Generate the NumPy Array representing the overlap between two masks

    Args:
        fov (str): Name of the fov to view
        mask_name (str): Name of mask to view
        object_mask_dir (pathlib.Path): Directory where the object masks are stored.
        cell_mask_dir (pathlib.Path): Directory where the cell masks are stored.
        merged_mask_dir (pathlib.Path): Directory where the merged masks are stored.

    Returns:
        np.ndarray:
            Contains an overlap image of the two masks
    """
    # read in masks
    object_mask: np.ndarray = imread(object_mask_dir / f"{fov}_{mask_name}.tiff")
    cell_mask: np.ndarray = imread(
        cell_mask_dir / f"{fov}_whole_cell.tiff", as_gray=True
    )
    merged_mask: np.ndarray = imread(
        merged_mask_dir / f"{fov}_{mask_name}_merged.tiff", as_gray=True
    )

    # Assign colors to the non-overlapping areas of each mask
    # Object masks in red
    red_array = np.zeros(shape=object_mask.shape, dtype=np.uint8)
    red_array[object_mask > 0] = 225

    # Cell masks in blue
    blue_array = np.zeros(shape=object_mask.shape, dtype=np.uint8)
    blue_array[cell_mask > 0] = 255

    # Merged mask edges in green
    merge_bool = merged_mask > 0
    edges = filters.sobel(merge_bool)
    green_array = np.zeros(shape=object_mask.shape, dtype=np.uint8)
    green_array[edges > 0] = 255

    # Combine red, green, and blue channels to create the final image
    image = np.stack([red_array, green_array, blue_array], axis=-1)

    # return this image to the multi_merge_mask_display function.
    return image

1	import pathlib	6✔
2	from typing import Union	6✔
3	from matplotlib.axes import Axes	6✔
4	from skimage.io import imread	6✔
5	from skimage import feature, color, filters	6✔
6	from skimage.util import img_as_ubyte	6✔
7	import numpy as np	6✔
8	import matplotlib.pyplot as plt	6✔
9	import os	6✔
10	from matplotlib.figure import Figure	6✔
11	from matplotlib import gridspec	6✔
12	from alpineer import io_utils	6✔
13
14
15	def display_channel_image(	6✔
16	base_image_path: Union[str, pathlib.Path],
17	sub_folder_name: str,
18	test_fov_name: str,
19	channel_name: str,
20	composite: bool = False,
21	) -> None:
22	"""
23	Displays a channel or a composite image.
24
25	Args:
26	base_image_path (Union[str, pathlib.Path]): The path to the image.
27	sub_folder_name (str): If a subfolder name for the channel data exists.
28	test_fov_name (str): The name of the fov you wish to display.
29	channel_name (str): The name of the channel you wish to display.
30	composite (bool): Whether the image to be viewed is a composite image.
31	"""
32	# Show test composite image
33	if composite or (sub_folder_name is None):	6✔
34	sub_folder_name = ""	6✔
35
36	image_path = (	6!
37	pathlib.Path(base_image_path)
38	/ test_fov_name
39	/ sub_folder_name
40	/ f"{channel_name}.tiff"
41	)
42
43	if isinstance(image_path, str):	6✔
NEW 44	image_path = pathlib.Path(image_path)	×
45	io_utils.validate_paths(image_path)	6✔
46
47	base_image: np.ndarray = imread(image_path, as_gray=True)	6✔
48
49	base_image_scaled = img_as_ubyte(base_image)	6✔
50
51	# Plot
52	fig: Figure = plt.figure(dpi=300, figsize=(6, 6))	6✔
53	fig.set_layout_engine(layout="constrained")	6✔
54	gs = gridspec.GridSpec(1, 1, figure=fig)	6✔
55	fig.suptitle(f"{image_path.name}")	6✔
56
57	ax: Axes = fig.add_subplot(gs[0, 0])	6✔
58	ax.imshow(base_image_scaled)	6✔
59	ax.axis("off")	6✔
60
61
62	# for displaying segmentation masks overlaid upon a base channel or composite
63	def overlay_mask_outlines(	6✔
64	fov: str,
65	channel: str,
66	image_dir: Union[str, os.PathLike],
67	sub_folder_name: str,
68	mask_name: str,
69	mask_dir: Union[str, os.PathLike],
70	) -> None:
71	"""
72	Displays a segmentation mask overlaid on a base image (channel or composite).
73
74	Args:
75	fov (str): name of fov to be viewed
76	channel (str): name of channel to view
77	image_dir (Union[str, os.PathLike]): The Path to channel for viewing.
78	sub_folder_name (str): If a subfolder name for the channel data exists.
79	mask_name (str): The name of mask to view
80	mask_dir (Union[str, os.PathLike]): The path to the directory containing the mask.
81	"""
82	if sub_folder_name is None:	6✔
83	sub_folder_name = ""	6✔
84
85	if isinstance(image_dir, str):	6!
86	image_dir = pathlib.Path(image_dir)	3✔
87	if isinstance(mask_dir, str):	6✔
88	mask_dir = pathlib.Path(mask_dir)	3✔
89
90	image_dir = image_dir / sub_folder_name	6✔
91
92	io_utils.validate_paths([image_dir, mask_dir])	6✔
93
94	# Get ezseg and channel image paths
95	channel_image_path = pathlib.Path(image_dir) / fov / f"{channel}.tiff"	6✔
96	mask_image_path = pathlib.Path(mask_dir) / f"{fov}_{mask_name}.tiff"	6✔
97
98	# Validate paths
99	io_utils.validate_paths(paths=[channel_image_path, mask_image_path])	6✔
100
101	# Load the base image and mask image
102	# Autoscale the base image
103	channel_image: np.ndarray = imread(channel_image_path, as_gray=True)	6✔
104	mask_image: np.ndarray = imread(mask_image_path, as_gray=True)	6✔
105
106	# Auto-scale the base image
107	channel_image_scaled = img_as_ubyte(channel_image)	6✔
108
109	# Apply Canny edge detection to extract outlines
110	edges: np.ndarray = feature.canny(	6✔
111	image=mask_image, low_threshold=30, high_threshold=100
112	)
113
114	# Set the outline color to red
115	outline_color = (255, 0, 0)	6✔
116
117	# Convert the base image to RGB
118	rgb_channel_image_scaled = color.gray2rgb(channel_image_scaled)	6✔
119
120	# Overlay the outlines on the copy of the base image
121	rgb_channel_image_scaled[edges != 0] = outline_color	6✔
122
123	# Create a new figure
124	fig: Figure = plt.figure(dpi=300, figsize=(6, 6))	6✔
125	fig.set_layout_engine(layout="constrained")	6✔
126	gs = gridspec.GridSpec(1, 1, figure=fig)	6✔
127	fig.suptitle(f"Mask: {mask_name}")	6✔
128	ax: Axes = fig.add_subplot(gs[0, 0])	6✔
129	ax.imshow(channel_image)	6✔
130	# Display color mask with transparency
131	ax.imshow(rgb_channel_image_scaled, alpha=0.3)	6✔
132	ax.axis("off")	6✔
133
134
135	def multiple_mask_display(	6✔
136	fov: str,
137	mask_name: str,
138	object_mask_dir: Union[str, os.PathLike],
139	cell_mask_dir: Union[str, os.PathLike],
140	merged_mask_dir: Union[str, os.PathLike],
141	) -> None:
142	"""
143	Create a grid to display the object, cell, and merged masks for a given fov.
144
145	Args:
146	fov (str): Name of the fov to view
147	mask_name (str): Name of mask to view
148	object_mask_dir (Union[str, os.PathLike]): Directory where the object masks are stored.
149	cell_mask_dir (Union[str, os.PathLike]): Directory where the cell masks are stored.
150	merged_mask_dir (Union[str, os.PathLike]): Directory where the merged masks are stored.
151	"""
152	if isinstance(object_mask_dir, str):	6✔
153	object_mask_dir = pathlib.Path(object_mask_dir)	3✔
154	if isinstance(cell_mask_dir, str):	6✔
155	cell_mask_dir = pathlib.Path(cell_mask_dir)	3✔
156	if isinstance(merged_mask_dir, str):	6✔
157	merged_mask_dir = pathlib.Path(merged_mask_dir)	3✔
158	io_utils.validate_paths([object_mask_dir, cell_mask_dir, merged_mask_dir])	6✔
159
160	modified_overlay_mask: np.ndarray = create_overlap_and_merge_visual(	6✔
161	fov, mask_name, object_mask_dir, cell_mask_dir, merged_mask_dir
162	)
163
164	# Create a new figure
165	fig: Figure = plt.figure(dpi=300, figsize=(6, 6))	6✔
166	fig.set_layout_engine(layout="constrained")	6✔
167	gs = gridspec.GridSpec(1, 1, figure=fig)	6✔
168	fig.suptitle(f"Merged Mask: {mask_name}")	6✔
169	ax: Axes = fig.add_subplot(gs[0, 0])	6✔
170	# Display color mask with transparency
171	ax.imshow(modified_overlay_mask)	6✔
172	ax.axis("off")	6✔
173
174
175	def create_overlap_and_merge_visual(	6✔
176	fov: str,
177	mask_name: str,
178	object_mask_dir: pathlib.Path,
179	cell_mask_dir: pathlib.Path,
180	merged_mask_dir: pathlib.Path,
181	) -> np.ndarray:
182	"""
183	Generate the NumPy Array representing the overlap between two masks
184
185	Args:
186	fov (str): Name of the fov to view
187	mask_name (str): Name of mask to view
188	object_mask_dir (pathlib.Path): Directory where the object masks are stored.
189	cell_mask_dir (pathlib.Path): Directory where the cell masks are stored.
190	merged_mask_dir (pathlib.Path): Directory where the merged masks are stored.
191
192	Returns:
193	np.ndarray:
194	Contains an overlap image of the two masks
195	"""
196	# read in masks
197	object_mask: np.ndarray = imread(object_mask_dir / f"{fov}_{mask_name}.tiff")	6✔
198	cell_mask: np.ndarray = imread(	6✔
199	cell_mask_dir / f"{fov}_whole_cell.tiff", as_gray=True
200	)
201	merged_mask: np.ndarray = imread(	6✔
202	merged_mask_dir / f"{fov}_{mask_name}_merged.tiff", as_gray=True
203	)
204
205	# Assign colors to the non-overlapping areas of each mask
206	# Object masks in red
207	red_array = np.zeros(shape=object_mask.shape, dtype=np.uint8)	6✔
208	red_array[object_mask > 0] = 225	6✔
209
210	# Cell masks in blue
211	blue_array = np.zeros(shape=object_mask.shape, dtype=np.uint8)	6✔
212	blue_array[cell_mask > 0] = 255	6✔
213
214	# Merged mask edges in green
215	merge_bool = merged_mask > 0	6✔
216	edges = filters.sobel(merge_bool)	6✔
217	green_array = np.zeros(shape=object_mask.shape, dtype=np.uint8)	6✔
218	green_array[edges > 0] = 255	6✔
219
220	# Combine red, green, and blue channels to create the final image
221	image = np.stack([red_array, green_array, blue_array], axis=-1)	6✔
222
223	# return this image to the multi_merge_mask_display function.
224	return image	6✔

angelolab / ark-analysis / 6898444902

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous