def make_simple_dataset():
dataset = AnnotatedDataset()
for i, info in enumerate(INFOS):
data = list(range(3*i, 3*i + 3, 3))
image = AnnotatedImage(info, data)
dataset.update_with(image)
return dataset
def test_getitem(self):
dataset = AnnotatedDataset()
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
dataset.update_with(labeled_f0)
gotten = dataset[labeled_f0.info.slide]
self.assertIs(type(gotten), AnnotatedSlideFolder)
def test_update_with_if_different_slide(self):
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
labeled_fp = AnnotatedImage(INFO_FP, '1-cell')
dataset = AnnotatedDataset()
dataset.update_with(labeled_f0)
dataset.update_with(labeled_fp)
self.assertEqual(len(dataset), 2)
def test_update_with_when_empty(self):
dataset = AnnotatedDataset()
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
dataset.update_with(labeled_f0)
self.assertEqual(len(dataset), 1)
type_ok = type(dataset[labeled_f0.info.slide]) == AnnotatedSlideFolder
self.assertTrue(type_ok)
def test_keys(self):
image = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(image)
keys = dataset.keys()
truth = list(dataset._dict.keys())
self.assertEqual(keys, truth)
self.assertEqual(type(keys), list)
def predict_all(self, filenames):
zona = self.predict_zona(filenames)
boxes = self.calculate_boxes(zona)
filenames_and_boxes = [
(nm, b.annotation)
for nm, b in zip(filenames, boxes)]
frag = self.predict_frag(filenames_and_boxes)
# FIXME check low frag
stage_raw = self.predict_stage_raw(filenames_and_boxes)
stage_smooth = self.predict_stage_smooth(stage_raw)
names_boxes_1cell = self._grab_1cell_names_and_boxes(
stage_smooth,
filenames_and_boxes)
pronuclei = self.predict_pronuclei(names_boxes_1cell)
names_boxes_cleavage = self._grab_cleavage_names_and_boxes(
stage_smooth,
filenames_and_boxes)
blastomeres = self.predict_blastomeres(names_boxes_cleavage)
out = {
'zona': zona,
'boxes': AnnotatedDataset.create_from_list(boxes),
'frag': frag,
'stage_raw': stage_raw,
'stage_smooth': stage_smooth,
'pronuclei': pronuclei,
'blastomeres': blastomeres,
}
return out
def test_copy_is_deep(self):
image = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(image)
copied = dataset.copy()
key = dataset.keys()[0]
self.assertTrue(dataset[key] is not copied[key])
def test_values(self):
image = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(image)
values = dataset.values()
truth = list(dataset._dict.values())
self.assertEqual(values, truth)
self.assertEqual(type(values), list)
def test_create_from_list(self):
images = [
AnnotatedImage(info, '{}-cell'.format(index))
for index, info in enumerate(INFOS)]
dataset = AnnotatedDataset.create_from_list(images)
for image in dataset.iterate_over_images():
self.assertIn(image, images)
def test_iterate_over_images(self):
labeled_images = [AnnotatedImage(info, 'annotation') for info in INFOS]
dataset = AnnotatedDataset.create_from_list(labeled_images)
iterated_images = [i for i in dataset.iterate_over_images()]
each_in = [l in iterated_images for l in labeled_images]
self.assertEqual(len(iterated_images), len(labeled_images))
self.assertTrue(all(each_in))
def test_is_image_in_focus_when_does_contain(self):
labeled1 = AnnotatedImage(INFO_F0, '1-cell')
labeled2 = AnnotatedImage(INFO_F0_2, '1-cell')
dataset = AnnotatedDataset.create_from(labeled1)
dataset.update_with(labeled2)
self.assertTrue(dataset.contains_image(labeled1.info))
self.assertTrue(dataset.contains_image(labeled2.info))
def test_add_entry_from_includes_in_dict(self):
dataset = AnnotatedDataset()
image1 = AnnotatedImage(INFO_F0, '1-cell')
dataset.update_with(image1)
image2 = AnnotatedImage(INFO_F0_2, '1-cell')
dataset._add_entry_from(image2)
self.assertTrue(dataset.contains_image(image2.info))
def make_fake_smoothed_stages():
base_info = INFOS[0]
out = list()
image_number = 0
for stage in range(13):
for _ in range(10):
image_number += 1
info = ImageInfo(*base_info[:3], image_number)
out.append(AnnotatedImage(info, stage))
return AnnotatedDataset.create_from_list(out)
def decompress_zona(compressed_dataset):
zona_images = list()
for entry in compressed_dataset.iterate_over_images():
compressed = entry.annotation
as_pil = Image.open(compressed)
segmentation = np.array(as_pil, dtype='uint8')
zona_images.append(
AnnotatedImage(entry.info, segmentation)
)
return AnnotatedDataset.create_from_list(zona_images)
def test_save_as_json(self):
dataset = make_simple_dataset()
filename = make_safe_filename_in(self._test_directory)
dataset.save_as_json(filename)
loaded = AnnotatedDataset.load_from_json(filename)
# They should be different objects that are equal:
self.assertFalse(loaded is dataset)
self.assertEqual(loaded, dataset)
# And we need to clean the file:
os.remove(filename)
def test_iter(self):
image_f0 = AnnotatedImage(INFO_F0, '1-cell')
image_fm = AnnotatedImage(INFO_FM, '1-cell')
image_fp = AnnotatedImage(INFO_FP, '1-cell')
dataset = AnnotatedDataset.create_from(image_f0)
dataset.update_with(image_fm)
dataset.update_with(image_fp)
entries_manual = [v for v in dataset._dict.values()]
entries_iter = [v for v in dataset]
ok = [m == i for m, i in zip(entries_manual, entries_iter)]
self.assertTrue(all(ok))
def compress_zona(zona_dataset):
compressed_images = list()
for entry in zona_dataset.iterate_over_images():
segmentation = entry.annotation.astype('uint8')
as_pil = Image.fromarray(segmentation, mode="L")
compressed = io.BytesIO()
as_pil.save(compressed, format='png')
compressed_images.append(
AnnotatedImage(entry.info, compressed)
)
return AnnotatedDataset.create_from_list(compressed_images)
def predict_stage_smooth(self, stage_raw_dataset):
predictor = DynamicProgramming()
embryos = [well for slide in stage_raw_dataset for well in slide]
out = list()
for embryo in embryos:
these_images = embryo.iterate_over_images()
these_probs = np.array([i.annotation for i in these_images])
these_smoothed = predictor.predict(these_probs.astype('float32'))
for image, label in zip(these_images, these_smoothed):
out.append(AnnotatedImage(image.info, label))
return AnnotatedDataset.create_from_list(out)
def test_labeleddataset_pack_for_json_not_pretty(self):
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(labeled_f0)
for_json = dataset.pack_for_json(pretty=False)
truth = OrderedDict(
{labeled_f0.info.slide: OrderedDict(
{labeled_f0.info.well: OrderedDict(
{labeled_f0.info.focus: OrderedDict(
{labeled_f0.info.image_number: labeled_f0.annotation})
})
})
})
self.assertEqual(for_json, truth)
def test_create_from_dict(self):
truth = AnnotatedDataset()
image = AnnotatedImage(INFO_F0, [1, 2, 3])
truth.update_with(image)
the_dict = truth.pack_for_json(pretty=True)
new_dataset = AnnotatedDataset.create_from_dict(the_dict)
self.assertEqual(new_dataset, truth)
def test_does_update_with_if_same_focus(self):
dataset = AnnotatedDataset()
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
dataset.update_with(labeled_f0)
labeled_f0_2 = AnnotatedImage(INFO_F0_2, '1-cell')
dataset.update_with(labeled_f0_2)
# Then the length should be 1, since it should update the same
# dictionary!
self.assertEqual(len(dataset), 1)
def test_labeleddataset_pack_for_json_pretty(self):
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(labeled_f0)
for_json = dataset.pack_for_json(pretty=True)
slide_key = labeled_f0.info.slide
well_key = 'WELL' + str(labeled_f0.info.well).rjust(2, '0')
focus_key = 'F' + str(labeled_f0.info.focus)
image_key = str(labeled_f0.info.image_number).rjust(3, '0') + '.jpg'
truth = OrderedDict(
{slide_key: OrderedDict(
{well_key: OrderedDict(
{focus_key: OrderedDict(
{image_key: labeled_f0.annotation})
})
})
})
self.assertEqual(for_json, truth)
def test_copy_returns_equal_dataset(self):
image = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(image)
copied = dataset.copy()
self.assertEqual(dataset, copied)
def make_zona_dataset(infos):
images = [
AnnotatedImage(i, np.random.randint(low=0, high=4, size=(500, 500)))
for i in infos]
return AnnotatedDataset.create_from_list(images)
def test_items(self):
image = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(image)
items = dataset.items()
truth = dataset._dict.items()
self.assertEqual(items, truth)
def test_create_from(self):
labeled_f0 = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(labeled_f0)
self.assertEqual(len(dataset), 1)
def test_is_image_in_dataset_when_in_same_folder_but_not_present(self):
labeled1 = AnnotatedImage(INFO_F0, '1-cell')
info1 = labeled1.info
info2 = INFO_F0_2
dataset = AnnotatedDataset.create_from(labeled1)
self.assertFalse(dataset.contains_image(info2))
def test_deprettify(self):
slide_name = 'name'
pretty = AnnotatedDataset._prettify(slide_name)
back = AnnotatedDataset._de_prettify(pretty)
self.assertEqual(back, slide_name)
def test_prettify(self):
slide_name = 'name'
correct = slide_name # should not alter names
output = AnnotatedDataset._prettify(slide_name)
self.assertEqual(output, correct)
def test_copy_returns_separate_object(self):
image = AnnotatedImage(INFO_F0, '1-cell')
dataset = AnnotatedDataset.create_from(image)
copied = dataset.copy()
self.assertTrue(dataset is not copied)