def run(self, workspace):
image_set = workspace.image_set
if self.source_choice == IO_OBJECTS:
objects = workspace.get_objects(self.object_name.value)
labels = objects.segmented
if self.invert_mask.value:
mask = labels == 0
else:
mask = labels > 0
else:
objects = None
try:
mask = image_set.get_image(self.masking_image_name.value,
must_be_binary=True).pixel_data
except ValueError:
mask = image_set.get_image(self.masking_image_name.value,
must_be_grayscale=True).pixel_data
mask = mask > .5
if self.invert_mask.value:
mask = mask == 0
orig_image = image_set.get_image(self.image_name.value)
if (orig_image.multichannel
and mask.shape != orig_image.pixel_data.shape[:-1]
) or mask.shape != orig_image.pixel_data.shape:
tmp = np.zeros(orig_image.pixel_data.shape[:2], mask.dtype)
tmp[mask] = True
mask = tmp
if orig_image.has_mask:
mask = np.logical_and(mask, orig_image.mask)
masked_pixels = orig_image.pixel_data.copy()
masked_pixels[np.logical_not(mask)] = 0
masked_image = cpi.Image(masked_pixels,
mask=mask,
parent_image=orig_image,
masking_objects=objects,
dimensions=orig_image.dimensions)
image_set.add(self.masked_image_name.value, masked_image)
if self.show_window:
workspace.display_data.dimensions = orig_image.dimensions
workspace.display_data.orig_image_pixel_data = orig_image.pixel_data
workspace.display_data.masked_pixels = masked_pixels
workspace.display_data.multichannel = orig_image.multichannel
def test_01_03_test_two_dark_objects(self):
x = YS.IdentifyYeastCells()
x.object_name.value = OBJECTS_NAME
x.segmentation_precision.value = 11
x.input_image_name.value = IMAGE_NAME
x.background_brighter_then_cell_inside.value = True
x.average_cell_diameter.value = 10
img = convert_to_brightfield(get_two_cell_mask(), True)
image = cpi.Image(img, file_name="test_01_03_test_two_dark_objects")
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.providers.append(cpi.VanillaImageProvider(IMAGE_NAME, image))
object_set = cpo.ObjectSet()
measurements = cpmeas.Measurements()
pipeline = cellprofiler.pipeline.Pipeline()
x.run(Workspace(pipeline, x, image_set, object_set, measurements,
None))
self.assertEqual(len(object_set.object_names), 1)
self.assertTrue(OBJECTS_NAME in object_set.object_names)
objects = object_set.get_objects(OBJECTS_NAME)
self.assertTrue(
is_segmentation_correct(get_two_cell_mask(), objects.segmented))
self.assertTrue("Image" in measurements.get_object_names())
self.assertTrue(OBJECTS_NAME in measurements.get_object_names())
self.assertTrue(
"Features_Quality" in measurements.get_feature_names(OBJECTS_NAME))
quality = measurements.get_current_measurement(OBJECTS_NAME,
"Features_Quality")
self.assertTrue(len(quality) == 2)
self.assertTrue("Location_Center_Y" in measurements.get_feature_names(
OBJECTS_NAME))
location_center_y = measurements.get_current_measurement(
OBJECTS_NAME, "Location_Center_Y")
location_center_x = measurements.get_current_measurement(
OBJECTS_NAME, "Location_Center_X")
positions = sorted(zip(location_center_x, location_center_y))
self.assertEqual(2, len(positions))
self.assertRange(3, 18, positions[0][0])
self.assertRange(25, 45, positions[0][1])
self.assertRange(20, 40, positions[1][0])
self.assertRange(5, 25, positions[1][1])
def make_workspace(self, image, mask):
"""Make a workspace for testing FilterByObjectMeasurement"""
module = S.Smooth()
pipeline = cpp.Pipeline()
object_set = cpo.ObjectSet()
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
workspace = cpw.Workspace(
pipeline,
module,
image_set,
object_set,
cpmeas.Measurements(),
image_set_list,
)
image_set.add(INPUT_IMAGE_NAME, cpi.Image(image, mask))
module.image_name.value = INPUT_IMAGE_NAME
module.filtered_image_name.value = OUTPUT_IMAGE_NAME
return workspace, module
def prepare_run(self, message, session_id, grouping_allowed=False):
'''Prepare a pipeline and measurements to run
message - the run-request or run-groups-request message
session_id - the session ID for the session
grouping_allowed - true to allow grouped images
'''
pipeline = cpp.Pipeline()
m = cpmeas.Measurements()
object_set = cpo.ObjectSet()
if len(message) < 2:
self.raise_cellprofiler_exception(session_id,
"Missing run request sections")
return
pipeline_txt = message.pop(0).bytes
image_metadata = message.pop(0).bytes
try:
image_metadata = json.loads(image_metadata)
for channel_name, channel_metadata in image_metadata:
if len(message) < 1:
self.raise_cellprofiler_exception(
session_id,
"Missing binary data for channel %s" % channel_name)
return None, None, None
pixel_data = self.decode_image(
channel_metadata,
message.pop(0).bytes,
grouping_allowed=grouping_allowed)
m.add(channel_name, cpi.Image(pixel_data))
except Exception as e:
logger.warn("Failed to decode message", exc_info=1)
self.raise_cellprofiler_exception(session_id, e.message)
return None, None, None
try:
pipeline.loadtxt(StringIO(pipeline_txt))
except Exception as e:
logger.warning(
"Failed to load pipeline: sending pipeline exception",
exc_info=1)
self.raise_pipeline_exception(session_id, str(e))
return None, None, None
return pipeline, m, object_set
def test_06_04_wrong_size(self):
'''Regression test of IMG-961 - objects and images of different sizes'''
np.random.seed(0)
image1 = np.random.uniform(size=(20, 20))
i1 = cpi.Image(image1)
labels = np.zeros((10, 30), int)
labels[:4, :4] = 1
labels[6:, 6:] = 2
o = cpo.Objects()
o.segmented = labels
workspace, module = self.make_workspace(i1, i1, o)
module.run(workspace)
m = workspace.measurements
mi = module.get_measurement_images(None, OBJECTS_NAME, "Correlation",
"Correlation")
corr = m.get_current_measurement(OBJECTS_NAME,
"Correlation_Correlation_%s" % mi[0])
self.assertAlmostEqual(corr[0], 1)
self.assertAlmostEqual(corr[1], 1)
def make_workspace(self, image, outlier_percentile):
'''Make a workspace '''
module = C.ClipRange()
pipeline = cpp.Pipeline()
object_set = cpo.ObjectSet()
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
workspace = cpw.Workspace(pipeline, module, image_set, object_set,
cpmeas.Measurements(), image_set_list)
# setup the input images
image_set.add(INPUT_IMAGE_NAME, cpi.Image(image))
# setup the input images settings
module.x_name.value = INPUT_IMAGE_NAME
module.y_name.value = OUTPUT_IMAGE_NAME
module.outlier_percentile.value = outlier_percentile
return workspace, module
def test_03_01_image_casts(self):
one_target = np.ones((10, 10), dtype=np.float64)
zero_target = np.zeros((10, 10), dtype=np.float64)
tests = [(np.float64, 0, 1.0), (np.float32, 0, 1.0),
(np.uint32, 0, math.pow(2.0, 32.0) - 1),
(np.uint16, 0, math.pow(2.0, 16.0) - 1),
(np.uint8, 0, math.pow(2.0, 8.0) - 1),
(np.int32, -math.pow(2.0, 31.0), math.pow(2.0, 31.0) - 1),
(np.int16, -math.pow(2.0, 15.0), math.pow(2.0, 15.0) - 1),
(np.int8, -math.pow(2.0, 7.0), math.pow(2.0, 7.0) - 1)]
for dtype, zval, oval in tests:
x = cpi.Image()
x.set_image((one_target * zval).astype(dtype))
self.assertTrue((x.image == zero_target).all(),
msg="Failed setting %s to min" % (repr(dtype)))
x.set_image((one_target * oval).astype(dtype))
y = (x.image == one_target)
self.assertTrue((x.image == one_target).all(),
msg="Failed setting %s to max" % (repr(dtype)))
def run(self, workspace):
image = workspace.image_set.get_image(self.image_name.value)
if image.has_mask:
mask = image.mask
else:
mask = None
pixel_data = image.pixel_data
if pixel_data.ndim == 3:
if any([np.any(pixel_data[:, :, 0] != pixel_data[:, :, plane])
for plane in range(1, pixel_data.shape[2])]):
logger.warn("Image is color, converting to grayscale")
pixel_data = np.sum(pixel_data, 2) / pixel_data.shape[2]
for function in self.functions:
pixel_data = self.run_function(function, pixel_data, mask)
new_image = cpi.Image(pixel_data, parent_image=image)
workspace.image_set.add(self.output_image_name.value, new_image)
if self.show_window:
workspace.display_data.image = image.pixel_data
workspace.display_data.pixel_data = pixel_data
def test_02_02_mask_invert(self):
labels = np.zeros((10, 15), int)
labels[2:5, 3:8] = 1
labels[5:8, 10:14] = 2
object_set = cpo.ObjectSet()
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, OBJECTS_NAME)
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
np.random.seed(0)
pixel_data = np.random.uniform(size=(10, 15)).astype(np.float32)
image_set.add(IMAGE_NAME, cpi.Image(pixel_data))
pipeline = cpp.Pipeline()
module = M.MaskImage()
module.source_choice.value = M.IO_OBJECTS
module.object_name.value = OBJECTS_NAME
module.image_name.value = IMAGE_NAME
module.masked_image_name.value = MASKED_IMAGE_NAME
module.invert_mask.value = True
module.module_num = 1
workspace = cpw.Workspace(
pipeline,
module,
image_set,
object_set,
cpmeas.Measurements(),
image_set_list,
)
module.run(workspace)
masked_image = workspace.image_set.get_image(MASKED_IMAGE_NAME)
self.assertTrue(isinstance(masked_image, cpi.Image))
self.assertTrue(
np.all(masked_image.pixel_data[labels == 0] == pixel_data[labels ==
0]))
self.assertTrue(np.all(masked_image.pixel_data[labels > 0] == 0))
self.assertTrue(np.all(masked_image.mask == (labels == 0)))
self.assertTrue(
np.all(masked_image.masking_objects.segmented == labels))
def run(self, workspace):
image_name = self.image_name.value
objects_name = self.objects_name.value
outlines_name = self.outlines_name.value
image = workspace.image_set.get_image(image_name)
pixel_data = image.pixel_data
labels = workspace.interaction_request(
self, pixel_data, workspace.measurements.image_set_number)
if labels is None:
# User cancelled. Soldier on as best we can.
workspace.cancel_request()
labels = np.zeros(pixel_data.shape[:2], int)
objects = cpo.Objects()
objects.segmented = labels
workspace.object_set.add_objects(objects, objects_name)
##################
#
# Add measurements
#
m = workspace.measurements
#
# The object count
#
object_count = np.max(labels)
I.add_object_count_measurements(m, objects_name, object_count)
#
# The object locations
#
I.add_object_location_measurements(m, objects_name, labels)
#
# Outlines if we want them
#
if self.wants_outlines:
outlines_name = self.outlines_name.value
outlines = outline(labels)
outlines_image = cpi.Image(outlines.astype(bool))
workspace.image_set.add(outlines_name, outlines_image)
workspace.display_data.labels = labels
workspace.display_data.pixel_data = pixel_data
def make_workspace(self, measurement, labels=None, image=None):
object_set = cpo.ObjectSet()
module = D.DisplayDataOnImage()
module.module_num = 1
module.image_name.value = INPUT_IMAGE_NAME
module.display_image.value = OUTPUT_IMAGE_NAME
module.objects_name.value = OBJECTS_NAME
m = cpmeas.Measurements()
if labels is None:
module.objects_or_image.value = D.OI_IMAGE
m.add_image_measurement(MEASUREMENT_NAME, measurement)
if image is None:
image = np.zeros((50, 120))
else:
module.objects_or_image.value = D.OI_OBJECTS
o = cpo.Objects()
o.segmented = labels
object_set.add_objects(o, OBJECTS_NAME)
m.add_measurement(OBJECTS_NAME, MEASUREMENT_NAME,
np.array(measurement))
y, x = centers_of_labels(labels)
m.add_measurement(OBJECTS_NAME, "Location_Center_X", x)
m.add_measurement(OBJECTS_NAME, "Location_Center_Y", y)
if image is None:
image = np.zeros(labels.shape)
module.measurement.value = MEASUREMENT_NAME
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
pipeline.add_module(module)
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.add(INPUT_IMAGE_NAME, cpi.Image(image))
workspace = cpw.Workspace(pipeline, module, image_set, object_set, m,
image_set_list)
return workspace, module
def make_workspace(self, object_dict={}, image_dict={}):
'''Make a workspace for testing MeasureImageIntensity'''
module = M.MeasureImageIntensity()
pipeline = cpp.Pipeline()
object_set = cpo.ObjectSet()
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
workspace = cpw.Workspace(pipeline,
module,
image_set,
object_set,
cpmeas.Measurements(),
image_set_list)
for key in image_dict.keys():
image_set.add(key, cpi.Image(image_dict[key]))
for key in object_dict.keys():
o = cpo.Objects()
o.segmented = object_dict[key]
object_set.add_objects(o, key)
return workspace, module
def apply_crop(self, workspace, input_image_name, output_image_name,
crop_slice):
image = workspace.image_set.get_image(input_image_name)
image_pixels = image.pixel_data
if image_pixels.ndim > 2:
crop_slice = self.add_slice_dimension(crop_slice)
output_image = cpi.Image(image_pixels[crop_slice], parent_image=image)
workspace.image_set.add(output_image_name, output_image)
if self.show_window:
if not hasattr(workspace.display_data, 'input_images'):
workspace.display_data.input_images = [image.pixel_data]
workspace.display_data.output_images = [output_image.pixel_data]
workspace.display_data.input_image_names = [input_image_name]
workspace.display_data.output_image_names = [output_image_name]
else:
workspace.display_data.input_images += [image.pixel_data]
workspace.display_data.output_images += [output_image.pixel_data]
workspace.display_data.input_image_names += [input_image_name]
workspace.display_data.output_image_names += [output_image_name]
def make_workspace(self, labels, overlap_choice, masking_objects=None,
masking_image=None, renumber=True):
module = M.MaskObjects()
module.module_num = 1
module.object_name.value = INPUT_OBJECTS
module.remaining_objects.value = OUTPUT_OBJECTS
module.mask_choice.value = (M.MC_OBJECTS if masking_objects is not None
else M.MC_IMAGE)
module.masking_image.value = MASKING_IMAGE
module.masking_objects.value = MASKING_OBJECTS
module.retain_or_renumber.value = (M.R_RENUMBER if renumber
else M.R_RETAIN)
module.overlap_choice.value = overlap_choice
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
pipeline.add_module(module)
object_set = cpo.ObjectSet()
io = cpo.Objects()
io.segmented = labels
object_set.add_objects(io, INPUT_OBJECTS)
if masking_objects is not None:
oo = cpo.Objects()
oo.segmented = masking_objects
object_set.add_objects(oo, MASKING_OBJECTS)
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
if masking_image is not None:
mi = cpi.Image(masking_image)
image_set.add(MASKING_IMAGE, mi)
workspace = cpw.Workspace(pipeline, module, image_set, object_set,
cpmeas.Measurements(), image_set_list)
return workspace, module
def test_07_01_make_ijv_outlines(self):
np.random.seed(70)
x = cpo.Objects()
ii, jj = np.mgrid[0:10, 0:20]
masks = [(ii - ic)**2 + (jj - jc)**2 < r**2
for ic, jc, r in ((4, 5, 5), (4, 12, 5), (6, 8, 5))]
i = np.hstack([ii[mask] for mask in masks])
j = np.hstack([jj[mask] for mask in masks])
v = np.hstack([[k + 1] * np.sum(mask) for k, mask in enumerate(masks)])
x.set_ijv(np.column_stack((i, j, v)), ii.shape)
x.parent_image = cpi.Image(np.zeros((10, 20)))
colors = np.random.uniform(size=(3, 3)).astype(np.float32)
image = x.make_ijv_outlines(colors)
i1 = [
i for i, color in enumerate(colors)
if np.all(color == image[0, 5, :])
]
self.assertEqual(len(i1), 1)
i2 = [
i for i, color in enumerate(colors)
if np.all(color == image[0, 12, :])
]
self.assertEqual(len(i2), 1)
i3 = [
i for i, color in enumerate(colors)
if np.all(color == image[-1, 8, :])
]
self.assertEqual(len(i3), 1)
self.assertNotEqual(i1[0], i2[0])
self.assertNotEqual(i2[0], i3[0])
colors = colors[np.array([i1[0], i2[0], i3[0]])]
outlines = np.zeros((10, 20, 3), np.float32)
alpha = np.zeros((10, 20))
for i, (color, mask) in enumerate(zip(colors, masks)):
my_outline = outline(mask)
outlines[my_outline] += color
alpha[my_outline] += 1
alpha[alpha == 0] = 1
outlines /= alpha[:, :, np.newaxis]
np.testing.assert_almost_equal(outlines, image)
def test_01_00_test_zero_objects(self):
x = YS.IdentifyYeastCells()
x.object_name.value = OBJECTS_NAME
x.segmentation_precision.value = 11
x.input_image_name.value = IMAGE_NAME
x.background_brighter_then_cell_inside.value = False
x.average_cell_diameter.value = 5
img = np.zeros((25, 25))
image = cpi.Image(img, file_name="test_01_00_test_zero_objects")
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.providers.append(cpi.VanillaImageProvider(IMAGE_NAME, image))
object_set = cpo.ObjectSet()
measurements = cpmeas.Measurements()
pipeline = cellprofiler.pipeline.Pipeline()
x.run(Workspace(pipeline, x, image_set, object_set, measurements,
None))
self.assertEqual(len(object_set.object_names), 1)
self.assertTrue(OBJECTS_NAME in object_set.object_names)
objects = object_set.get_objects(OBJECTS_NAME)
segmented = objects.segmented
self.assertTrue(np.all(segmented == 0))
self.assertTrue("Image" in measurements.get_object_names())
self.assertTrue(OBJECTS_NAME in measurements.get_object_names())
self.assertTrue(
"Count_" + OBJECTS_NAME in measurements.get_feature_names("Image"))
count = measurements.get_current_measurement("Image",
"Count_" + OBJECTS_NAME)
self.assertEqual(count, 0)
self.assertTrue("Location_Center_X" in measurements.get_feature_names(
OBJECTS_NAME))
location_center_x = measurements.get_current_measurement(
OBJECTS_NAME, "Location_Center_X")
self.assertTrue(isinstance(location_center_x, np.ndarray))
self.assertEqual(np.product(location_center_x.shape), 0)
self.assertTrue("Location_Center_Y" in measurements.get_feature_names(
OBJECTS_NAME))
location_center_y = measurements.get_current_measurement(
OBJECTS_NAME, "Location_Center_Y")
self.assertTrue(isinstance(location_center_y, np.ndarray))
self.assertEqual(np.product(location_center_y.shape), 0)
def make_obj_workspace(self, ground_truth_obj, id_obj, ground_truth, id):
'''make a workspace to test comparing objects'''
''' ground truth object and ID object are dictionaires w/ the following keys'''
'''i - i component of pixel coordinates
j - j component of pixel coordinates
l - label '''
module = C.CalculateImageOverlap()
module.module_num = 1
module.obj_or_img.value = O_OBJ
module.object_name_GT.value = GROUND_TRUTH_OBJ
module.object_name_ID.value = ID_OBJ
module.wants_emd.value = True
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
pipeline.add_module(module)
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
for name, d in ((GROUND_TRUTH_OBJ_IMAGE_NAME, ground_truth),
(ID_OBJ_IMAGE_NAME, id)):
image = cpi.Image(d["image"],
mask=d.get("mask"),
crop_mask=d.get("crop_mask"))
image_set.add(name, image)
object_set = cpo.ObjectSet()
for name, d in ((GROUND_TRUTH_OBJ, ground_truth_obj), (ID_OBJ,
id_obj)):
object = cpo.Objects()
if d.shape[1] == 3:
object.ijv = d
else:
object.segmented = d
object_set.add_objects(object, name)
workspace = cpw.Workspace(pipeline, module, image_set, object_set,
cpmeas.Measurements(), image_set_list)
return workspace, module
def make_pipeline(self, image, mask, subsample_size, image_sample_size,
element_size, granular_spectrum_length,
labels=None):
'''Make a pipeline with a MeasureGranularity module
image - measure granularity on this image
mask - exclude / include pixels from measurement. None = no mask
subsample_size, etc. - values for corresponding settings in the module
returns tuple of module & workspace
'''
module = M.MeasureGranularity()
module.module_num = 1
image_setting = module.images[0]
# assert isinstance(image_setting, M.MeasureGranularity)
image_setting.image_name.value = IMAGE_NAME
image_setting.subsample_size.value = subsample_size
image_setting.image_sample_size.value = image_sample_size
image_setting.element_size.value = element_size
image_setting.granular_spectrum_length.value = granular_spectrum_length
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
img = cpi.Image(image, mask)
image_set.add(IMAGE_NAME, img)
pipeline = cpp.Pipeline()
def error_callback(event, caller):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(error_callback)
pipeline.add_module(module)
object_set = cpo.ObjectSet()
if labels is not None:
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, OBJECTS_NAME)
image_setting.add_objects()
image_setting.objects[0].objects_name.value = OBJECTS_NAME
workspace = cpw.Workspace(pipeline, module, image_set,
object_set, cpmeas.Measurements(),
image_set_list)
return module, workspace
def make_workspace(self, image, labels, convert=True, mask=None):
'''Make a workspace for testing MeasureTexture'''
module = M.MeasureTexture()
module.image_groups[0].image_name.value = INPUT_IMAGE_NAME
module.object_groups[0].object_name.value = INPUT_OBJECTS_NAME
pipeline = cpp.Pipeline()
object_set = cpo.ObjectSet()
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
workspace = cpw.Workspace(pipeline,
module,
image_set,
object_set,
cpmeas.Measurements(),
image_set_list)
image_set.add(INPUT_IMAGE_NAME, cpi.Image(image, convert=convert,
mask=mask))
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, INPUT_OBJECTS_NAME)
return workspace, module
def make_workspace(self,
image,
size_method,
interpolation,
mask=None,
cropping=None):
module = R.Resize()
module.image_name.value = INPUT_IMAGE_NAME
module.resized_image_name.value = OUTPUT_IMAGE_NAME
module.size_method.value = size_method
module.interpolation.value = interpolation
module.module_num = 1
pipeline = cpp.Pipeline()
pipeline.add_module(module)
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
image = cpi.Image(image, mask, cropping)
image_set.add(INPUT_IMAGE_NAME, image)
workspace = cpw.Workspace(pipeline, module, image_set, cpo.ObjectSet(),
cpmeas.Measurements(), image_set_list)
return workspace, module
def make_workspace(self, labels, pixel_data, mask=None):
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.add(IMAGE_NAME, cpi.Image(pixel_data, mask))
object_set = cpo.ObjectSet()
o = cpo.Objects()
if labels.shape[1] == 3:
o.ijv = labels
else:
o.segmented = labels
object_set.add_objects(o, OBJECT_NAME)
pipeline = P.Pipeline()
module = MOI.MeasureObjectIntensity()
module.images[0].name.value = IMAGE_NAME
module.objects[0].name.value = OBJECT_NAME
module.module_num = 1
pipeline.add_listener(self.error_callback)
pipeline.add_module(module)
workspace = cpw.Workspace(pipeline, module, image_set, object_set,
cpmeas.Measurements(), image_set_list)
return workspace, module
def test_01_02_object_with_cropping(self):
labels = np.zeros((10, 10), int)
labels[0:7, 3:8] = 1
mask = np.zeros((10, 10), bool)
mask[1:9, 1:9] = True
image = cpi.Image(np.zeros((10, 10)), mask=mask)
area_occupied = np.sum(labels[mask])
perimeter = np.sum(outline(np.logical_and(labels, mask)))
total_area = np.sum(mask)
workspace = self.make_workspace(labels, image)
module = workspace.module
module.operands[0].operand_choice.value = "Objects"
module.run(workspace)
m = workspace.measurements
def mn(x):
return "AreaOccupied_%s_%s" % (x, module.operands[0].operand_objects.value)
self.assertEqual(m.get_current_measurement("Image", mn("AreaOccupied")), area_occupied)
self.assertEqual(m.get_current_measurement("Image", mn("Perimeter")), perimeter)
self.assertEqual(m.get_current_measurement("Image", mn("TotalArea")), total_area)
def execute(self,
image,
function,
mask=None,
custom_repeats=None,
scale=None,
module=None):
"""Run the morph module on an input and return the resulting image"""
INPUT_IMAGE_NAME = "input"
OUTPUT_IMAGE_NAME = "output"
if module is None:
module = morph.Morph()
module.functions[0].function.value = function
module.image_name.value = INPUT_IMAGE_NAME
module.output_image_name.value = OUTPUT_IMAGE_NAME
if custom_repeats is None:
module.functions[0].repeats_choice.value = morph.R_ONCE
elif custom_repeats == -1:
module.functions[0].repeats_choice.value = morph.R_FOREVER
else:
module.functions[0].repeats_choice.value = morph.R_CUSTOM
module.functions[0].custom_repeats.value = custom_repeats
if scale is not None:
module.functions[0].scale.value = scale
pipeline = cpp.Pipeline()
object_set = cpo.ObjectSet()
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
workspace = cpw.Workspace(
pipeline,
module,
image_set,
object_set,
cpmeas.Measurements(),
image_set_list,
)
image_set.add(INPUT_IMAGE_NAME, cpi.Image(image, mask=mask))
module.run(workspace)
output = image_set.get_image(OUTPUT_IMAGE_NAME)
return output.pixel_data
def run_classify(self, workspace):
pixels = self.get_5d_image(workspace)
#
# Process the image in chunks
#
with self.get_classifier("r") as c:
assert isinstance(c, PixelClassifier)
class_names = c.get_class_names()
prob_idxs = np.array([
class_names.index(group.class_name.value)
for group in self.outputs
])
chunk_size = 128
prob_maps = np.zeros(
(len(prob_idxs), pixels.shape[3], pixels.shape[4]))
for i in range(0, pixels.shape[3], chunk_size):
iend = min(i + chunk_size, pixels.shape[3])
for j in range(0, pixels.shape[4], chunk_size):
jend = min(j + chunk_size, pixels.shape[4])
ii, jj = [_.flatten() for _ in np.mgrid[i:iend, j:jend]]
coords = np.column_stack(
(np.zeros(len(ii), int), np.zeros(len(ii), int),
np.zeros(len(ii), int), ii, jj))
samples = c.get_samples(pixels, coords)
probs = c.run_final_pipeline(samples)
prob_maps[:, i:iend, j:jend] = \
probs[:, prob_idxs].reshape(
iend - i, jend - j, len(prob_maps)).transpose(2, 0, 1)
for i, group in enumerate(self.outputs):
image_name = group.output_image.value
image = cpi.Image(prob_maps[i])
workspace.image_set.add(image_name, image)
if self.show_window:
workspace.display_data.input_images = [
pixels[i].reshape(*pixels.shape[-2:])
for i in range(pixels.shape[0])
]
workspace.display_data.output_images = [
prob_maps[i] for i in range(len(prob_maps))
]
def test_07_02_cache(self):
import h5py
import os
import tempfile
r = np.random.RandomState()
r.seed(72)
test_cases = ({
"image": r.uniform(size=(10, 20))
}, {
"image": r.uniform(size=(20, 10, 3))
}, {
"image": r.uniform(size=(10, 20)),
"mask": r.uniform(size=(10, 20)) > .5
}, {
"image": r.uniform(size=(10, 20)),
"crop_mask": np.all(np.mgrid[0:10, 0:20] > 3, 0)
})
h, path = tempfile.mkstemp(suffix=".h5")
hdf_file = h5py.File(path, "w")
os.close(h)
for test_case in test_cases:
image = cpi.Image(**test_case)
image.cache("foo", hdf_file)
expected = test_case["image"].astype(np.float32)
np.testing.assert_array_equal(image.pixel_data, expected)
if "mask" in test_case:
np.testing.assert_array_equal(image.mask, test_case["mask"])
else:
np.testing.assert_equal(image.mask, True)
np.testing.assert_equal(tuple(image.mask.shape),
tuple(expected.shape[:2]))
if "crop_mask" in test_case:
np.testing.assert_array_equal(image.crop_mask,
test_case["crop_mask"])
else:
np.testing.assert_equal(tuple(image.crop_mask.shape),
tuple(expected.shape[:2]))
def make_workspace(self, pixels, choices):
"""Make a workspace for running UnmixColors
pixels - input image
choices - a list of choice strings for the images desired
"""
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
module = U.UnmixColors()
module.input_image_name.value = INPUT_IMAGE
module.outputs[0].image_name.value = output_image_name(0)
module.outputs[0].stain_choice.value = choices[0]
for i, choice in enumerate(choices[1:]):
module.add_image()
module.outputs[i + 1].image_name.value = output_image_name(i + 1)
module.outputs[i + 1].stain_choice.value = choice
module.module_num = 1
pipeline.add_module(module)
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
image = cpi.Image(pixels)
image_set.add(INPUT_IMAGE, image)
workspace = cpw.Workspace(
pipeline,
module,
image_set,
cpo.ObjectSet(),
cpmeas.Measurements(),
image_set_list,
)
return workspace, module
def run_image(self, image, workspace):
'''Perform illumination according to the parameters of one image setting group
'''
#
# Get the image names from the settings
#
image_name = image.image_name.value
spill_correct_name = image.spill_correct_function_image_name.value
corrected_image_name = image.corrected_image_name.value
#
# Get images from the image set
#
orig_image = workspace.image_set.get_image(image_name)
spillover_mat = workspace.image_set.get_image(spill_correct_name)
#
# Either divide or subtract the illumination image from the original
#
method = image.spill_correct_method.value
output_pixels = self.compensate_image_ls(orig_image.pixel_data,
spillover_mat.pixel_data,
method)
# Save the output image in the image set and have it inherit
# mask & cropping from the original image.
#
output_image = cpi.Image(output_pixels, parent_image=orig_image)
workspace.image_set.add(corrected_image_name, output_image)
#
# Save images for display
#
if self.show_window:
if not hasattr(workspace.display_data, 'images'):
workspace.display_data.images = {}
workspace.display_data.images[
image_name] = orig_image.pixel_data
workspace.display_data.images[
corrected_image_name] = output_pixels
workspace.display_data.images[
spill_correct_name] = spillover_mat.pixel_data
def test_01_03_combine_channels(self):
np.random.seed(13)
image = np.random.uniform(size=(20, 10, 5))
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.add(IMAGE_NAME, cpi.Image(image))
module = cpm_ctg.ColorToGray()
module.module_num = 1
module.image_name.value = IMAGE_NAME
module.combine_or_split.value = cpm_ctg.COMBINE
module.grayscale_name.value = OUTPUT_IMAGE_F % 1
module.rgb_or_channels.value = cpm_ctg.CH_CHANNELS
module.add_channel()
module.add_channel()
channel_indexes = np.array([2, 0, 3])
factors = np.random.uniform(size=3)
divisor = np.sum(factors)
expected = np.zeros((20, 10))
for i, channel_index in enumerate(channel_indexes):
module.channels[i].channel_choice.value = module.channel_names[channel_index]
module.channels[i].contribution.value_text = "%.10f" % factors[i]
expected += image[:, :, channel_index] * factors[i] / divisor
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
pipeline.add_module(module)
workspace = Workspace(pipeline, module, image_set, cpo.ObjectSet(),
cpm.Measurements(), image_set_list)
module.run(workspace)
pixels = image_set.get_image(module.grayscale_name.value).pixel_data
self.assertEqual(pixels.ndim, 2)
self.assertEqual(tuple(pixels.shape), (20, 10))
np.testing.assert_almost_equal(expected, pixels)
def run(self, workspace):
parent_image = None
parent_image_name = None
imgset = workspace.image_set
stack_pixel_data = None
input_image_names = []
channel_names = []
input_image_names = [sc.image_name.value for sc in self.stack_channels]
channel_names = input_image_names
source_channels = [
imgset.get_image(name, must_be_grayscale=False).pixel_data
for name in input_image_names
]
parent_image = imgset.get_image(input_image_names[0])
for idx, pd in enumerate(source_channels):
if pd.shape[:2] != source_channels[0].shape[:2]:
raise ValueError(
"The %s image and %s image have different sizes (%s vs %s)"
% (self.stack_channels[0].image_name.value,
self.stack_channels[idx].image_name.value,
source_channels[0].shape[:2], pd.pixel_data.shape[:2]))
stack_pixel_data = np.dstack(source_channels)
##############
# Save image #
##############
stack_image = cpi.Image(stack_pixel_data, parent_image=parent_image)
stack_image.channel_names = channel_names
imgset.add(self.stack_image_name.value, stack_image)
##################
# Display images #
##################
if self.show_window:
workspace.display_data.input_image_names = input_image_names
workspace.display_data.stack_pixel_data = stack_pixel_data
workspace.display_data.images = \
[imgset.get_image(name, must_be_grayscale=False).pixel_data
for name in input_image_names]
def make_place_workspace(self, images):
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
module = T.Tile()
module.module_num = 1
module.tile_method.value = T.T_WITHIN_CYCLES
module.output_image.value = OUTPUT_IMAGE_NAME
module.wants_automatic_rows.value = False
module.wants_automatic_columns.value = True
module.rows.value = 1
for i, image in enumerate(images):
image_name = input_image_name(i)
if i == 0:
module.input_image.value = image_name
else:
if len(module.additional_images) <= i:
module.add_image()
module.additional_images[i -
1].input_image_name.value = image_name
image_set.add(image_name, cpi.Image(image))
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
pipeline.add_module(module)
workspace = cpw.Workspace(
pipeline,
module,
image_set,
cpo.ObjectSet(),
cpmeas.Measurements(),
image_set_list,
)
return workspace, module
