def test_encode_decode_auto_params(self):
parameters = params_util.default_parameters(10, 30)
encoded = "[[1.31, 6.2, -8.3, 4.4000000000000004], [4.1, 2.88, 773.3, 14, -34]]"
self.assertEqual(True, Segmentation.decode_auto_params_into(parameters, encoded))
encoded_back = Segmentation.encode_auto_params_from_all_params(parameters)
self.assertEqual(encoded, encoded_back)
def test_encode_auto_params(self):
parameters = params_util.default_parameters(10, 30)
star_parameters = parameters['segmentation']['stars']
star_parameters['brightnessWeight'] = 1.1
star_parameters['cumBrightnessWeight'] = 2.2
star_parameters['gradientWeight'] = 3.3
star_parameters['sizeWeight'] = 4.4
rank_parameters = parameters['segmentation']['ranking']
rank_parameters['avgBorderBrightnessWeight'] = 11.1
rank_parameters['avgInnerBrightnessWeight'] = 12.2
rank_parameters['avgInnerDarknessWeight'] = 13.3
rank_parameters['logAreaBonus'] = 14.4
rank_parameters['maxInnerBrightnessWeight'] = 15.5
encoded = Segmentation.encode_auto_params_from_all_params(parameters)
self.assertEqual(
"[[1.1, 2.2, 3.3, 4.4000000000000004], [11.1, 12.2, 13.3, 14.4, 15.5]]",
encoded)
# check list size weight
star_parameters['sizeWeight'] = [2, 5, 11]
encoded2 = Segmentation.encode_auto_params_from_all_params(parameters)
self.assertEqual(
"[[1.1, 2.2, 3.3, 6.0], [11.1, 12.2, 13.3, 14.4, 15.5]]", encoded2)
def test_no_objects(self):
img = prepare_image((50, 50))
cellstar = Segmentation(9, 10)
cellstar.set_frame(img)
segmentation, snakes = cellstar.run_segmentation()
self.assertEqual(0, segmentation.max())
self.assertEqual(0, len(snakes))
def test_encode_decode_auto_params(self):
parameters = params_util.default_parameters(10, 30)
encoded = "[[1.31, 6.2, -8.3, 4.4000000000000004], [4.1, 2.88, 773.3, 14, -34]]"
self.assertEqual(
True, Segmentation.decode_auto_params_into(parameters, encoded))
encoded_back = Segmentation.encode_auto_params_from_all_params(
parameters)
self.assertEqual(encoded, encoded_back)
def test_multiple_objects(self):
img = prepare_image((50, 50))
draw_cell(img, (10, 10), 6)
draw_cell(img, (30, 15), 8)
cellstar = Segmentation(9, 10)
cellstar.set_frame(img)
segmentation, snakes = cellstar.run_segmentation()
self.assertEqual(2, segmentation.max())
self.assertEqual(2, len(snakes))
def test_decode_auto_params_invalid(self):
parameters = params_util.default_parameters(10, 30)
encoded_params_invalid = "[[11.1, 12.2, 13.3, 14.4, 15.5], [1.1, 2.2, 3.3, 4.4]]"
self.assertEqual(
False,
Segmentation.decode_auto_params_into(parameters,
encoded_params_invalid))
def test_contour_fitting(self):
process.SEARCH_LENGTH_NORMAL = 20
img = prepare_image((80, 80))
gt = np.zeros((80,80), dtype=int)
draw_weak_cell(img, (60, 20), 12)
draw_disc(gt, (60, 20), 14, 1)
draw_weak_cell(img, (40, 25), 8)
draw_disc(gt, (40, 25), 8, 2)
draw_weak_cell(img, (30, 40), 9)
draw_disc(gt, (30, 40), 9, 3)
img = finish_image(img)
cellstar = Segmentation(11, 20)
# break parameters
weights = cellstar.parameters["segmentation"]["stars"]["sizeWeight"]
encoded = params.pf_parameters_encode(cellstar.parameters)
one_params = [0.5 for k in encoded]
one_params[3] = 0.001
one_decoded = params.pf_parameters_decode(one_params, weights)
broken_params = PFSnake.merge_parameters(cellstar.parameters, one_decoded)
cellstar.parameters = broken_params
cellstar.set_frame(img)
segmentation, snakes = cellstar.run_segmentation()
# fail miserably (not all snakes are found)
self.assertGreater(3, segmentation.max())
self.assertGreater(3, len(snakes))
new_params, _ = run_pf(img, None, None, gt, cellstar.parameters, 11, 20)
cellstar = Segmentation(11, 20)
cellstar.parameters = new_params
cellstar.set_frame(img)
segmentation2, snakes2 = cellstar.run_segmentation()
self.assertLessEqual(3, segmentation2.max())
self.assertLessEqual(3, len(snakes2))
# find best 3 objects
best3 = get_best_mask(segmentation2, 3)
segmentation_quality = calculate_diff_fraction(best3, gt)
self.assertLessEqual(0.7, segmentation_quality)
def test_rank_fitting(self):
img = prepare_image((80, 80))
gt = np.zeros((80, 80), dtype=int)
draw_weak_cell(img, (60, 20), 12)
draw_disc(gt, (60, 20), 10, 1)
draw_weak_cell(img, (40, 25), 8)
draw_disc(gt, (40, 25), 6, 2)
draw_weak_cell(img, (30, 40), 9)
draw_disc(gt, (30, 40), 7, 3)
img = finish_image(img)
cellstar = Segmentation(11, 20)
# break parameters
encoded = params.pf_rank_parameters_encode(cellstar.parameters)
one_params = [0.1 for k in encoded]
one_decoded = params.pf_rank_parameters_decode(one_params)
broken_params = PFRankSnake.merge_rank_parameters(cellstar.parameters, one_decoded)
cellstar.parameters = broken_params
cellstar.set_frame(img)
segmentation, snakes = cellstar.run_segmentation()
# fail miserably (best snakes are nowhere close)
best3 = get_best_mask(segmentation, 3)
segmentation_quality = calculate_diff_fraction(best3, gt)
self.assertLessEqual(segmentation_quality, 0.01)
new_params, _ = run_rank_pf(img, None, None, gt, cellstar.parameters)
cellstar = Segmentation(11, 20)
cellstar.parameters = new_params
cellstar.set_frame(img)
segmentation2, snakes2 = cellstar.run_segmentation()
self.assertLessEqual(3, segmentation2.max())
self.assertLessEqual(3, len(snakes2))
# find best 3 objects
best3 = get_best_mask(segmentation2, 3)
snake3 = snakes2[:3]
segmentation_quality = calculate_diff_fraction(best3, gt)
self.assertLessEqual(0.3, segmentation_quality) # there was no contour fitting
object_diffs = calculate_diffs_per_object(best3, gt)
self.assertLessEqual(0.3, min(object_diffs))
def test_large_image(self):
img = prepare_image((300, 300))
gt = np.zeros((300, 300), dtype=int)
draw_cell(img, (40, 40), 30)
draw_disc(gt, (40, 40), 30, 1)
draw_cell(img, (150, 90), 25)
draw_disc(gt, (150, 90), 25, 2)
draw_cell(img, (180, 70), 20)
draw_disc(gt, (180, 70), 20, 3)
cellstar = Segmentation(11, 60)
cellstar.set_frame(img)
segmentation, snakes = cellstar.run_segmentation()
self.assertEqual(3, segmentation.max())
self.assertEqual(3, len(snakes))
object_diffs = calculate_diffs_per_object(segmentation, gt)
self.assertLessEqual(0.8, min(object_diffs))
def test_encode_auto_params(self):
parameters = params_util.default_parameters(10, 30)
star_parameters = parameters['segmentation']['stars']
star_parameters['brightnessWeight'] = 1.1
star_parameters['cumBrightnessWeight'] = 2.2
star_parameters['gradientWeight'] = 3.3
star_parameters['sizeWeight'] = 4.4
rank_parameters = parameters['segmentation']['ranking']
rank_parameters['avgBorderBrightnessWeight'] = 11.1
rank_parameters['avgInnerBrightnessWeight'] = 12.2
rank_parameters['avgInnerDarknessWeight'] = 13.3
rank_parameters['logAreaBonus'] = 14.4
rank_parameters['maxInnerBrightnessWeight'] = 15.5
encoded = Segmentation.encode_auto_params_from_all_params(parameters)
self.assertEqual("[[1.1, 2.2, 3.3, 4.4000000000000004], [11.1, 12.2, 13.3, 14.4, 15.5]]", encoded)
# check list size weight
star_parameters['sizeWeight'] = [2, 5, 11]
encoded2 = Segmentation.encode_auto_params_from_all_params(parameters)
self.assertEqual("[[1.1, 2.2, 3.3, 6.0], [11.1, 12.2, 13.3, 14.4, 15.5]]", encoded2)
def test_trained_parameters(image, star_params, ranking_params, precision, avg_cell_diameter, output_name=None):
seg = Segmentation(segmentation_precision=precision, avg_cell_diameter=avg_cell_diameter)
for k, v in star_params.iteritems():
seg.parameters["segmentation"]["stars"][k] = v
for k, v in ranking_params.iteritems():
seg.parameters["segmentation"]["ranking"][k] = v
seg.set_frame(image)
seg.run_segmentation()
if output_name is None:
image_show(seg.images.segmentation, 1)
else:
image_save(seg.images.segmentation, output_name)
def test_trained_parameters(image,
star_params,
ranking_params,
precision,
avg_cell_diameter,
output_name=None):
seg = Segmentation(segmentation_precision=precision,
avg_cell_diameter=avg_cell_diameter)
for k, v in star_params.iteritems():
seg.parameters["segmentation"]["stars"][k] = v
for k, v in ranking_params.iteritems():
seg.parameters["segmentation"]["ranking"][k] = v
seg.set_frame(image)
seg.run_segmentation()
if output_name is None:
image_show(seg.images.segmentation, 1)
else:
image_save(seg.images.segmentation, output_name)
def test_decode_auto_params_valid(self):
parameters = params_util.default_parameters(10, 30)
encoded_params = "[[1.1, 2.2, 3.3, 4.4], [11.1, 12.2, 13.3, 14.4, 15.5]]"
self.assertEqual(True, Segmentation.decode_auto_params_into(parameters, encoded_params))
# check all the fields
star_parameters = parameters['segmentation']['stars']
self.assertEqual(1.1, star_parameters['brightnessWeight'])
self.assertEqual(2.2, star_parameters['cumBrightnessWeight'])
self.assertEqual(3.3, star_parameters['gradientWeight'])
self.assertEqual(4.4, np.mean(star_parameters['sizeWeight']))
rank_parameters = parameters['segmentation']['ranking']
self.assertEqual(11.1, rank_parameters['avgBorderBrightnessWeight'])
self.assertEqual(12.2, rank_parameters['avgInnerBrightnessWeight'])
self.assertEqual(13.3, rank_parameters['avgInnerDarknessWeight'])
self.assertEqual(14.4, rank_parameters['logAreaBonus'])
self.assertEqual(15.5, rank_parameters['maxInnerBrightnessWeight'])
def test_decode_auto_params_valid(self):
parameters = params_util.default_parameters(10, 30)
encoded_params = "[[1.1, 2.2, 3.3, 4.4], [11.1, 12.2, 13.3, 14.4, 15.5]]"
self.assertEqual(
True,
Segmentation.decode_auto_params_into(parameters, encoded_params))
# check all the fields
star_parameters = parameters['segmentation']['stars']
self.assertEqual(1.1, star_parameters['brightnessWeight'])
self.assertEqual(2.2, star_parameters['cumBrightnessWeight'])
self.assertEqual(3.3, star_parameters['gradientWeight'])
self.assertEqual(4.4, np.mean(star_parameters['sizeWeight']))
rank_parameters = parameters['segmentation']['ranking']
self.assertEqual(11.1, rank_parameters['avgBorderBrightnessWeight'])
self.assertEqual(12.2, rank_parameters['avgInnerBrightnessWeight'])
self.assertEqual(13.3, rank_parameters['avgInnerDarknessWeight'])
self.assertEqual(14.4, rank_parameters['logAreaBonus'])
self.assertEqual(15.5, rank_parameters['maxInnerBrightnessWeight'])
def __init__(self, image, images, ui, cell_star, params=None):
"""
@type cell_star: Segmentation
"""
self.image = image
self.images = images
self.ui = ui
self.ui.onclick = self.manage_click
self.ui.press = self.manage_press
if cell_star is None:
self.cell_star = Segmentation(
11, params["segmentation"]["avgCellDiameter"])
self.cellstar.parameters = params
self.cellstar.set_frame(image)
self.cellstar.images = images
self.image = self.cellstar.images.image
self.images = self.cellstar.images
else:
self.cell_star = cell_star
self.clear()
self.smoothing = self.cell_star_smoothing
self.stick_seeds = []
self.stick_snakes = []
image_path,
mask_path,
precision,
avg_cell_diameter,
method,
options=options,
callback_progress=callback_progress)
complete_params, _, _ = test_rank_pf(image_path,
mask_path,
precision,
avg_cell_diameter,
method,
initial_params=full_params_contour,
options=options,
callback_progress=callback_progress)
#complete_params["segmentation"]["ranking"]["stickingWeight"] = 60.0
print "Best_params:", complete_params
print
print "CellProfiler autoparams:", Segmentation.encode_auto_params_from_all_params(
complete_params)
debug_util.DEBUGING = True
test_pf.test_parameters(image_path,
mask_path,
precision,
avg_cell_diameter,
complete_params,
image_result_path,
options=options)
def test_mask_usage(self):
img = prepare_image((80, 80))
gt = np.zeros((80, 80), dtype=int)
draw_very_weak_cell(img, (10, 10), 6)
draw_disc(gt, (10, 10), 6, 1)
draw_very_weak_cell(img, (30, 15), 8)
draw_disc(gt, (30, 15), 6, 1)
# very bright points
img[50:70, 50:70] = 1
img[50:70, 10:30] = 0
cellstar = Segmentation(9, 10)
cellstar.set_frame(img)
segmentation, snakes = cellstar.run_segmentation()
self.assertEqual(0, segmentation.max())
self.assertEqual(0, len(snakes))
ignore_mask = (img == 1) | (img == 0)
cellstar = Segmentation(9, 10)
cellstar.set_frame(img)
cellstar.set_mask(ignore_mask)
segmentation, snakes = cellstar.run_segmentation()
self.assertEqual(2, segmentation.max())
self.assertEqual(2, len(snakes))
def test_background_usage(self):
img = prepare_image((80, 80))
gt = np.zeros((80, 80), dtype=int)
background = np.ones((80, 80))
background = background * 0.5
draw_cell(img, (10, 10), 6)
draw_disc(gt, (10, 10), 6, 1)
draw_cell(img, (30, 15), 8)
draw_disc(gt, (30, 15), 6, 1)
# background with cell looking noise
draw_cell(img, (30, 40), 9)
draw_cell(background, (30, 40), 9)
cellstar = Segmentation(9, 14)
cellstar.set_frame(img)
segmentation, snakes = cellstar.run_segmentation()
# background noise is returned as cell
self.assertEqual(3, segmentation.max())
self.assertEqual(3, len(snakes))
cellstar = Segmentation(9, 14)
cellstar.set_frame(img)
cellstar.set_background(background)
segmentation, snakes = cellstar.run_segmentation()
self.assertEqual(2, segmentation.max())
self.assertEqual(2, len(snakes))
# from cellstar.core.snake import Snake
# from cellstar.tests.experiments import smooth_contour_turns
# Snake.smooth_contour = smooth_contour_turns
pf_rank.get_max_workers = lambda: 2
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
logger = logging.getLogger('cellstar.parameter_fitting')
logger.setLevel(logging.DEBUG)
logger.addHandler(ch)
test_pf.default_data_path = sys.argv[1]
precision = int(sys.argv[4])
avg_cell_diameter = float(sys.argv[5])
image_result_path = None
if len(sys.argv) >= 8:
image_result_path = sys.argv[7]
# complete_params = default_parameters(segmentation_precision=precision, avg_cell_diameter=avg_cell_diameter)
complete_params, _, _ = test_rank_pf(sys.argv[2], sys.argv[3], precision, avg_cell_diameter, sys.argv[6])
print "Best_params:", complete_params
print
print "CellProfiler autoparams:", Segmentation.encode_auto_params_from_all_params(complete_params)
debug_util.DEBUGING = True
if image_result_path is not None:
test_pf.test_parameters(sys.argv[2], sys.argv[3], precision, avg_cell_diameter, complete_params,
image_result_path)
if len(sys.argv) < 2:
print "Usage: <script> input_path [cell_diameter]"
print "Given: " + " ".join(sys.argv)
average_cell_diameter = 35
if len(sys.argv) > 2:
average_cell_diameter = int(sys.argv[2])
debug_util.DEBUGING = True
input_path = sys.argv[1]
# image2 = load_image("D:\Fafa\Drozdze\CellStarTesting\Data\Benchmark1\TestSet6\BF_frame001_invert.tif")
image = load_image(input_path)
# image3 = 1 - image
# p2 = debug_util.image_save(image2, "Image2_Invert")
# p1 = debug_util.image_save(image, "Image1")
# read2 = load_image(p2)
# read1 = load_image(p1)
cell_star = Segmentation(12, average_cell_diameter)
cellstar.set_frame(image)
cellstar.pre_process()
app = wx.App(0)
explorer_ui = ExplorerFrame(cellstar.images)
explorer = Explorer(image, cellstar.images, explorer_ui, cell_star)
app.MainLoop()
def test_rank_fitting(self):
img = prepare_image((80, 80))
gt = np.zeros((80, 80), dtype=int)
draw_weak_cell(img, (60, 20), 12)
draw_disc(gt, (60, 20), 10, 1)
draw_weak_cell(img, (40, 25), 8)
draw_disc(gt, (40, 25), 6, 2)
draw_weak_cell(img, (30, 40), 9)
draw_disc(gt, (30, 40), 7, 3)
img = finish_image(img)
cellstar = Segmentation(11, 20)
# break parameters
encoded = params.pf_rank_parameters_encode(cellstar.parameters)
one_params = [0.1 for k in encoded]
one_decoded = params.pf_rank_parameters_decode(one_params)
broken_params = PFRankSnake.merge_rank_parameters(
cellstar.parameters, one_decoded)
cellstar.parameters = broken_params
cellstar.set_frame(img)
segmentation, snakes = cellstar.run_segmentation()
# fail miserably (best snakes are nowhere close)
best3 = get_best_mask(segmentation, 3)
segmentation_quality = calculate_diff_fraction(best3, gt)
self.assertLessEqual(segmentation_quality, 0.01)
new_params, _ = run_rank_pf(img, None, None, gt, cellstar.parameters)
cellstar = Segmentation(11, 20)
cellstar.parameters = new_params
cellstar.set_frame(img)
segmentation2, snakes2 = cellstar.run_segmentation()
self.assertLessEqual(3, segmentation2.max())
self.assertLessEqual(3, len(snakes2))
# find best 3 objects
best3 = get_best_mask(segmentation2, 3)
snake3 = snakes2[:3]
segmentation_quality = calculate_diff_fraction(best3, gt)
self.assertLessEqual(
0.3, segmentation_quality) # there was no contour fitting
object_diffs = calculate_diffs_per_object(best3, gt)
self.assertLessEqual(0.3, min(object_diffs))
def test_contour_fitting(self):
process.SEARCH_LENGTH_NORMAL = 20
img = prepare_image((80, 80))
gt = np.zeros((80, 80), dtype=int)
draw_weak_cell(img, (60, 20), 12)
draw_disc(gt, (60, 20), 14, 1)
draw_weak_cell(img, (40, 25), 8)
draw_disc(gt, (40, 25), 8, 2)
draw_weak_cell(img, (30, 40), 9)
draw_disc(gt, (30, 40), 9, 3)
img = finish_image(img)
cellstar = Segmentation(11, 20)
# break parameters
weights = cellstar.parameters["segmentation"]["stars"]["sizeWeight"]
encoded = params.pf_parameters_encode(cellstar.parameters)
one_params = [0.5 for k in encoded]
one_params[3] = 0.001
one_decoded = params.pf_parameters_decode(one_params, weights)
broken_params = PFSnake.merge_parameters(cellstar.parameters,
one_decoded)
cellstar.parameters = broken_params
cellstar.set_frame(img)
segmentation, snakes = cellstar.run_segmentation()
# fail miserably (not all snakes are found)
self.assertGreater(3, segmentation.max())
self.assertGreater(3, len(snakes))
new_params, _ = run_pf(img, None, None, gt, cellstar.parameters, 11,
20)
cellstar = Segmentation(11, 20)
cellstar.parameters = new_params
cellstar.set_frame(img)
segmentation2, snakes2 = cellstar.run_segmentation()
self.assertLessEqual(3, segmentation2.max())
self.assertLessEqual(3, len(snakes2))
# find best 3 objects
best3 = get_best_mask(segmentation2, 3)
segmentation_quality = calculate_diff_fraction(best3, gt)
self.assertLessEqual(0.7, segmentation_quality)
def test_decode_auto_params_invalid(self):
parameters = params_util.default_parameters(10, 30)
encoded_params_invalid = "[[11.1, 12.2, 13.3, 14.4, 15.5], [1.1, 2.2, 3.3, 4.4]]"
self.assertEqual(False, Segmentation.decode_auto_params_into(parameters, encoded_params_invalid))