def add_threshold_measurements(self, measurements, image, mask,
local_threshold, global_threshold, objname):
'''Compute and add threshold statistics measurements
measurements - add the measurements here
image - the image that was thresholded
mask - mask of significant pixels
local_threshold - either a per-pixel threshold (a matrix) or a
copy of the global threshold (a scalar)
global_threshold - the globally-calculated threshold
objname - either the name of the objects that were created or,
for ApplyThreshold, the image created.
'''
if self.threshold_modifier == TM_GLOBAL:
# The local threshold is a single number
assert (not isinstance(local_threshold, np.ndarray))
ave_threshold = local_threshold
else:
# The local threshold is an array
ave_threshold = local_threshold.mean()
measurements.add_measurement(cpmeas.IMAGE,
FF_FINAL_THRESHOLD % (objname),
np.array([ave_threshold], dtype=float))
measurements.add_measurement(cpmeas.IMAGE,
FF_ORIG_THRESHOLD % (objname),
np.array([global_threshold], dtype=float))
wv = weighted_variance(image, mask, local_threshold)
measurements.add_measurement(cpmeas.IMAGE,
FF_WEIGHTED_VARIANCE % (objname),
np.array([wv], dtype=float))
entropies = sum_of_entropies(image, mask, local_threshold)
measurements.add_measurement(cpmeas.IMAGE,
FF_SUM_OF_ENTROPIES % (objname),
np.array([entropies], dtype=float))
def add_threshold_measurements(self, measurements, image, mask,
local_threshold, global_threshold,
objname):
'''Compute and add threshold statistics measurements
measurements - add the measurements here
image - the image that was thresholded
mask - mask of significant pixels
local_threshold - either a per-pixel threshold (a matrix) or a
copy of the global threshold (a scalar)
global_threshold - the globally-calculated threshold
objname - either the name of the objects that were created or,
for ApplyThreshold, the image created.
'''
if self.threshold_modifier == TM_GLOBAL:
# The local threshold is a single number
assert(not isinstance(local_threshold,np.ndarray))
ave_threshold = local_threshold
else:
# The local threshold is an array
ave_threshold = local_threshold.mean()
measurements.add_measurement(cpmeas.IMAGE,
FF_FINAL_THRESHOLD%(objname),
np.array([ave_threshold],
dtype=float))
measurements.add_measurement(cpmeas.IMAGE,
FF_ORIG_THRESHOLD%(objname),
np.array([global_threshold],
dtype=float))
wv = weighted_variance(image, mask, local_threshold)
measurements.add_measurement(cpmeas.IMAGE,
FF_WEIGHTED_VARIANCE%(objname),
np.array([wv],dtype=float))
entropies = sum_of_entropies(image, mask, local_threshold)
measurements.add_measurement(cpmeas.IMAGE,
FF_SUM_OF_ENTROPIES%(objname),
np.array([entropies],dtype=float))
def run(self, workspace):
assert isinstance(workspace, cpw.Workspace)
image = workspace.image_set.get_image(self.image_name.value,
must_be_grayscale = True)
img = image.pixel_data
mask = image.mask
objects = workspace.object_set.get_objects(self.primary_objects.value)
global_threshold = None
if self.method == M_DISTANCE_N:
has_threshold = False
elif self.threshold_method == cpthresh.TM_BINARY_IMAGE:
binary_image = workspace.image_set.get_image(self.binary_image.value,
must_be_binary = True)
local_threshold = np.ones(img.shape) * np.max(img) + np.finfo(float).eps
local_threshold[binary_image.pixel_data] = np.min(img) - np.finfo(float).eps
global_threshold = cellprofiler.cpmath.otsu.otsu(img[mask],
self.threshold_range.min,
self.threshold_range.max)
has_threshold = True
else:
local_threshold,global_threshold = self.get_threshold(img, mask, None, workspace)
has_threshold = True
if has_threshold:
thresholded_image = img > local_threshold
#
# Get the following labels:
# * all edited labels
# * labels touching the edge, including small removed
#
labels_in = objects.unedited_segmented.copy()
labels_touching_edge = np.hstack(
(labels_in[0,:], labels_in[-1,:], labels_in[:,0], labels_in[:,-1]))
labels_touching_edge = np.unique(labels_touching_edge)
is_touching = np.zeros(np.max(labels_in)+1, bool)
is_touching[labels_touching_edge] = True
is_touching = is_touching[labels_in]
labels_in[(~ is_touching) & (objects.segmented == 0)] = 0
#
# Stretch the input labels to match the image size. If there's no
# label matrix, then there's no label in that area.
#
if tuple(labels_in.shape) != tuple(img.shape):
tmp = np.zeros(img.shape, labels_in.dtype)
i_max = min(img.shape[0], labels_in.shape[0])
j_max = min(img.shape[1], labels_in.shape[1])
tmp[:i_max, :j_max] = labels_in[:i_max, :j_max]
labels_in = tmp
if self.method in (M_DISTANCE_B, M_DISTANCE_N):
if self.method == M_DISTANCE_N:
distances,(i,j) = scind.distance_transform_edt(labels_in == 0,
return_indices = True)
labels_out = np.zeros(labels_in.shape,int)
dilate_mask = distances <= self.distance_to_dilate.value
labels_out[dilate_mask] =\
labels_in[i[dilate_mask],j[dilate_mask]]
else:
labels_out, distances = propagate(img, labels_in,
thresholded_image,
1.0)
labels_out[distances>self.distance_to_dilate.value] = 0
labels_out[labels_in > 0] = labels_in[labels_in>0]
if self.fill_holes:
small_removed_segmented_out = fill_labeled_holes(labels_out)
else:
small_removed_segmented_out = labels_out
#
# Create the final output labels by removing labels in the
# output matrix that are missing from the segmented image
#
segmented_labels = objects.segmented
segmented_out = self.filter_labels(small_removed_segmented_out,
objects, workspace)
elif self.method == M_PROPAGATION:
labels_out, distance = propagate(img, labels_in,
thresholded_image,
self.regularization_factor.value)
if self.fill_holes:
small_removed_segmented_out = fill_labeled_holes(labels_out)
else:
small_removed_segmented_out = labels_out.copy()
segmented_out = self.filter_labels(small_removed_segmented_out,
objects, workspace)
elif self.method == M_WATERSHED_G:
#
# First, apply the sobel filter to the image (both horizontal
# and vertical). The filter measures gradient.
#
sobel_image = np.abs(scind.sobel(img))
#
# Combine the image mask and threshold to mask the watershed
#
watershed_mask = np.logical_or(thresholded_image, labels_in > 0)
watershed_mask = np.logical_and(watershed_mask, mask)
#
# Perform the first watershed
#
labels_out = watershed(sobel_image,
labels_in,
np.ones((3,3),bool),
mask=watershed_mask)
if self.fill_holes:
small_removed_segmented_out = fill_labeled_holes(labels_out)
else:
small_removed_segmented_out = labels_out.copy()
segmented_out = self.filter_labels(small_removed_segmented_out,
objects, workspace)
elif self.method == M_WATERSHED_I:
#
# invert the image so that the maxima are filled first
# and the cells compete over what's close to the threshold
#
inverted_img = 1-img
#
# Same as above, but perform the watershed on the original image
#
watershed_mask = np.logical_or(thresholded_image, labels_in > 0)
watershed_mask = np.logical_and(watershed_mask, mask)
#
# Perform the watershed
#
labels_out = watershed(inverted_img,
labels_in,
np.ones((3,3),bool),
mask=watershed_mask)
if self.fill_holes:
small_removed_segmented_out = fill_labeled_holes(labels_out)
else:
small_removed_segmented_out = labels_out
segmented_out = self.filter_labels(small_removed_segmented_out,
objects, workspace)
if self.wants_discard_edge and self.wants_discard_primary:
#
# Make a new primary object
#
lookup = scind.maximum(segmented_out,
objects.segmented,
range(np.max(objects.segmented)+1))
lookup = fix(lookup)
lookup[0] = 0
lookup[lookup != 0] = np.arange(np.sum(lookup != 0)) + 1
segmented_labels = lookup[objects.segmented]
segmented_out = lookup[segmented_out]
new_objects = cpo.Objects()
new_objects.segmented = segmented_labels
if objects.has_unedited_segmented:
new_objects.unedited_segmented = objects.unedited_segmented
if objects.has_small_removed_segmented:
new_objects.small_removed_segmented = objects.small_removed_segmented
new_objects.parent_image = objects.parent_image
primary_outline = outline(segmented_labels)
if self.wants_primary_outlines:
out_img = cpi.Image(primary_outline.astype(bool),
parent_image = image)
workspace.image_set.add(self.new_primary_outlines_name.value,
out_img)
else:
primary_outline = outline(objects.segmented)
secondary_outline = outline(segmented_out)
if workspace.frame != None:
object_area = np.sum(segmented_out > 0)
object_pct = 100 * object_area / np.product(segmented_out.shape)
my_frame=workspace.create_or_find_figure(title="IdentifySecondaryObjects, image cycle #%d"%(
workspace.measurements.image_set_number),subplots=(2,2))
title = "Input image, cycle #%d"%(workspace.image_set.number+1)
my_frame.subplot_imshow_grayscale(0, 0, img, title)
my_frame.subplot_imshow_labels(1, 0, segmented_out, "Labeled image",
sharex = my_frame.subplot(0,0),
sharey = my_frame.subplot(0,0))
outline_img = np.dstack((img, img, img))
cpmi.draw_outline(outline_img, secondary_outline > 0,
cpprefs.get_secondary_outline_color())
my_frame.subplot_imshow(0, 1, outline_img, "Outlined image",
normalize=False,
sharex = my_frame.subplot(0,0),
sharey = my_frame.subplot(0,0))
primary_img = np.dstack((img, img, img))
cpmi.draw_outline(primary_img, primary_outline > 0,
cpprefs.get_primary_outline_color())
cpmi.draw_outline(primary_img, secondary_outline > 0,
cpprefs.get_secondary_outline_color())
my_frame.subplot_imshow(1, 1, primary_img,
"Primary and output outlines",
normalize=False,
sharex = my_frame.subplot(0,0),
sharey = my_frame.subplot(0,0))
if global_threshold is not None:
my_frame.status_bar.SetFields(
["Threshold: %.3f" % global_threshold,
"Area covered by objects: %.1f %%" % object_pct])
else:
my_frame.status_bar.SetFields(
["Area covered by objects: %.1f %%" % object_pct])
#
# Add the objects to the object set
#
objects_out = cpo.Objects()
objects_out.unedited_segmented = small_removed_segmented_out
objects_out.small_removed_segmented = small_removed_segmented_out
objects_out.segmented = segmented_out
objects_out.parent_image = image
objname = self.objects_name.value
workspace.object_set.add_objects(objects_out, objname)
if self.use_outlines.value:
out_img = cpi.Image(secondary_outline.astype(bool),
parent_image = image)
workspace.image_set.add(self.outlines_name.value, out_img)
object_count = np.max(segmented_out)
#
# Add the background measurements if made
#
measurements = workspace.measurements
if has_threshold:
if isinstance(local_threshold,np.ndarray):
ave_threshold = np.mean(local_threshold)
else:
ave_threshold = local_threshold
measurements.add_measurement(cpmeas.IMAGE,
cpmi.FF_FINAL_THRESHOLD%(objname),
np.array([ave_threshold],
dtype=float))
measurements.add_measurement(cpmeas.IMAGE,
cpmi.FF_ORIG_THRESHOLD%(objname),
np.array([global_threshold],
dtype=float))
wv = cpthresh.weighted_variance(img, mask, local_threshold)
measurements.add_measurement(cpmeas.IMAGE,
cpmi.FF_WEIGHTED_VARIANCE%(objname),
np.array([wv],dtype=float))
entropies = cpthresh.sum_of_entropies(img, mask, local_threshold)
measurements.add_measurement(cpmeas.IMAGE,
cpmi.FF_SUM_OF_ENTROPIES%(objname),
np.array([entropies],dtype=float))
cpmi.add_object_count_measurements(measurements, objname, object_count)
cpmi.add_object_location_measurements(measurements, objname,
segmented_out)
#
# Relate the secondary objects to the primary ones and record
# the relationship.
#
children_per_parent, parents_of_children = \
objects.relate_children(objects_out)
measurements.add_measurement(self.primary_objects.value,
cpmi.FF_CHILDREN_COUNT%objname,
children_per_parent)
measurements.add_measurement(objname,
cpmi.FF_PARENT%self.primary_objects.value,
parents_of_children)
#
# If primary objects were created, add them
#
if self.wants_discard_edge and self.wants_discard_primary:
workspace.object_set.add_objects(new_objects,
self.new_primary_objects_name.value)
cpmi.add_object_count_measurements(measurements,
self.new_primary_objects_name.value,
np.max(new_objects.segmented))
cpmi.add_object_location_measurements(measurements,
self.new_primary_objects_name.value,
new_objects.segmented)
for parent_objects, parent_name, child_objects, child_name in (
(objects, self.primary_objects.value,
new_objects, self.new_primary_objects_name.value),
(new_objects, self.new_primary_objects_name.value,
objects_out, objname)):
children_per_parent, parents_of_children = \
parent_objects.relate_children(child_objects)
measurements.add_measurement(parent_name,
cpmi.FF_CHILDREN_COUNT%child_name,
children_per_parent)
measurements.add_measurement(child_name,
cpmi.FF_PARENT%parent_name,
parents_of_children)
def run(self, workspace):
assert isinstance(workspace, cpw.Workspace)
image = workspace.image_set.get_image(self.image_name.value,
must_be_grayscale=True)
img = image.pixel_data
mask = image.mask
objects = workspace.object_set.get_objects(self.primary_objects.value)
global_threshold = None
if self.method == M_DISTANCE_N:
has_threshold = False
elif self.threshold_method == cpthresh.TM_BINARY_IMAGE:
binary_image = workspace.image_set.get_image(
self.binary_image.value, must_be_binary=True)
local_threshold = np.ones(
img.shape) * np.max(img) + np.finfo(float).eps
local_threshold[
binary_image.pixel_data] = np.min(img) - np.finfo(float).eps
global_threshold = cellprofiler.cpmath.otsu.otsu(
img[mask], self.threshold_range.min, self.threshold_range.max)
has_threshold = True
else:
local_threshold, global_threshold = self.get_threshold(
img, mask, None, workspace)
has_threshold = True
if has_threshold:
thresholded_image = img > local_threshold
#
# Get the following labels:
# * all edited labels
# * labels touching the edge, including small removed
#
labels_in = objects.unedited_segmented.copy()
labels_touching_edge = np.hstack(
(labels_in[0, :], labels_in[-1, :], labels_in[:,
0], labels_in[:,
-1]))
labels_touching_edge = np.unique(labels_touching_edge)
is_touching = np.zeros(np.max(labels_in) + 1, bool)
is_touching[labels_touching_edge] = True
is_touching = is_touching[labels_in]
labels_in[(~is_touching) & (objects.segmented == 0)] = 0
#
# Stretch the input labels to match the image size. If there's no
# label matrix, then there's no label in that area.
#
if tuple(labels_in.shape) != tuple(img.shape):
tmp = np.zeros(img.shape, labels_in.dtype)
i_max = min(img.shape[0], labels_in.shape[0])
j_max = min(img.shape[1], labels_in.shape[1])
tmp[:i_max, :j_max] = labels_in[:i_max, :j_max]
labels_in = tmp
if self.method in (M_DISTANCE_B, M_DISTANCE_N):
if self.method == M_DISTANCE_N:
distances, (i, j) = scind.distance_transform_edt(
labels_in == 0, return_indices=True)
labels_out = np.zeros(labels_in.shape, int)
dilate_mask = distances <= self.distance_to_dilate.value
labels_out[dilate_mask] =\
labels_in[i[dilate_mask],j[dilate_mask]]
else:
labels_out, distances = propagate(img, labels_in,
thresholded_image, 1.0)
labels_out[distances > self.distance_to_dilate.value] = 0
labels_out[labels_in > 0] = labels_in[labels_in > 0]
if self.fill_holes:
small_removed_segmented_out = fill_labeled_holes(labels_out)
else:
small_removed_segmented_out = labels_out
#
# Create the final output labels by removing labels in the
# output matrix that are missing from the segmented image
#
segmented_labels = objects.segmented
segmented_out = self.filter_labels(small_removed_segmented_out,
objects, workspace)
elif self.method == M_PROPAGATION:
labels_out, distance = propagate(img, labels_in, thresholded_image,
self.regularization_factor.value)
if self.fill_holes:
small_removed_segmented_out = fill_labeled_holes(labels_out)
else:
small_removed_segmented_out = labels_out.copy()
segmented_out = self.filter_labels(small_removed_segmented_out,
objects, workspace)
elif self.method == M_WATERSHED_G:
#
# First, apply the sobel filter to the image (both horizontal
# and vertical). The filter measures gradient.
#
sobel_image = np.abs(scind.sobel(img))
#
# Combine the image mask and threshold to mask the watershed
#
watershed_mask = np.logical_or(thresholded_image, labels_in > 0)
watershed_mask = np.logical_and(watershed_mask, mask)
#
# Perform the first watershed
#
labels_out = watershed(sobel_image,
labels_in,
np.ones((3, 3), bool),
mask=watershed_mask)
if self.fill_holes:
small_removed_segmented_out = fill_labeled_holes(labels_out)
else:
small_removed_segmented_out = labels_out.copy()
segmented_out = self.filter_labels(small_removed_segmented_out,
objects, workspace)
elif self.method == M_WATERSHED_I:
#
# invert the image so that the maxima are filled first
# and the cells compete over what's close to the threshold
#
inverted_img = 1 - img
#
# Same as above, but perform the watershed on the original image
#
watershed_mask = np.logical_or(thresholded_image, labels_in > 0)
watershed_mask = np.logical_and(watershed_mask, mask)
#
# Perform the watershed
#
labels_out = watershed(inverted_img,
labels_in,
np.ones((3, 3), bool),
mask=watershed_mask)
if self.fill_holes:
small_removed_segmented_out = fill_labeled_holes(labels_out)
else:
small_removed_segmented_out = labels_out
segmented_out = self.filter_labels(small_removed_segmented_out,
objects, workspace)
if self.wants_discard_edge and self.wants_discard_primary:
#
# Make a new primary object
#
lookup = scind.maximum(segmented_out, objects.segmented,
range(np.max(objects.segmented) + 1))
lookup = fix(lookup)
lookup[0] = 0
lookup[lookup != 0] = np.arange(np.sum(lookup != 0)) + 1
segmented_labels = lookup[objects.segmented]
segmented_out = lookup[segmented_out]
new_objects = cpo.Objects()
new_objects.segmented = segmented_labels
if objects.has_unedited_segmented:
new_objects.unedited_segmented = objects.unedited_segmented
if objects.has_small_removed_segmented:
new_objects.small_removed_segmented = objects.small_removed_segmented
new_objects.parent_image = objects.parent_image
primary_outline = outline(segmented_labels)
if self.wants_primary_outlines:
out_img = cpi.Image(primary_outline.astype(bool),
parent_image=image)
workspace.image_set.add(self.new_primary_outlines_name.value,
out_img)
else:
primary_outline = outline(objects.segmented)
secondary_outline = outline(segmented_out)
if workspace.frame != None:
object_area = np.sum(segmented_out > 0)
object_pct = 100 * object_area / np.product(segmented_out.shape)
my_frame = workspace.create_or_find_figure(
title="IdentifySecondaryObjects, image cycle #%d" %
(workspace.measurements.image_set_number),
subplots=(2, 2))
title = "Input image, cycle #%d" % (workspace.image_set.number + 1)
my_frame.subplot_imshow_grayscale(0, 0, img, title)
my_frame.subplot_imshow_labels(1,
0,
segmented_out,
"Labeled image",
sharex=my_frame.subplot(0, 0),
sharey=my_frame.subplot(0, 0))
outline_img = np.dstack((img, img, img))
cpmi.draw_outline(outline_img, secondary_outline > 0,
cpprefs.get_secondary_outline_color())
my_frame.subplot_imshow(0,
1,
outline_img,
"Outlined image",
normalize=False,
sharex=my_frame.subplot(0, 0),
sharey=my_frame.subplot(0, 0))
primary_img = np.dstack((img, img, img))
cpmi.draw_outline(primary_img, primary_outline > 0,
cpprefs.get_primary_outline_color())
cpmi.draw_outline(primary_img, secondary_outline > 0,
cpprefs.get_secondary_outline_color())
my_frame.subplot_imshow(1,
1,
primary_img,
"Primary and output outlines",
normalize=False,
sharex=my_frame.subplot(0, 0),
sharey=my_frame.subplot(0, 0))
if global_threshold is not None:
my_frame.status_bar.SetFields([
"Threshold: %.3f" % global_threshold,
"Area covered by objects: %.1f %%" % object_pct
])
else:
my_frame.status_bar.SetFields(
["Area covered by objects: %.1f %%" % object_pct])
#
# Add the objects to the object set
#
objects_out = cpo.Objects()
objects_out.unedited_segmented = small_removed_segmented_out
objects_out.small_removed_segmented = small_removed_segmented_out
objects_out.segmented = segmented_out
objects_out.parent_image = image
objname = self.objects_name.value
workspace.object_set.add_objects(objects_out, objname)
if self.use_outlines.value:
out_img = cpi.Image(secondary_outline.astype(bool),
parent_image=image)
workspace.image_set.add(self.outlines_name.value, out_img)
object_count = np.max(segmented_out)
#
# Add the background measurements if made
#
measurements = workspace.measurements
if has_threshold:
if isinstance(local_threshold, np.ndarray):
ave_threshold = np.mean(local_threshold)
else:
ave_threshold = local_threshold
measurements.add_measurement(
cpmeas.IMAGE, cpmi.FF_FINAL_THRESHOLD % (objname),
np.array([ave_threshold], dtype=float))
measurements.add_measurement(
cpmeas.IMAGE, cpmi.FF_ORIG_THRESHOLD % (objname),
np.array([global_threshold], dtype=float))
wv = cpthresh.weighted_variance(img, mask, local_threshold)
measurements.add_measurement(cpmeas.IMAGE,
cpmi.FF_WEIGHTED_VARIANCE % (objname),
np.array([wv], dtype=float))
entropies = cpthresh.sum_of_entropies(img, mask, local_threshold)
measurements.add_measurement(cpmeas.IMAGE,
cpmi.FF_SUM_OF_ENTROPIES % (objname),
np.array([entropies], dtype=float))
cpmi.add_object_count_measurements(measurements, objname, object_count)
cpmi.add_object_location_measurements(measurements, objname,
segmented_out)
#
# Relate the secondary objects to the primary ones and record
# the relationship.
#
children_per_parent, parents_of_children = \
objects.relate_children(objects_out)
measurements.add_measurement(self.primary_objects.value,
cpmi.FF_CHILDREN_COUNT % objname,
children_per_parent)
measurements.add_measurement(
objname, cpmi.FF_PARENT % self.primary_objects.value,
parents_of_children)
#
# If primary objects were created, add them
#
if self.wants_discard_edge and self.wants_discard_primary:
workspace.object_set.add_objects(
new_objects, self.new_primary_objects_name.value)
cpmi.add_object_count_measurements(
measurements, self.new_primary_objects_name.value,
np.max(new_objects.segmented))
cpmi.add_object_location_measurements(
measurements, self.new_primary_objects_name.value,
new_objects.segmented)
for parent_objects, parent_name, child_objects, child_name in (
(objects, self.primary_objects.value, new_objects,
self.new_primary_objects_name.value),
(new_objects, self.new_primary_objects_name.value, objects_out,
objname)):
children_per_parent, parents_of_children = \
parent_objects.relate_children(child_objects)
measurements.add_measurement(
parent_name, cpmi.FF_CHILDREN_COUNT % child_name,
children_per_parent)
measurements.add_measurement(child_name,
cpmi.FF_PARENT % parent_name,
parents_of_children)