def make_workspace(image,
size_method,
interpolation,
mask=None,
cropping=None,
dimensions=2):
module = cellprofiler.modules.resize.Resize()
module.x_name.value = INPUT_IMAGE_NAME
module.y_name.value = OUTPUT_IMAGE_NAME
module.size_method.value = size_method
module.interpolation.value = interpolation
module.set_module_num(1)
pipeline = cellprofiler_core.pipeline.Pipeline()
pipeline.add_module(module)
image_set_list = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
image = cellprofiler_core.image.Image(image,
mask,
cropping,
dimensions=dimensions)
image_set.add(INPUT_IMAGE_NAME, image)
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set,
cellprofiler_core.object.ObjectSet(),
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
return workspace, module
def test_invert_binary_invert():
#
# Regression for issue #1329
#
r = numpy.random.RandomState()
r.seed(1102)
m = cellprofiler_core.measurement.Measurements()
pixel_data = r.uniform(size=(20, 20)) > 0.5
m.add("inputimage", cellprofiler_core.image.Image(pixel_data))
module = cellprofiler.modules.imagemath.ImageMath()
module.images[0].image_name.value = "inputimage"
module.output_image_name.value = "intermediateimage"
module.operation.value = cellprofiler.modules.imagemath.O_INVERT
module.set_module_num(1)
pipeline = cellprofiler_core.pipeline.Pipeline()
pipeline.add_module(module)
module = cellprofiler.modules.imagemath.ImageMath()
module.images[0].image_name.value = "intermediateimage"
module.output_image_name.value = "outputimage"
module.operation.value = cellprofiler.modules.imagemath.O_INVERT
module.set_module_num(2)
pipeline = cellprofiler_core.pipeline.Pipeline()
workspace = cellprofiler_core.workspace.Workspace(pipeline, module, m,
None, m, None)
for module in pipeline.modules():
module.run(workspace)
numpy.testing.assert_array_equal(
pixel_data,
m.get_image("inputimage").pixel_data > 0.5)
def make_tile_workspace(images):
module = cellprofiler.modules.tile.Tile()
module.set_module_num(1)
module.tile_method.value = cellprofiler.modules.tile.T_ACROSS_CYCLES
module.input_image.value = INPUT_IMAGE_NAME
module.output_image.value = OUTPUT_IMAGE_NAME
pipeline = cellprofiler_core.pipeline.Pipeline()
def callback(caller, event):
assert not isinstance(event, cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
pipeline.add_module(module)
image_set_list = cellprofiler_core.image.ImageSetList()
for i, image in enumerate(images):
image_set = image_set_list.get_image_set(i)
image_set.add(INPUT_IMAGE_NAME, cellprofiler_core.image.Image(image))
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set_list.get_image_set(0),
cellprofiler_core.object.ObjectSet(),
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
return workspace, module
def make_workspace(labels,
operation,
iterations=1,
wants_outlines=False,
wants_fill_holes=False):
object_set = cellprofiler_core.object.ObjectSet()
objects = cellprofiler_core.object.Objects()
objects.segmented = labels
object_set.add_objects(objects, INPUT_NAME)
module = cellprofiler.modules.expandorshrinkobjects.ExpandOrShrink()
module.object_name.value = INPUT_NAME
module.output_object_name.value = OUTPUT_NAME
module.operation.value = operation
module.iterations.value = iterations
module.wants_fill_holes.value = wants_fill_holes
module.set_module_num(1)
pipeline = cellprofiler_core.pipeline.Pipeline()
pipeline.add_module(module)
image_set_list = cellprofiler_core.image.ImageSetList()
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set_list.get_image_set(0),
object_set,
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
return workspace, module
def make_workspace(pixel_data, mask=None):
image = cellprofiler_core.image.Image(pixel_data, mask)
image_set_list = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.add(IMAGE_NAME, image)
module = cellprofiler.modules.identifydeadworms.IdentifyDeadWorms()
module.set_module_num(1)
module.image_name.value = IMAGE_NAME
module.object_name.value = OBJECTS_NAME
pipeline = cellprofiler_core.pipeline.Pipeline()
def callback(caller, event):
assert not isinstance(event, cellprofiler_core.pipeline.event.LoadException)
assert not isinstance(event, cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
pipeline.add_module(module)
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set,
cellprofiler_core.object.ObjectSet(),
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
return workspace, module
def make_workspace(gridding, labels=None):
module = cellprofiler.modules.identifyobjectsingrid.IdentifyObjectsInGrid()
module.set_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 = cellprofiler_core.image.ImageSetList()
object_set = cellprofiler_core.object.ObjectSet()
if labels is not None:
my_objects = cellprofiler_core.object.Objects()
my_objects.segmented = labels
object_set.add_objects(my_objects, GUIDING_OBJECTS_NAME)
pipeline = cellprofiler_core.pipeline.Pipeline()
def callback(caller, event):
assert not isinstance(event, cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
pipeline.add_module(module)
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set_list.get_image_set(0),
object_set,
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
workspace.set_grid(GRID_NAME, gridding)
return workspace, module
def make_workspace(image, labels):
module = cellprofiler.modules.definegrid.DefineGrid()
module.set_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 = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.add(INPUT_IMAGE_NAME, cellprofiler_core.image.Image(image))
object_set = cellprofiler_core.object.ObjectSet()
objects = cellprofiler_core.object.Objects()
objects.segmented = labels
object_set.add_objects(objects, OBJECTS_NAME)
pipeline = cellprofiler_core.pipeline.Pipeline()
def callback(caller, event):
assert not isinstance(event,
cellprofiler_core.pipeline.event.LoadException)
assert not isinstance(event,
cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
pipeline.add_module(module)
measurements = cellprofiler_core.measurement.Measurements()
workspace = cellprofiler_core.workspace.Workspace(pipeline, module,
image_set, object_set,
measurements,
image_set_list)
return workspace, module
def make_workspace(labels, parent_image=None):
object_set = cellprofiler_core.object.ObjectSet()
objects = cellprofiler_core.object.Objects()
objects.segmented = labels
objects.parent_image = parent_image
object_set.add_objects(objects, OBJECTS_NAME)
pipeline = cellprofiler_core.pipeline.Pipeline()
module = cellprofiler.modules.measureimageareaoccupied.MeasureImageAreaOccupied(
)
module.set_module_num(1)
module.operand_choice.value = (
cellprofiler.modules.measureimageareaoccupied.O_OBJECTS)
module.objects_list.value = OBJECTS_NAME
pipeline.add_module(module)
image_set_list = cellprofiler_core.image.ImageSetList()
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set_list.get_image_set(0),
object_set,
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
return workspace
def test_scaling():
"""Test loading an image scaled and unscaled"""
folder = "loaddata"
file_name = "1-162hrh2ax2.tif"
path = tests.modules.make_12_bit_image(folder, file_name, (22, 18))
csv_text = (
"Image_PathName_MyFile,Image_FileName_MyFile\n" "%s,%s\n" % os.path.split(path)
)
c0_image = []
for rescale in (False, True):
pipeline, module, filename = make_pipeline(csv_text)
try:
module.rescale.value = rescale
def callback(workspace):
imgset = workspace.image_set
image = imgset.get_image("MyFile")
pixels = image.pixel_data
c0_image.append(pixels.copy())
c0 = C0()
c0.callback = callback
c0.set_module_num(2)
pipeline.add_module(c0)
pipeline.run()
finally:
os.remove(filename)
unscaled, scaled = c0_image
numpy.testing.assert_almost_equal(unscaled * 65535.0 / 4095.0, scaled)
def test_non_contiguous():
"""make sure MeasureObjectAreaShape doesn't crash if fed non-contiguous objects"""
module = cellprofiler.modules.measureobjectsizeshape.MeasureObjectAreaShape()
module.objects_list.value.append("SomeObjects")
module.calculate_zernikes.value = True
object_set = cellprofiler_core.object.ObjectSet()
labels = numpy.zeros((10, 20), int)
labels[1:9, 1:5] = 1
labels[4:6, 6:19] = 1
objects = cellprofiler_core.object.Objects()
objects.segmented = labels
object_set.add_objects(objects, "SomeObjects")
module.set_module_num(1)
image_set_list = cellprofiler_core.image.ImageSetList()
measurements = cellprofiler_core.measurement.Measurements()
pipeline = cellprofiler_core.pipeline.Pipeline()
pipeline.add_module(module)
def callback(caller, event):
assert not isinstance(event, cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
workspace = cellprofiler_core.workspace.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")
assert len(values) == 1
assert values[0] == 54
def test_dont_load_file():
csv_text = """"Image_FileName_DNA","Image_PathName_DNA"
"%s","%s"
""" % (
test_filename,
test_path,
)
pipeline, module, filename = make_pipeline(csv_text)
c0_ran = [False]
def callback(workspace):
imgset = workspace.image_set
assert len(imgset.names) == 0
c0_ran[0] = True
c0 = C0()
c0.callback = callback
c0.set_module_num(1)
pipeline.add_module(c0)
try:
module.wants_images.value = False
pipeline.run()
assert c0_ran[0]
finally:
os.remove(filename)
def test_load_file():
csv_text = """"Image_FileName_DNA","Image_PathName_DNA"
"%s","%s"
""" % (
test_filename,
test_path,
)
pipeline, module, filename = make_pipeline(csv_text)
c0_ran = [False]
def callback(workspace):
imgset = workspace.image_set
image = imgset.get_image("DNA")
pixels = image.pixel_data
assert pixels.shape[0] == test_shape[0]
c0_ran[0] = True
c0 = C0()
c0.callback = callback
c0.set_module_num(2)
pipeline.add_module(c0)
try:
m = pipeline.run()
assert isinstance(m, cellprofiler_core.measurement.Measurements)
assert c0_ran[0]
hexdigest = m.get_current_image_measurement("MD5Digest_DNA")
assert hexdigest == test_md5
assert "PathName_DNA" in m.get_feature_names(cellprofiler_core.measurement.IMAGE)
assert m.get_current_image_measurement("PathName_DNA") == test_path
assert "FileName_DNA" in m.get_feature_names(cellprofiler_core.measurement.IMAGE)
assert m.get_current_image_measurement("FileName_DNA") == test_filename
finally:
os.remove(filename)
def make_workspace(pixel_data, mask=None, objects=None, dimensions=2):
image_set_list = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
object_set = cellprofiler_core.object.ObjectSet()
image = cellprofiler_core.image.Image(pixel_data, dimensions=dimensions)
if not mask is None:
image.mask = mask
image_set.add(IMAGES_NAME, image)
if not objects is None:
o = cellprofiler_core.object.Objects()
o.segmented = objects
object_set.add_objects(o, OBJECTS_NAME)
module = cellprofiler.modules.measureimagequality.MeasureImageQuality()
module.images_choice.value = cellprofiler.modules.measureimagequality.O_SELECT
module.image_groups[0].include_image_scalings.value = False
module.image_groups[0].image_names.value = IMAGES_NAME
module.image_groups[0].use_all_threshold_methods.value = False
module.set_module_num(1)
pipeline = cellprofiler_core.pipeline.Pipeline()
pipeline.add_module(module)
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set,
object_set,
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
return workspace
def check(module, url, dd, keys=None, xml=None):
"""Check that running the metadata module on a url generates the expected dictionary"""
pipeline = cellprofiler_core.pipeline.Pipeline()
imgs = cellprofiler_core.modules.images.Images()
imgs.filter_choice.value = (
cellprofiler_core.constants.modules.images.FILTER_CHOICE_NONE)
imgs.module_num = 1
pipeline.add_module(imgs)
module.set_module_num(2)
pipeline.add_module(module)
pipeline.add_urls([url])
m = cellprofiler_core.measurement.Measurements()
workspace = cellprofiler_core.workspace.Workspace(pipeline, module, None,
None, m, None)
file_list = workspace.file_list
file_list.add_files_to_filelist([url])
if xml is not None:
file_list.add_metadata(url, xml)
ipds = pipeline.get_image_plane_details(workspace)
assert len(ipds) == len(dd)
for d, ipd in zip(dd, ipds):
assert dict(ipd.metadata, **d) == ipd.metadata
all_keys = list(pipeline.get_available_metadata_keys().keys())
if keys is not None:
for key in keys:
assert key in all_keys
def make_workspace(labels, mode, distance=0, neighbors_labels=None):
"""Make a workspace for testing MeasureObjectNeighbors"""
module = cellprofiler.modules.measureobjectneighbors.MeasureObjectNeighbors(
)
module.set_module_num(1)
module.object_name.value = OBJECTS_NAME
module.distance_method.value = mode
module.distance.value = distance
pipeline = cellprofiler_core.pipeline.Pipeline()
pipeline.add_module(module)
object_set = cellprofiler_core.object.ObjectSet()
image_set_list = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
measurements = cellprofiler_core.measurement.Measurements()
measurements.group_index = 1
measurements.group_number = 1
workspace = cellprofiler_core.workspace.Workspace(pipeline, module,
image_set, object_set,
measurements,
image_set_list)
objects = cellprofiler_core.object.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 = cellprofiler_core.object.Objects()
objects.segmented = neighbors_labels
object_set.add_objects(objects, NEIGHBORS_NAME)
return workspace, module
def run_module(
color_image=None, red_image=None, green_image=None, blue_image=None, fn=None
):
"""Run the InvertForPrinting module
Call this with Numpy arrays for the images and optionally
specify a function (fn) whose argument is an InvertForPrinting module.
You can specialize the module inside this function.
Returns a dictionary of the pixel data of the images in the image set
"""
image_set_list = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
module = cellprofiler.modules.invertforprinting.InvertForPrinting()
module.set_module_num(1)
for image, name, setting, check in (
(color_image, I_COLOR_IN, module.color_input_image, None),
(red_image, I_RED_IN, module.red_input_image, module.wants_red_input),
(green_image, I_GREEN_IN, module.green_input_image, module.wants_green_input),
(blue_image, I_BLUE_IN, module.blue_input_image, module.wants_blue_input),
):
if image is not None:
img = cellprofiler_core.image.Image(image)
image_set.add(name, img)
setting.value = name
if check is not None:
check.value = True
elif check is not None:
check.value = False
for name, setting in (
(I_COLOR_OUT, module.color_output_image),
(I_RED_OUT, module.red_output_image),
(I_GREEN_OUT, module.green_output_image),
(I_BLUE_OUT, module.blue_output_image),
):
setting.value = name
if fn is not None:
fn(module)
pipeline = cellprofiler_core.pipeline.Pipeline()
pipeline.add_module(module)
def callback(caller, event):
assert not isinstance(event, cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set,
cellprofiler_core.object.ObjectSet(),
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
module.run(workspace)
result = {}
for provider in image_set.providers:
result[provider.get_name()] = provider.provide_image(image_set).pixel_data
return result
def make_workspace(self, parents, children, fake_measurement=False):
"""Make a workspace for testing Relate"""
pipeline = cellprofiler_core.pipeline.Pipeline()
if fake_measurement:
class FakeModule(cellprofiler_core.module.Module):
def get_measurement_columns(self, pipeline):
return [
(
CHILD_OBJECTS,
MEASUREMENT,
cellprofiler_core.measurement.COLTYPE_FLOAT,
),
(
CHILD_OBJECTS,
IGNORED_MEASUREMENT,
cellprofiler_core.measurement.COLTYPE_INTEGER,
),
]
module = FakeModule()
module.set_module_num(1)
pipeline.add_module(module)
module = cellprofiler.modules.relateobjects.Relate()
module.x_name.value = PARENT_OBJECTS
module.y_name.value = CHILD_OBJECTS
module.find_parent_child_distances.value = (
cellprofiler.modules.relateobjects.D_NONE
)
module.wants_child_objects_saved.value = False
new_module_num = 2 if fake_measurement else 1
module.set_module_num(new_module_num)
pipeline.add_module(module)
object_set = cellprofiler_core.object.ObjectSet()
image_set_list = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
m = cellprofiler_core.measurement.Measurements()
m.add_image_measurement(cellprofiler_core.measurement.GROUP_NUMBER, 1)
m.add_image_measurement(cellprofiler_core.measurement.GROUP_INDEX, 1)
workspace = cellprofiler_core.workspace.Workspace(
pipeline, module, image_set, object_set, m, image_set_list
)
o = cellprofiler_core.object.Objects()
if parents.shape[1] == 3:
# IJV format
o.ijv = parents
else:
o.segmented = parents
object_set.add_objects(o, PARENT_OBJECTS)
o = cellprofiler_core.object.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(labels,
image,
mask=None,
intensity_image=None,
wants_graph=False):
m = cellprofiler_core.measurement.Measurements()
image_set_list = cellprofiler_core.image.ImageSetList()
m.add_measurement(
cellprofiler_core.measurement.IMAGE,
cellprofiler_core.measurement.GROUP_NUMBER,
1,
)
m.add_measurement(
cellprofiler_core.measurement.IMAGE,
cellprofiler_core.measurement.GROUP_INDEX,
1,
)
image_set = m
img = cellprofiler_core.image.Image(image, mask)
image_set.add(IMAGE_NAME, img)
object_set = cellprofiler_core.object.ObjectSet()
o = cellprofiler_core.object.Objects()
o.segmented = labels
object_set.add_objects(o, OBJECT_NAME)
module = cellprofiler.modules.measureobjectskeleton.MeasureObjectSkeleton()
module.image_name.value = IMAGE_NAME
module.seed_objects_name.value = OBJECT_NAME
if intensity_image is not None:
img = cellprofiler_core.image.Image(intensity_image)
image_set.add(INTENSITY_IMAGE_NAME, img)
module.intensity_image_name.value = INTENSITY_IMAGE_NAME
if wants_graph:
module.wants_objskeleton_graph.value = True
module.directory.dir_choice = cellprofiler_core.setting.ABSOLUTE_FOLDER_NAME
module.directory.custom_path = temp_dir
module.edge_file_name.value = EDGE_FILE
module.vertex_file_name.value = VERTEX_FILE
module.set_module_num(1)
pipeline = cellprofiler_core.pipeline.Pipeline()
def callback(caller, event):
assert not isinstance(event,
cellprofiler_core.pipeline.event.LoadException)
assert not isinstance(event,
cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
pipeline.add_module(module)
workspace = cellprofiler_core.workspace.Workspace(pipeline, module,
image_set, object_set, m,
image_set_list)
return workspace, module
def test_split_all():
img = get_my_image()
inj = cellprofiler_core.modules.injectimage.InjectImage("my_image", img)
inj.set_module_num(1)
ctg = cellprofiler.modules.colortogray.ColorToGray()
ctg.set_module_num(2)
ctg.image_name.value = "my_image"
ctg.combine_or_split.value = cellprofiler.modules.colortogray.SPLIT
ctg.use_red.value = True
ctg.use_blue.value = True
ctg.use_green.value = True
ctg.red_name.value = "my_red"
ctg.green_name.value = "my_green"
ctg.blue_name.value = "my_blue"
pipeline = cellprofiler_core.pipeline.Pipeline()
pipeline.add_module(inj)
pipeline.add_module(ctg)
pipeline.test_valid()
measurements = cellprofiler_core.measurement.Measurements()
object_set = cellprofiler_core.object.ObjectSet()
image_set_list = cellprofiler_core.image.ImageSetList()
workspace = cellprofiler_core.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(
cellprofiler_core.workspace.Workspace(pipeline, inj, image_set,
object_set, measurements, None))
ctg.run(
cellprofiler_core.workspace.Workspace(pipeline, ctg, image_set,
object_set, measurements, None))
red = image_set.get_image("my_red")
assert red
img = red.image
numpy.testing.assert_almost_equal(img[0, 0], 1)
numpy.testing.assert_almost_equal(img[0, 25], 0)
numpy.testing.assert_almost_equal(img[25, 0], 0)
numpy.testing.assert_almost_equal(img[25, 25], 0)
green = image_set.get_image("my_green")
assert green
img = green.image
numpy.testing.assert_almost_equal(img[0, 0], 0)
numpy.testing.assert_almost_equal(img[0, 25], 1)
numpy.testing.assert_almost_equal(img[25, 0], 0)
numpy.testing.assert_almost_equal(img[25, 25], 0)
blue = image_set.get_image("my_blue")
assert blue
img = blue.image
numpy.testing.assert_almost_equal(img[0, 0], 0)
numpy.testing.assert_almost_equal(img[0, 25], 0)
numpy.testing.assert_almost_equal(img[25, 0], 1)
numpy.testing.assert_almost_equal(img[25, 25], 0)
def make_workspace(
labels, overlap_choice, masking_objects=None, masking_image=None, renumber=True
):
module = cellprofiler.modules.maskobjects.MaskObjects()
module.set_module_num(1)
module.object_name.value = INPUT_OBJECTS
module.remaining_objects.value = OUTPUT_OBJECTS
module.mask_choice.value = (
cellprofiler.modules.maskobjects.MC_OBJECTS
if masking_objects is not None
else cellprofiler.modules.maskobjects.MC_IMAGE
)
module.masking_image.value = MASKING_IMAGE
module.masking_objects.value = MASKING_OBJECTS
module.retain_or_renumber.value = (
cellprofiler.modules.maskobjects.R_RENUMBER
if renumber
else cellprofiler.modules.maskobjects.R_RETAIN
)
module.overlap_choice.value = overlap_choice
pipeline = cellprofiler_core.pipeline.Pipeline()
def callback(caller, event):
assert not isinstance(event, cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
pipeline.add_module(module)
object_set = cellprofiler_core.object.ObjectSet()
io = cellprofiler_core.object.Objects()
io.segmented = labels
object_set.add_objects(io, INPUT_OBJECTS)
if masking_objects is not None:
oo = cellprofiler_core.object.Objects()
oo.segmented = masking_objects
object_set.add_objects(oo, MASKING_OBJECTS)
image_set_list = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
if masking_image is not None:
mi = cellprofiler_core.image.Image(masking_image)
image_set.add(MASKING_IMAGE, mi)
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set,
object_set,
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
return workspace, module
def test_images_to_process():
#
# Test MeasureImageQuality.images_to_process on a pipeline with a
# variety of image providers.
#
expected_names = ["foo", "bar"]
pipeline = cellprofiler_core.pipeline.Pipeline()
module1 = cellprofiler_core.modules.namesandtypes.NamesAndTypes()
module1.set_module_num(1)
module1.assignment_method.value = (
cellprofiler_core.modules.namesandtypes.ASSIGN_RULES
)
module1.add_assignment()
module1.add_assignment()
module1.assignments[0].image_name.value = expected_names[0]
module1.assignments[
0
].load_as_choice.value = (
cellprofiler_core.modules.namesandtypes.LOAD_AS_GRAYSCALE_IMAGE
)
#
# TO_DO: issue #652
# This test should fail at some later date when we can detect
# that an illumination function should not be QA measured
#
module1.assignments[1].image_name.value = expected_names[1]
module1.assignments[
1
].load_as_choice.value = (
cellprofiler_core.modules.namesandtypes.LOAD_AS_ILLUMINATION_FUNCTION
)
module1.assignments[
2
].load_as_choice.value = cellprofiler_core.modules.namesandtypes.LOAD_AS_OBJECTS
pipeline.add_module(module1)
module2 = cellprofiler.modules.smooth.Smooth()
module2.set_module_num(2)
module2.image_name.value = expected_names[0]
module2.filtered_image_name.value = "henry"
pipeline.add_module(module2)
miq_module = cellprofiler.modules.measureimagequality.MeasureImageQuality()
miq_module.set_module_num(3)
miq_module.images_choice.value = (
cellprofiler.modules.measureimagequality.O_ALL_LOADED
)
image_names = miq_module.images_to_process(
miq_module.image_groups[0], None, pipeline
)
assert len(image_names) == len(expected_names)
for image_name in image_names:
assert image_name in expected_names
def make_workspace(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 = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
module = cellprofiler.modules.crop.Crop()
module.set_module_num(1)
image_set.add(INPUT_IMAGE, cellprofiler_core.image.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, cellprofiler_core.image.Image(crop_image))
module.image_mask_source.value = CROP_IMAGE
if cropping is not None:
image_set.add(
CROPPING,
cellprofiler_core.image.Image(numpy.zeros(cropping.shape),
crop_mask=cropping),
)
module.cropping_mask_source.value = CROPPING
object_set = cellprofiler_core.object.ObjectSet()
if crop_objects is not None:
objects = cellprofiler_core.object.Objects()
objects.segmented = crop_objects
object_set.add_objects(objects, CROP_OBJECTS)
pipeline = cellprofiler_core.pipeline.Pipeline()
def callback(caller, event):
assert not isinstance(event,
cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
pipeline.add_module(module)
m = cellprofiler_core.measurement.Measurements()
workspace = cellprofiler_core.workspace.Workspace(pipeline, module,
image_set, object_set, m,
image_set_list)
m.add_measurement(
cellprofiler_core.measurement.IMAGE,
cellprofiler_core.measurement.GROUP_INDEX,
0,
image_set_number=1,
)
m.add_measurement(
cellprofiler_core.measurement.IMAGE,
cellprofiler_core.measurement.GROUP_NUMBER,
1,
image_set_number=1,
)
return workspace, module
def make_pipeline(
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 = cellprofiler.modules.measuregranularity.MeasureGranularity()
module.set_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 = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
img = cellprofiler_core.image.Image(image, mask)
image_set.add(IMAGE_NAME, img)
pipeline = cellprofiler_core.pipeline.Pipeline()
def error_callback(event, caller):
assert not isinstance(event, cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(error_callback)
pipeline.add_module(module)
object_set = cellprofiler_core.object.ObjectSet()
if labels is not None:
objects = cellprofiler_core.object.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 = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set,
object_set,
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
return module, workspace
def make_workspace(labels,
contrast_choice,
measurement1=None,
measurement2=None):
object_set = cellprofiler_core.object.ObjectSet()
objects = cellprofiler_core.object.Objects()
objects.segmented = labels
object_set.add_objects(objects, OBJECTS_NAME)
measurements = cellprofiler_core.measurement.Measurements()
module = cellprofiler.modules.classifyobjects.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 = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
module.contrast_choice.value = contrast_choice
if (module.contrast_choice ==
cellprofiler.modules.classifyobjects.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.set_module_num(1)
pipeline = cellprofiler_core.pipeline.Pipeline()
def callback(caller, event):
assert not isinstance(event,
cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
pipeline.add_module(module)
workspace = cellprofiler_core.workspace.Workspace(pipeline, module,
image_set, object_set,
measurements,
image_set_list)
return workspace, module
def test_zeros():
"""Run on an empty labels matrix"""
object_set = cellprofiler_core.object.ObjectSet()
labels = numpy.zeros((10, 20), int)
objects = cellprofiler_core.object.Objects()
objects.segmented = labels
object_set.add_objects(objects, "SomeObjects")
module = cellprofiler.modules.measureobjectsizeshape.MeasureObjectAreaShape(
)
settings = ["SomeObjects", "Yes"]
module.set_settings_from_values(settings, 1, module.module_class())
module.set_module_num(1)
image_set_list = cellprofiler_core.image.ImageSetList()
measurements = cellprofiler_core.measurement.Measurements()
pipeline = cellprofiler_core.pipeline.Pipeline()
pipeline.add_module(module)
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set_list.get_image_set(0),
object_set,
measurements,
image_set_list,
)
module.run(workspace)
for f in (
cellprofiler.modules.measureobjectsizeshape.F_AREA,
cellprofiler.modules.measureobjectsizeshape.F_CENTER_X,
cellprofiler.modules.measureobjectsizeshape.F_CENTER_Y,
cellprofiler.modules.measureobjectsizeshape.F_ECCENTRICITY,
cellprofiler.modules.measureobjectsizeshape.F_EULER_NUMBER,
cellprofiler.modules.measureobjectsizeshape.F_EXTENT,
cellprofiler.modules.measureobjectsizeshape.F_FORM_FACTOR,
cellprofiler.modules.measureobjectsizeshape.F_MAJOR_AXIS_LENGTH,
cellprofiler.modules.measureobjectsizeshape.F_MINOR_AXIS_LENGTH,
cellprofiler.modules.measureobjectsizeshape.F_ORIENTATION,
cellprofiler.modules.measureobjectsizeshape.F_PERIMETER,
cellprofiler.modules.measureobjectsizeshape.F_SOLIDITY,
cellprofiler.modules.measureobjectsizeshape.F_COMPACTNESS,
cellprofiler.modules.measureobjectsizeshape.F_MAXIMUM_RADIUS,
cellprofiler.modules.measureobjectsizeshape.F_MEAN_RADIUS,
cellprofiler.modules.measureobjectsizeshape.F_MEDIAN_RADIUS,
cellprofiler.modules.measureobjectsizeshape.F_MIN_FERET_DIAMETER,
cellprofiler.modules.measureobjectsizeshape.F_MAX_FERET_DIAMETER,
):
m = cellprofiler.modules.measureobjectsizeshape.AREA_SHAPE + "_" + f
a = measurements.get_current_measurement("SomeObjects", m)
assert len(a) == 0
def check(self, module, url, expected):
"""Check filtering of one URL using the module as configured"""
pipeline = cellprofiler_core.pipeline.Pipeline()
pipeline.add_urls([url])
module.set_module_num(1)
pipeline.add_module(module)
m = cellprofiler_core.measurement.Measurements()
workspace = cellprofiler_core.workspace.Workspace(
pipeline, module, None, None, m, None)
file_list = pipeline.get_filtered_file_list(workspace)
if expected:
assert len(file_list) == 1
assert file_list[0] == url
else:
assert len(file_list) == 0
def test_zernikes_are_different():
"""Regression test of IMG-773"""
numpy.random.seed(32)
labels = numpy.zeros((40, 20), int)
#
# Make two "objects" composed of random foreground/background
#
labels[1:19,
1:19] = (numpy.random.uniform(size=(18, 18)) > 0.5).astype(int)
labels[21:39,
1:19] = (numpy.random.uniform(size=(18, 18)) > 0.5).astype(int) * 2
objects = cellprofiler_core.object.Objects()
objects.segmented = labels
object_set = cellprofiler_core.object.ObjectSet()
object_set.add_objects(objects, "SomeObjects")
module = cellprofiler.modules.measureobjectsizeshape.MeasureObjectAreaShape(
)
module.objects_list.value.append("SomeObjects")
module.calculate_zernikes.value = True
module.set_module_num(1)
image_set_list = cellprofiler_core.image.ImageSetList()
measurements = cellprofiler_core.measurement.Measurements()
pipeline = cellprofiler_core.pipeline.Pipeline()
pipeline.add_module(module)
def callback(caller, event):
assert not isinstance(event,
cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
workspace = cellprofiler_core.workspace.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)
assert len(values) == 2
assert values[0] != values[1]
def make_workspace(ground_truth, test, dimensions=2):
"""Make a workspace with a ground-truth image and a test image
ground_truth and test are dictionaries with the following keys:
image - the pixel data
mask - (optional) the mask data
crop_mask - (optional) a cropping mask
returns a workspace and module
"""
module = cellprofiler.modules.measureimageoverlap.MeasureImageOverlap()
module.set_module_num(1)
module.ground_truth.value = GROUND_TRUTH_IMAGE_NAME
module.test_img.value = TEST_IMAGE_NAME
module.wants_emd.value = True
pipeline = cellprofiler_core.pipeline.Pipeline()
def callback(caller, event):
assert not isinstance(event,
cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
pipeline.add_module(module)
image_set_list = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
for name, d in ((GROUND_TRUTH_IMAGE_NAME, ground_truth), (TEST_IMAGE_NAME,
test)):
image = cellprofiler_core.image.Image(
d["image"],
mask=d.get("mask"),
crop_mask=d.get("crop_mask"),
dimensions=dimensions,
)
image_set.add(name, image)
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set,
cellprofiler_core.object.ObjectSet(),
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
return workspace, module
def make_obj_workspace(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 = cellprofiler.modules.measureobjectoverlap.MeasureObjectOverlap()
module.set_module_num(1)
module.object_name_GT.value = GROUND_TRUTH_OBJ
module.object_name_ID.value = ID_OBJ
module.wants_emd.value = True
pipeline = cellprofiler_core.pipeline.Pipeline()
def callback(caller, event):
assert not isinstance(event, cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
pipeline.add_module(module)
image_set_list = cellprofiler_core.image.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 = cellprofiler_core.image.Image(
d["image"], mask=d.get("mask"), crop_mask=d.get("crop_mask")
)
image_set.add(name, image)
object_set = cellprofiler_core.object.ObjectSet()
for name, d in ((GROUND_TRUTH_OBJ, ground_truth_obj), (ID_OBJ, id_obj)):
object = cellprofiler_core.object.Objects()
if d.shape[1] == 3:
object.ijv = d
else:
object.segmented = d
object_set.add_objects(object, name)
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set,
object_set,
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
return workspace, module
def test_combine_channels():
numpy.random.seed(13)
image = numpy.random.uniform(size=(20, 10, 5))
image_set_list = cellprofiler_core.image.ImageSetList()
image_set = image_set_list.get_image_set(0)
image_set.add(IMAGE_NAME, cellprofiler_core.image.Image(image))
module = cellprofiler.modules.colortogray.ColorToGray()
module.set_module_num(1)
module.image_name.value = IMAGE_NAME
module.combine_or_split.value = cellprofiler.modules.colortogray.COMBINE
module.grayscale_name.value = OUTPUT_IMAGE_F % 1
module.rgb_or_channels.value = cellprofiler.modules.colortogray.CH_CHANNELS
module.add_channel()
module.add_channel()
channel_indexes = numpy.array([2, 0, 3])
factors = numpy.random.uniform(size=3)
divisor = numpy.sum(factors)
expected = numpy.zeros((20, 10))
for i, channel_index in enumerate(channel_indexes):
module.channels[i].channel_choice.value = channel_index + 1
module.channels[i].contribution.value_text = "%.10f" % factors[i]
expected += image[:, :, channel_index] * factors[i] / divisor
pipeline = cellprofiler_core.pipeline.Pipeline()
def callback(caller, event):
assert not isinstance(event,
cellprofiler_core.pipeline.event.RunException)
pipeline.add_listener(callback)
pipeline.add_module(module)
workspace = cellprofiler_core.workspace.Workspace(
pipeline,
module,
image_set,
cellprofiler_core.object.ObjectSet(),
cellprofiler_core.measurement.Measurements(),
image_set_list,
)
module.run(workspace)
pixels = image_set.get_image(module.grayscale_name.value).pixel_data
assert pixels.ndim == 2
assert tuple(pixels.shape) == (20, 10)
numpy.testing.assert_almost_equal(expected, pixels)
