def run_image_set(self,
projection_type,
images_and_masks,
frequency=9,
run_last=True):
image_set_list = cpi.ImageSetList()
image_count = len(images_and_masks)
for i in range(image_count):
pixel_data, mask = images_and_masks[i]
if mask is None:
image = cpi.Image(pixel_data)
else:
image = cpi.Image(pixel_data, mask)
image_set_list.get_image_set(i).add(IMAGE_NAME, image)
#
# Add bogus image at end for 2nd group
#
bogus_image = cpi.Image(np.zeros((10, 20)))
image_set_list.get_image_set(image_count).add(IMAGE_NAME, bogus_image)
pipeline = cpp.Pipeline()
module = M.MakeProjection()
module.module_num = 1
module.image_name.value = IMAGE_NAME
module.projection_image_name.value = PROJECTED_IMAGE_NAME
module.projection_type.value = projection_type
module.frequency.value = frequency
pipeline.add_module(module)
m = cpmeas.Measurements()
workspace = cpw.Workspace(pipeline, module, None, None, m,
image_set_list)
module.prepare_run(workspace)
module.prepare_group(workspace, {}, range(1,
len(images_and_masks) + 1))
for i in range(image_count):
if i > 0:
image_set_list.purge_image_set(i - 1)
w = cpw.Workspace(pipeline,
module, image_set_list.get_image_set(i),
cpo.ObjectSet(), m, image_set_list)
if i < image_count - 1 or run_last:
module.run(w)
module.post_group(w, {})
image = w.image_set.get_image(PROJECTED_IMAGE_NAME)
#
# Make sure that the image provider is reset after prepare_group
#
module.prepare_group(workspace, {}, [image_count + 1])
image_set = image_set_list.get_image_set(image_count)
w = cpw.Workspace(pipeline, module, image_set, cpo.ObjectSet(), m,
image_set_list)
module.run(w)
image_provider = image_set.get_image_provider(PROJECTED_IMAGE_NAME)
self.assertEqual(np.max(image_provider.count), 1)
return image
def test_02_04_mask_input_image(self):
x = YS.IdentifyYeastCells()
x.object_name.value = OBJECTS_NAME
x.input_image_name.value = IMAGE_NAME
x.segmentation_precision.value = 11
x.background_brighter_then_cell_inside.value = False
x.average_cell_diameter.value = 30
img = np.ones((200, 200)) * 0.5
draw_brightfield_cell(img, 100, 100, 20, False)
draw_brightfield_cell(img, 25, 25, 10, False)
img[0:10, 0:10] = 1
img[180:200, 180:200] = 0
msk = np.zeros((200, 200))
msk[0:10, 0:10] = 1
msk[180:200, 180:200] = 1
image = cpi.Image(img, file_name="test_02_04_mask_input_image")
mask = cpi.Image(msk)
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.providers.append(cpi.VanillaImageProvider(IMAGE_NAME, image))
image_set.providers.append(
cpi.VanillaImageProvider(MASK_IMAGE_NAME, mask))
# first try without masking
object_set = cpo.ObjectSet()
measurements = cpmeas.Measurements()
pipeline = cellprofiler.pipeline.Pipeline()
x.run(Workspace(pipeline, x, image_set, object_set, measurements,
None))
objects = object_set.get_objects(OBJECTS_NAME)
self.assertEqual(0, objects.segmented.max(),
"Cells should not be found due to the distractors")
# now if we use masking option we should find these cells
object_set = cpo.ObjectSet()
measurements = cpmeas.Measurements()
pipeline = cellprofiler.pipeline.Pipeline()
x.ignore_mask_image_name.value = MASK_IMAGE_NAME
x.run(Workspace(pipeline, x, image_set, object_set, measurements,
None))
objects = object_set.get_objects(OBJECTS_NAME)
self.assertEqual(objects.segmented[25, 25] > 0, 1,
"The small object was not there")
self.assertEqual(objects.segmented[100, 100] > 0, 1,
"The large object was not there")
def test_01_04_split_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.SPLIT
module.rgb_or_channels.value = cpm_ctg.CH_CHANNELS
module.add_channel()
module.add_channel()
channel_indexes = np.array([1, 4, 2])
for i, channel_index in enumerate(channel_indexes):
module.channels[i].channel_choice.value = module.channel_names[channel_index]
module.channels[i].image_name.value = OUTPUT_IMAGE_F % i
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)
for i, channel_index in enumerate(channel_indexes):
pixels = image_set.get_image(module.channels[i].image_name.value).pixel_data
self.assertEqual(pixels.ndim, 2)
self.assertEqual(tuple(pixels.shape), (20, 10))
np.testing.assert_almost_equal(image[:, :, channel_index], pixels)
def make_workspace(self, file_name):
fd = open(os.path.join(self.path, file_name), 'w')
fd.write("As the poet said, 'Only God can make a tree' -- probably "
"because it's so hard to figure out how to get the "
"bark on.\n-- Woody Allen\n")
fd.close()
module = R.RenameOrRenumberFiles()
module.image_name.value = IMAGE_NAME
module.module_num = 1
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
pipeline.add_module(module)
m = cpmeas.Measurements()
m.add_image_measurement("FileName_%s" % IMAGE_NAME,
file_name)
m.add_image_measurement("PathName_%s" % IMAGE_NAME,
self.path)
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
workspace = cpw.Workspace(pipeline, module, image_set,
cpo.ObjectSet(), m, image_set_list)
return workspace, module
def make_workspace(self, primary_labels, secondary_labels):
"""Make a workspace that has objects for the input labels
returns a workspace with the following
object_set - has object with name "primary" containing
the primary labels
has object with name "secondary" containing
the secondary labels
"""
isl = cpi.ImageSetList()
module = cpmit.IdentifyTertiarySubregion()
module.module_num = 1
module.primary_objects_name.value = PRIMARY
module.secondary_objects_name.value = SECONDARY
module.subregion_objects_name.value = TERTIARY
workspace = cpw.Workspace(cpp.Pipeline(), module, isl.get_image_set(0),
cpo.ObjectSet(), cpm.Measurements(), isl)
workspace.pipeline.add_module(module)
for labels, name in ((primary_labels, PRIMARY), (secondary_labels,
SECONDARY)):
objects = cpo.Objects()
objects.segmented = labels
workspace.object_set.add_objects(objects, name)
return workspace
def test_03_03_color_mask(self):
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, 3)).astype(np.float32)
image_set.add(IMAGE_NAME, cpi.Image(pixel_data))
masking_image = np.random.uniform(size=(10, 15))
image_set.add(MASKING_IMAGE_NAME, cpi.Image(masking_image))
expected_mask = masking_image > .5
pipeline = cpp.Pipeline()
module = M.MaskImage()
module.source_choice.value = M.IO_IMAGE
module.object_name.value = OBJECTS_NAME
module.image_name.value = IMAGE_NAME
module.masking_image_name.value = MASKING_IMAGE_NAME
module.masked_image_name.value = MASKED_IMAGE_NAME
module.invert_mask.value = False
module.module_num = 1
workspace = cpw.Workspace(pipeline, module, image_set, cpo.ObjectSet(),
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[expected_mask, :] == pixel_data[
expected_mask, :]))
self.assertTrue(
np.all(masked_image.pixel_data[~expected_mask, :] == 0))
self.assertTrue(np.all(masked_image.mask == expected_mask))
self.assertFalse(masked_image.has_masking_objects)
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 make_workspace(self, images, masks):
pipeline = cpp.Pipeline()
object_set = cpo.ObjectSet()
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
module = A.Align()
workspace = cpw.Workspace(pipeline,
module,
image_set,
object_set,
cpmeas.Measurements(),
image_set_list)
for index, (pixels, mask) in enumerate(zip(images, masks)):
if mask is None:
image = cpi.Image(pixels)
else:
image = cpi.Image(pixels, mask=mask)
input_name = 'Channel%d' % index
output_name = 'Aligned%d' % index
image_set.add(input_name, image)
if index == 0:
module.first_input_image.value = input_name
module.first_output_image.value = output_name
elif index == 1:
module.second_input_image.value = input_name
module.second_output_image.value = output_name
else:
module.add_image()
ai = module.additional_images[-1]
ai.input_image_name.value = input_name
ai.output_image_name.value = output_name
return workspace, module
def test_04_01_extent(self):
module = cpmoas.MeasureObjectAreaShape()
module.object_groups[0].name.value = "SomeObjects"
module.calculate_zernikes.value = True
object_set = cpo.ObjectSet()
labels = np.zeros((10, 20), int)
# 3/4 of a square is covered
labels[5:7, 5:10] = 1
labels[7:9, 5:15] = 1
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, "SomeObjects")
module.module_num = 1
image_set_list = cpi.ImageSetList()
measurements = cpmeas.Measurements()
pipeline = cpp.Pipeline()
pipeline.add_module(module)
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
workspace = cpw.Workspace(pipeline, module,
image_set_list.get_image_set(0),
object_set, measurements, image_set_list)
module.run(workspace)
values = measurements.get_current_measurement(
"SomeObjects", "_".join((cpmoas.AREA_SHAPE, cpmoas.F_EXTENT)))
self.assertEqual(len(values), 1)
self.assertAlmostEqual(values[0], .75)
def test_13_05_extra_lines_skip_rows(self):
#
# Regression test of issue #1211 - extra line at end / blank lines
# Different code path from 13_04
#
path = os.path.join(example_images_directory(), "ExampleSBSImages")
file_names = ['Channel2-01-A-01.tif', 'Channel2-02-A-02.tif']
csv_text = '''"Image_FileName_DNA","Image_PathName_DNA"
"%s","%s"
"%s","%s"
''' % (file_names[0], path, file_names[1], path)
pipeline, module, filename = self.make_pipeline(csv_text)
try:
assert isinstance(module, L.LoadData)
m = cpmeas.Measurements()
workspace = cpw.Workspace(pipeline, module, m, cpo.ObjectSet(), m,
cpi.ImageSetList())
module.wants_rows.value = True
module.row_range.min = 2
module.row_range.max = 3
self.assertTrue(module.prepare_run(workspace))
self.assertTrue(isinstance(m, cpmeas.Measurements))
self.assertEqual(m.image_set_count, 1)
self.assertTrue(
'FileName_DNA' in m.get_feature_names(cpmeas.IMAGE))
self.assertEqual(m[cpmeas.IMAGE, 'FileName_DNA', 1], file_names[0])
finally:
os.remove(filename)
def test_13_06_load_default_input_folder(self):
# Regression test of issue #1365 - load a file from the default
# input folder and check that PathName_xxx is absolute
csv_text = '''"Image_FileName_DNA","Image_PathName_DNA"\n"%s","%s"''' \
% (self.test_filename, self.test_path)
pipeline, module, filename = self.make_pipeline(csv_text)
try:
assert isinstance(module, L.LoadData)
module.image_directory.dir_choice = cps.ABSOLUTE_FOLDER_NAME
module.image_directory.custom_path = self.test_path
m = cpmeas.Measurements()
workspace = cpw.Workspace(pipeline, module, m, cpo.ObjectSet(), m,
cpi.ImageSetList())
self.assertTrue(module.prepare_run(workspace))
self.assertEqual(
m.get_measurement(cpmeas.IMAGE, "FileName_DNA", 1),
self.test_filename)
path_out = m.get_measurement(cpmeas.IMAGE, "PathName_DNA", 1)
self.assertEqual(self.test_path, path_out)
self.assertEqual(
m.get_measurement(cpmeas.IMAGE, "URL_DNA", 1),
L.pathname2url(os.path.join(self.test_path,
self.test_filename)))
module.prepare_group(workspace, {}, [1])
module.run(workspace)
img = workspace.image_set.get_image("DNA", must_be_grayscale=True)
self.assertEqual(tuple(img.pixel_data.shape), self.test_shape)
finally:
os.remove(filename)
def rruunn(self,
input_labels,
relabel_option,
merge_option=cellprofiler.modules.splitormergeobjects.
UNIFY_DISTANCE,
unify_method=cellprofiler.modules.splitormergeobjects.
UM_DISCONNECTED,
distance_threshold=5,
minimum_intensity_fraction=.9,
where_algorithm=cellprofiler.modules.splitormergeobjects.
CA_CLOSEST_POINT,
image=None,
parent_object="Parent_object",
parents_of=None):
'''Run the SplitOrMergeObjects module
returns the labels matrix and the workspace.
'''
module = cellprofiler.modules.splitormergeobjects.SplitOrMergeObjects()
module.module_num = 1
module.objects_name.value = INPUT_OBJECTS_NAME
module.output_objects_name.value = OUTPUT_OBJECTS_NAME
module.relabel_option.value = relabel_option
module.merge_option.value = merge_option
module.merging_method.value = unify_method
module.parent_object.value = parent_object
module.distance_threshold.value = distance_threshold
module.minimum_intensity_fraction.value = minimum_intensity_fraction
module.wants_image.value = (image is not None)
module.where_algorithm.value = where_algorithm
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)
if image is not None:
img = cpi.Image(image)
image_set.add(IMAGE_NAME, img)
module.image_name.value = IMAGE_NAME
object_set = cpo.ObjectSet()
o = cpo.Objects()
o.segmented = input_labels
object_set.add_objects(o, INPUT_OBJECTS_NAME)
workspace = cpw.Workspace(pipeline, module, image_set, object_set,
cpmeas.Measurements(), image_set_list)
if parents_of is not None:
m = workspace.measurements
ftr = cellprofiler.measurement.FF_PARENT % parent_object
m[INPUT_OBJECTS_NAME, ftr] = parents_of
module.run(workspace)
output_objects = workspace.object_set.get_objects(OUTPUT_OBJECTS_NAME)
return output_objects.segmented, workspace
def test_13_04_extra_lines(self):
#
# Regression test of issue #1211 - extra line at end / blank lines
#
dir = os.path.join(example_images_directory(), "ExampleSBSImages")
file_name = 'Channel2-01-A-01.tif'
csv_text = '''"Image_FileName_DNA","Image_PathName_DNA"
"%s","%s"
''' % (file_name, dir)
pipeline, module, filename = self.make_pipeline(csv_text)
try:
assert isinstance(module, L.LoadData)
m = cpmeas.Measurements()
workspace = cpw.Workspace(pipeline, module, m, cpo.ObjectSet(), m,
cpi.ImageSetList())
self.assertTrue(module.prepare_run(workspace))
self.assertTrue(isinstance(m, cpmeas.Measurements))
self.assertEqual(m.image_set_count, 1)
self.assertTrue(
'FileName_DNA' in m.get_feature_names(cpmeas.IMAGE))
self.assertEqual(m[cpmeas.IMAGE, 'FileName_DNA', 1], file_name)
finally:
os.remove(filename)
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 make_workspace(self, labels, mode, distance=0, neighbors_labels=None):
'''Make a workspace for testing MeasureObjectNeighbors'''
module = M.MeasureObjectNeighbors()
module.module_num = 1
module.object_name.value = OBJECTS_NAME
module.distance_method.value = mode
module.distance.value = distance
pipeline = cpp.Pipeline()
pipeline.add_module(module)
object_set = cpo.ObjectSet()
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
measurements = cpmeas.Measurements()
measurements.group_index = 1
measurements.group_number = 1
workspace = cpw.Workspace(pipeline, module, image_set, object_set,
measurements, image_set_list)
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, OBJECTS_NAME)
if neighbors_labels is None:
module.neighbors_name.value = OBJECTS_NAME
else:
module.neighbors_name.value = NEIGHBORS_NAME
objects = cpo.Objects()
objects.segmented = neighbors_labels
object_set.add_objects(objects, NEIGHBORS_NAME)
return workspace, module
def make_workspace(self, image, outline=None, labels=None):
'''Make a workspace for testing ApplyThreshold'''
m = cpmeas.Measurements()
object_set = cpo.ObjectSet()
module = O.OverlayOutlines()
module.blank_image.value = False
module.image_name.value = INPUT_IMAGE_NAME
module.output_image_name.value = OUTPUT_IMAGE_NAME
if outline is not None:
module.outlines[0].outline_name.value = OUTLINE_NAME
m.add(OUTLINE_NAME, cpi.Image(outline))
module.outlines[0].outline_choice.value = O.FROM_IMAGES
if labels is not None:
objects = cpo.Objects()
if len(labels) > 1:
ijv = np.vstack([
np.column_stack(list(np.where(l > 0)) + [l[l > 0]])
for l in labels
])
objects.set_ijv(ijv, shape=labels[0].shape)
else:
objects.segmented = labels[0]
object_set.add_objects(objects, OBJECTS_NAME)
module.outlines[0].outline_choice.value = O.FROM_OBJECTS
module.outlines[0].objects_name.value = OBJECTS_NAME
pipeline = cpp.Pipeline()
workspace = cpw.Workspace(pipeline, module, m, object_set, m, None)
m.add(INPUT_IMAGE_NAME, cpi.Image(image))
return workspace, module
def test_01_01_combine(self):
img = self.get_my_image()
inj = cpm_inject.InjectImage("my_image", img)
inj.module_num = 1
ctg = cpm_ctg.ColorToGray()
ctg.module_num = 2
ctg.image_name.value = "my_image"
ctg.combine_or_split.value = cpm_ctg.COMBINE
ctg.red_contribution.value = 1
ctg.green_contribution.value = 2
ctg.blue_contribution.value = 3
ctg.grayscale_name.value = "my_grayscale"
pipeline = cpp.Pipeline()
pipeline.add_module(inj)
pipeline.add_module(ctg)
pipeline.test_valid()
measurements = cpm.Measurements()
object_set = cpo.ObjectSet()
image_set_list = cpi.ImageSetList()
workspace = Workspace(pipeline, inj, None, None, measurements,
image_set_list, None)
inj.prepare_run(workspace)
inj.prepare_group(workspace, {}, [1])
image_set = image_set_list.get_image_set(0)
inj.run(Workspace(pipeline, inj, image_set, object_set, measurements, None))
ctg.run(Workspace(pipeline, ctg, image_set, object_set, measurements, None))
grayscale = image_set.get_image("my_grayscale")
self.assertTrue(grayscale)
img = grayscale.image
self.assertAlmostEqual(img[0, 0], 1.0 / 6.0)
self.assertAlmostEqual(img[0, 25], 1.0 / 3.0)
self.assertAlmostEqual(img[25, 0], 1.0 / 2.0)
self.assertAlmostEqual(img[25, 25], 0)
def test_13_01_load_filename(self):
#
# Load a file, only specifying the FileName in the CSV
#
csv_text = '''"Image_FileName_DNA"
"%s"
''' % self.test_filename
pipeline, module, filename = self.make_pipeline(csv_text)
assert isinstance(module, L.LoadData)
module.image_directory.dir_choice = cps.ABSOLUTE_FOLDER_NAME
module.image_directory.custom_path = self.test_path
m = cpmeas.Measurements()
workspace = cpw.Workspace(pipeline, module, m, cpo.ObjectSet(), m,
cpi.ImageSetList())
self.assertTrue(module.prepare_run(workspace))
self.assertEqual(m.get_measurement(cpmeas.IMAGE, "FileName_DNA", 1),
self.test_filename)
path = m.get_measurement(cpmeas.IMAGE, "PathName_DNA", 1)
self.assertEqual(path, self.test_path)
self.assertEqual(
m.get_measurement(cpmeas.IMAGE, "URL_DNA", 1),
L.pathname2url(os.path.join(self.test_path, self.test_filename)))
module.prepare_group(workspace, {}, [1])
module.run(workspace)
img = workspace.image_set.get_image("DNA", must_be_grayscale=True)
self.assertEqual(tuple(img.pixel_data.shape), self.test_shape)
def make_tile_workspace(self, images):
module = T.Tile()
module.module_num = 1
module.tile_method.value = T.T_ACROSS_CYCLES
module.input_image.value = INPUT_IMAGE_NAME
module.output_image.value = OUTPUT_IMAGE_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()
for i, image in enumerate(images):
image_set = image_set_list.get_image_set(i)
image_set.add(INPUT_IMAGE_NAME, cpi.Image(image))
workspace = cpw.Workspace(
pipeline,
module,
image_set_list.get_image_set(0),
cpo.ObjectSet(),
cpmeas.Measurements(),
image_set_list,
)
return workspace, module
def test_13_03_extra_fields(self):
#
# Regression test of issue #853, extra fields
#
csv_text = '''"Image_URL_DNA"
"%(cp_logo_url)s", "foo"
"http:%(cp_logo_url_filename)s"
"bogusurl.png"
''' % globals()
pipeline, module, filename = self.make_pipeline(csv_text)
assert isinstance(module, L.LoadData)
m = cpmeas.Measurements()
workspace = cpw.Workspace(pipeline, module, m, cpo.ObjectSet(), m,
cpi.ImageSetList())
self.assertTrue(module.prepare_run(workspace))
self.assertEqual(m.get_measurement(cpmeas.IMAGE, "FileName_DNA", 1),
cp_logo_url_filename)
path = m.get_measurement(cpmeas.IMAGE, "PathName_DNA", 1)
self.assertEqual(path, cp_logo_url_folder)
self.assertEqual(m.get_measurement(cpmeas.IMAGE, "URL_DNA", 1),
cp_logo_url)
self.assertEqual(m[cpmeas.IMAGE, "FileName_DNA", 2],
cp_logo_url_filename)
self.assertEqual(m[cpmeas.IMAGE, "PathName_DNA", 2], "http:")
self.assertEqual(m[cpmeas.IMAGE, "FileName_DNA", 3], "bogusurl.png")
self.assertEqual(m[cpmeas.IMAGE, "PathName_DNA", 3], "")
module.prepare_group(workspace, {}, [1])
module.run(workspace)
img = workspace.image_set.get_image("DNA", must_be_color=True)
self.assertEqual(tuple(img.pixel_data.shape), cp_logo_url_shape)
def test_03_01_non_contiguous(self):
'''make sure MeasureObjectAreaShape doesn't crash if fed non-contiguous objects'''
module = cpmoas.MeasureObjectAreaShape()
module.object_groups[0].name.value = "SomeObjects"
module.calculate_zernikes.value = True
object_set = cpo.ObjectSet()
labels = np.zeros((10, 20), int)
labels[1:9, 1:5] = 1
labels[4:6, 6:19] = 1
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, "SomeObjects")
module.module_num = 1
image_set_list = cpi.ImageSetList()
measurements = cpmeas.Measurements()
pipeline = cpp.Pipeline()
pipeline.add_module(module)
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
workspace = cpw.Workspace(pipeline, module,
image_set_list.get_image_set(0),
object_set, measurements, image_set_list)
module.run(workspace)
values = measurements.get_current_measurement("SomeObjects",
"AreaShape_Perimeter")
self.assertEqual(len(values), 1)
self.assertEqual(values[0], 54)
def make_workspace(self, pixel_data, mask=None):
image = cpi.Image(pixel_data, mask)
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.add(IMAGE_NAME, image)
module = ID.IdentifyDeadWorms()
module.module_num = 1
module.image_name.value = IMAGE_NAME
module.object_name.value = OBJECTS_NAME
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.LoadExceptionEvent))
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
def test_01_00_zeros(self):
"""Run on an empty labels matrix"""
object_set = cpo.ObjectSet()
labels = np.zeros((10, 20), int)
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, "SomeObjects")
module = cpmoas.MeasureObjectAreaShape()
settings = ["SomeObjects", "Yes"]
module.set_settings_from_values(settings, 1, module.module_class())
module.module_num = 1
image_set_list = cpi.ImageSetList()
measurements = cpmeas.Measurements()
pipeline = cpp.Pipeline()
pipeline.add_module(module)
workspace = cpw.Workspace(pipeline, module,
image_set_list.get_image_set(0),
object_set, measurements, image_set_list)
module.run(workspace)
for f in (cpmoas.F_AREA, cpmoas.F_CENTER_X, cpmoas.F_CENTER_Y,
cpmoas.F_ECCENTRICITY, cpmoas.F_EULER_NUMBER,
cpmoas.F_EXTENT, cpmoas.F_FORM_FACTOR,
cpmoas.F_MAJOR_AXIS_LENGTH, cpmoas.F_MINOR_AXIS_LENGTH,
cpmoas.F_ORIENTATION, cpmoas.F_PERIMETER,
cpmoas.F_SOLIDITY, cpmoas.F_COMPACTNESS,
cpmoas.F_MAXIMUM_RADIUS, cpmoas.F_MEAN_RADIUS,
cpmoas.F_MEDIAN_RADIUS,
cpmoas.F_MIN_FERET_DIAMETER, cpmoas.F_MAX_FERET_DIAMETER):
m = cpmoas.AREA_SHAPE + "_" + f
a = measurements.get_current_measurement('SomeObjects', m)
self.assertEqual(len(a), 0)
def test_04_02_masked_edge(self):
# Regression test of issue #1115
labels = np.zeros((20, 50), int)
labels[15:25, 15:25] = 1
image = np.random.uniform(size=labels.shape).astype(np.float32)
#
# Mask the edge of the object
#
mask = ~cpmo.outline(labels).astype(bool)
m = cpmeas.Measurements()
m.add(IMAGE_NAME, cpi.Image(image, mask=mask))
object_set = cpo.ObjectSet()
o = cpo.Objects()
o.segmented = labels
object_set.add_objects(o, OBJECT_NAME)
pipeline = P.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, P.RunExceptionEvent))
pipeline.add_listener(callback)
module = MOI.MeasureObjectIntensity()
module.module_num = 1
module.images[0].name.value = IMAGE_NAME
module.objects[0].name.value = OBJECT_NAME
pipeline.add_module(module)
workspace = cpw.Workspace(pipeline, module, m, object_set, m, None)
module.run(workspace)
def make_workspace(self, image1, image2, objects=None):
'''Make a workspace for testing Threshold'''
module = M.MeasureColocalization()
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
for image_group, name, image in zip(module.image_groups,
(IMAGE1_NAME, IMAGE2_NAME),
(image1, image2)):
image_group.image_name.value = name
image_set.add(name, image)
object_set = cpo.ObjectSet()
if objects is None:
module.images_or_objects.value = M.M_IMAGES
else:
module.images_or_objects.value = M.M_IMAGES_AND_OBJECTS
module.object_groups[0].object_name.value = OBJECTS_NAME
object_set.add_objects(objects, OBJECTS_NAME)
pipeline = cpp.Pipeline()
workspace = cpw.Workspace(pipeline,
module,
image_set,
object_set,
cpmeas.Measurements(),
image_set_list)
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, e:
logger.warn("Failed to decode message", exc_info=1)
self.raise_cellprofiler_exception(session_id, e.message)
return None, None, None
def test_04_01_wrong_image_size(self):
'''Regression test of IMG-961 - object and image size differ'''
np.random.seed(41)
labels = np.ones((20, 50), int)
image = np.random.uniform(size=(30, 40)).astype(np.float32)
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.add('MyImage', cpi.Image(image))
object_set = cpo.ObjectSet()
o = cpo.Objects()
o.segmented = labels
object_set.add_objects(o, "MyObjects")
pipeline = P.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, P.RunExceptionEvent))
pipeline.add_listener(callback)
module = MOI.MeasureObjectIntensity()
module.module_num = 1
module.images[0].name.value = "MyImage"
module.objects[0].name.value = "MyObjects"
pipeline.add_module(module)
workspace = cpw.Workspace(pipeline, module, image_set, object_set,
cpmeas.Measurements(), image_set_list)
module.run(workspace)
feature_name = '%s_%s_%s' % (MOI.INTENSITY, MOI.INTEGRATED_INTENSITY,
"MyImage")
m = workspace.measurements.get_current_measurement(
"MyObjects", feature_name)
self.assertEqual(len(m), 1)
self.assertAlmostEqual(m[0], np.sum(image[:20, :40]), 4)
def make_workspace(self,
labels,
operation,
iterations=1,
wants_outlines=False,
wants_fill_holes=False):
object_set = cpo.ObjectSet()
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, INPUT_NAME)
module = E.ExpandOrShrink()
module.object_name.value = INPUT_NAME
module.output_object_name.value = OUTPUT_NAME
module.outlines_name.value = OUTLINES_NAME
module.operation.value = operation
module.iterations.value = iterations
module.wants_outlines.value = wants_outlines
module.wants_fill_holes.value = wants_fill_holes
module.module_num = 1
pipeline = cpp.Pipeline()
pipeline.add_module(module)
image_set_list = cpi.ImageSetList()
workspace = cpw.Workspace(pipeline,
module,
image_set_list.get_image_set(0),
object_set,
cpmeas.Measurements(),
image_set_list)
return workspace, module
def make_workspace(self, image, labels):
module = D.DefineGrid()
module.module_num = 1
module.grid_image.value = GRID_NAME
module.manual_image.value = INPUT_IMAGE_NAME
module.display_image_name.value = INPUT_IMAGE_NAME
module.object_name.value = OBJECTS_NAME
module.save_image_name.value = OUTPUT_IMAGE_NAME
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.add(INPUT_IMAGE_NAME, cpi.Image(image))
object_set = cpo.ObjectSet()
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, OBJECTS_NAME)
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.LoadExceptionEvent))
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
pipeline.add_module(module)
measurements = cpmeas.Measurements()
workspace = cpw.Workspace(pipeline, module, image_set, object_set,
measurements, image_set_list)
return workspace, module
def make_workspace(self, gridding, labels=None):
module = I.IdentifyObjectsInGrid()
module.module_num = 1
module.grid_name.value = GRID_NAME
module.output_objects_name.value = OUTPUT_OBJECTS_NAME
module.guiding_object_name.value = GUIDING_OBJECTS_NAME
image_set_list = cpi.ImageSetList()
object_set = cpo.ObjectSet()
if labels is not None:
my_objects = cpo.Objects()
my_objects.segmented = labels
object_set.add_objects(my_objects, GUIDING_OBJECTS_NAME)
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_list.get_image_set(0),
object_set,
cpmeas.Measurements(),
image_set_list,
)
workspace.set_grid(GRID_NAME, gridding)
return workspace, module
