def segment_images(inpDir, outDir, config_data):
""" Workflow for data with similar morphology
as connexin-43
Args:
inpDir : path to the input directory
outDir : path to the output directory
config_data : path to the configuration file
"""
logging.basicConfig(
format='%(asctime)s - %(name)-8s - %(levelname)-8s - %(message)s',
datefmt='%d-%b-%y %H:%M:%S')
logger = logging.getLogger("main")
logger.setLevel(logging.INFO)
inpDir_files = os.listdir(inpDir)
for i, f in enumerate(inpDir_files):
logger.info('Segmenting image : {}'.format(f))
# Load image
br = BioReader(os.path.join(inpDir, f))
image = br.read_image()
structure_channel = 0
struct_img0 = image[:, :, :, structure_channel, 0]
struct_img0 = struct_img0.transpose(2, 0, 1).astype(np.float32)
# main algorithm
intensity_scaling_param = config_data['intensity_scaling_param']
struct_img = intensity_normalization(
struct_img0, scaling_param=intensity_scaling_param)
gaussian_smoothing_sigma = config_data['gaussian_smoothing_sigma']
structure_img_smooth = image_smoothing_gaussian_slice_by_slice(
struct_img, sigma=gaussian_smoothing_sigma)
s3_param = config_data['s3_param']
bw = dot_3d_wrapper(structure_img_smooth, s3_param)
minArea = config_data['minArea']
seg = remove_small_objects(bw > 0,
min_size=minArea,
connectivity=1,
in_place=False)
seg = seg > 0
out_img = seg.astype(np.uint8)
out_img[out_img > 0] = 255
# create output image
out_img = out_img.transpose(1, 2, 0)
out_img = out_img.reshape(
(out_img.shape[0], out_img.shape[1], out_img.shape[2], 1, 1))
# write image using BFIO
bw = BioWriter(os.path.join(outDir, f), metadata=br.read_metadata())
bw.num_x(out_img.shape[1])
bw.num_y(out_img.shape[0])
bw.num_z(out_img.shape[2])
bw.num_c(out_img.shape[3])
bw.num_t(out_img.shape[4])
bw.pixel_type(dtype='uint8')
bw.write_image(out_img)
bw.close_image()
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_lamp1(
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 LAMP1
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_scaling_param = [3, 19]
gaussian_smoothing_sigma = 1
gaussian_smoothing_truncate_range = 3.0
minArea = 15
# ves_th_2d = 0.1
vesselness_sigma = [1]
vesselness_cutoff = 0.15
# hole_min = 60
hole_max = 1600
log_sigma_1 = 5
log_cutoff_1 = 0.09
log_sigma_2 = 2.5
log_cutoff_2 = 0.07
log_sigma_3 = 1
log_cutoff_3 = 0.01
##########################################################################
out_img_list = []
out_name_list = []
# intenisty normalization
struct_img = intensity_normalization(
struct_img, scaling_param=intensity_scaling_param
)
out_img_list.append(struct_img.copy())
out_name_list.append("im_norm")
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
)
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")
# spot detection
response1 = dot_slice_by_slice(structure_img_smooth, log_sigma=log_sigma_1)
bw1 = response1 > log_cutoff_1
response2 = dot_slice_by_slice(structure_img_smooth, log_sigma=log_sigma_2)
bw2 = response2 > log_cutoff_2
bw_spot = np.logical_or(bw1, bw2)
response3 = dot_slice_by_slice(structure_img_smooth, log_sigma=log_sigma_3)
bw3 = response3 > log_cutoff_3
bw_spot = np.logical_or(bw_spot, bw3)
# ring/filament detection
ves = vesselnessSliceBySlice(
structure_img_smooth, sigmas=vesselness_sigma, tau=1, whiteonblack=True
)
bw_ves = ves > vesselness_cutoff
# fill holes
partial_fill = np.logical_or(bw_spot, bw_ves)
out_img_list.append(partial_fill.copy())
out_name_list.append("interm_before_hole")
holes = np.zeros_like(partial_fill)
for zz in range(partial_fill.shape[0]):
background_lab = label(~partial_fill[zz, :, :], connectivity=1)
out = np.copy(background_lab)
component_sizes = np.bincount(background_lab.ravel())
too_big = component_sizes > hole_max
too_big_mask = too_big[background_lab]
out[too_big_mask] = 0
# too_small = component_sizes <hole_min
# too_small_mask = too_small[background_lab]
# out[too_small_mask] = 0
holes[zz, :, :] = out
full_fill = np.logical_or(partial_fill, holes)
seg = remove_small_objects(
full_fill, 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_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 segment_images(inpDir, outDir, config_data):
""" Workflow for dot like shapes such as
Centrin-2, Desmoplakin, PMP34.
Args:
inpDir : path to the input directory
outDir : path to the output directory
config_data : path to the configuration file
"""
logging.basicConfig(
format='%(asctime)s - %(name)-8s - %(levelname)-8s - %(message)s',
datefmt='%d-%b-%y %H:%M:%S')
logger = logging.getLogger("main")
logger.setLevel(logging.INFO)
inpDir_files = os.listdir(inpDir)
for i, f in enumerate(inpDir_files):
logger.info('Segmenting image : {}'.format(f))
# Load an image
br = BioReader(os.path.join(inpDir, f))
image = br.read_image()
structure_channel = 0
struct_img0 = image[:, :, :, structure_channel, 0]
struct_img0 = struct_img0.transpose(2, 0, 1).astype(np.float32)
# main algorithm
intensity_scaling_param = config_data['intensity_scaling_param']
struct_img = intensity_normalization(
struct_img0, scaling_param=intensity_scaling_param)
gaussian_smoothing_sigma = config_data['gaussian_smoothing_sigma']
if config_data["gaussian_smoothing"] == "gaussian_slice_by_slice":
structure_img_smooth = image_smoothing_gaussian_slice_by_slice(
struct_img, sigma=gaussian_smoothing_sigma)
else:
structure_img_smooth = image_smoothing_gaussian_3d(
struct_img, sigma=gaussian_smoothing_sigma)
s3_param = config_data['s3_param']
bw = dot_3d_wrapper(structure_img_smooth, s3_param)
minArea = config_data['minArea']
Mask = remove_small_objects(bw > 0,
min_size=minArea,
connectivity=1,
in_place=False)
Seed = dilation(peak_local_max(struct_img,
labels=label(Mask),
min_distance=2,
indices=False),
selem=ball(1))
Watershed_Map = -1 * distance_transform_edt(bw)
seg = watershed(Watershed_Map,
label(Seed),
mask=Mask,
watershed_line=True)
seg = remove_small_objects(seg > 0,
min_size=minArea,
connectivity=1,
in_place=False)
seg = seg > 0
out_img = seg.astype(np.uint8)
out_img[out_img > 0] = 255
# create output image
out_img = out_img.transpose(1, 2, 0)
out_img = out_img.reshape(
(out_img.shape[0], out_img.shape[1], out_img.shape[2], 1, 1))
# write image using BFIO
bw = BioWriter(os.path.join(outDir, f))
bw.num_x(out_img.shape[1])
bw.num_y(out_img.shape[0])
bw.num_z(out_img.shape[2])
bw.num_c(out_img.shape[3])
bw.num_t(out_img.shape[4])
bw.pixel_type(dtype='uint8')
bw.write_image(out_img)
bw.close_image()
def FABP3_Cardio_Pipeline(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
# ADD you parameters here
intensity_norm_param = [1, 18]
minArea = 0
gaussian_smoothing_sigma = 1
# lower_bound = 685
# upper_b = 18
# ADD-HERE
##########################################################################
out_img_list = []
out_name_list = []
###################
# PRE_PROCESSING
###################
# intenisty normalization (min/max)
struct_img = intensity_normalization(struct_img,
scaling_param=intensity_norm_param)
# upper_bound = np.mean(struct_img) + 18 * np.std(struct_img)
# struct_img[struct_img < lower_bound] = lower_bound
# struct_img[struct_img > upper_bound] = upper_bound
# struct_img = (struct_img - lower_bound).astype(float)/(upper_bound - lower_bound)
out_img_list.append(struct_img.copy())
out_name_list.append("im_norm")
# rescale if needed
if rescale_ratio > 0:
struct_img = resize(struct_img, [1, rescale_ratio, rescale_ratio],
method="cubic")
struct_img = (struct_img - struct_img.min() +
1e-8) / (struct_img.max() - struct_img.min() + 1e-8)
# smoothing with gaussian filter
structure_img_smooth = image_smoothing_gaussian_slice_by_slice(
struct_img, sigma=gaussian_smoothing_sigma) # ADD-HERE
out_img_list.append(structure_img_smooth.copy())
out_name_list.append("im_smooth")
# core algorithm
# th_li = threshold_li(structure_img_smooth)
# PARAMETERS for this step ##
s2_param = [[1, 0.02]]
bw = dot_2d_slice_by_slice_wrapper(structure_img_smooth, s2_param)
# POST-PROCESSING
seg = remove_small_objects(bw,
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
save_segmentation(seg, False, output_path, fn)
elif output_type == "TEMPLATE":
# the hook for pre-defined output functions
template_output(out_img_list, out_name_list, output_type, output_path,
fn)
