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 test_02_03_prepare_run(self):
# regression test for issue #673 and #1161
#
# If LoadSingleImage appears first, pathname data does not show
# up in the measurements.
#
maybe_download_sbs()
folder = "ExampleSBSImages"
path = os.path.join(example_images_directory(), folder)
filename = "Channel1-01-A-01.tif"
pipeline = cpp.Pipeline()
lsi = L.LoadSingleImage()
lsi.module_num = 1
lsi.directory.dir_choice = cps.ABSOLUTE_FOLDER_NAME
lsi.directory.custom_path = path
lsi.file_settings[0].image_name.value = self.get_image_name(0)
lsi.file_settings[0].file_name.value = filename
pipeline.add_module(lsi)
li = LI.LoadImages()
li.module_num = 2
pipeline.add_module(li)
li.match_method.value = LI.MS_EXACT_MATCH
li.location.dir_choice = cps.ABSOLUTE_FOLDER_NAME
li.location.custom_path = path
li.images[0].common_text.value = "Channel2-"
m = cpmeas.Measurements()
workspace = cpw.Workspace(pipeline, lsi, m, cpo.ObjectSet(), m,
cpi.ImageSetList())
self.assertTrue(pipeline.prepare_run(workspace))
self.assertGreater(m.image_set_count, 1)
pipeline.prepare_group(workspace, {}, m.get_image_numbers())
#
# Skip to the second image set
#
m.next_image_set(2)
lsi.run(workspace)
#
# Are the measurements populated?
#
m_file = "_".join((cpmeas.C_FILE_NAME, self.get_image_name(0)))
self.assertEqual(m[cpmeas.IMAGE, m_file, 2], filename)
#
# Can we retrieve the image?
#
pixel_data = m.get_image(self.get_image_name(0)).pixel_data
self.assertEqual(tuple(pixel_data.shape), (640, 640))
def make_workspace(self, labels, parent_image=None):
object_set = cpo.ObjectSet()
objects = cpo.Objects()
objects.segmented = labels
objects.parent_image = parent_image
object_set.add_objects(objects, OBJECTS_NAME)
pipeline = cpp.Pipeline()
module = mia.MeasureImageAreaOccupied()
module.module_num = 1
module.operands[0].operand_objects.value = OBJECTS_NAME
pipeline.add_module(module)
image_set_list = cpi.ImageSetList()
workspace = cpw.Workspace(pipeline, module,
image_set_list.get_image_set(0), object_set,
cpmm.Measurements(), image_set_list)
return workspace
def test_11_01_load_objects(self):
r = np.random.RandomState()
r.seed(1101)
labels = r.randint(0, 10, size=(30, 20)).astype(np.uint8)
handle, name = tempfile.mkstemp(".png")
fd = os.fdopen(handle, "wb")
img = PIL.Image.fromarray(labels, "L")
img.save(fd, "PNG")
fd.close()
png_path, png_file = os.path.split(name)
sbs_dir = os.path.join(example_images_directory(), "ExampleSBSImages")
csv_text = """%s_%s,%s_%s,%s_DNA,%s_DNA
%s,%s,Channel2-01-A-01.tif,%s
""" % (L.C_OBJECTS_FILE_NAME, OBJECTS_NAME, L.C_OBJECTS_PATH_NAME,
OBJECTS_NAME, L.C_FILE_NAME, L.C_PATH_NAME, png_file, png_path, sbs_dir)
pipeline, module, csv_name = self.make_pipeline(csv_text)
assert isinstance(pipeline, cpp.Pipeline)
assert isinstance(module, L.LoadData)
module.wants_images.value = True
try:
image_set_list = cpi.ImageSetList()
measurements = cpmeas.Measurements()
workspace = cpw.Workspace(pipeline, module, None, None,
measurements, image_set_list)
pipeline.prepare_run(workspace)
key_names, g = pipeline.get_groupings(workspace)
self.assertEqual(len(g), 1)
module.prepare_group(workspace, g[0][0], g[0][1])
image_set = image_set_list.get_image_set(g[0][1][0] - 1)
object_set = cpo.ObjectSet()
workspace = cpw.Workspace(pipeline, module, image_set, object_set,
measurements, image_set_list)
module.run(workspace)
objects = object_set.get_objects(OBJECTS_NAME)
self.assertTrue(np.all(objects.segmented == labels))
self.assertEqual(
measurements.get_current_image_measurement(L.I.FF_COUNT %
OBJECTS_NAME), 9)
for feature in (L.I.M_LOCATION_CENTER_X, L.I.M_LOCATION_CENTER_Y,
L.I.M_NUMBER_OBJECT_NUMBER):
value = measurements.get_current_measurement(
OBJECTS_NAME, feature)
self.assertEqual(len(value), 9)
finally:
os.remove(name)
os.remove(csv_name)
def test_04_03_load_planes(self):
file_name = "RLM1 SSN3 300308 008015000.flex"
maybe_download_test_image(file_name)
path = testimages_directory()
pathname = os.path.join(path, file_name)
url = pathname2url(pathname)
ftrs = (cpmeas.C_URL, cpmeas.C_SERIES, cpmeas.C_FRAME)
channels = ("Channel1", "Channel2")
header = ",".join([
",".join(["_".join((ftr, channel)) for ftr in ftrs])
for channel in channels
])
csv_lines = [header]
for series in range(4):
csv_lines.append(",".join([
'"%s","%d","%d"' % (url, series, frame) for frame in range(2)
]))
csv_text = "\n".join(csv_lines)
pipeline, module, filename = self.make_pipeline(csv_text)
assert isinstance(module, L.LoadData)
m = cpmeas.Measurements()
image_set_list = cpi.ImageSetList()
try:
workspace = cpw.Workspace(pipeline, module, m, None, m,
image_set_list)
self.assertTrue(module.prepare_run(workspace))
pixel_hashes = []
for i in range(4):
m.next_image_set(i + 1)
module.run(workspace)
chashes = []
for channel in channels:
pixel_data = m.get_image(channel).pixel_data
h = hashlib.md5()
h.update(pixel_data)
chashes.append(h.digest())
self.assertNotEqual(chashes[0], chashes[1])
for j, ph in enumerate(pixel_hashes):
for k, phh in enumerate(ph):
for l, phd in enumerate(chashes):
self.assertNotEqual(phh, phd)
pixel_hashes.append(chashes)
finally:
os.remove(filename)
def make_workspace(self,
labels,
image,
mask=None,
intensity_image=None,
wants_graph=False):
m = cpmeas.Measurements()
image_set_list = cpi.ImageSetList()
m.add_measurement(cpmeas.IMAGE, cpmeas.GROUP_NUMBER, 1)
m.add_measurement(cpmeas.IMAGE, cpmeas.GROUP_INDEX, 1)
image_set = m
img = cpi.Image(image, mask)
image_set.add(IMAGE_NAME, img)
object_set = cpo.ObjectSet()
o = cpo.Objects()
o.segmented = labels
object_set.add_objects(o, OBJECT_NAME)
module = M.MeasureNeurons()
module.image_name.value = IMAGE_NAME
module.seed_objects_name.value = OBJECT_NAME
if intensity_image is not None:
img = cpi.Image(intensity_image)
image_set.add(INTENSITY_IMAGE_NAME, img)
module.intensity_image_name.value = INTENSITY_IMAGE_NAME
if wants_graph:
module.wants_neuron_graph.value = True
module.directory.dir_choice = cps.ABSOLUTE_FOLDER_NAME
module.directory.custom_path = self.temp_dir
module.edge_file_name.value = EDGE_FILE
module.vertex_file_name.value = VERTEX_FILE
module.module_num = 1
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, object_set, m,
image_set_list)
return workspace, module
def test_04_02_object_outlines(self):
labels = np.zeros((30, 40), int)
labels[10:15, 20:30] = 1
expected_outlines = labels != 0
expected_outlines[11:14, 21:29] = False
filename = "myobjects.png"
directory = tempfile.mkdtemp()
cpprefs.set_default_image_directory(directory)
pilimage = PIL.Image.fromarray(labels.astype(np.uint8), "L")
pilimage.save(os.path.join(directory, filename))
del pilimage
try:
module = L.LoadSingleImage()
module.module_num = 1
module.directory.set_dir_choice(L.DEFAULT_INPUT_FOLDER_NAME)
fs = module.file_settings[0]
fs.file_name.value = filename
fs.image_objects_choice.value = L.IO_OBJECTS
fs.objects_name.value = OBJECTS_NAME
fs.wants_outlines.value = True
fs.outlines_name.value = OUTLINES_NAME
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
pipeline.add_module(module)
m = cpmeas.Measurements()
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,
m, image_set_list)
module.prepare_run(workspace)
module.run(workspace)
outlines = image_set.get_image(OUTLINES_NAME)
np.testing.assert_equal(outlines.pixel_data, expected_outlines)
finally:
try:
os.remove(os.path.join(directory, filename))
os.rmdir(directory)
except:
print "Failed to delete directory " + directory
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, parents, children, fake_measurement=False):
'''Make a workspace for testing Relate'''
pipeline = cpp.Pipeline()
if fake_measurement:
class FakeModule(cpm.CPModule):
def get_measurement_columns(self, pipeline):
return [(CHILD_OBJECTS, MEASUREMENT, cpmeas.COLTYPE_FLOAT),
(CHILD_OBJECTS, IGNORED_MEASUREMENT, cpmeas.COLTYPE_INTEGER)]
module = FakeModule()
module.module_num = 1
pipeline.add_module(module)
module = R.Relate()
module.parent_name.value = PARENT_OBJECTS
module.sub_object_name.value = CHILD_OBJECTS
module.find_parent_child_distances.value = R.D_NONE
module.module_num = 2 if fake_measurement else 1
pipeline.add_module(module)
object_set = cpo.ObjectSet()
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
m = cpmeas.Measurements()
m.add_image_measurement(cpmeas.GROUP_NUMBER, 1)
m.add_image_measurement(cpmeas.GROUP_INDEX, 1)
workspace = cpw.Workspace(pipeline,
module,
image_set,
object_set,
m,
image_set_list)
o = cpo.Objects()
if parents.shape[1] == 3:
# IJV format
o.ijv = parents
else:
o.segmented = parents
object_set.add_objects(o, PARENT_OBJECTS)
o = cpo.Objects()
if children.shape[1] == 3:
o.ijv = children
else:
o.segmented = children
object_set.add_objects(o, CHILD_OBJECTS)
return workspace, module
def make_workspace(self, labels, contrast_choice,
measurement1=None, measurement2=None):
object_set = cpo.ObjectSet()
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, OBJECTS_NAME)
measurements = cpmeas.Measurements()
module = C.ClassifyObjects()
m_names = []
if measurement1 is not None:
measurements.add_measurement(OBJECTS_NAME, MEASUREMENT_NAME_1,
measurement1)
m_names.append(MEASUREMENT_NAME_1)
if measurement2 is not None:
measurements.add_measurement(OBJECTS_NAME, MEASUREMENT_NAME_2,
measurement2)
module.add_single_measurement()
m_names.append(MEASUREMENT_NAME_2)
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
module.contrast_choice.value = contrast_choice
if module.contrast_choice == C.BY_SINGLE_MEASUREMENT:
for i, m in enumerate(m_names):
group = module.single_measurements[i]
group.object_name.value = OBJECTS_NAME
group.measurement.value = m
group.image_name.value = IMAGE_NAME
else:
module.object_name.value = OBJECTS_NAME
module.image_name.value = IMAGE_NAME
module.first_measurement.value = MEASUREMENT_NAME_1
module.second_measurement.value = MEASUREMENT_NAME_2
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)
workspace = cpw.Workspace(pipeline, module, image_set,
object_set, measurements,
image_set_list)
return workspace, module
def run_module(self,
image,
labels,
center_labels=None,
center_choice=M.C_CENTERS_OF_OTHER,
bin_count=4,
maximum_radius=100,
wants_scaled=True):
'''Run the module, returning the measurements
image - matrix representing the image to be analyzed
labels - labels matrix of objects to be analyzed
center_labels - labels matrix of alternate centers or None for self
centers
bin_count - # of radial bins
'''
module = M.MeasureObjectRadialDistribution()
module.images[0].image_name.value = IMAGE_NAME
module.objects[0].object_name.value = OBJECT_NAME
object_set = cpo.ObjectSet()
main_objects = cpo.Objects()
main_objects.segmented = labels
object_set.add_objects(main_objects, OBJECT_NAME)
if center_labels is None:
module.objects[0].center_choice.value = M.C_SELF
else:
module.objects[0].center_choice.value = center_choice
module.objects[0].center_object_name.value = CENTER_NAME
center_objects = cpo.Objects()
center_objects.segmented = center_labels
object_set.add_objects(center_objects, CENTER_NAME)
module.bin_counts[0].bin_count.value = bin_count
module.bin_counts[0].wants_scaled.value = wants_scaled
module.bin_counts[0].maximum_radius.value = maximum_radius
pipeline = cpp.Pipeline()
measurements = cpmeas.Measurements()
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
img = cpi.Image(image)
image_set.add(IMAGE_NAME, img)
workspace = cpw.Workspace(pipeline, module, image_set, object_set,
measurements, image_set_list)
module.run(workspace)
return measurements
def test_08_01_get_groupings(self):
'''Test the get_groupings method'''
dir = os.path.join(example_images_directory(), "ExampleSBSImages")
pattern = 'Channel1-[0-9]{2}-(?P<ROW>[A-H])-(?P<COL>[0-9]{2})\\.tif'
csv_text = '"Image_FileName_Cytoplasm","Image_PathName_Cytoplasm","Metadata_ROW","Metadata_COL"\n'
for filename in os.listdir(dir):
match = re.match(pattern, filename)
if match:
csv_text += (
'"%s","%s","%s","%s"\n' %
(filename, dir, match.group("ROW"), match.group("COL")))
pipeline, module, filename = self.make_pipeline(csv_text)
self.assertTrue(isinstance(module, L.LoadText))
module.wants_images.value = True
module.wants_image_groupings.value = True
module.metadata_fields.value = "ROW"
image_set_list = cpi.ImageSetList()
measurements = cpmeas.Measurements()
workspace = cpw.Workspace(pipeline, module, None, None, measurements,
image_set_list)
module.prepare_run(workspace)
keys, groupings = module.get_groupings(workspace)
self.assertEqual(len(keys), 1)
self.assertEqual(keys[0], "Metadata_ROW")
self.assertEqual(len(groupings), 8)
my_rows = [g[0]["Metadata_ROW"] for g in groupings]
my_rows.sort()
self.assertEqual(''.join(my_rows), 'ABCDEFGH')
for grouping in groupings:
row = grouping[0]["Metadata_ROW"]
module.prepare_group(
cpw.Workspace(pipeline, module, None, None, measurements,
image_set_list), grouping[0], grouping[1])
for image_number in grouping[1]:
image_set = image_set_list.get_image_set(image_number - 1)
measurements.next_image_set(image_number)
workspace = cpw.Workspace(pipeline, module, image_set,
cpo.ObjectSet(), measurements,
image_set_list)
module.run(workspace)
provider = image_set.get_image_provider("Cytoplasm")
match = re.search(pattern, provider.get_filename())
self.assertTrue(match)
self.assertEqual(row, match.group("ROW"))
def test_01_01_divide(self):
"""Test correction by division"""
np.random.seed(0)
image = np.random.uniform(size=(10,10)).astype(np.float32)
illum = np.random.uniform(size=(10,10)).astype(np.float32)
expected = image / illum
pipeline = cpp.Pipeline()
pipeline.add_listener(self.error_callback)
input_module = inj.InjectImage("InputImage",image)
input_module.module_num = 1
pipeline.add_module(input_module)
illum_module = inj.InjectImage("IllumImage", illum)
illum_module.module_num = 2
pipeline.add_module(illum_module)
module = cpmcia.CorrectIlluminationApply()
module.module_num = 3
pipeline.add_module(module)
image = module.images[0]
image.image_name.value = "InputImage"
image.illum_correct_function_image_name.value = "IllumImage"
image.corrected_image_name.value = "OutputImage"
image.divide_or_subtract.value = cpmcia.DOS_DIVIDE
image.rescale_option = cpmcia.RE_NONE
image_set_list = cpi.ImageSetList()
measurements = cpm.Measurements()
workspace = cpw.Workspace(pipeline, None, None, None,
measurements, image_set_list)
pipeline.prepare_run(workspace)
input_module.prepare_group(workspace, {}, [1])
illum_module.prepare_group(workspace, {}, [1])
module.prepare_group(workspace, {}, [1])
image_set = image_set_list.get_image_set(0)
object_set = cpo.ObjectSet()
workspace = cpw.Workspace(pipeline,
input_module,
image_set,
object_set,
measurements,
image_set_list)
input_module.run(workspace)
illum_module.run(workspace)
module.run(workspace)
output_image = workspace.image_set.get_image("OutputImage")
self.assertTrue(np.all(output_image.pixel_data == expected))
def make_workspace(self, labels):
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
object_set = cpo.ObjectSet()
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, OBJECTS_NAME)
m = cpmeas.Measurements()
module = cpmoas.MeasureObjectAreaShape()
module.module_num = 1
module.object_groups[0].name.value = 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, object_set,
m, image_set_list)
return workspace, module
def make_workspace(self):
module = C.ConvertToImage()
labels = np.reshape(np.arange(256),(16,16))
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)
objects = cpo.Objects()
objects.segmented = labels
object_set.add_objects(objects, OBJECTS_NAME)
module.image_name.value = IMAGE_NAME
module.object_name.value = OBJECTS_NAME
return (workspace,module)
def on_run(self, event):
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
workspace = cpw.Workspace(self.pipeline,
self.module,
image_set,
cpo.ObjectSet(),
self.measurements,
image_set_list,
frame=self)
self.module.show_window = True # to make sure it saves display data
self.module.run_as_data_tool(workspace)
self.measurements.flush()
fig = cpf.create_or_find(parent=self,
title="%s Output" % (self.module.module_name),
name="CellProfiler:DataTool:%s" %
(self.module.module_name))
self.module.display(workspace, fig)
fig.figure.canvas.draw()
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()
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 make_workspace(self, file_names):
module = L.LoadSingleImage()
module.module_num = 1
for i, file_name in enumerate(file_names):
if i > 0:
module.add_file()
module.file_settings[i].image_name.value = self.get_image_name(i)
module.file_settings[i].file_name.value = file_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()
workspace = cpw.Workspace(pipeline, module,
image_set_list.get_image_set(0),
cpo.ObjectSet(), cpmeas.Measurements(),
image_set_list)
return workspace, module
def test_02_02_add_two_image_providers(self):
x = cpi.ImageSetList()
y = x.get_image_set(0)
img1 = cpi.Image(np.ones((10, 10)))
def fn1(image_set, image_provider):
self.assertEquals(y, image_set, "Callback was not called with the correct image set")
return img1
img2 = cpi.Image(np.ones((5, 5)))
def fn2(image_set, image_provider):
self.assertEquals(y, image_set, "Callback was not called with the correct image set")
return img2
y.providers.append(cpi.CallbackImageProvider("IP1", fn1))
y.providers.append(cpi.CallbackImageProvider("IP2", fn2))
self.assertEquals(img1, y.get_image("IP1"), "Failed to get correct first image")
self.assertEquals(img2, y.get_image("IP2"), "Failed to get correct second image")
def test_01_02_run(self):
measurements = cpmeas.Measurements()
image_set_list = cpi.ImageSetList()
workspace = cpw.Workspace(self.pipeline, self.module, None, None,
measurements, image_set_list)
self.assertTrue(self.module.prepare_run(workspace))
for i, expected in enumerate((IMAGE_1, IMAGE_2)):
image_number = i + 1
if hasattr(measurements, "get_image"):
measurements.next_image_set(image_number)
image_set = measurements
else:
image_set = image_set_list.get_image_set(image_number)
workspace = cpw.Workspace(self.pipeline, self.module, image_set,
None, measurements, image_set_list)
self.module.run(workspace)
image = image_set.get_image(IMAGE_NAME)
pixel_data = (image.pixel_data * 255).astype(int)
np.testing.assert_array_equal(pixel_data, expected)
def make_workspace(self, image_set_count):
image_set_list = cpi.ImageSetList()
for i in range(image_set_count):
image_set = image_set_list.get_image_set(i)
module = L.LabelImages()
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
module.module_num = 1
pipeline.add_module(module)
workspace = cpw.Workspace(pipeline, module,
image_set_list.get_image_set(0),
cpo.ObjectSet(), cpmeas.Measurements(),
image_set_list)
return workspace, module
def make_workspace(self, image, mask=None):
'''Make a workspace for testing FindEdges'''
module = F.FindEdges()
module.image_name.value = INPUT_IMAGE_NAME
module.output_image_name.value = OUTPUT_IMAGE_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) if mask is None
else cpi.Image(image,mask))
return workspace, module
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, labels, overlap_choice, masking_objects = None,
masking_image = None, renumber = True,
wants_outlines = False):
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
module.wants_outlines.value = wants_outlines
module.outlines_name.value = OUTPUT_OUTLINES
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_03_02_zernikes_are_different(self):
'''Regression test of IMG-773'''
np.random.seed(32)
labels = np.zeros((40, 20), int)
#
# Make two "objects" composed of random foreground/background
#
labels[1:19,
1:19] = (np.random.uniform(size=(18, 18)) > .5).astype(int)
labels[21:39,
1:19] = (np.random.uniform(size=(18, 18)) > .5).astype(int) * 2
objects = cpo.Objects()
objects.segmented = labels
object_set = cpo.ObjectSet()
object_set.add_objects(objects, "SomeObjects")
module = cpmoas.MeasureObjectAreaShape()
module.object_groups[0].name.value = "SomeObjects"
module.calculate_zernikes.value = True
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)
features = [
x[1] for x in module.get_measurement_columns(pipeline)
if x[0] == "SomeObjects" and x[1].startswith("AreaShape_Zernike")
]
for feature in features:
values = measurements.get_current_measurement(
"SomeObjects", feature)
self.assertEqual(len(values), 2)
self.assertNotEqual(values[0], values[1])
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.img_obj_found_in_GT.value = GROUND_TRUTH_OBJ_IMAGE_NAME
module.object_name_ID.value = ID_OBJ
module.img_obj_found_in_ID.value = ID_OBJ_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()
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 test_02_01_color_by_bw(self):
'''Correct a color image with a black & white illumination fn'''
np.random.seed(0)
image = np.random.uniform(size=(10, 10, 3)).astype(np.float32)
illum = np.random.uniform(size=(10, 10)).astype(np.float32)
expected = image - illum[:, :, np.newaxis]
expected[expected < 0] = 0
pipeline = cpp.Pipeline()
pipeline.add_listener(self.error_callback)
input_module = inj.InjectImage("InputImage", image)
input_module.module_num = 1
pipeline.add_module(input_module)
illum_module = inj.InjectImage("IllumImage", illum)
illum_module.module_num = 2
pipeline.add_module(illum_module)
module = cpmcia.CorrectIlluminationApply()
module.module_num = 3
pipeline.add_module(module)
image = module.images[0]
image.image_name.value = "InputImage"
image.illum_correct_function_image_name.value = "IllumImage"
image.corrected_image_name.value = "OutputImage"
image.divide_or_subtract.value = cpmcia.DOS_SUBTRACT
image.rescale_option = cpmcia.RE_NONE
measurements = cpm.Measurements()
image_set_list = cpi.ImageSetList()
measurements = cpm.Measurements()
workspace = cpw.Workspace(pipeline, None, None, None, measurements,
image_set_list)
pipeline.prepare_run(workspace)
input_module.prepare_group(workspace, {}, [1])
illum_module.prepare_group(workspace, {}, [1])
module.prepare_group(workspace, {}, [1])
image_set = image_set_list.get_image_set(0)
object_set = cpo.ObjectSet()
workspace = cpw.Workspace(pipeline, input_module, image_set,
object_set, measurements, image_set_list)
input_module.run(workspace)
illum_module.run(workspace)
module.run(workspace)
output_image = workspace.image_set.get_image("OutputImage")
self.assertTrue(np.all(output_image.pixel_data == expected))
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 make_workspace(self,
mdict,
controls_measurement,
dose_measurements=[]):
'''Make a workspace and module for running CalculateStatistics
mdict - a two-level dictionary that mimics the measurements structure
for instance:
mdict = { cpmeas.Image: { "M1": [ 1,2,3] }}
for the measurement M1 with values for 3 image sets
controls_measurement - the name of the controls measurement
'''
module = C.CalculateStatistics()
module.module_num = 1
module.grouping_values.value = controls_measurement
pipeline = cpp.Pipeline()
pipeline.add_module(module)
m = cpmeas.Measurements()
nimages = None
for object_name in mdict.keys():
odict = mdict[object_name]
for feature in odict.keys():
m.add_all_measurements(object_name, feature, odict[feature])
if nimages is None:
nimages = len(odict[feature])
else:
self.assertEqual(nimages, len(odict[feature]))
if object_name == cpmeas.IMAGE and feature in dose_measurements:
if len(module.dose_values) > 1:
module.add_dose_value()
dv = module.dose_values[-1]
dv.measurement.value = feature
m.image_set_number = nimages
image_set_list = cpi.ImageSetList()
for i in range(nimages):
image_set = image_set_list.get_image_set(i)
workspace = cpw.Workspace(pipeline, module, image_set, cpo.ObjectSet(),
m, image_set_list)
return workspace, module
def make_workspace(self,
input_pixels,
crop_image = None,
cropping = None,
crop_objects = None ):
"""Return a workspace with the given images installed and the crop module"""
image_set_list = cpi.ImageSetList()
image_set = image_set_list.get_image_set(0)
module = cpmc.Crop()
module.module_num = 1
image_set.add(INPUT_IMAGE, cpi.Image(input_pixels))
module.image_name.value = INPUT_IMAGE
module.cropped_image_name.value = OUTPUT_IMAGE
if crop_image is not None:
image_set.add(CROP_IMAGE, cpi.Image(crop_image))
module.image_mask_source.value = CROP_IMAGE
if cropping is not None:
image_set.add(CROPPING, cpi.Image(np.zeros(cropping.shape),
crop_mask = cropping))
module.cropping_mask_source.value = CROPPING
object_set = cpo.ObjectSet()
if crop_objects is not None:
objects = cpo.Objects()
objects.segmented = crop_objects
object_set.add_objects(objects, CROP_OBJECTS)
pipeline = cpp.Pipeline()
def callback(caller, event):
self.assertFalse(isinstance(event, cpp.RunExceptionEvent))
pipeline.add_listener(callback)
pipeline.add_module(module)
m = cpm.Measurements()
workspace = cpw.Workspace(pipeline,
module,
image_set,
object_set,
m,
image_set_list)
m.add_measurement(cpm.IMAGE, cpm.GROUP_INDEX, 0, image_set_number = 1)
m.add_measurement(cpm.IMAGE, cpm.GROUP_NUMBER, 1, image_set_number = 1)
return workspace, module
