def explore_dot_3d(img, sigma, th, roi=[-1]):
# roi = [x0, y0, x1, y1]
if roi[0] < 0:
roi = [0, 0, img.shape[1], img.shape[2]]
im = img[:, roi[1]:roi[3], roi[0]:roi[2]]
from aicssegmentation.core.seg_dot import dot_3d
response = dot_3d(im, log_sigma=sigma)
bw = response > th
out = img_seg_combine(im, bw)
return out
def Workflow_son(struct_img, rescale_ratio, output_type, output_path, fn, output_func=None):
##########################################################################
# PARAMETERS:
# note that these parameters are supposed to be fixed for the structure
# and work well accross different datasets
##########################################################################
intensity_norm_param = [2, 30]
vesselness_sigma = [1.2]
vesselness_cutoff = 0.15
minArea = 15
dot_2d_sigma = 1
dot_3d_sigma = 1.15
##########################################################################
###################
# PRE_PROCESSING
###################
# intenisty normalization (min/max)
struct_img = intensity_normalization(struct_img, scaling_param=intensity_norm_param)
# smoothing with boundary preserving smoothing
structure_img_smooth = edge_preserving_smoothing_3d(struct_img)
###################
# core algorithm
###################
response_f3 = vesselness3D(structure_img_smooth, sigmas=vesselness_sigma, tau=1, whiteonblack=True)
response_f3 = response_f3 > vesselness_cutoff
response_s3_1 = dot_3d(structure_img_smooth, log_sigma=dot_3d_sigma)
response_s3_3 = dot_3d(structure_img_smooth, log_sigma=3)
bw_small_inverse = remove_small_objects(response_s3_1>0.03, min_size=150)
bw_small = np.logical_xor(bw_small_inverse, response_s3_1>0.02)
bw_medium = np.logical_or(bw_small, response_s3_1>0.07)
bw_large = np.logical_or(response_s3_3>0.2, response_f3>0.25)
bw = np.logical_or( np.logical_or(bw_small, bw_medium), bw_large)
###################
# POST-PROCESSING
###################
bw = remove_small_objects(bw>0, min_size=minArea, connectivity=1, in_place=False)
for zz in range(bw.shape[0]):
bw[zz,: , :] = remove_small_objects(bw[zz,:,:], min_size=3, connectivity=1, in_place=False)
seg = remove_small_objects(bw>0, min_size=minArea, connectivity=1, in_place=False)
seg = seg>0
seg = seg.astype(np.uint8)
seg[seg>0]=255
if output_type == 'default':
# the default final output
save_segmentation(seg, False, output_path, fn)
elif output_type == 'array':
return seg
elif output_type == 'array_with_contour':
return (seg, generate_segmentation_contour(seg))
else:
print('your can implement your output hook here, but not yet')
quit()
def Workflow_slc25a17(
struct_img: np.ndarray,
rescale_ratio: float = -1,
output_type: str = "default",
output_path: Union[str, Path] = None,
fn: Union[str, Path] = None,
output_func=None,
):
"""
classic segmentation workflow wrapper for structure SLC25A17
Parameter:
-----------
struct_img: np.ndarray
the 3D image to be segmented
rescale_ratio: float
an optional parameter to allow rescale the image before running the
segmentation functions, default is no rescaling
output_type: str
select how to handle output. Currently, four types are supported:
1. default: the result will be saved at output_path whose filename is
original name without extention + "_struct_segmentaiton.tiff"
2. array: the segmentation result will be simply returned as a numpy array
3. array_with_contour: segmentation result will be returned together with
the contour of the segmentation
4. customize: pass in an extra output_func to do a special save. All the
intermediate results, names of these results, the output_path, and the
original filename (without extension) will be passed in to output_func.
"""
##########################################################################
# PARAMETERS:
# note that these parameters are supposed to be fixed for the structure
# and work well accross different datasets
intensity_norm_param = [2, 36]
gaussian_smoothing_sigma = 1
gaussian_smoothing_truncate_range = 3.0
dot_3d_sigma = 1
dot_3d_cutoff = 0.045 # 0.03 #0.04
minArea = 3 # 5
##########################################################################
out_img_list = []
out_name_list = []
###################
# PRE_PROCESSING
###################
# intenisty normalization (min/max)
struct_img = intensity_normalization(struct_img,
scaling_param=intensity_norm_param)
out_img_list.append(struct_img.copy())
out_name_list.append("im_norm")
# rescale if needed
if rescale_ratio > 0:
struct_img = zoom(struct_img, (1, rescale_ratio, rescale_ratio),
order=2)
struct_img = (struct_img - struct_img.min() +
1e-8) / (struct_img.max() - struct_img.min() + 1e-8)
gaussian_smoothing_truncate_range = (
gaussian_smoothing_truncate_range * rescale_ratio)
# smoothing with gaussian filter
structure_img_smooth = image_smoothing_gaussian_slice_by_slice(
struct_img,
sigma=gaussian_smoothing_sigma,
truncate_range=gaussian_smoothing_truncate_range,
)
out_img_list.append(structure_img_smooth.copy())
out_name_list.append("im_smooth")
###################
# core algorithm
###################
# step 1: LOG 3d
response = dot_3d(structure_img_smooth, log_sigma=dot_3d_sigma)
bw = response > dot_3d_cutoff
bw = remove_small_objects(bw > 0,
min_size=minArea,
connectivity=1,
in_place=False)
out_img_list.append(bw.copy())
out_name_list.append("interm_mask")
# step 2: 'local_maxi + watershed' for cell cutting
local_maxi = peak_local_max(struct_img,
labels=label(bw),
min_distance=2,
indices=False)
out_img_list.append(local_maxi.copy())
out_name_list.append("interm_local_max")
distance = distance_transform_edt(bw)
im_watershed = watershed(
-1 * distance,
label(dilation(local_maxi, selem=ball(1))),
mask=bw,
watershed_line=True,
)
###################
# POST-PROCESSING
###################
seg = remove_small_objects(im_watershed,
min_size=minArea,
connectivity=1,
in_place=False)
# HACK: Only for 2019 April Release #####
if np.count_nonzero(seg > 0) < 50000:
print("FLAG: please check the meta data of the original CZI for QC")
# output
seg = seg > 0
seg = seg.astype(np.uint8)
seg[seg > 0] = 255
out_img_list.append(seg.copy())
out_name_list.append("bw_final")
if output_type == "default":
# the default final output, simply save it to the output path
save_segmentation(seg, False, Path(output_path), fn)
elif output_type == "customize":
# the hook for passing in a customized output function
# use "out_img_list" and "out_name_list" in your hook to
# customize your output functions
output_func(out_img_list, out_name_list, Path(output_path), fn)
elif output_type == "array":
return seg
elif output_type == "array_with_contour":
return (seg, generate_segmentation_contour(seg))
else:
raise NotImplementedError("invalid output type: {output_type}")
def Workflow_rab5a(
struct_img: np.ndarray,
rescale_ratio: float = -1,
output_type: str = "default",
output_path: Union[str, Path] = None,
fn: Union[str, Path] = None,
output_func=None,
):
"""
classic segmentation workflow wrapper for structure RAB5A
Parameter:
-----------
struct_img: np.ndarray
the 3D image to be segmented
rescale_ratio: float
an optional parameter to allow rescale the image before running the
segmentation functions, default is no rescaling
output_type: str
select how to handle output. Currently, four types are supported:
1. default: the result will be saved at output_path whose filename is
original name without extention + "_struct_segmentaiton.tiff"
2. array: the segmentation result will be simply returned as a numpy array
3. array_with_contour: segmentation result will be returned together with
the contour of the segmentation
4. customize: pass in an extra output_func to do a special save. All the
intermediate results, names of these results, the output_path, and the
original filename (without extension) will be passed in to output_func.
"""
##########################################################################
# PARAMETERS:
# note that these parameters are supposed to be fixed for the structure
# and work well accross different datasets
intensity_norm_param = [1000]
gaussian_smoothing_sigma = 1
gaussian_smoothing_truncate_range = 3.0
dot_3d_sigma = 1
dot_3d_cutoff = 0.03
hole_min = 0
hole_max = 81
minArea = 3
##########################################################################
out_img_list = []
out_name_list = []
###################
# PRE_PROCESSING
###################
# intenisty normalization (min/max)
struct_img = intensity_normalization(struct_img,
scaling_param=intensity_norm_param)
out_img_list.append(struct_img.copy())
out_name_list.append("im_norm")
# rescale if needed
if rescale_ratio > 0:
struct_img = zoom(struct_img, (1, rescale_ratio, rescale_ratio),
order=2)
struct_img = (struct_img - struct_img.min() +
1e-8) / (struct_img.max() - struct_img.min() + 1e-8)
gaussian_smoothing_truncate_range = (
gaussian_smoothing_truncate_range * rescale_ratio)
# smoothing with gaussian filter
structure_img_smooth = image_smoothing_gaussian_slice_by_slice(
struct_img,
sigma=gaussian_smoothing_sigma,
truncate_range=gaussian_smoothing_truncate_range,
)
out_img_list.append(structure_img_smooth.copy())
out_name_list.append("im_smooth")
###################
# core algorithm
###################
# step 1: LOG 3d
response = dot_3d(structure_img_smooth, log_sigma=dot_3d_sigma)
bw = response > dot_3d_cutoff
# step 2: fill holes and remove small objects
bw_filled = hole_filling(bw, hole_min, hole_max, True)
seg = remove_small_objects(bw_filled,
min_size=minArea,
connectivity=1,
in_place=False)
# output
seg = seg > 0
seg = seg.astype(np.uint8)
seg[seg > 0] = 255
out_img_list.append(seg.copy())
out_name_list.append("bw_final")
if output_type == "default":
# the default final output, simply save it to the output path
save_segmentation(seg, False, Path(output_path), fn)
elif output_type == "customize":
# the hook for passing in a customized output function
# use "out_img_list" and "out_name_list" in your hook to
# customize your output functions
output_func(out_img_list, out_name_list, Path(output_path), fn)
elif output_type == "array":
return seg
elif output_type == "array_with_contour":
return (seg, generate_segmentation_contour(seg))
else:
raise NotImplementedError("invalid output type: {output_type}")
def Workflow_son(
struct_img: np.ndarray,
rescale_ratio: float = -1,
output_type: str = "default",
output_path: Union[str, Path] = None,
fn: Union[str, Path] = None,
output_func=None,
):
"""
classic segmentation workflow wrapper for structure SON
Parameter:
-----------
struct_img: np.ndarray
the 3D image to be segmented
rescale_ratio: float
an optional parameter to allow rescale the image before running the
segmentation functions, default is no rescaling
output_type: str
select how to handle output. Currently, four types are supported:
1. default: the result will be saved at output_path whose filename is
original name without extention + "_struct_segmentaiton.tiff"
2. array: the segmentation result will be simply returned as a numpy array
3. array_with_contour: segmentation result will be returned together with
the contour of the segmentation
4. customize: pass in an extra output_func to do a special save. All the
intermediate results, names of these results, the output_path, and the
original filename (without extension) will be passed in to output_func.
"""
##########################################################################
# PARAMETERS:
# note that these parameters are supposed to be fixed for the structure
# and work well accross different datasets
##########################################################################
intensity_norm_param = [2, 30]
vesselness_sigma = [1.2]
vesselness_cutoff = 0.15
minArea = 15
# dot_2d_sigma = 1
dot_3d_sigma = 1.15
##########################################################################
out_img_list = []
out_name_list = []
###################
# PRE_PROCESSING
###################
# intenisty normalization (min/max)
struct_img = intensity_normalization(struct_img,
scaling_param=intensity_norm_param)
out_img_list.append(struct_img.copy())
out_name_list.append("im_norm")
# smoothing with boundary preserving smoothing
structure_img_smooth = edge_preserving_smoothing_3d(struct_img)
out_img_list.append(structure_img_smooth.copy())
out_name_list.append("im_smooth")
###################
# core algorithm
###################
response_f3 = vesselness3D(structure_img_smooth,
sigmas=vesselness_sigma,
tau=1,
whiteonblack=True)
response_f3 = response_f3 > vesselness_cutoff
response_s3_1 = dot_3d(structure_img_smooth, log_sigma=dot_3d_sigma)
response_s3_3 = dot_3d(structure_img_smooth, log_sigma=3)
bw_small_inverse = remove_small_objects(response_s3_1 > 0.03, min_size=150)
bw_small = np.logical_xor(bw_small_inverse, response_s3_1 > 0.02)
bw_medium = np.logical_or(bw_small, response_s3_1 > 0.07)
bw_large = np.logical_or(response_s3_3 > 0.2, response_f3 > 0.25)
bw = np.logical_or(np.logical_or(bw_small, bw_medium), bw_large)
###################
# POST-PROCESSING
###################
bw = remove_small_objects(bw > 0,
min_size=minArea,
connectivity=1,
in_place=False)
for zz in range(bw.shape[0]):
bw[zz, :, :] = remove_small_objects(bw[zz, :, :],
min_size=3,
connectivity=1,
in_place=False)
seg = remove_small_objects(bw > 0,
min_size=minArea,
connectivity=1,
in_place=False)
seg = seg > 0
seg = seg.astype(np.uint8)
seg[seg > 0] = 255
out_img_list.append(seg.copy())
out_name_list.append("bw_final")
if output_type == "default":
# the default final output, simply save it to the output path
save_segmentation(seg, False, Path(output_path), fn)
elif output_type == "customize":
# the hook for passing in a customized output function
# use "out_img_list" and "out_name_list" in your hook to
# customize your output functions
output_func(out_img_list, out_name_list, Path(output_path), fn)
elif output_type == "array":
return seg
elif output_type == "array_with_contour":
return (seg, generate_segmentation_contour(seg))
else:
raise NotImplementedError("invalid output type: {output_type}")
def Workflow_st6gal1(
struct_img: np.ndarray,
rescale_ratio: float = -1,
output_type: str = "default",
output_path: Union[str, Path] = None,
fn: Union[str, Path] = None,
output_func=None,
):
"""
classic segmentation workflow wrapper for structure ST6GAL1
Parameter:
-----------
struct_img: np.ndarray
the 3D image to be segmented
rescale_ratio: float
an optional parameter to allow rescale the image before running the
segmentation functions, default is no rescaling
output_type: str
select how to handle output. Currently, four types are supported:
1. default: the result will be saved at output_path whose filename is
original name without extention + "_struct_segmentaiton.tiff"
2. array: the segmentation result will be simply returned as a numpy array
3. array_with_contour: segmentation result will be returned together with
the contour of the segmentation
4. customize: pass in an extra output_func to do a special save. All the
intermediate results, names of these results, the output_path, and the
original filename (without extension) will be passed in to output_func.
"""
##########################################################################
# PARAMETERS:
# note that these parameters are supposed to be fixed for the structure
# and work well accross different datasets
intensity_norm_param = [9, 19]
gaussian_smoothing_sigma = 1
gaussian_smoothing_truncate_range = 3.0
cell_wise_min_area = 1200
dot_3d_sigma = 1.6
dot_3d_cutoff = 0.02
minArea = 10
thin_dist = 1
thin_dist_preserve = 1.6
##########################################################################
out_img_list = []
out_name_list = []
###################
# PRE_PROCESSING
###################
# intenisty normalization (min/max)
struct_img = intensity_normalization(struct_img, scaling_param=intensity_norm_param)
out_img_list.append(struct_img.copy())
out_name_list.append("im_norm")
# rescale if needed
if rescale_ratio > 0:
struct_img = zoom(struct_img, (1, rescale_ratio, rescale_ratio), order=2)
struct_img = (struct_img - struct_img.min() + 1e-8) / (
struct_img.max() - struct_img.min() + 1e-8
)
gaussian_smoothing_truncate_range = (
gaussian_smoothing_truncate_range * rescale_ratio
)
# smoothing with gaussian filter
structure_img_smooth = image_smoothing_gaussian_3d(
struct_img,
sigma=gaussian_smoothing_sigma,
truncate_range=gaussian_smoothing_truncate_range,
)
out_img_list.append(structure_img_smooth.copy())
out_name_list.append("im_smooth")
###################
# core algorithm
###################
# cell-wise local adaptive thresholding
th_low_level = threshold_triangle(structure_img_smooth)
bw_low_level = structure_img_smooth > th_low_level
bw_low_level = remove_small_objects(
bw_low_level, min_size=cell_wise_min_area, connectivity=1, in_place=True
)
bw_low_level = dilation(bw_low_level, selem=ball(2))
bw_high_level = np.zeros_like(bw_low_level)
lab_low, num_obj = label(bw_low_level, return_num=True, connectivity=1)
for idx in range(num_obj):
single_obj = lab_low == (idx + 1)
local_otsu = threshold_otsu(structure_img_smooth[single_obj > 0])
bw_high_level[
np.logical_and(structure_img_smooth > local_otsu * 0.98, single_obj)
] = 1
# LOG 3d to capture spots
response = dot_3d(structure_img_smooth, log_sigma=dot_3d_sigma)
bw_extra = response > dot_3d_cutoff
# thinning
bw_high_level = topology_preserving_thinning(
bw_high_level, thin_dist_preserve, thin_dist
)
# combine the two parts
bw = np.logical_or(bw_high_level, bw_extra)
###################
# POST-PROCESSING
###################
seg = remove_small_objects(bw > 0, min_size=minArea, connectivity=1, in_place=False)
# output
seg = seg > 0
seg = seg.astype(np.uint8)
seg[seg > 0] = 255
out_img_list.append(seg.copy())
out_name_list.append("bw_final")
if output_type == "default":
# the default final output, simply save it to the output path
save_segmentation(seg, False, Path(output_path), fn)
elif output_type == "customize":
# the hook for passing in a customized output function
# use "out_img_list" and "out_name_list" in your hook to
# customize your output functions
output_func(out_img_list, out_name_list, Path(output_path), fn)
elif output_type == "array":
return seg
elif output_type == "array_with_contour":
return (seg, generate_segmentation_contour(seg))
else:
raise NotImplementedError("invalid output type: {output_type}")