def filter_using_image(self, workspace, mask):
'''Filter out connections using local intensity minima between objects
workspace - the workspace for the image set
mask - mask of background points within the minimum distance
'''
#
# NOTE: This is an efficient implementation and an improvement
# in accuracy over the Matlab version. It would be faster and
# more accurate to eliminate the line-connecting and instead
# do the following:
# * Distance transform to get the coordinates of the closest
# point in an object for points in the background that are
# at most 1/2 of the max distance between objects.
# * Take the intensity at this closest point and similarly
# label the background point if the background intensity
# is at least the minimum intensity fraction
# * Assume there is a connection between objects if, after this
# labeling, there are adjacent points in each object.
#
# As it is, the algorithm duplicates the Matlab version but suffers
# for cells whose intensity isn't high in the centroid and clearly
# suffers when two cells touch at some point that's off of the line
# between the two.
#
objects = workspace.object_set.get_objects(self.objects_name.value)
labels = objects.segmented
image = self.get_image(workspace)
if self.show_window:
# Save the image for display
workspace.display_data.image = image
#
# Do a distance transform into the background to label points
# in the background with their closest foreground object
#
i, j = scind.distance_transform_edt(labels == 0,
return_indices=True,
return_distances=False)
confluent_labels = labels[i, j]
confluent_labels[~mask] = 0
if self.where_algorithm == CA_CLOSEST_POINT:
#
# For the closest point method, find the intensity at
# the closest point in the object (which will be the point itself
# for points in the object).
#
object_intensity = image[i,
j] * self.minimum_intensity_fraction.value
confluent_labels[object_intensity > image] = 0
count, index, c_j = morph.find_neighbors(confluent_labels)
if len(c_j) == 0:
# Nobody touches - return the labels matrix
return labels
#
# Make a row of i matching the touching j
#
c_i = np.zeros(len(c_j))
#
# Eliminate labels without matches
#
label_numbers = np.arange(1, len(count) + 1)[count > 0]
index = index[count > 0]
count = count[count > 0]
#
# Get the differences between labels so we can use a cumsum trick
# to increment to the next label when they change
#
label_numbers[1:] = label_numbers[1:] - label_numbers[:-1]
c_i[index] = label_numbers
c_i = np.cumsum(c_i).astype(int)
if self.where_algorithm == CA_CENTROIDS:
#
# Only connect points > minimum intensity fraction
#
center_i, center_j = morph.centers_of_labels(labels)
indexes, counts, i, j = morph.get_line_pts(center_i[c_i - 1],
center_j[c_i - 1],
center_i[c_j - 1],
center_j[c_j - 1])
#
# The indexes of the centroids at pt1
#
last_indexes = indexes + counts - 1
#
# The minimum of the intensities at pt0 and pt1
#
centroid_intensities = np.minimum(
image[i[indexes], j[indexes]], image[i[last_indexes],
j[last_indexes]])
#
# Assign label numbers to each point so we can use
# scipy.ndimage.minimum. The label numbers are indexes into
# "connections" above.
#
pt_labels = np.zeros(len(i), int)
pt_labels[indexes[1:]] = 1
pt_labels = np.cumsum(pt_labels)
minima = scind.minimum(image[i, j], pt_labels,
np.arange(len(indexes)))
minima = morph.fixup_scipy_ndimage_result(minima)
#
# Filter the connections using the image
#
mif = self.minimum_intensity_fraction.value
i = c_i[centroid_intensities * mif <= minima]
j = c_j[centroid_intensities * mif <= minima]
else:
i = c_i
j = c_j
#
# Add in connections from self to self
#
unique_labels = np.unique(labels)
i = np.hstack((i, unique_labels))
j = np.hstack((j, unique_labels))
#
# Run "all_connected_components" to get a component # for
# objects identified as same.
#
new_indexes = morph.all_connected_components(i, j)
new_labels = np.zeros(labels.shape, int)
new_labels[labels != 0] = new_indexes[labels[labels != 0]]
return new_labels
def filter_using_image(self, workspace, mask):
'''Filter out connections using local intensity minima between objects
workspace - the workspace for the image set
mask - mask of background points within the minimum distance
'''
#
# NOTE: This is an efficient implementation and an improvement
# in accuracy over the Matlab version. It would be faster and
# more accurate to eliminate the line-connecting and instead
# do the following:
# * Distance transform to get the coordinates of the closest
# point in an object for points in the background that are
# at most 1/2 of the max distance between objects.
# * Take the intensity at this closest point and similarly
# label the background point if the background intensity
# is at least the minimum intensity fraction
# * Assume there is a connection between objects if, after this
# labeling, there are adjacent points in each object.
#
# As it is, the algorithm duplicates the Matlab version but suffers
# for cells whose intensity isn't high in the centroid and clearly
# suffers when two cells touch at some point that's off of the line
# between the two.
#
objects = workspace.object_set.get_objects(self.objects_name.value)
labels = objects.segmented
image = self.get_image(workspace)
if self.show_window:
# Save the image for display
workspace.display_data.image = image
#
# Do a distance transform into the background to label points
# in the background with their closest foreground object
#
i, j = scind.distance_transform_edt(labels==0,
return_indices=True,
return_distances=False)
confluent_labels = labels[i,j]
confluent_labels[~mask] = 0
if self.where_algorithm == CA_CLOSEST_POINT:
#
# For the closest point method, find the intensity at
# the closest point in the object (which will be the point itself
# for points in the object).
#
object_intensity = image[i,j] * self.minimum_intensity_fraction.value
confluent_labels[object_intensity > image] = 0
count, index, c_j = morph.find_neighbors(confluent_labels)
if len(c_j) == 0:
# Nobody touches - return the labels matrix
return labels
#
# Make a row of i matching the touching j
#
c_i = np.zeros(len(c_j))
#
# Eliminate labels without matches
#
label_numbers = np.arange(1,len(count)+1)[count > 0]
index = index[count > 0]
count = count[count > 0]
#
# Get the differences between labels so we can use a cumsum trick
# to increment to the next label when they change
#
label_numbers[1:] = label_numbers[1:] - label_numbers[:-1]
c_i[index] = label_numbers
c_i = np.cumsum(c_i).astype(int)
if self.where_algorithm == CA_CENTROIDS:
#
# Only connect points > minimum intensity fraction
#
center_i, center_j = morph.centers_of_labels(labels)
indexes, counts, i, j = morph.get_line_pts(
center_i[c_i-1], center_j[c_i-1],
center_i[c_j-1], center_j[c_j-1])
#
# The indexes of the centroids at pt1
#
last_indexes = indexes+counts-1
#
# The minimum of the intensities at pt0 and pt1
#
centroid_intensities = np.minimum(
image[i[indexes],j[indexes]],
image[i[last_indexes], j[last_indexes]])
#
# Assign label numbers to each point so we can use
# scipy.ndimage.minimum. The label numbers are indexes into
# "connections" above.
#
pt_labels = np.zeros(len(i), int)
pt_labels[indexes[1:]] = 1
pt_labels = np.cumsum(pt_labels)
minima = scind.minimum(image[i,j], pt_labels, np.arange(len(indexes)))
minima = morph.fixup_scipy_ndimage_result(minima)
#
# Filter the connections using the image
#
mif = self.minimum_intensity_fraction.value
i = c_i[centroid_intensities * mif <= minima]
j = c_j[centroid_intensities * mif <= minima]
else:
i = c_i
j = c_j
#
# Add in connections from self to self
#
unique_labels = np.unique(labels)
i = np.hstack((i, unique_labels))
j = np.hstack((j, unique_labels))
#
# Run "all_connected_components" to get a component # for
# objects identified as same.
#
new_indexes = morph.all_connected_components(i, j)
new_labels = np.zeros(labels.shape, int)
new_labels[labels != 0] = new_indexes[labels[labels != 0]]
return new_labels