def get_colors(self, count):
"""Get colors used for two-measurement labels image"""
import matplotlib.cm as cm
cmap = cm.get_cmap(cpprefs.get_default_colormap())
#
# Trick the colormap into divulging the values used.
#
sm = cm.ScalarMappable(cmap=cmap)
colors = sm.to_rgba(np.arange(count) + 1)
return np.vstack((np.zeros(colors.shape[1]), colors))
def display_on_figure(self, workspace, axes, imshow_fn):
if self.use_color_map():
labels = workspace.display_data.labels
if self.wants_image:
pixel_data = workspace.display_data.pixel_data
else:
pixel_data = (labels != 0).astype(numpy.float32)
if pixel_data.ndim == 3:
pixel_data = numpy.sum(pixel_data, 2) / pixel_data.shape[2]
colormap_name = self.colormap.value
if colormap_name == "Default":
colormap_name = get_default_colormap()
colormap = matplotlib.cm.get_cmap(colormap_name)
values = workspace.display_data.values
vmask = workspace.display_data.mask
colors = numpy.ones((len(vmask) + 1, 4))
colors[1:][~vmask, :3] = 1
sm = matplotlib.cm.ScalarMappable(cmap=colormap)
if self.color_map_scale_choice == CMS_MANUAL:
sm.set_clim(self.color_map_scale.min, self.color_map_scale.max)
sm.set_array(values)
colors[1:][vmask, :] = sm.to_rgba(values)
img = colors[labels, :3] * pixel_data[:, :, numpy.newaxis]
imshow_fn(img)
assert isinstance(axes, matplotlib.axes.Axes)
figure = axes.get_figure()
assert isinstance(figure, matplotlib.figure.Figure)
figure.colorbar(sm, ax=axes)
else:
imshow_fn(workspace.display_data.pixel_data)
for x, y, value in zip(
workspace.display_data.x,
workspace.display_data.y,
workspace.display_data.values,
):
try:
fvalue = float(value)
svalue = "%.*f" % (self.decimals.value, value)
except:
svalue = str(value)
text = matplotlib.text.Text(
x=x,
y=y,
text=svalue,
size=self.font_size.value,
color=self.text_color.value,
verticalalignment="center",
horizontalalignment="center",
)
axes.add_artist(text)
def __init__(self, vw, color, can_delete):
super(WorkspaceViewObjectsRow, self).__init__(vw, color, can_delete)
self.update_chooser(first=True)
name = self.chooser.GetStringSelection()
self.data = bind_data_class(ObjectsData, self.color_ctrl, vw.redraw)(
name,
None,
outline_color=self.color,
colormap=get_default_colormap(),
alpha=0.5,
mode=MODE_HIDE,
)
vw.image.add(self.data)
self.last_mode = MODE_LINES
def upgrade_settings(self, setting_values, variable_revision_number,
module_name):
if variable_revision_number == 1:
(
objects_or_image,
objects_name,
measurement,
image_name,
text_color,
display_image,
dpi,
saved_image_contents,
) = setting_values
setting_values = [
objects_or_image,
objects_name,
measurement,
image_name,
text_color,
display_image,
10,
2,
saved_image_contents,
]
variable_revision_number = 2
if variable_revision_number == 2:
"""Added annotation offset"""
setting_values = setting_values + ["0"]
variable_revision_number = 3
if variable_revision_number == 3:
# Added color map mode
setting_values = setting_values + [
CT_TEXT,
get_default_colormap(),
]
variable_revision_number = 4
if variable_revision_number == 4:
# added wants_image
setting_values = setting_values + ["Yes"]
variable_revision_number = 5
if variable_revision_number == 5:
# added color_map_scale_choice and color_map_scale
setting_values = setting_values + [
CMS_USE_MEASUREMENT_RANGE, "0.0,1.0"
]
variable_revision_number = 6
return setting_values, variable_revision_number
def display(self, workspace, figure):
import matplotlib
nsubplots = 0
if self.wants_population_density():
nsubplots += 1
if self.wants_distance_to_edge():
nsubplots += 1
figure = workspace.create_or_find_figure(subplots=(nsubplots, 1))
cmap = cpprefs.get_default_colormap()
cm = matplotlib.cm.get_cmap(cmap)
cm.set_bad(color='black')
axes = None
if self.wants_population_density():
image = np.ma.MaskedArray(workspace.display_data.count_display,
workspace.display_data.count_display < 0)
title = "# objects within %d px" % self.radius.value
axes = figure.subplot_imshow(0,
0,
image,
title=title,
colormap=cm,
colorbar=True,
normalize=False,
vmin=0,
vmax=np.max(image))
if self.wants_distance_to_edge():
sm = matplotlib.cm.ScalarMappable(cmap=cm)
image = np.ma.MaskedArray(workspace.display_data.distances,
workspace.display_data.distances < 0)
image = sm.to_rgba(image)
#
# We give the edge a little blur so that single pixels show up ok
#
edge = gaussian_filter(workspace.display_data.edge.astype(float),
3)
edge = edge / np.max(edge)
edge_color = sm.to_rgba(
np.array([np.max(workspace.display_data.distances)]))[0]
image = image * (1 - edge[:, :, np.newaxis]) + \
edge[:, :, np.newaxis] * edge_color[np.newaxis, np.newaxis, :]
figure.subplot_imshow(nsubplots - 1,
0,
image,
title="Distance to edge")
def display(self, workspace, figure):
"""Display a visualization of the results"""
from matplotlib.axes import Axes
from matplotlib.lines import Line2D
import matplotlib.cm
if self.wants_objskeleton_graph:
figure.set_subplots((2, 1))
else:
figure.set_subplots((1, 1))
title = (
"Branchpoints of %s and %s\nTrunks are red\nBranches are green\nEndpoints are blue"
% (self.seed_objects_name.value, self.image_name.value))
figure.subplot_imshow(0, 0, workspace.display_data.branchpoint_image,
title)
if self.wants_objskeleton_graph:
image = workspace.display_data.intensity_image
figure.subplot_imshow_grayscale(1,
0,
image,
title="ObjectSkeleton graph",
sharexy=figure.subplot(0, 0))
axes = figure.subplot(1, 0)
assert isinstance(axes, Axes)
edge_graph = workspace.display_data.edge_graph
vertex_graph = workspace.display_data.vertex_graph
i = vertex_graph["i"]
j = vertex_graph["j"]
kind = vertex_graph["kind"]
brightness = edge_graph["total_intensity"] / edge_graph["length"]
brightness = (brightness - np.min(brightness)) / (
np.max(brightness) - np.min(brightness) + 0.000001)
cm = matplotlib.cm.get_cmap(cpprefs.get_default_colormap())
cmap = matplotlib.cm.ScalarMappable(cmap=cm)
edge_color = cmap.to_rgba(brightness)
for idx in range(len(edge_graph["v1"])):
v = np.array(
[edge_graph["v1"][idx] - 1, edge_graph["v2"][idx] - 1])
line = Line2D(j[v], i[v], color=edge_color[idx])
axes.add_line(line)
def __init__(self, workspace_view, color, can_delete):
super(WorkspaceViewImageRow, self).__init__(workspace_view, color, can_delete)
image_set = workspace_view.workspace.image_set
name = self.chooser.GetStringSelection()
im = get_intensity_mode()
if im == INTENSITY_MODE_LOG:
normalization = NORMALIZE_LOG
elif im == INTENSITY_MODE_NORMAL:
normalization = NORMALIZE_LINEAR
else:
normalization = NORMALIZE_RAW
alpha = 1.0 / (len(workspace_view.image_rows) + 1.0)
self.data = bind_data_class(ImageData, self.color_ctrl, workspace_view.redraw)(
name,
None,
mode=MODE_HIDE,
color=self.color,
colormap=get_default_colormap(),
alpha=alpha,
normalization=normalization,
)
workspace_view.image.add(self.data)
self.last_mode = MODE_COLORIZE
def display(self, workspace, figure):
"""Show an informative display"""
import matplotlib
import cellprofiler.gui.figure
figure.set_subplots((2, 1))
assert isinstance(figure, cellprofiler.gui.figure.Figure)
i = workspace.display_data.i
j = workspace.display_data.j
angles = workspace.display_data.angle
mask = workspace.display_data.mask
labels = workspace.display_data.labels
count = workspace.display_data.count
color_image = numpy.zeros((mask.shape[0], mask.shape[1], 4))
#
# We do the coloring using alpha values to let the different
# things we draw meld together.
#
# The binary mask is white.
#
color_image[mask, :] = MASK_ALPHA
if count > 0:
mappable = matplotlib.cm.ScalarMappable(
cmap=matplotlib.cm.get_cmap(get_default_colormap())
)
numpy.random.seed(0)
colors = mappable.to_rgba(numpy.random.permutation(numpy.arange(count)))
#
# The labels
#
color_image[labels > 0, :] += (
colors[labels[labels > 0] - 1, :] * LABEL_ALPHA
)
#
# Do each diamond individually (because the angles are almost certainly
# different for each
#
lcolors = colors * 0.5 + 0.5 # Wash the colors out a little
for ii in range(count):
diamond = self.get_diamond(angles[ii])
hshape = ((numpy.array(diamond.shape) - 1) / 2).astype(int)
iii = i[ii]
jjj = j[ii]
color_image[
iii - hshape[0] : iii + hshape[0] + 1,
jjj - hshape[1] : jjj + hshape[1] + 1,
:,
][diamond, :] += (lcolors[ii, :] * WORM_ALPHA)
#
# Do our own alpha-normalization
#
color_image[:, :, -1][color_image[:, :, -1] == 0] = 1
color_image[:, :, :-1] = (
color_image[:, :, :-1] / color_image[:, :, -1][:, :, numpy.newaxis]
)
plot00 = figure.subplot_imshow_bw(0, 0, mask, self.image_name.value)
figure.subplot_imshow_color(
1,
0,
color_image[:, :, :-1],
title=self.object_name.value,
normalize=False,
sharexy=plot00,
)
def get_colormap(name):
"""Get colormap, accounting for possible request for default"""
if name == "Default":
name = cpprefs.get_default_colormap()
return matplotlib.cm.get_cmap(name)
def run(self, workspace):
objects = workspace.object_set.get_objects(self.object_name.value)
dimensions = len(objects.shape)
assert isinstance(objects, cpo.Objects)
has_pixels = objects.areas > 0
labels = objects.small_removed_segmented
kept_labels = objects.segmented
neighbor_objects = workspace.object_set.get_objects(
self.neighbors_name.value)
neighbor_labels = neighbor_objects.small_removed_segmented
neighbor_kept_labels = neighbor_objects.segmented
assert isinstance(neighbor_objects, cpo.Objects)
if not self.wants_excluded_objects.value:
# Remove labels not present in kept segmentation while preserving object IDs.
mask = neighbor_kept_labels > 0
neighbor_labels[~mask] = 0
nobjects = np.max(labels)
nkept_objects = len(objects.indices)
nneighbors = np.max(neighbor_labels)
_, object_numbers = objects.relate_labels(labels, kept_labels)
if self.neighbors_are_objects:
neighbor_numbers = object_numbers
neighbor_has_pixels = has_pixels
else:
_, neighbor_numbers = neighbor_objects.relate_labels(
neighbor_labels, neighbor_objects.small_removed_segmented)
neighbor_has_pixels = np.bincount(neighbor_labels.ravel())[1:] > 0
neighbor_count = np.zeros((nobjects, ))
pixel_count = np.zeros((nobjects, ))
first_object_number = np.zeros((nobjects, ), int)
second_object_number = np.zeros((nobjects, ), int)
first_x_vector = np.zeros((nobjects, ))
second_x_vector = np.zeros((nobjects, ))
first_y_vector = np.zeros((nobjects, ))
second_y_vector = np.zeros((nobjects, ))
angle = np.zeros((nobjects, ))
percent_touching = np.zeros((nobjects, ))
expanded_labels = None
if self.distance_method == D_EXPAND:
# Find the i,j coordinates of the nearest foreground point
# to every background point
if dimensions == 2:
i, j = scind.distance_transform_edt(labels == 0,
return_distances=False,
return_indices=True)
# Assign each background pixel to the label of its nearest
# foreground pixel. Assign label to label for foreground.
labels = labels[i, j]
else:
k, i, j = scind.distance_transform_edt(labels == 0,
return_distances=False,
return_indices=True)
labels = labels[k, i, j]
expanded_labels = labels # for display
distance = 1 # dilate once to make touching edges overlap
scale = S_EXPANDED
if self.neighbors_are_objects:
neighbor_labels = labels.copy()
elif self.distance_method == D_WITHIN:
distance = self.distance.value
scale = str(distance)
elif self.distance_method == D_ADJACENT:
distance = 1
scale = S_ADJACENT
else:
raise ValueError("Unknown distance method: %s" %
self.distance_method.value)
if nneighbors > (1 if self.neighbors_are_objects else 0):
first_objects = []
second_objects = []
object_indexes = np.arange(nobjects, dtype=np.int32) + 1
#
# First, compute the first and second nearest neighbors,
# and the angles between self and the first and second
# nearest neighbors
#
ocenters = centers_of_labels(
objects.small_removed_segmented).transpose()
ncenters = centers_of_labels(
neighbor_objects.small_removed_segmented).transpose()
areas = fix(
scind.sum(np.ones(labels.shape), labels, object_indexes))
perimeter_outlines = outline(labels)
perimeters = fix(
scind.sum(np.ones(labels.shape), perimeter_outlines,
object_indexes))
i, j = np.mgrid[0:nobjects, 0:nneighbors]
distance_matrix = np.sqrt((ocenters[i, 0] - ncenters[j, 0])**2 +
(ocenters[i, 1] - ncenters[j, 1])**2)
#
# order[:,0] should be arange(nobjects)
# order[:,1] should be the nearest neighbor
# order[:,2] should be the next nearest neighbor
#
if distance_matrix.shape[1] == 1:
# a little buggy, lexsort assumes that a 2-d array of
# second dimension = 1 is a 1-d array
order = np.zeros(distance_matrix.shape, int)
else:
order = np.lexsort([distance_matrix])
first_neighbor = 1 if self.neighbors_are_objects else 0
first_object_index = order[:, first_neighbor]
first_x_vector = ncenters[first_object_index, 1] - ocenters[:, 1]
first_y_vector = ncenters[first_object_index, 0] - ocenters[:, 0]
if nneighbors > first_neighbor + 1:
second_object_index = order[:, first_neighbor + 1]
second_x_vector = ncenters[second_object_index,
1] - ocenters[:, 1]
second_y_vector = ncenters[second_object_index,
0] - ocenters[:, 0]
v1 = np.array((first_x_vector, first_y_vector))
v2 = np.array((second_x_vector, second_y_vector))
#
# Project the unit vector v1 against the unit vector v2
#
dot = np.sum(v1 * v2, 0) / np.sqrt(
np.sum(v1**2, 0) * np.sum(v2**2, 0))
angle = np.arccos(dot) * 180.0 / np.pi
# Make the structuring element for dilation
if dimensions == 2:
strel = strel_disk(distance)
else:
strel = skimage.morphology.ball(distance)
#
# A little bigger one to enter into the border with a structure
# that mimics the one used to create the outline
#
if dimensions == 2:
strel_touching = strel_disk(distance + 0.5)
else:
strel_touching = skimage.morphology.ball(distance + 0.5)
#
# Get the extents for each object and calculate the patch
# that excises the part of the image that is "distance"
# away
if dimensions == 2:
i, j = np.mgrid[0:labels.shape[0], 0:labels.shape[1]]
minimums_i, maximums_i, _, _ = scind.extrema(
i, labels, object_indexes)
minimums_j, maximums_j, _, _ = scind.extrema(
j, labels, object_indexes)
minimums_i = np.maximum(fix(minimums_i) - distance,
0).astype(int)
maximums_i = np.minimum(
fix(maximums_i) + distance + 1,
labels.shape[0]).astype(int)
minimums_j = np.maximum(fix(minimums_j) - distance,
0).astype(int)
maximums_j = np.minimum(
fix(maximums_j) + distance + 1,
labels.shape[1]).astype(int)
else:
k, i, j = np.mgrid[0:labels.shape[0], 0:labels.shape[1],
0:labels.shape[2]]
minimums_k, maximums_k, _, _ = scind.extrema(
k, labels, object_indexes)
minimums_i, maximums_i, _, _ = scind.extrema(
i, labels, object_indexes)
minimums_j, maximums_j, _, _ = scind.extrema(
j, labels, object_indexes)
minimums_k = np.maximum(fix(minimums_k) - distance,
0).astype(int)
maximums_k = np.minimum(
fix(maximums_k) + distance + 1,
labels.shape[0]).astype(int)
minimums_i = np.maximum(fix(minimums_i) - distance,
0).astype(int)
maximums_i = np.minimum(
fix(maximums_i) + distance + 1,
labels.shape[1]).astype(int)
minimums_j = np.maximum(fix(minimums_j) - distance,
0).astype(int)
maximums_j = np.minimum(
fix(maximums_j) + distance + 1,
labels.shape[2]).astype(int)
#
# Loop over all objects
# Calculate which ones overlap "index"
# Calculate how much overlap there is of others to "index"
#
for object_number in object_numbers:
if object_number == 0:
#
# No corresponding object in small-removed. This means
# that the object has no pixels, e.g., not renumbered.
#
continue
index = object_number - 1
if dimensions == 2:
patch = labels[minimums_i[index]:maximums_i[index],
minimums_j[index]:maximums_j[index], ]
npatch = neighbor_labels[
minimums_i[index]:maximums_i[index],
minimums_j[index]:maximums_j[index], ]
else:
patch = labels[minimums_k[index]:maximums_k[index],
minimums_i[index]:maximums_i[index],
minimums_j[index]:maximums_j[index], ]
npatch = neighbor_labels[
minimums_k[index]:maximums_k[index],
minimums_i[index]:maximums_i[index],
minimums_j[index]:maximums_j[index], ]
#
# Find the neighbors
#
patch_mask = patch == (index + 1)
extended = scind.binary_dilation(patch_mask, strel)
neighbors = np.unique(npatch[extended])
neighbors = neighbors[neighbors != 0]
if self.neighbors_are_objects:
neighbors = neighbors[neighbors != object_number]
nc = len(neighbors)
neighbor_count[index] = nc
if nc > 0:
first_objects.append(np.ones(nc, int) * object_number)
second_objects.append(neighbors)
#
# Find the # of overlapping pixels. Dilate the neighbors
# and see how many pixels overlap our image. Use a 3x3
# structuring element to expand the overlapping edge
# into the perimeter.
#
if dimensions == 2:
outline_patch = (perimeter_outlines[
minimums_i[index]:maximums_i[index],
minimums_j[index]:maximums_j[index], ] == object_number
)
else:
outline_patch = (perimeter_outlines[
minimums_k[index]:maximums_k[index],
minimums_i[index]:maximums_i[index],
minimums_j[index]:maximums_j[index], ] == object_number
)
if self.neighbors_are_objects:
extended = scind.binary_dilation(
(patch != 0) & (patch != object_number),
strel_touching)
else:
extended = scind.binary_dilation((npatch != 0),
strel_touching)
overlap = np.sum(outline_patch & extended)
pixel_count[index] = overlap
if sum([len(x) for x in first_objects]) > 0:
first_objects = np.hstack(first_objects)
reverse_object_numbers = np.zeros(
max(np.max(object_numbers), np.max(first_objects)) + 1,
int)
reverse_object_numbers[object_numbers] = (
np.arange(len(object_numbers)) + 1)
first_objects = reverse_object_numbers[first_objects]
second_objects = np.hstack(second_objects)
reverse_neighbor_numbers = np.zeros(
max(np.max(neighbor_numbers), np.max(second_objects)) + 1,
int)
reverse_neighbor_numbers[neighbor_numbers] = (
np.arange(len(neighbor_numbers)) + 1)
second_objects = reverse_neighbor_numbers[second_objects]
to_keep = (first_objects > 0) & (second_objects > 0)
first_objects = first_objects[to_keep]
second_objects = second_objects[to_keep]
else:
first_objects = np.zeros(0, int)
second_objects = np.zeros(0, int)
percent_touching = pixel_count * 100 / perimeters
object_indexes = object_numbers - 1
neighbor_indexes = neighbor_numbers - 1
#
# Have to recompute nearest
#
first_object_number = np.zeros(nkept_objects, int)
second_object_number = np.zeros(nkept_objects, int)
if nkept_objects > (1 if self.neighbors_are_objects else 0):
di = (ocenters[object_indexes[:, np.newaxis], 0] -
ncenters[neighbor_indexes[np.newaxis, :], 0])
dj = (ocenters[object_indexes[:, np.newaxis], 1] -
ncenters[neighbor_indexes[np.newaxis, :], 1])
distance_matrix = np.sqrt(di * di + dj * dj)
distance_matrix[~has_pixels, :] = np.inf
distance_matrix[:, ~neighbor_has_pixels] = np.inf
#
# order[:,0] should be arange(nobjects)
# order[:,1] should be the nearest neighbor
# order[:,2] should be the next nearest neighbor
#
order = np.lexsort([distance_matrix
]).astype(first_object_number.dtype)
if self.neighbors_are_objects:
first_object_number[has_pixels] = order[has_pixels, 1] + 1
if nkept_objects > 2:
second_object_number[has_pixels] = order[has_pixels,
2] + 1
else:
first_object_number[has_pixels] = order[has_pixels, 0] + 1
if order.shape[1] > 1:
second_object_number[has_pixels] = order[has_pixels,
1] + 1
else:
object_indexes = object_numbers - 1
neighbor_indexes = neighbor_numbers - 1
first_objects = np.zeros(0, int)
second_objects = np.zeros(0, int)
#
# Now convert all measurements from the small-removed to
# the final number set.
#
neighbor_count = neighbor_count[object_indexes]
neighbor_count[~has_pixels] = 0
percent_touching = percent_touching[object_indexes]
percent_touching[~has_pixels] = 0
first_x_vector = first_x_vector[object_indexes]
second_x_vector = second_x_vector[object_indexes]
first_y_vector = first_y_vector[object_indexes]
second_y_vector = second_y_vector[object_indexes]
angle = angle[object_indexes]
#
# Record the measurements
#
assert isinstance(workspace, cpw.Workspace)
m = workspace.measurements
assert isinstance(m, cpmeas.Measurements)
image_set = workspace.image_set
features_and_data = [
(M_NUMBER_OF_NEIGHBORS, neighbor_count),
(M_FIRST_CLOSEST_OBJECT_NUMBER, first_object_number),
(
M_FIRST_CLOSEST_DISTANCE,
np.sqrt(first_x_vector**2 + first_y_vector**2),
),
(M_SECOND_CLOSEST_OBJECT_NUMBER, second_object_number),
(
M_SECOND_CLOSEST_DISTANCE,
np.sqrt(second_x_vector**2 + second_y_vector**2),
),
(M_ANGLE_BETWEEN_NEIGHBORS, angle),
(M_PERCENT_TOUCHING, percent_touching),
]
for feature_name, data in features_and_data:
m.add_measurement(self.object_name.value,
self.get_measurement_name(feature_name), data)
if len(first_objects) > 0:
m.add_relate_measurement(
self.module_num,
cpmeas.NEIGHBORS,
self.object_name.value,
self.object_name.value
if self.neighbors_are_objects else self.neighbors_name.value,
m.image_set_number * np.ones(first_objects.shape, int),
first_objects,
m.image_set_number * np.ones(second_objects.shape, int),
second_objects,
)
labels = kept_labels
neighbor_count_image = np.zeros(labels.shape, int)
object_mask = objects.segmented != 0
object_indexes = objects.segmented[object_mask] - 1
neighbor_count_image[object_mask] = neighbor_count[object_indexes]
workspace.display_data.neighbor_count_image = neighbor_count_image
percent_touching_image = np.zeros(labels.shape)
percent_touching_image[object_mask] = percent_touching[object_indexes]
workspace.display_data.percent_touching_image = percent_touching_image
image_set = workspace.image_set
if self.wants_count_image.value:
neighbor_cm_name = self.count_colormap.value
neighbor_cm = get_colormap(neighbor_cm_name)
sm = matplotlib.cm.ScalarMappable(cmap=neighbor_cm)
img = sm.to_rgba(neighbor_count_image)[:, :, :3]
img[:, :, 0][~object_mask] = 0
img[:, :, 1][~object_mask] = 0
img[:, :, 2][~object_mask] = 0
count_image = cpi.Image(img, masking_objects=objects)
image_set.add(self.count_image_name.value, count_image)
else:
neighbor_cm_name = cpprefs.get_default_colormap()
neighbor_cm = matplotlib.cm.get_cmap(neighbor_cm_name)
if self.wants_percent_touching_image:
percent_touching_cm_name = self.touching_colormap.value
percent_touching_cm = get_colormap(percent_touching_cm_name)
sm = matplotlib.cm.ScalarMappable(cmap=percent_touching_cm)
img = sm.to_rgba(percent_touching_image)[:, :, :3]
img[:, :, 0][~object_mask] = 0
img[:, :, 1][~object_mask] = 0
img[:, :, 2][~object_mask] = 0
touching_image = cpi.Image(img, masking_objects=objects)
image_set.add(self.touching_image_name.value, touching_image)
else:
percent_touching_cm_name = cpprefs.get_default_colormap()
percent_touching_cm = matplotlib.cm.get_cmap(
percent_touching_cm_name)
if self.show_window:
workspace.display_data.neighbor_cm_name = neighbor_cm_name
workspace.display_data.percent_touching_cm_name = percent_touching_cm_name
workspace.display_data.orig_labels = objects.segmented
workspace.display_data.neighbor_labels = neighbor_labels
workspace.display_data.expanded_labels = expanded_labels
workspace.display_data.object_mask = object_mask
workspace.display_data.dimensions = dimensions
def run(self, workspace):
objects = workspace.object_set.get_objects(self.object_name.value)
alpha = numpy.zeros(objects.shape)
convert = True
if self.image_mode == "Binary (black & white)":
pixel_data = numpy.zeros(objects.shape, bool)
elif self.image_mode == "Grayscale":
pixel_data = numpy.zeros(objects.shape)
elif self.image_mode == "uint16":
pixel_data = numpy.zeros(objects.shape, numpy.int32)
convert = False
else:
pixel_data = numpy.zeros(objects.shape + (3, ))
for labels, _ in objects.get_labels():
mask = labels != 0
if numpy.all(~mask):
continue
if self.image_mode == "Binary (black & white)":
pixel_data[mask] = True
alpha[mask] = 1
elif self.image_mode == "Grayscale":
pixel_data[mask] = labels[mask].astype(float) / numpy.max(
labels)
alpha[mask] = 1
elif self.image_mode == "Color":
if self.colormap.value == DEFAULT_COLORMAP:
cm_name = get_default_colormap()
elif self.colormap.value == "colorcube":
# Colorcube missing from matplotlib
cm_name = "gist_rainbow"
elif self.colormap.value == "lines":
# Lines missing from matplotlib and not much like it,
# Pretty boring palette anyway, hence
cm_name = "Pastel1"
elif self.colormap.value == "white":
# White missing from matplotlib, it's just a colormap
# of all completely white... not even different kinds of
# white. And, isn't white just a uniform sampling of
# frequencies from the spectrum?
cm_name = "Spectral"
else:
cm_name = self.colormap.value
cm = matplotlib.cm.get_cmap(cm_name)
mapper = matplotlib.cm.ScalarMappable(cmap=cm)
if labels.ndim == 3:
for index, plane in enumerate(mask):
pixel_data[index, plane, :] = mapper.to_rgba(
centrosome.cpmorphology.distance_color_labels(
labels[index]))[plane, :3]
else:
pixel_data[mask, :] += mapper.to_rgba(
centrosome.cpmorphology.distance_color_labels(labels))[
mask, :3]
alpha[mask] += 1
elif self.image_mode == "uint16":
pixel_data[mask] = labels[mask]
alpha[mask] = 1
mask = alpha > 0
if self.image_mode == "Color":
pixel_data[
mask, :] = pixel_data[mask, :] / alpha[mask][:, numpy.newaxis]
elif self.image_mode != "Binary (black & white)":
pixel_data[mask] = pixel_data[mask] / alpha[mask]
image = Image(
pixel_data,
parent_image=objects.parent_image,
convert=convert,
dimensions=len(objects.shape),
)
workspace.image_set.add(self.image_name.value, image)
if self.show_window:
if image.dimensions == 2:
workspace.display_data.ijv = objects.ijv
else:
workspace.display_data.segmented = objects.segmented
workspace.display_data.pixel_data = pixel_data
workspace.display_data.dimensions = image.dimensions
