def test_3D_perfect_overlap(self):
image_data = numpy.random.rand(10, 100, 100) >= 0.5
workspace, module = self.make_workspace(
ground_truth={
"image": image_data
},
test={
"image": image_data
},
dimensions=3
)
module.run(workspace)
measurements = workspace.measurements
ftr_precision = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_PRECISION)
ftr_precision_measurement = measurements.get_current_image_measurement(ftr_precision)
assert ftr_precision_measurement == 1.0
ftr_true_pos_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_TRUE_POS_RATE)
ftr_true_pos_rate_measurement = measurements.get_current_image_measurement(ftr_true_pos_rate)
assert ftr_true_pos_rate_measurement == 1.0
ftr_false_pos_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_FALSE_POS_RATE)
ftr_false_pos_rate_measurement = measurements.get_current_image_measurement(ftr_false_pos_rate)
assert ftr_false_pos_rate_measurement == 0
ftr_true_neg_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_TRUE_NEG_RATE)
ftr_true_neg_rate_measurement = measurements.get_current_image_measurement(ftr_true_neg_rate)
assert ftr_true_neg_rate_measurement == 1.0
ftr_false_neg_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_FALSE_NEG_RATE)
ftr_false_neg_rate_measurement = measurements.get_current_image_measurement(ftr_false_neg_rate)
assert ftr_false_neg_rate_measurement == 0
ftr_precision = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_PRECISION)
ftr_precision_measurement = measurements.get_current_image_measurement(ftr_precision)
self.assertAlmostEqual(ftr_precision_measurement, 1)
ftr_F_factor = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_F_FACTOR)
ftr_F_factor_measurement = measurements.get_current_image_measurement(ftr_F_factor)
self.assertAlmostEqual(ftr_F_factor_measurement, 1)
ftr_Earth_Movers_Distance = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)
ftr_Earth_Movers_Distance_measurement = measurements.get_current_image_measurement(ftr_Earth_Movers_Distance)
self.assertAlmostEqual(ftr_Earth_Movers_Distance_measurement, 0)
ftr_rand_index = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_RAND_INDEX)
ftr_rand_index_measurement = measurements.get_current_image_measurement(ftr_rand_index)
self.assertAlmostEqual(ftr_rand_index_measurement, 1)
ftr_adj_rand_index = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_ADJUSTED_RAND_INDEX)
ftr_adj_rand_index_measurement = measurements.get_current_image_measurement(ftr_adj_rand_index)
self.assertAlmostEqual(ftr_adj_rand_index_measurement, 1)
def test_05_00_test_measure_overlap_no_objects(self):
# Regression test of issue #934 - no objects
workspace, module = self.make_obj_workspace(
numpy.zeros((0, 3), int),
numpy.zeros((0, 3), int),
dict(image=numpy.zeros((20, 10), bool)),
dict(image=numpy.zeros((20, 10), bool)))
module.run(workspace)
m = workspace.measurements
for feature in cellprofiler.modules.measureimageoverlap.FTR_ALL:
mname = module.measurement_name(feature)
value = m[cellprofiler.measurement.IMAGE, mname, 1]
if feature == cellprofiler.modules.measureimageoverlap.FTR_TRUE_NEG_RATE:
self.assertEqual(value, 1)
elif feature == cellprofiler.modules.measureimageoverlap.FTR_FALSE_POS_RATE:
self.assertEqual(value, 0)
else:
self.assertTrue(
numpy.isnan(value), msg="%s was %f. not nan" % (mname, value))
#
# Make sure they don't crash
#
workspace, module = self.make_obj_workspace(
numpy.zeros((0, 3), int),
numpy.ones((1, 3), int),
dict(image=numpy.zeros((20, 10), bool)),
dict(image=numpy.zeros((20, 10), bool)))
module.run(workspace)
workspace, module = self.make_obj_workspace(
numpy.ones((1, 3), int),
numpy.zeros((0, 3), int),
dict(image=numpy.zeros((20, 10), bool)),
dict(image=numpy.zeros((20, 10), bool)))
module.run(workspace)
def test_03_01_zeros(self):
'''Test ground-truth of zeros and image of zeros'''
workspace, module = self.make_workspace(
dict(image=numpy.ones((20, 10), bool)),
dict(image=numpy.ones((20, 10), bool)))
self.assertTrue(
isinstance(
module,
cellprofiler.modules.measureimageoverlap.MeasureImageOverlap))
module.run(workspace)
measurements = workspace.measurements
self.assertTrue(
isinstance(measurements, cellprofiler.measurement.Measurements))
self.assertEqual(
measurements.get_current_image_measurement(
"Overlap_FalseNegRate_test"), 0)
features = measurements.get_feature_names(
cellprofiler.measurement.IMAGE)
for feature in cellprofiler.modules.measureimageoverlap.FTR_ALL + [
cellprofiler.modules.measureimageoverlap.
FTR_EARTH_MOVERS_DISTANCE
]:
field = '_'.join(
(cellprofiler.modules.measureimageoverlap.C_IMAGE_OVERLAP,
feature, TEST_IMAGE_NAME))
self.assertTrue(field in features, "Missing feature: %s" % feature)
ftr_emd = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)
self.assertEqual(measurements[cellprofiler.measurement.IMAGE, ftr_emd],
0)
def test_zeros():
"""Test ground-truth of zeros and image of zeros"""
workspace, module = make_workspace(dict(image=numpy.ones((20, 10), bool)),
dict(image=numpy.ones((20, 10), bool)))
assert isinstance(
module, cellprofiler.modules.measureimageoverlap.MeasureImageOverlap)
module.run(workspace)
measurements = workspace.measurements
assert isinstance(measurements, cellprofiler.measurement.Measurements)
assert measurements.get_current_image_measurement(
"Overlap_FalseNegRate_test") == 0
features = measurements.get_feature_names(cellprofiler.measurement.IMAGE)
for feature in cellprofiler.modules.measureimageoverlap.FTR_ALL + [
cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE
]:
field = "_".join((
cellprofiler.modules.measureimageoverlap.C_IMAGE_OVERLAP,
feature,
TEST_IMAGE_NAME,
))
assert field in features, "Missing feature: %s" % feature
ftr_emd = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)
assert measurements[cellprofiler.measurement.IMAGE, ftr_emd] == 0
def test_05_00_test_measure_overlap_no_objects(self):
# Regression test of issue #934 - no objects
workspace, module = self.make_obj_workspace(
numpy.zeros((0, 3), int),
numpy.zeros((0, 3), int),
dict(image=numpy.zeros((20, 10), bool)),
dict(image=numpy.zeros((20, 10), bool)))
module.run(workspace)
m = workspace.measurements
for feature in cellprofiler.modules.measureobjectoverlap.FTR_ALL:
mname = module.measurement_name(feature)
value = m[cellprofiler.measurement.IMAGE, mname, 1]
if feature == cellprofiler.modules.measureobjectoverlap.FTR_TRUE_NEG_RATE:
self.assertEqual(value, 1)
elif feature == cellprofiler.modules.measureobjectoverlap.FTR_FALSE_POS_RATE:
self.assertEqual(value, 0)
else:
self.assertTrue(
numpy.isnan(value), msg="%s was %f. not nan" % (mname, value))
#
# Make sure they don't crash
#
workspace, module = self.make_obj_workspace(
numpy.zeros((0, 3), int),
numpy.ones((1, 3), int),
dict(image=numpy.zeros((20, 10), bool)),
dict(image=numpy.zeros((20, 10), bool)))
module.run(workspace)
workspace, module = self.make_obj_workspace(
numpy.ones((1, 3), int),
numpy.zeros((0, 3), int),
dict(image=numpy.zeros((20, 10), bool)),
dict(image=numpy.zeros((20, 10), bool)))
module.run(workspace)
def test_06_04_decimate_k_means(self):
r = numpy.random.RandomState()
r.seed(64)
img = r.uniform(size=(10, 10)) > 0.5
workspace, module = self.make_workspace(dict(image=img),
dict(image=img.transpose()))
#
# Pick a single point for decimation - the emd should be zero
#
module.max_points._Number__minval = 1
module.max_points.value = 1
module.run(workspace)
self.assertEqual(
workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.
measureimageoverlap.
FTR_EARTH_MOVERS_DISTANCE), ],
0,
)
#
# Pick a large number of points to get the real EMD
#
workspace, module = self.make_workspace(dict(image=img),
dict(image=img.transpose()))
module.max_points._Number__minval = 1
module.max_points.value = 100
module.run(workspace)
emd = workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.
FTR_EARTH_MOVERS_DISTANCE), ]
#
# The EMD after decimation is going to be randomly different,
# but not by much.
#
workspace, module = self.make_workspace(dict(image=img),
dict(image=img.transpose()))
module.max_points._Number__minval = 1
module.max_points.value = numpy.sum(img | img.transpose()) / 2
module.run(workspace)
decimated_emd = workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.
FTR_EARTH_MOVERS_DISTANCE), ]
self.assertLess(decimated_emd, emd * 2)
self.assertGreater(decimated_emd, emd / 2)
def test_06_00_no_emd(self):
workspace, module = self.make_workspace(
dict(image=numpy.ones((20, 10), bool)),
dict(image=numpy.ones((20, 10), bool)))
module.wants_emd.value = False
module.run(workspace)
self.assertFalse(workspace.measurements.has_feature(
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)))
def test_06_00_no_emd(self):
workspace, module = self.make_workspace(
dict(image=numpy.ones((20, 10), bool)),
dict(image=numpy.ones((20, 10), bool)))
module.wants_emd.value = False
module.run(workspace)
self.assertFalse(workspace.measurements.has_feature(
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)))
def test_06_04_decimate_k_means(self):
r = numpy.random.RandomState()
r.seed(64)
img = r.uniform(size=(10, 10)) > .5
workspace, module = self.make_workspace(
dict(image=img), dict(image=img.transpose()))
#
# Pick a single point for decimation - the emd should be zero
#
module.max_points._Number__minval = 1
module.max_points.value = 1
module.run(workspace)
self.assertEqual(workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)], 0)
#
# Pick a large number of points to get the real EMD
#
workspace, module = self.make_workspace(
dict(image=img), dict(image=img.transpose()))
module.max_points._Number__minval = 1
module.max_points.value = 100
module.run(workspace)
emd = workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)]
#
# The EMD after decimation is going to be randomly different,
# but not by much.
#
workspace, module = self.make_workspace(
dict(image=img), dict(image=img.transpose()))
module.max_points._Number__minval = 1
module.max_points.value = numpy.sum(img | img.transpose()) / 2
module.run(workspace)
decimated_emd = workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)]
self.assertLess(decimated_emd, emd * 2)
self.assertGreater(decimated_emd, emd / 2)
def test_06_01_one_pixel(self):
#
# The earth movers distance should be sqrt((8-5)**2 + (7 - 3) ** 2) = 5
#
src = numpy.zeros((20, 10), bool)
dest = numpy.zeros((20, 10), bool)
src[5, 3] = True
dest[8, 7] = True
workspace, module = self.make_workspace(
dict(image=src), dict(image=dest))
module.run(workspace)
self.assertEqual(workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)], 5)
def test_06_03_max_distance(self):
src = numpy.zeros((20, 10), bool)
dest = numpy.zeros((20, 10), bool)
src[5, 3] = True
dest[8, 7] = True
src[19, 9] = True
dest[11, 9] = True
workspace, module = self.make_workspace(
dict(image=src), dict(image=dest))
module.max_distance.value = 6
module.run(workspace)
self.assertEqual(workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)], 11)
def test_06_01_one_pixel(self):
#
# The earth movers distance should be sqrt((8-5)**2 + (7 - 3) ** 2) = 5
#
src = numpy.zeros((20, 10), bool)
dest = numpy.zeros((20, 10), bool)
src[5, 3] = True
dest[8, 7] = True
workspace, module = self.make_workspace(
dict(image=src), dict(image=dest))
module.run(workspace)
self.assertEqual(workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)], 5)
def test_06_03_max_distance(self):
src = numpy.zeros((20, 10), bool)
dest = numpy.zeros((20, 10), bool)
src[5, 3] = True
dest[8, 7] = True
src[19, 9] = True
dest[11, 9] = True
workspace, module = self.make_workspace(
dict(image=src), dict(image=dest))
module.max_distance.value = 6
module.run(workspace)
self.assertEqual(workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)], 11)
def test_06_05_decimate_skel(self):
#
# Mostly, this is to check that the skeleton method doesn't crash
#
i, j = numpy.mgrid[0:10, 0:20]
image1 = ((i - 4) ** 2) * 4 + (j - 8) ** 2 < 32
image2 = ((i - 6) ** 2) * 4 + (j - 12) ** 2 < 32
workspace, module = self.make_workspace(
dict(image=image1), dict(image=image2))
module.max_points._Number__minval = 1
module.max_points.value = 5
module.decimation_method.value = cellprofiler.modules.measureimageoverlap.DM_SKEL
module.run(workspace)
emd = workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)]
self.assertGreater(emd, numpy.sum(image1) * 3)
self.assertLess(emd, numpy.sum(image1) * 6)
def test_06_02_missing_penalty(self):
#
# Test that the missing penalty works
#
src = numpy.zeros((20, 10), bool)
dest = numpy.zeros((20, 10), bool)
src[2, 2] = True
dest[2, 2] = True
dest[8, 7] = True
dest[2, 6] = True
workspace, module = self.make_workspace(
dict(image=src), dict(image=dest))
module.penalize_missing.value = True
module.max_distance.value = 8
module.run(workspace)
self.assertEqual(workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)], 16)
def test_06_05_decimate_skel(self):
#
# Mostly, this is to check that the skeleton method doesn't crash
#
i, j = numpy.mgrid[0:10, 0:20]
image1 = ((i - 4) ** 2) * 4 + (j - 8) ** 2 < 32
image2 = ((i - 6) ** 2) * 4 + (j - 12) ** 2 < 32
workspace, module = self.make_workspace(
dict(image=image1), dict(image=image2))
module.max_points._Number__minval = 1
module.max_points.value = 5
module.decimation_method.value = cellprofiler.modules.measureimageoverlap.DM_SKEL
module.run(workspace)
emd = workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)]
self.assertGreater(emd, numpy.sum(image1) * 3)
self.assertLess(emd, numpy.sum(image1) * 6)
def test_06_02_missing_penalty(self):
#
# Test that the missing penalty works
#
src = numpy.zeros((20, 10), bool)
dest = numpy.zeros((20, 10), bool)
src[2, 2] = True
dest[2, 2] = True
dest[8, 7] = True
dest[2, 6] = True
workspace, module = self.make_workspace(
dict(image=src), dict(image=dest))
module.penalize_missing.value = True
module.max_distance.value = 8
module.run(workspace)
self.assertEqual(workspace.measurements[
cellprofiler.measurement.IMAGE,
module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)], 16)
def test_03_01_zeros(self):
'''Test ground-truth of zeros and image of zeros'''
workspace, module = self.make_workspace(
dict(image=numpy.ones((20, 10), bool)),
dict(image=numpy.ones((20, 10), bool)))
self.assertTrue(isinstance(module, cellprofiler.modules.measureimageoverlap.MeasureImageOverlap))
module.run(workspace)
measurements = workspace.measurements
self.assertTrue(isinstance(measurements, cellprofiler.measurement.Measurements))
self.assertEqual(
measurements.get_current_image_measurement("Overlap_FalseNegRate_test"),
0)
features = measurements.get_feature_names(cellprofiler.measurement.IMAGE)
for feature in cellprofiler.modules.measureimageoverlap.FTR_ALL + [cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE]:
field = '_'.join((cellprofiler.modules.measureimageoverlap.C_IMAGE_OVERLAP, feature, TEST_IMAGE_NAME))
self.assertTrue(field in features,
"Missing feature: %s" % feature)
ftr_emd = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)
self.assertEqual(measurements[cellprofiler.measurement.IMAGE, ftr_emd], 0)
def test_3D_no_overlap(self):
ground_truth_image_data = numpy.zeros((10, 100, 100), dtype=numpy.bool_)
ground_truth_image_data[4:6, 30:40, 30:40] = True
ground_truth_image_data[7:10, 50:60, 50:60] = True
test_image_data = numpy.zeros((10, 100, 100), dtype=numpy.bool_)
test_image_data[7:9, 30:40, 30:40] = True
test_image_data[7:10, 70:80, 70:80] = True
workspace, module = self.make_workspace(
ground_truth={
"image": ground_truth_image_data
},
test={
"image": test_image_data
},
dimensions=3
)
module.run(workspace)
measurements = workspace.measurements
ftr_true_pos_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_TRUE_POS_RATE)
ftr_true_pos_rate_measurement = measurements.get_current_image_measurement(ftr_true_pos_rate)
self.assertAlmostEqual(ftr_true_pos_rate_measurement, 0)
ftr_false_pos_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_FALSE_POS_RATE)
ftr_false_pos_rate_measurement = measurements.get_current_image_measurement(ftr_false_pos_rate)
self.assertAlmostEqual(ftr_false_pos_rate_measurement, 0.005025125628141)
ftr_true_neg_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_TRUE_NEG_RATE)
ftr_true_neg_rate_measurement = measurements.get_current_image_measurement(ftr_true_neg_rate)
self.assertAlmostEqual(ftr_true_neg_rate_measurement, 0.994974874371859)
ftr_false_neg_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_FALSE_NEG_RATE)
ftr_false_neg_rate_measurement = measurements.get_current_image_measurement(ftr_false_neg_rate)
self.assertAlmostEqual(ftr_false_neg_rate_measurement,1)
ftr_precision = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_PRECISION)
ftr_precision_measurement = measurements.get_current_image_measurement(ftr_precision)
self.assertAlmostEqual(ftr_precision_measurement,0)
ftr_recall = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_RECALL)
ftr_recall_measurement = measurements.get_current_image_measurement(ftr_recall)
self.assertAlmostEqual(ftr_recall_measurement,0)
ftr_F_factor = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_F_FACTOR)
ftr_F_factor_measurement = measurements.get_current_image_measurement(ftr_F_factor)
self.assertAlmostEqual(ftr_F_factor_measurement, 0)
ftr_Earth_Movers_Distance = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)
ftr_Earth_Movers_Distance_measurement = measurements.get_current_image_measurement(ftr_Earth_Movers_Distance)
self.assertAlmostEqual(ftr_Earth_Movers_Distance_measurement, 52812)
ftr_rand_index = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_RAND_INDEX)
ftr_rand_index_measurement = measurements.get_current_image_measurement(ftr_rand_index)
self.assertAlmostEqual(ftr_rand_index_measurement, 0.980199801998020,2)
ftr_adj_rand_index = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_ADJUSTED_RAND_INDEX)
ftr_adj_rand_index_measurement = measurements.get_current_image_measurement(ftr_adj_rand_index)
self.assertAlmostEqual(ftr_adj_rand_index_measurement, -0.004974470347776,2)
def test_3D_no_overlap(self):
ground_truth_image_data = numpy.zeros((10, 100, 100),
dtype=numpy.bool_)
ground_truth_image_data[4:6, 30:40, 30:40] = True
ground_truth_image_data[7:10, 50:60, 50:60] = True
test_image_data = numpy.zeros((10, 100, 100), dtype=numpy.bool_)
test_image_data[7:9, 30:40, 30:40] = True
test_image_data[7:10, 70:80, 70:80] = True
workspace, module = self.make_workspace(
ground_truth={"image": ground_truth_image_data},
test={"image": test_image_data},
dimensions=3)
module.run(workspace)
measurements = workspace.measurements
ftr_true_pos_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_TRUE_POS_RATE)
ftr_true_pos_rate_measurement = measurements.get_current_image_measurement(
ftr_true_pos_rate)
self.assertAlmostEqual(ftr_true_pos_rate_measurement, 0)
ftr_false_pos_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_FALSE_POS_RATE)
ftr_false_pos_rate_measurement = measurements.get_current_image_measurement(
ftr_false_pos_rate)
self.assertAlmostEqual(ftr_false_pos_rate_measurement,
0.005025125628141)
ftr_true_neg_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_TRUE_NEG_RATE)
ftr_true_neg_rate_measurement = measurements.get_current_image_measurement(
ftr_true_neg_rate)
self.assertAlmostEqual(ftr_true_neg_rate_measurement,
0.994974874371859)
ftr_false_neg_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_FALSE_NEG_RATE)
ftr_false_neg_rate_measurement = measurements.get_current_image_measurement(
ftr_false_neg_rate)
self.assertAlmostEqual(ftr_false_neg_rate_measurement, 1)
ftr_precision = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_PRECISION)
ftr_precision_measurement = measurements.get_current_image_measurement(
ftr_precision)
self.assertAlmostEqual(ftr_precision_measurement, 0)
ftr_recall = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_RECALL)
ftr_recall_measurement = measurements.get_current_image_measurement(
ftr_recall)
self.assertAlmostEqual(ftr_recall_measurement, 0)
ftr_F_factor = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_F_FACTOR)
ftr_F_factor_measurement = measurements.get_current_image_measurement(
ftr_F_factor)
self.assertAlmostEqual(ftr_F_factor_measurement, 0)
ftr_Earth_Movers_Distance = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)
ftr_Earth_Movers_Distance_measurement = measurements.get_current_image_measurement(
ftr_Earth_Movers_Distance)
self.assertAlmostEqual(ftr_Earth_Movers_Distance_measurement, 52812)
ftr_rand_index = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_RAND_INDEX)
ftr_rand_index_measurement = measurements.get_current_image_measurement(
ftr_rand_index)
self.assertAlmostEqual(ftr_rand_index_measurement, 0.980199801998020,
2)
ftr_adj_rand_index = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_ADJUSTED_RAND_INDEX)
ftr_adj_rand_index_measurement = measurements.get_current_image_measurement(
ftr_adj_rand_index)
numpy.testing.assert_almost_equal(ftr_adj_rand_index_measurement, 0, 2)
def test_3D_perfect_overlap(self):
image_data = numpy.random.rand(10, 100, 100) >= 0.5
workspace, module = self.make_workspace(
ground_truth={"image": image_data},
test={"image": image_data},
dimensions=3)
module.run(workspace)
measurements = workspace.measurements
ftr_precision = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_PRECISION)
ftr_precision_measurement = measurements.get_current_image_measurement(
ftr_precision)
assert ftr_precision_measurement == 1.0
ftr_true_pos_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_TRUE_POS_RATE)
ftr_true_pos_rate_measurement = measurements.get_current_image_measurement(
ftr_true_pos_rate)
assert ftr_true_pos_rate_measurement == 1.0
ftr_false_pos_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_FALSE_POS_RATE)
ftr_false_pos_rate_measurement = measurements.get_current_image_measurement(
ftr_false_pos_rate)
assert ftr_false_pos_rate_measurement == 0
ftr_true_neg_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_TRUE_NEG_RATE)
ftr_true_neg_rate_measurement = measurements.get_current_image_measurement(
ftr_true_neg_rate)
assert ftr_true_neg_rate_measurement == 1.0
ftr_false_neg_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_FALSE_NEG_RATE)
ftr_false_neg_rate_measurement = measurements.get_current_image_measurement(
ftr_false_neg_rate)
assert ftr_false_neg_rate_measurement == 0
ftr_precision = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_PRECISION)
ftr_precision_measurement = measurements.get_current_image_measurement(
ftr_precision)
self.assertAlmostEqual(ftr_precision_measurement, 1)
ftr_F_factor = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_F_FACTOR)
ftr_F_factor_measurement = measurements.get_current_image_measurement(
ftr_F_factor)
self.assertAlmostEqual(ftr_F_factor_measurement, 1)
ftr_Earth_Movers_Distance = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)
ftr_Earth_Movers_Distance_measurement = measurements.get_current_image_measurement(
ftr_Earth_Movers_Distance)
self.assertAlmostEqual(ftr_Earth_Movers_Distance_measurement, 0)
ftr_rand_index = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_RAND_INDEX)
ftr_rand_index_measurement = measurements.get_current_image_measurement(
ftr_rand_index)
self.assertAlmostEqual(ftr_rand_index_measurement, 1)
ftr_adj_rand_index = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_ADJUSTED_RAND_INDEX)
ftr_adj_rand_index_measurement = measurements.get_current_image_measurement(
ftr_adj_rand_index)
self.assertAlmostEqual(ftr_adj_rand_index_measurement, 1)
def test_3D_half_overlap():
ground_truth_image_data = numpy.zeros((10, 100, 100), dtype=numpy.bool_)
ground_truth_image_data[2:7, 30:40, 30:40] = True
ground_truth_image_data[8, 10:20, 10:20] = True
ground_truth_image_data[1:5, 50:60, 50:60] = True
test_image_data = numpy.zeros((10, 100, 100), dtype=numpy.bool_)
test_image_data[2:7, 35:45, 30:40] = True
test_image_data[8, 10:20, 15:25] = True
test_image_data[3:7, 50:60, 50:60] = True
workspace, module = make_workspace(
ground_truth={"image": ground_truth_image_data},
test={"image": test_image_data},
dimensions=3,
)
module.run(workspace)
measurements = workspace.measurements
ftr_true_pos_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_TRUE_POS_RATE)
ftr_true_pos_rate_measurement = measurements.get_current_image_measurement(
ftr_true_pos_rate)
assert round(abs(ftr_true_pos_rate_measurement - 0.5), 7) == 0
ftr_false_pos_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_FALSE_POS_RATE)
ftr_false_pos_rate_measurement = measurements.get_current_image_measurement(
ftr_false_pos_rate)
assert round(abs(ftr_false_pos_rate_measurement - 0.005050505), 7) == 0
ftr_true_neg_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_TRUE_NEG_RATE)
ftr_true_neg_rate_measurement = measurements.get_current_image_measurement(
ftr_true_neg_rate)
assert round(abs(ftr_true_neg_rate_measurement - 0.99494949), 7) == 0
ftr_false_neg_rate = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_FALSE_NEG_RATE)
ftr_false_neg_rate_measurement = measurements.get_current_image_measurement(
ftr_false_neg_rate)
assert round(abs(ftr_false_neg_rate_measurement - 0.5), 7) == 0
ftr_precision = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_PRECISION)
ftr_precision_measurement = measurements.get_current_image_measurement(
ftr_precision)
assert round(abs(ftr_precision_measurement - 0.5), 7) == 0
ftr_recall = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_RECALL)
ftr_recall_measurement = measurements.get_current_image_measurement(
ftr_recall)
assert round(abs(ftr_recall_measurement - 0.5), 7) == 0
ftr_F_factor = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_F_FACTOR)
ftr_F_factor_measurement = measurements.get_current_image_measurement(
ftr_F_factor)
assert round(abs(ftr_F_factor_measurement - 0.5), 7) == 0
ftr_Earth_Movers_Distance = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)
ftr_Earth_Movers_Distance_measurement = measurements.get_current_image_measurement(
ftr_Earth_Movers_Distance)
assert round(abs(ftr_Earth_Movers_Distance_measurement - 52921), 7) == 0
ftr_rand_index = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_RAND_INDEX)
ftr_rand_index_measurement = measurements.get_current_image_measurement(
ftr_rand_index)
assert round(abs(ftr_rand_index_measurement - 0.980199801998020), 2) == 0
ftr_adj_rand_index = module.measurement_name(
cellprofiler.modules.measureimageoverlap.FTR_ADJUSTED_RAND_INDEX)
ftr_adj_rand_index_measurement = measurements.get_current_image_measurement(
ftr_adj_rand_index)
numpy.testing.assert_almost_equal(ftr_adj_rand_index_measurement, 0.5, 2)
def test_3D_half_overlap(self):
ground_truth_image_data = numpy.zeros((10, 100, 100), dtype=numpy.bool_)
ground_truth_image_data[2:7, 30:40, 30:40] = True
ground_truth_image_data[8, 10:20, 10:20] = True
ground_truth_image_data[1:5, 50:60, 50:60] = True
test_image_data = numpy.zeros((10, 100, 100), dtype=numpy.bool_)
test_image_data[2:7, 35:45, 30:40] = True
test_image_data[8, 10:20, 15:25] = True
test_image_data[3:7, 50:60, 50:60] = True
workspace, module = self.make_workspace(
ground_truth={
"image": ground_truth_image_data
},
test={
"image": test_image_data
},
dimensions=3
)
module.run(workspace)
measurements = workspace.measurements
ftr_true_pos_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_TRUE_POS_RATE)
ftr_true_pos_rate_measurement = measurements.get_current_image_measurement(ftr_true_pos_rate)
self.assertAlmostEqual(ftr_true_pos_rate_measurement, 0.5)
ftr_false_pos_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_FALSE_POS_RATE)
ftr_false_pos_rate_measurement = measurements.get_current_image_measurement(ftr_false_pos_rate)
self.assertAlmostEqual(ftr_false_pos_rate_measurement, 0.005050505)
ftr_true_neg_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_TRUE_NEG_RATE)
ftr_true_neg_rate_measurement = measurements.get_current_image_measurement(ftr_true_neg_rate)
self.assertAlmostEqual(ftr_true_neg_rate_measurement, 0.99494949)
ftr_false_neg_rate = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_FALSE_NEG_RATE)
ftr_false_neg_rate_measurement = measurements.get_current_image_measurement(ftr_false_neg_rate)
self.assertAlmostEqual(ftr_false_neg_rate_measurement, 0.5)
ftr_precision = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_PRECISION)
ftr_precision_measurement = measurements.get_current_image_measurement(ftr_precision)
self.assertAlmostEqual(ftr_precision_measurement, 0.5)
ftr_recall = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_RECALL)
ftr_recall_measurement = measurements.get_current_image_measurement(ftr_recall)
self.assertAlmostEqual(ftr_recall_measurement, 0.5)
ftr_F_factor = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_F_FACTOR)
ftr_F_factor_measurement = measurements.get_current_image_measurement(ftr_F_factor)
self.assertAlmostEqual(ftr_F_factor_measurement, 0.5)
ftr_Earth_Movers_Distance = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_EARTH_MOVERS_DISTANCE)
ftr_Earth_Movers_Distance_measurement = measurements.get_current_image_measurement(ftr_Earth_Movers_Distance)
self.assertAlmostEqual(ftr_Earth_Movers_Distance_measurement, 52921)
ftr_rand_index = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_RAND_INDEX)
ftr_rand_index_measurement = measurements.get_current_image_measurement(ftr_rand_index)
self.assertAlmostEqual(ftr_rand_index_measurement, 0.980199801998020,2)
ftr_adj_rand_index = module.measurement_name(cellprofiler.modules.measureimageoverlap.FTR_ADJUSTED_RAND_INDEX)
ftr_adj_rand_index_measurement = measurements.get_current_image_measurement(ftr_adj_rand_index)
self.assertAlmostEqual(ftr_adj_rand_index_measurement, 0.489899917362959,2)
