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)