def get_skeleton_points(self, obj):
'''Get points by skeletonizing the objects and decimating'''
ii = []
jj = []
total_skel = np.zeros(obj.shape, bool)
for labels, indexes in obj.get_labels():
colors = morph.color_labels(labels)
for color in range(1, np.max(colors) + 1):
labels_mask = colors == color
skel = morph.skeletonize(
labels_mask,
ordering = distance_transform_edt(labels_mask) *
poisson_equation(labels_mask))
total_skel = total_skel | skel
n_pts = np.sum(total_skel)
if n_pts == 0:
return np.zeros(0, np.int32), np.zeros(0, np.int32)
i, j = np.where(total_skel)
if n_pts > self.max_points.value:
#
# Decimate the skeleton by finding the branchpoints in the
# skeleton and propagating from those.
#
markers = np.zeros(total_skel.shape, np.int32)
branchpoints = \
morph.branchpoints(total_skel) | morph.endpoints(total_skel)
markers[branchpoints] = np.arange(np.sum(branchpoints))+1
#
# We compute the propagation distance to that point, then impose
# a slightly arbitarary order to get an unambiguous ordering
# which should number the pixels in a skeleton branch monotonically
#
ts_labels, distances = propagate(np.zeros(markers.shape),
markers, total_skel, 1)
order = np.lexsort((j, i, distances[i, j], ts_labels[i, j]))
#
# Get a linear space of self.max_points elements with bounds at
# 0 and len(order)-1 and use that to select the points.
#
order = order[
np.linspace(0, len(order)-1, self.max_points.value).astype(int)]
return i[order], j[order]
return i, j
def do_measurements(self, workspace, image_name, object_name,
center_object_name, center_choice,
bin_count_settings, dd):
'''Perform the radial measurements on the image set
workspace - workspace that holds images / objects
image_name - make measurements on this image
object_name - make measurements on these objects
center_object_name - use the centers of these related objects as
the centers for radial measurements. None to use the
objects themselves.
center_choice - the user's center choice for this object:
C_SELF, C_CENTERS_OF_OBJECTS or C_EDGES_OF_OBJECTS.
bin_count_settings - the bin count settings group
d - a dictionary for saving reusable partial results
returns one statistics tuple per ring.
'''
assert isinstance(workspace, cpw.Workspace)
assert isinstance(workspace.object_set, cpo.ObjectSet)
bin_count = bin_count_settings.bin_count.value
wants_scaled = bin_count_settings.wants_scaled.value
maximum_radius = bin_count_settings.maximum_radius.value
image = workspace.image_set.get_image(image_name,
must_be_grayscale=True)
objects = workspace.object_set.get_objects(object_name)
labels, pixel_data = cpo.crop_labels_and_image(objects.segmented,
image.pixel_data)
nobjects = np.max(objects.segmented)
measurements = workspace.measurements
assert isinstance(measurements, cpmeas.Measurements)
if nobjects == 0:
for bin in range(1, bin_count+1):
for feature in (F_FRAC_AT_D, F_MEAN_FRAC, F_RADIAL_CV):
feature_name = (
(feature + FF_GENERIC) % (image_name, bin, bin_count))
measurements.add_measurement(
object_name, "_".join([M_CATEGORY, feature_name]),
np.zeros(0))
if not wants_scaled:
measurement_name = "_".join([M_CATEGORY, feature,
image_name, FF_OVERFLOW])
measurements.add_measurement(
object_name, measurement_name, np.zeros(0))
return [(image_name, object_name, "no objects","-","-","-","-")]
name = (object_name if center_object_name is None
else "%s_%s"%(object_name, center_object_name))
if dd.has_key(name):
normalized_distance, i_center, j_center, good_mask = dd[name]
else:
d_to_edge = distance_to_edge(labels)
if center_object_name is not None:
#
# Use the center of the centering objects to assign a center
# to each labeled pixel using propagation
#
center_objects=workspace.object_set.get_objects(center_object_name)
center_labels, cmask = cpo.size_similarly(
labels, center_objects.segmented)
pixel_counts = fix(scind.sum(
np.ones(center_labels.shape),
center_labels,
np.arange(1, np.max(center_labels)+1,dtype=np.int32)))
good = pixel_counts > 0
i,j = (centers_of_labels(center_labels) + .5).astype(int)
if center_choice == C_CENTERS_OF_OTHER:
#
# Reduce the propagation labels to the centers of
# the centering objects
#
ig = i[good]
jg = j[good]
lg = np.arange(1, len(i)+1)[good]
center_labels = np.zeros(center_labels.shape, int)
center_labels[ig,jg] = lg
cl,d_from_center = propagate(np.zeros(center_labels.shape),
center_labels,
labels != 0, 1)
#
# Erase the centers that fall outside of labels
#
cl[labels == 0] = 0
#
# If objects are hollow or crescent-shaped, there may be
# objects without center labels. As a backup, find the
# center that is the closest to the center of mass.
#
missing_mask = (labels != 0) & (cl == 0)
missing_labels = np.unique(labels[missing_mask])
if len(missing_labels):
all_centers = centers_of_labels(labels)
missing_i_centers, missing_j_centers = \
all_centers[:, missing_labels-1]
di = missing_i_centers[:, np.newaxis] - ig[np.newaxis, :]
dj = missing_j_centers[:, np.newaxis] - jg[np.newaxis, :]
missing_best = lg[np.lexsort((di*di + dj*dj, ))[:, 0]]
best = np.zeros(np.max(labels) + 1, int)
best[missing_labels] = missing_best
cl[missing_mask] = best[labels[missing_mask]]
#
# Now compute the crow-flies distance to the centers
# of these pixels from whatever center was assigned to
# the object.
#
iii, jjj = np.mgrid[0:labels.shape[0], 0:labels.shape[1]]
di = iii[missing_mask] - i[cl[missing_mask] - 1]
dj = jjj[missing_mask] - j[cl[missing_mask] - 1]
d_from_center[missing_mask] = np.sqrt(di*di + dj*dj)
else:
# Find the point in each object farthest away from the edge.
# This does better than the centroid:
# * The center is within the object
# * The center tends to be an interesting point, like the
# center of the nucleus or the center of one or the other
# of two touching cells.
#
i,j = maximum_position_of_labels(d_to_edge, labels, objects.indices)
center_labels = np.zeros(labels.shape, int)
center_labels[i,j] = labels[i,j]
#
# Use the coloring trick here to process touching objects
# in separate operations
#
colors = color_labels(labels)
ncolors = np.max(colors)
d_from_center = np.zeros(labels.shape)
cl = np.zeros(labels.shape, int)
for color in range(1,ncolors+1):
mask = colors == color
l,d = propagate(np.zeros(center_labels.shape),
center_labels,
mask, 1)
d_from_center[mask] = d[mask]
cl[mask] = l[mask]
good_mask = cl > 0
if center_choice == C_EDGES_OF_OTHER:
# Exclude pixels within the centering objects
# when performing calculations from the centers
good_mask = good_mask & (center_labels == 0)
i_center = np.zeros(cl.shape)
i_center[good_mask] = i[cl[good_mask]-1]
j_center = np.zeros(cl.shape)
j_center[good_mask] = j[cl[good_mask]-1]
normalized_distance = np.zeros(labels.shape)
if wants_scaled:
total_distance = d_from_center + d_to_edge
normalized_distance[good_mask] = (d_from_center[good_mask] /
(total_distance[good_mask] + .001))
else:
normalized_distance[good_mask] = \
d_from_center[good_mask] / maximum_radius
dd[name] = [normalized_distance, i_center, j_center, good_mask]
ngood_pixels = np.sum(good_mask)
good_labels = labels[good_mask]
bin_indexes = (normalized_distance * bin_count).astype(int)
bin_indexes[bin_indexes > bin_count] = bin_count
labels_and_bins = (good_labels-1,bin_indexes[good_mask])
histogram = coo_matrix((pixel_data[good_mask], labels_and_bins),
(nobjects, bin_count+1)).toarray()
sum_by_object = np.sum(histogram, 1)
sum_by_object_per_bin = np.dstack([sum_by_object]*(bin_count + 1))[0]
fraction_at_distance = histogram / sum_by_object_per_bin
number_at_distance = coo_matrix((np.ones(ngood_pixels),labels_and_bins),
(nobjects, bin_count+1)).toarray()
object_mask = number_at_distance > 0
sum_by_object = np.sum(number_at_distance, 1)
sum_by_object_per_bin = np.dstack([sum_by_object]*(bin_count+1))[0]
fraction_at_bin = number_at_distance / sum_by_object_per_bin
mean_pixel_fraction = fraction_at_distance / (fraction_at_bin +
np.finfo(float).eps)
masked_fraction_at_distance = masked_array(fraction_at_distance,
~object_mask)
masked_mean_pixel_fraction = masked_array(mean_pixel_fraction,
~object_mask)
# Anisotropy calculation. Split each cell into eight wedges, then
# compute coefficient of variation of the wedges' mean intensities
# in each ring.
#
# Compute each pixel's delta from the center object's centroid
i,j = np.mgrid[0:labels.shape[0], 0:labels.shape[1]]
imask = i[good_mask] > i_center[good_mask]
jmask = j[good_mask] > j_center[good_mask]
absmask = (abs(i[good_mask] - i_center[good_mask]) >
abs(j[good_mask] - j_center[good_mask]))
radial_index = (imask.astype(int) + jmask.astype(int)*2 +
absmask.astype(int)*4)
statistics = []
for bin in range(bin_count + (0 if wants_scaled else 1)):
bin_mask = (good_mask & (bin_indexes == bin))
bin_pixels = np.sum(bin_mask)
bin_labels = labels[bin_mask]
bin_radial_index = radial_index[bin_indexes[good_mask] == bin]
labels_and_radii = (bin_labels-1, bin_radial_index)
radial_values = coo_matrix((pixel_data[bin_mask],
labels_and_radii),
(nobjects, 8)).toarray()
pixel_count = coo_matrix((np.ones(bin_pixels), labels_and_radii),
(nobjects, 8)).toarray()
mask = pixel_count==0
radial_means = masked_array(radial_values / pixel_count, mask)
radial_cv = np.std(radial_means,1) / np.mean(radial_means, 1)
radial_cv[np.sum(~mask,1)==0] = 0
for measurement, feature, overflow_feature in (
(fraction_at_distance[:,bin], MF_FRAC_AT_D, OF_FRAC_AT_D),
(mean_pixel_fraction[:,bin], MF_MEAN_FRAC, OF_MEAN_FRAC),
(np.array(radial_cv), MF_RADIAL_CV, OF_RADIAL_CV)):
if bin == bin_count:
measurement_name = overflow_feature % image_name
else:
measurement_name = feature % (image_name, bin+1, bin_count)
measurements.add_measurement(object_name,
measurement_name,
measurement)
radial_cv.mask = np.sum(~mask,1)==0
bin_name = str(bin+1) if bin < bin_count else "Overflow"
statistics += [(image_name, object_name, bin_name, str(bin_count),
round(np.mean(masked_fraction_at_distance[:,bin]),4),
round(np.mean(masked_mean_pixel_fraction[:, bin]),4),
round(np.mean(radial_cv),4))]
return statistics
def run(self, workspace):
'''Run the module on the image set'''
seed_objects_name = self.seed_objects_name.value
skeleton_name = self.image_name.value
seed_objects = workspace.object_set.get_objects(seed_objects_name)
labels = seed_objects.segmented
labels_count = np.max(labels)
label_range = np.arange(labels_count,dtype=np.int32)+1
skeleton_image = workspace.image_set.get_image(
skeleton_name, must_be_binary = True)
skeleton = skeleton_image.pixel_data
if skeleton_image.has_mask:
skeleton = skeleton & skeleton_image.mask
try:
labels = skeleton_image.crop_image_similarly(labels)
except:
labels, m1 = cpo.size_similarly(skeleton, labels)
labels[~m1] = 0
#
# The following code makes a ring around the seed objects with
# the skeleton trunks sticking out of it.
#
# Create a new skeleton with holes at the seed objects
# First combine the seed objects with the skeleton so
# that the skeleton trunks come out of the seed objects.
#
# Erode the labels once so that all of the trunk branchpoints
# will be within the labels
#
#
# Dilate the objects, then subtract them to make a ring
#
my_disk = morph.strel_disk(1.5).astype(int)
dilated_labels = grey_dilation(labels, footprint=my_disk)
seed_mask = dilated_labels > 0
combined_skel = skeleton | seed_mask
closed_labels = grey_erosion(dilated_labels,
footprint = my_disk)
seed_center = closed_labels > 0
combined_skel = combined_skel & (~seed_center)
#
# Fill in single holes (but not a one-pixel hole made by
# a one-pixel image)
#
if self.wants_to_fill_holes:
def size_fn(area, is_object):
return (~ is_object) and (area <= self.maximum_hole_size.value)
combined_skel = morph.fill_labeled_holes(
combined_skel, ~seed_center, size_fn)
#
# Reskeletonize to make true branchpoints at the ring boundaries
#
combined_skel = morph.skeletonize(combined_skel)
#
# The skeleton outside of the labels
#
outside_skel = combined_skel & (dilated_labels == 0)
#
# Associate all skeleton points with seed objects
#
dlabels, distance_map = propagate.propagate(np.zeros(labels.shape),
dilated_labels,
combined_skel, 1)
#
# Get rid of any branchpoints not connected to seeds
#
combined_skel[dlabels == 0] = False
#
# Find the branchpoints
#
branch_points = morph.branchpoints(combined_skel)
#
# Odd case: when four branches meet like this, branchpoints are not
# assigned because they are arbitrary. So assign them.
#
# . .
# B.
# .B
# . .
#
odd_case = (combined_skel[:-1,:-1] & combined_skel[1:,:-1] &
combined_skel[:-1,1:] & combined_skel[1,1])
branch_points[:-1,:-1][odd_case] = True
branch_points[1:,1:][odd_case] = True
#
# Find the branching counts for the trunks (# of extra branches
# eminating from a point other than the line it might be on).
#
branching_counts = morph.branchings(combined_skel)
branching_counts = np.array([0,0,0,1,2])[branching_counts]
#
# Only take branches within 1 of the outside skeleton
#
dilated_skel = scind.binary_dilation(outside_skel, morph.eight_connect)
branching_counts[~dilated_skel] = 0
#
# Find the endpoints
#
end_points = morph.endpoints(combined_skel)
#
# We use two ranges for classification here:
# * anything within one pixel of the dilated image is a trunk
# * anything outside of that range is a branch
#
nearby_labels = dlabels.copy()
nearby_labels[distance_map > 1.5] = 0
outside_labels = dlabels.copy()
outside_labels[nearby_labels > 0] = 0
#
# The trunks are the branchpoints that lie within one pixel of
# the dilated image.
#
if labels_count > 0:
trunk_counts = fix(scind.sum(branching_counts, nearby_labels,
label_range)).astype(int)
else:
trunk_counts = np.zeros((0,),int)
#
# The branches are the branchpoints that lie outside the seed objects
#
if labels_count > 0:
branch_counts = fix(scind.sum(branch_points, outside_labels,
label_range))
else:
branch_counts = np.zeros((0,),int)
#
# Save the endpoints
#
if labels_count > 0:
end_counts = fix(scind.sum(end_points, outside_labels, label_range))
else:
end_counts = np.zeros((0,), int)
#
# Save measurements
#
m = workspace.measurements
assert isinstance(m, cpmeas.Measurements)
feature = "_".join((C_NEURON, F_NUMBER_TRUNKS, skeleton_name))
m.add_measurement(seed_objects_name, feature, trunk_counts)
feature = "_".join((C_NEURON, F_NUMBER_NON_TRUNK_BRANCHES,
skeleton_name))
m.add_measurement(seed_objects_name, feature, branch_counts)
feature = "_".join((C_NEURON, F_NUMBER_BRANCH_ENDS, skeleton_name))
m.add_measurement(seed_objects_name, feature, end_counts)
#
# Collect the graph information
#
if self.wants_neuron_graph:
trunk_mask = (branching_counts > 0) & (nearby_labels != 0)
intensity_image = workspace.image_set.get_image(
self.intensity_image_name.value)
edge_graph, vertex_graph = self.make_neuron_graph(
combined_skel, dlabels,
trunk_mask,
branch_points & ~trunk_mask,
end_points,
intensity_image.pixel_data)
image_number = workspace.measurements.image_set_number
edge_path, vertex_path = self.get_graph_file_paths(m, m.image_number)
workspace.interaction_request(
self, m.image_number, edge_path, edge_graph,
vertex_path, vertex_graph, headless_ok = True)
if self.show_window:
workspace.display_data.edge_graph = edge_graph
workspace.display_data.vertex_graph = vertex_graph
workspace.display_data.intensity_image = intensity_image.pixel_data
#
# Make the display image
#
if self.show_window or self.wants_branchpoint_image:
branchpoint_image = np.zeros((skeleton.shape[0],
skeleton.shape[1],
3))
trunk_mask = (branching_counts > 0) & (nearby_labels != 0)
branch_mask = branch_points & (outside_labels != 0)
end_mask = end_points & (outside_labels != 0)
branchpoint_image[outside_skel,:] = 1
branchpoint_image[trunk_mask | branch_mask | end_mask,:] = 0
branchpoint_image[trunk_mask,0] = 1
branchpoint_image[branch_mask,1] = 1
branchpoint_image[end_mask, 2] = 1
branchpoint_image[dilated_labels != 0,:] *= .875
branchpoint_image[dilated_labels != 0,:] += .1
if self.show_window:
workspace.display_data.branchpoint_image = branchpoint_image
if self.wants_branchpoint_image:
bi = cpi.Image(branchpoint_image,
parent_image = skeleton_image)
workspace.image_set.add(self.branchpoint_image_name.value, bi)
def run(self, workspace):
'''Run the module on the image set'''
seed_objects_name = self.seed_objects_name.value
skeleton_name = self.image_name.value
seed_objects = workspace.object_set.get_objects(seed_objects_name)
labels = seed_objects.segmented
labels_count = np.max(labels)
label_range = np.arange(labels_count, dtype=np.int32) + 1
skeleton_image = workspace.image_set.get_image(skeleton_name,
must_be_binary=True)
skeleton = skeleton_image.pixel_data
if skeleton_image.has_mask:
skeleton = skeleton & skeleton_image.mask
try:
labels = skeleton_image.crop_image_similarly(labels)
except:
labels, m1 = cpo.size_similarly(skeleton, labels)
labels[~m1] = 0
#
# The following code makes a ring around the seed objects with
# the skeleton trunks sticking out of it.
#
# Create a new skeleton with holes at the seed objects
# First combine the seed objects with the skeleton so
# that the skeleton trunks come out of the seed objects.
#
# Erode the labels once so that all of the trunk branchpoints
# will be within the labels
#
#
# Dilate the objects, then subtract them to make a ring
#
my_disk = morph.strel_disk(1.5).astype(int)
dilated_labels = grey_dilation(labels, footprint=my_disk)
seed_mask = dilated_labels > 0
combined_skel = skeleton | seed_mask
closed_labels = grey_erosion(dilated_labels, footprint=my_disk)
seed_center = closed_labels > 0
combined_skel = combined_skel & (~seed_center)
#
# Fill in single holes (but not a one-pixel hole made by
# a one-pixel image)
#
if self.wants_to_fill_holes:
def size_fn(area, is_object):
return (~is_object) and (area <= self.maximum_hole_size.value)
combined_skel = morph.fill_labeled_holes(combined_skel,
~seed_center, size_fn)
#
# Reskeletonize to make true branchpoints at the ring boundaries
#
combined_skel = morph.skeletonize(combined_skel)
#
# The skeleton outside of the labels
#
outside_skel = combined_skel & (dilated_labels == 0)
#
# Associate all skeleton points with seed objects
#
dlabels, distance_map = propagate.propagate(np.zeros(labels.shape),
dilated_labels,
combined_skel, 1)
#
# Get rid of any branchpoints not connected to seeds
#
combined_skel[dlabels == 0] = False
#
# Find the branchpoints
#
branch_points = morph.branchpoints(combined_skel)
#
# Odd case: when four branches meet like this, branchpoints are not
# assigned because they are arbitrary. So assign them.
#
# . .
# B.
# .B
# . .
#
odd_case = (combined_skel[:-1, :-1] & combined_skel[1:, :-1]
& combined_skel[:-1, 1:] & combined_skel[1, 1])
branch_points[:-1, :-1][odd_case] = True
branch_points[1:, 1:][odd_case] = True
#
# Find the branching counts for the trunks (# of extra branches
# eminating from a point other than the line it might be on).
#
branching_counts = morph.branchings(combined_skel)
branching_counts = np.array([0, 0, 0, 1, 2])[branching_counts]
#
# Only take branches within 1 of the outside skeleton
#
dilated_skel = scind.binary_dilation(outside_skel, morph.eight_connect)
branching_counts[~dilated_skel] = 0
#
# Find the endpoints
#
end_points = morph.endpoints(combined_skel)
#
# We use two ranges for classification here:
# * anything within one pixel of the dilated image is a trunk
# * anything outside of that range is a branch
#
nearby_labels = dlabels.copy()
nearby_labels[distance_map > 1.5] = 0
outside_labels = dlabels.copy()
outside_labels[nearby_labels > 0] = 0
#
# The trunks are the branchpoints that lie within one pixel of
# the dilated image.
#
if labels_count > 0:
trunk_counts = fix(
scind.sum(branching_counts, nearby_labels,
label_range)).astype(int)
else:
trunk_counts = np.zeros((0, ), int)
#
# The branches are the branchpoints that lie outside the seed objects
#
if labels_count > 0:
branch_counts = fix(
scind.sum(branch_points, outside_labels, label_range))
else:
branch_counts = np.zeros((0, ), int)
#
# Save the endpoints
#
if labels_count > 0:
end_counts = fix(scind.sum(end_points, outside_labels,
label_range))
else:
end_counts = np.zeros((0, ), int)
#
# Save measurements
#
m = workspace.measurements
assert isinstance(m, cpmeas.Measurements)
feature = "_".join((C_NEURON, F_NUMBER_TRUNKS, skeleton_name))
m.add_measurement(seed_objects_name, feature, trunk_counts)
feature = "_".join(
(C_NEURON, F_NUMBER_NON_TRUNK_BRANCHES, skeleton_name))
m.add_measurement(seed_objects_name, feature, branch_counts)
feature = "_".join((C_NEURON, F_NUMBER_BRANCH_ENDS, skeleton_name))
m.add_measurement(seed_objects_name, feature, end_counts)
#
# Collect the graph information
#
if self.wants_neuron_graph:
trunk_mask = (branching_counts > 0) & (nearby_labels != 0)
intensity_image = workspace.image_set.get_image(
self.intensity_image_name.value)
edge_graph, vertex_graph = self.make_neuron_graph(
combined_skel, dlabels, trunk_mask,
branch_points & ~trunk_mask, end_points,
intensity_image.pixel_data)
image_number = workspace.measurements.image_set_number
edge_path, vertex_path = self.get_graph_file_paths(
m, m.image_number)
workspace.interaction_request(self,
m.image_number,
edge_path,
edge_graph,
vertex_path,
vertex_graph,
headless_ok=True)
if self.show_window:
workspace.display_data.edge_graph = edge_graph
workspace.display_data.vertex_graph = vertex_graph
workspace.display_data.intensity_image = intensity_image.pixel_data
#
# Make the display image
#
if self.show_window or self.wants_branchpoint_image:
branchpoint_image = np.zeros(
(skeleton.shape[0], skeleton.shape[1], 3))
trunk_mask = (branching_counts > 0) & (nearby_labels != 0)
branch_mask = branch_points & (outside_labels != 0)
end_mask = end_points & (outside_labels != 0)
branchpoint_image[outside_skel, :] = 1
branchpoint_image[trunk_mask | branch_mask | end_mask, :] = 0
branchpoint_image[trunk_mask, 0] = 1
branchpoint_image[branch_mask, 1] = 1
branchpoint_image[end_mask, 2] = 1
branchpoint_image[dilated_labels != 0, :] *= .875
branchpoint_image[dilated_labels != 0, :] += .1
if self.show_window:
workspace.display_data.branchpoint_image = branchpoint_image
if self.wants_branchpoint_image:
bi = cpi.Image(branchpoint_image, parent_image=skeleton_image)
workspace.image_set.add(self.branchpoint_image_name.value, bi)
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_name = self.image_name.value
image = workspace.image_set.get_image(image_name,
must_be_grayscale=True)
workspace.display_data.statistics = []
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
else:
thresholded_image = self.threshold_image(image_name, workspace)
has_threshold = True
#
# 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)
#
# 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 measurements
#
measurements = workspace.measurements
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)
image_numbers = np.ones(len(parents_of_children), int) *\
measurements.image_set_number
mask = parents_of_children > 0
measurements.add_relate_measurement(
self.module_num, R_PARENT, self.primary_objects.value,
self.objects_name.value, image_numbers[mask],
parents_of_children[mask], image_numbers[mask],
np.arange(1,
len(parents_of_children) + 1)[mask])
#
# 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)
if self.show_window:
object_area = np.sum(segmented_out > 0)
workspace.display_data.object_pct = \
100 * object_area / np.product(segmented_out.shape)
workspace.display_data.img = img
workspace.display_data.segmented_out = segmented_out
workspace.display_data.primary_labels = objects.segmented
workspace.display_data.global_threshold = global_threshold
workspace.display_data.object_count = object_count
def run(self, workspace):
'''Run the module on the image set'''
seed_objects_name = self.seed_objects_name.value
skeleton_name = self.image_name.value
seed_objects = workspace.object_set.get_objects(seed_objects_name)
labels = seed_objects.segmented
labels_count = np.max(labels)
label_range = np.arange(labels_count,dtype=np.int32)+1
skeleton_image = workspace.image_set.get_image(
skeleton_name, must_be_binary = True)
skeleton = skeleton_image.pixel_data
if skeleton_image.has_mask:
skeleton = skeleton & skeleton_image.mask
try:
labels = skeleton_image.crop_image_similarly(labels)
except:
labels, m1 = cpo.size_similarly(skeleton, labels)
labels[~m1] = 0
#
# The following code makes a ring around the seed objects with
# the skeleton trunks sticking out of it.
#
# Create a new skeleton with holes at the seed objects
# First combine the seed objects with the skeleton so
# that the skeleton trunks come out of the seed objects.
#
# Erode the labels once so that all of the trunk branchpoints
# will be within the labels
#
#
# Dilate the objects, then subtract them to make a ring
#
my_disk = morph.strel_disk(1.5).astype(int)
dilated_labels = grey_dilation(labels, footprint=my_disk)
seed_mask = dilated_labels > 0
combined_skel = skeleton | seed_mask
closed_labels = grey_erosion(dilated_labels,
footprint = my_disk)
seed_center = closed_labels > 0
combined_skel = combined_skel & (~seed_center)
#
# Fill in single holes (but not a one-pixel hole made by
# a one-pixel image)
#
if self.wants_to_fill_holes:
def size_fn(area, is_object):
return (~ is_object) and (area <= self.maximum_hole_size.value)
combined_skel = morph.fill_labeled_holes(
combined_skel, ~seed_center, size_fn)
#
# Reskeletonize to make true branchpoints at the ring boundaries
#
combined_skel = morph.skeletonize(combined_skel)
#
# The skeleton outside of the labels
#
outside_skel = combined_skel & (dilated_labels == 0)
#
# Associate all skeleton points with seed objects
#
dlabels, distance_map = propagate.propagate(np.zeros(labels.shape),
dilated_labels,
combined_skel, 1)
#
# Get rid of any branchpoints not connected to seeds
#
combined_skel[dlabels == 0] = False
#
# Find the branchpoints
#
branch_points = morph.branchpoints(combined_skel)
#
# Odd case: when four branches meet like this, branchpoints are not
# assigned because they are arbitrary. So assign them.
#
# . .
# B.
# .B
# . .
#
odd_case = (combined_skel[:-1,:-1] & combined_skel[1:,:-1] &
combined_skel[:-1,1:] & combined_skel[1,1])
branch_points[:-1,:-1][odd_case] = True
branch_points[1:,1:][odd_case] = True
#
# Find the branching counts for the trunks (# of extra branches
# eminating from a point other than the line it might be on).
#
branching_counts = morph.branchings(combined_skel)
branching_counts = np.array([0,0,0,1,2])[branching_counts]
#
# Only take branches within 1 of the outside skeleton
#
dilated_skel = scind.binary_dilation(outside_skel, morph.eight_connect)
branching_counts[~dilated_skel] = 0
#
# Find the endpoints
#
end_points = morph.endpoints(combined_skel)
#
# We use two ranges for classification here:
# * anything within one pixel of the dilated image is a trunk
# * anything outside of that range is a branch
#
nearby_labels = dlabels.copy()
nearby_labels[distance_map > 1.5] = 0
outside_labels = dlabels.copy()
outside_labels[nearby_labels > 0] = 0
#
# The trunks are the branchpoints that lie within one pixel of
# the dilated image.
#
if labels_count > 0:
trunk_counts = fix(scind.sum(branching_counts, nearby_labels,
label_range)).astype(int)
else:
trunk_counts = np.zeros((0,),int)
#
# The branches are the branchpoints that lie outside the seed objects
#
if labels_count > 0:
branch_counts = fix(scind.sum(branch_points, outside_labels,
label_range))
else:
branch_counts = np.zeros((0,),int)
#
# Save the endpoints
#
if labels_count > 0:
end_counts = fix(scind.sum(end_points, outside_labels, label_range))
else:
end_counts = np.zeros((0,), int)
#
# Save measurements
#
m = workspace.measurements
assert isinstance(m, cpmeas.Measurements)
feature = "_".join((C_NEURON, F_NUMBER_TRUNKS, skeleton_name))
m.add_measurement(seed_objects_name, feature, trunk_counts)
feature = "_".join((C_NEURON, F_NUMBER_NON_TRUNK_BRANCHES,
skeleton_name))
m.add_measurement(seed_objects_name, feature, branch_counts)
feature = "_".join((C_NEURON, F_NUMBER_BRANCH_ENDS, skeleton_name))
m.add_measurement(seed_objects_name, feature, end_counts)
#
# Collect the graph information
#
if self.wants_neuron_graph:
trunk_mask = (branching_counts > 0) & (nearby_labels != 0)
intensity_image = workspace.image_set.get_image(
self.intensity_image_name.value)
edge_graph, vertex_graph = self.make_neuron_graph(
combined_skel, dlabels,
trunk_mask,
branch_points & ~trunk_mask,
end_points,
intensity_image.pixel_data)
#
# Add an image number column to both and change vertex index
# to vertex number (one-based)
#
image_number = workspace.measurements.image_set_number
vertex_graph = np.rec.fromarrays(
(np.ones(len(vertex_graph)) * image_number,
np.arange(1, len(vertex_graph) + 1),
vertex_graph['i'],
vertex_graph['j'],
vertex_graph['labels'],
vertex_graph['kind']),
names = ("image_number", "vertex_number", "i", "j",
"labels", "kind"))
edge_graph = np.rec.fromarrays(
(np.ones(len(edge_graph)) * image_number,
edge_graph["v1"],
edge_graph["v2"],
edge_graph["length"],
edge_graph["total_intensity"]),
names = ("image_number", "v1", "v2", "length",
"total_intensity"))
path = self.directory.get_absolute_path(m)
edge_file = m.apply_metadata(self.edge_file_name.value)
edge_path = os.path.abspath(os.path.join(path, edge_file))
vertex_file = m.apply_metadata(self.vertex_file_name.value)
vertex_path = os.path.abspath(os.path.join(path, vertex_file))
d = self.get_dictionary(workspace.image_set_list)
for file_path, table, fmt in (
(edge_path, edge_graph, "%d,%d,%d,%d,%.4f"),
(vertex_path, vertex_graph, "%d,%d,%d,%d,%d,%s")):
#
# Delete files first time through / otherwise append
#
if not d.has_key(file_path):
d[file_path] = True
if os.path.exists(file_path):
if workspace.frame is not None:
import wx
if wx.MessageBox(
"%s already exists. Do you want to overwrite it?" %
file_path, "Warning: overwriting file",
style = wx.YES_NO,
parent = workspace.frame) != wx.YES:
raise ValueError("Can't overwrite %s" % file_path)
os.remove(file_path)
fd = open(file_path, 'wt')
header = ','.join(table.dtype.names)
fd.write(header + '\n')
else:
fd = open(file_path, 'at')
np.savetxt(fd, table, fmt)
fd.close()
if workspace.frame is not None:
workspace.display_data.edge_graph = edge_graph
workspace.display_data.vertex_graph = vertex_graph
#
# Make the display image
#
if workspace.frame is not None or self.wants_branchpoint_image:
branchpoint_image = np.zeros((skeleton.shape[0],
skeleton.shape[1],
3))
trunk_mask = (branching_counts > 0) & (nearby_labels != 0)
branch_mask = branch_points & (outside_labels != 0)
end_mask = end_points & (outside_labels != 0)
branchpoint_image[outside_skel,:] = 1
branchpoint_image[trunk_mask | branch_mask | end_mask,:] = 0
branchpoint_image[trunk_mask,0] = 1
branchpoint_image[branch_mask,1] = 1
branchpoint_image[end_mask, 2] = 1
branchpoint_image[dilated_labels != 0,:] *= .875
branchpoint_image[dilated_labels != 0,:] += .1
if workspace.frame:
workspace.display_data.branchpoint_image = branchpoint_image
if self.wants_branchpoint_image:
bi = cpi.Image(branchpoint_image,
parent_image = skeleton_image)
workspace.image_set.add(self.branchpoint_image_name.value, bi)
def run(self, workspace):
'''Run the module on the image set'''
seed_objects_name = self.seed_objects_name.value
skeleton_name = self.image_name.value
seed_objects = workspace.object_set.get_objects(seed_objects_name)
labels = seed_objects.segmented
labels_count = np.max(labels)
label_range = np.arange(labels_count, dtype=np.int32) + 1
skeleton_image = workspace.image_set.get_image(skeleton_name,
must_be_binary=True)
skeleton = skeleton_image.pixel_data
if skeleton_image.has_mask:
skeleton = skeleton & skeleton_image.mask
try:
labels = skeleton_image.crop_image_similarly(labels)
except:
labels, m1 = cpo.size_similarly(skeleton, labels)
labels[~m1] = 0
#
# The following code makes a ring around the seed objects with
# the skeleton trunks sticking out of it.
#
# Create a new skeleton with holes at the seed objects
# First combine the seed objects with the skeleton so
# that the skeleton trunks come out of the seed objects.
#
# Erode the labels once so that all of the trunk branchpoints
# will be within the labels
#
#
# Dilate the objects, then subtract them to make a ring
#
my_disk = morph.strel_disk(1.5).astype(int)
dilated_labels = grey_dilation(labels, footprint=my_disk)
seed_mask = dilated_labels > 0
combined_skel = skeleton | seed_mask
closed_labels = grey_erosion(dilated_labels, footprint=my_disk)
seed_center = closed_labels > 0
combined_skel = combined_skel & (~seed_center)
#
# Fill in single holes (but not a one-pixel hole made by
# a one-pixel image)
#
if self.wants_to_fill_holes:
def size_fn(area, is_object):
return (~is_object) and (area <= self.maximum_hole_size.value)
combined_skel = morph.fill_labeled_holes(combined_skel,
~seed_center, size_fn)
#
# Reskeletonize to make true branchpoints at the ring boundaries
#
combined_skel = morph.skeletonize(combined_skel)
#
# The skeleton outside of the labels
#
outside_skel = combined_skel & (dilated_labels == 0)
#
# Associate all skeleton points with seed objects
#
dlabels, distance_map = propagate.propagate(np.zeros(labels.shape),
dilated_labels,
combined_skel, 1)
#
# Get rid of any branchpoints not connected to seeds
#
combined_skel[dlabels == 0] = False
#
# Find the branchpoints
#
branch_points = morph.branchpoints(combined_skel)
#
# Odd case: when four branches meet like this, branchpoints are not
# assigned because they are arbitrary. So assign them.
#
# . .
# B.
# .B
# . .
#
odd_case = (combined_skel[:-1, :-1] & combined_skel[1:, :-1]
& combined_skel[:-1, 1:] & combined_skel[1, 1])
branch_points[:-1, :-1][odd_case] = True
branch_points[1:, 1:][odd_case] = True
#
# Find the branching counts for the trunks (# of extra branches
# eminating from a point other than the line it might be on).
#
branching_counts = morph.branchings(combined_skel)
branching_counts = np.array([0, 0, 0, 1, 2])[branching_counts]
#
# Only take branches within 1 of the outside skeleton
#
dilated_skel = scind.binary_dilation(outside_skel, morph.eight_connect)
branching_counts[~dilated_skel] = 0
#
# Find the endpoints
#
end_points = morph.endpoints(combined_skel)
#
# We use two ranges for classification here:
# * anything within one pixel of the dilated image is a trunk
# * anything outside of that range is a branch
#
nearby_labels = dlabels.copy()
nearby_labels[distance_map > 1.5] = 0
outside_labels = dlabels.copy()
outside_labels[nearby_labels > 0] = 0
#
# The trunks are the branchpoints that lie within one pixel of
# the dilated image.
#
if labels_count > 0:
trunk_counts = fix(
scind.sum(branching_counts, nearby_labels,
label_range)).astype(int)
else:
trunk_counts = np.zeros((0, ), int)
#
# The branches are the branchpoints that lie outside the seed objects
#
if labels_count > 0:
branch_counts = fix(
scind.sum(branch_points, outside_labels, label_range))
else:
branch_counts = np.zeros((0, ), int)
#
# Save the endpoints
#
if labels_count > 0:
end_counts = fix(scind.sum(end_points, outside_labels,
label_range))
else:
end_counts = np.zeros((0, ), int)
#
# Save measurements
#
m = workspace.measurements
assert isinstance(m, cpmeas.Measurements)
feature = "_".join((C_NEURON, F_NUMBER_TRUNKS, skeleton_name))
m.add_measurement(seed_objects_name, feature, trunk_counts)
feature = "_".join(
(C_NEURON, F_NUMBER_NON_TRUNK_BRANCHES, skeleton_name))
m.add_measurement(seed_objects_name, feature, branch_counts)
feature = "_".join((C_NEURON, F_NUMBER_BRANCH_ENDS, skeleton_name))
m.add_measurement(seed_objects_name, feature, end_counts)
#
# Collect the graph information
#
if self.wants_neuron_graph:
trunk_mask = (branching_counts > 0) & (nearby_labels != 0)
intensity_image = workspace.image_set.get_image(
self.intensity_image_name.value)
edge_graph, vertex_graph = self.make_neuron_graph(
combined_skel, dlabels, trunk_mask,
branch_points & ~trunk_mask, end_points,
intensity_image.pixel_data)
#
# Add an image number column to both and change vertex index
# to vertex number (one-based)
#
image_number = workspace.measurements.image_set_number
vertex_graph = np.rec.fromarrays(
(np.ones(len(vertex_graph)) * image_number,
np.arange(1,
len(vertex_graph) + 1), vertex_graph['i'],
vertex_graph['j'], vertex_graph['labels'],
vertex_graph['kind']),
names=("image_number", "vertex_number", "i", "j", "labels",
"kind"))
edge_graph = np.rec.fromarrays(
(np.ones(len(edge_graph)) * image_number, edge_graph["v1"],
edge_graph["v2"], edge_graph["length"],
edge_graph["total_intensity"]),
names=("image_number", "v1", "v2", "length",
"total_intensity"))
path = self.directory.get_absolute_path(m)
edge_file = m.apply_metadata(self.edge_file_name.value)
edge_path = os.path.abspath(os.path.join(path, edge_file))
vertex_file = m.apply_metadata(self.vertex_file_name.value)
vertex_path = os.path.abspath(os.path.join(path, vertex_file))
d = self.get_dictionary(workspace.image_set_list)
for file_path, table, fmt in ((edge_path, edge_graph,
"%d,%d,%d,%d,%.4f"),
(vertex_path, vertex_graph,
"%d,%d,%d,%d,%d,%s")):
#
# Delete files first time through / otherwise append
#
if not d.has_key(file_path):
d[file_path] = True
if os.path.exists(file_path):
if workspace.frame is not None:
import wx
if wx.MessageBox(
"%s already exists. Do you want to overwrite it?"
% file_path,
"Warning: overwriting file",
style=wx.YES_NO,
parent=workspace.frame) != wx.YES:
raise ValueError("Can't overwrite %s" %
file_path)
os.remove(file_path)
fd = open(file_path, 'wt')
header = ','.join(table.dtype.names)
fd.write(header + '\n')
else:
fd = open(file_path, 'at')
np.savetxt(fd, table, fmt)
fd.close()
if workspace.frame is not None:
workspace.display_data.edge_graph = edge_graph
workspace.display_data.vertex_graph = vertex_graph
#
# Make the display image
#
if workspace.frame is not None or self.wants_branchpoint_image:
branchpoint_image = np.zeros(
(skeleton.shape[0], skeleton.shape[1], 3))
trunk_mask = (branching_counts > 0) & (nearby_labels != 0)
branch_mask = branch_points & (outside_labels != 0)
end_mask = end_points & (outside_labels != 0)
branchpoint_image[outside_skel, :] = 1
branchpoint_image[trunk_mask | branch_mask | end_mask, :] = 0
branchpoint_image[trunk_mask, 0] = 1
branchpoint_image[branch_mask, 1] = 1
branchpoint_image[end_mask, 2] = 1
branchpoint_image[dilated_labels != 0, :] *= .875
branchpoint_image[dilated_labels != 0, :] += .1
if workspace.frame:
workspace.display_data.branchpoint_image = branchpoint_image
if self.wants_branchpoint_image:
bi = cpi.Image(branchpoint_image, parent_image=skeleton_image)
workspace.image_set.add(self.branchpoint_image_name.value, bi)
def run(self, workspace):
assert isinstance(workspace, cpw.Workspace)
image_name = self.image_name.value
image = workspace.image_set.get_image(image_name,
must_be_grayscale = True)
workspace.display_data.statistics = []
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
else:
thresholded_image = self.threshold_image(image_name, workspace)
has_threshold = True
#
# 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)
#
# 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 measurements
#
measurements = workspace.measurements
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)
image_numbers = np.ones(len(parents_of_children), int) *\
measurements.image_set_number
mask = parents_of_children > 0
measurements.add_relate_measurement(
self.module_num, R_PARENT,
self.primary_objects.value, self.objects_name.value,
image_numbers[mask], parents_of_children[mask],
image_numbers[mask],
np.arange(1, len(parents_of_children) + 1)[mask])
#
# 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)
if self.show_window:
object_area = np.sum(segmented_out > 0)
workspace.display_data.object_pct = \
100 * object_area / np.product(segmented_out.shape)
workspace.display_data.img = img
workspace.display_data.segmented_out = segmented_out
workspace.display_data.primary_outline = primary_outline
workspace.display_data.secondary_outline = secondary_outline
workspace.display_data.global_threshold = global_threshold
workspace.display_data.object_count = object_count
def do_measurements(self, workspace, image_name, object_name,
center_object_name, bin_count,
dd):
'''Perform the radial measurements on the image set
workspace - workspace that holds images / objects
image_name - make measurements on this image
object_name - make measurements on these objects
center_object_name - use the centers of these related objects as
the centers for radial measurements. None to use the
objects themselves.
bin_count - bin the object into this many concentric rings
d - a dictionary for saving reusable partial results
returns one statistics tuple per ring.
'''
assert isinstance(workspace, cpw.Workspace)
assert isinstance(workspace.object_set, cpo.ObjectSet)
image = workspace.image_set.get_image(image_name,
must_be_grayscale=True)
objects = workspace.object_set.get_objects(object_name)
labels, pixel_data = cpo.crop_labels_and_image(objects.segmented,
image.pixel_data)
nobjects = np.max(objects.segmented)
measurements = workspace.measurements
assert isinstance(measurements, cpmeas.Measurements)
if nobjects == 0:
for bin in range(1, bin_count+1):
for feature in (FF_FRAC_AT_D, FF_MEAN_FRAC, FF_RADIAL_CV):
measurements.add_measurement(object_name,
M_CATEGORY + "_" + feature %
(image_name, bin, bin_count),
np.zeros(0))
return [(image_name, object_name, "no objects","-","-","-","-")]
name = (object_name if center_object_name is None
else "%s_%s"%(object_name, center_object_name))
if dd.has_key(name):
normalized_distance, i_center, j_center, good_mask = dd[name]
else:
d_to_edge = distance_to_edge(labels)
if center_object_name is not None:
center_objects=workspace.object_set.get_objects(center_object_name)
center_labels, cmask = cpo.size_similarly(
labels, center_objects.segmented)
pixel_counts = fix(scind.sum(np.ones(center_labels.shape),
center_labels,
np.arange(1, np.max(center_labels)+1,dtype=np.int32)))
good = pixel_counts > 0
i,j = (centers_of_labels(center_labels) + .5).astype(int)
ig = i[good]
jg = j[good]
center_labels = np.zeros(center_labels.shape, int)
center_labels[ig,jg] = labels[ig,jg] ## TODO: This is incorrect when objects are annular. Retrieves label# = 0
cl,d_from_center = propagate(np.zeros(center_labels.shape),
center_labels,
labels != 0, 1)
else:
# Find the point in each object farthest away from the edge.
# This does better than the centroid:
# * The center is within the object
# * The center tends to be an interesting point, like the
# center of the nucleus or the center of one or the other
# of two touching cells.
#
i,j = maximum_position_of_labels(d_to_edge, labels, objects.indices)
center_labels = np.zeros(labels.shape, int)
center_labels[i,j] = labels[i,j]
#
# Use the coloring trick here to process touching objects
# in separate operations
#
colors = color_labels(labels)
ncolors = np.max(colors)
d_from_center = np.zeros(labels.shape)
cl = np.zeros(labels.shape, int)
for color in range(1,ncolors+1):
mask = colors == color
l,d = propagate(np.zeros(center_labels.shape),
center_labels,
mask, 1)
d_from_center[mask] = d[mask]
cl[mask] = l[mask]
good_mask = cl > 0
i_center = np.zeros(cl.shape)
i_center[good_mask] = i[cl[good_mask]-1]
j_center = np.zeros(cl.shape)
j_center[good_mask] = j[cl[good_mask]-1]
normalized_distance = np.zeros(labels.shape)
total_distance = d_from_center + d_to_edge
normalized_distance[good_mask] = (d_from_center[good_mask] /
(total_distance[good_mask] + .001))
dd[name] = [normalized_distance, i_center, j_center, good_mask]
ngood_pixels = np.sum(good_mask)
good_labels = objects.segmented[good_mask]
bin_indexes = (normalized_distance * bin_count).astype(int)
labels_and_bins = (good_labels-1,bin_indexes[good_mask])
histogram = coo_matrix((image.pixel_data[good_mask], labels_and_bins),
(nobjects, bin_count)).toarray()
sum_by_object = np.sum(histogram, 1)
sum_by_object_per_bin = np.dstack([sum_by_object]*bin_count)[0]
fraction_at_distance = histogram / sum_by_object_per_bin
number_at_distance = coo_matrix((np.ones(ngood_pixels),labels_and_bins),
(nobjects, bin_count)).toarray()
object_mask = number_at_distance > 0
sum_by_object = np.sum(number_at_distance, 1)
sum_by_object_per_bin = np.dstack([sum_by_object]*bin_count)[0]
fraction_at_bin = number_at_distance / sum_by_object_per_bin
mean_pixel_fraction = fraction_at_distance / (fraction_at_bin +
np.finfo(float).eps)
masked_fraction_at_distance = masked_array(fraction_at_distance,
~object_mask)
masked_mean_pixel_fraction = masked_array(mean_pixel_fraction,
~object_mask)
# Anisotropy calculation. Split each cell into eight wedges, then
# compute coefficient of variation of the wedges' mean intensities
# in each ring.
#
# Compute each pixel's delta from the center object's centroid
i,j = np.mgrid[0:labels.shape[0], 0:labels.shape[1]]
imask = i[good_mask] > i_center[good_mask]
jmask = j[good_mask] > j_center[good_mask]
absmask = (abs(i[good_mask] - i_center[good_mask]) >
abs(j[good_mask] - j_center[good_mask]))
radial_index = (imask.astype(int) + jmask.astype(int)*2 +
absmask.astype(int)*4)
statistics = []
for bin in range(bin_count):
bin_mask = (good_mask & (bin_indexes == bin))
bin_pixels = np.sum(bin_mask)
bin_labels = labels[bin_mask]
bin_radial_index = radial_index[bin_indexes[good_mask] == bin]
labels_and_radii = (bin_labels-1, bin_radial_index)
radial_values = coo_matrix((pixel_data[bin_mask],
labels_and_radii),
(nobjects, 8)).toarray()
pixel_count = coo_matrix((np.ones(bin_pixels), labels_and_radii),
(nobjects, 8)).toarray()
mask = pixel_count==0
radial_means = masked_array(radial_values / pixel_count, mask)
radial_cv = np.std(radial_means,1) / np.mean(radial_means, 1)
radial_cv[np.sum(~mask,1)==0] = 0
for measurement, feature in ((fraction_at_distance[:,bin], MF_FRAC_AT_D),
(mean_pixel_fraction[:,bin], MF_MEAN_FRAC),
(np.array(radial_cv), MF_RADIAL_CV)):
measurements.add_measurement(object_name,
feature %
(image_name, bin+1, bin_count),
measurement)
radial_cv.mask = np.sum(~mask,1)==0
statistics += [(image_name, object_name, str(bin+1), str(bin_count),
round(np.mean(masked_fraction_at_distance[:,bin]),4),
round(np.mean(masked_mean_pixel_fraction[:, bin]),4),
round(np.mean(radial_cv),4))]
return statistics
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)
