def testDetectCircleParallel(self): """A test which executes a full workflow on image containing a white circle in the center of an black image in parallel """ # generate circle image w, h = 2000, 2000 image = np.zeros((w, h, 3), dtype="uint8") image = draw_circle(image, 750, (1000, 1000), [129, 129, 129]) # build workflow builder = SLDCWorkflowBuilder() builder.set_n_jobs(2) builder.set_segmenter(CircleSegmenter()) builder.add_catchall_classifier(CircleClassifier()) builder.set_parallel_dc(True) workflow = builder.get() # process image workflow_info = workflow.process(NumpyImage(image)) # Check results self.assertEqual(len(workflow_info.polygons), 1) # Check circle polygon = workflow_info.polygons[0] self.assertEqual( relative_error(polygon.area, np.pi * 750 * 750) <= 0.005, True) self.assertEqual( relative_error(polygon.centroid.x, 1000) <= 0.005, True) self.assertEqual( relative_error(polygon.centroid.y, 1000) <= 0.005, True) assert_array_equal(workflow_info.labels, [1]) assert_array_almost_equal(workflow_info.probas, [1.0]) assert_array_equal(workflow_info.dispatches, ["catchall"]) # check other information timing = workflow_info.timing self.assertEqual( timing.get_phases_hierarchy(), { "workflow.sldc": { "detect": { "load": None, "segment": None, "locate": None }, "merge": None, "dispatch_classify": { "dispatch": None, "classify": None } } })
def main(argv): with CytomineJob.from_cli(argv) as job: if not os.path.exists(job.parameters.working_path): os.makedirs(job.parameters.working_path) # create workflow component logger = StandardOutputLogger(Logger.INFO) random_state = check_random_state(int(job.parameters.rseed)) tile_builder = CytomineTileBuilder( working_path=job.parameters.working_path) segmenter = DemoSegmenter(job.parameters.threshold) area_rule = ValidAreaRule(job.parameters.min_area) classifier = PyxitClassifierAdapter.build_from_pickle( job.parameters.pyxit_model_path, tile_builder, logger, random_state=random_state, n_jobs=job.parameters.n_jobs, working_path=job.parameters.working_path) builder = SLDCWorkflowBuilder() builder.set_n_jobs(job.parameters.n_jobs) builder.set_logger(logger) builder.set_overlap(job.parameters.sldc_tile_overlap) builder.set_tile_size(job.parameters.sldc_tile_width, job.parameters.sldc_tile_height) builder.set_tile_builder(tile_builder) builder.set_segmenter(segmenter) builder.add_classifier(area_rule, classifier, dispatching_label="valid") workflow = builder.get() slide = CytomineSlide(job.parameters.cytomine_image_id) results = workflow.process(slide) # Upload results for polygon, label, proba, dispatch in results: if label is not None: # if image is a window, the polygon must be translated if isinstance(slide, ImageWindow): polygon = translate(polygon, slide.abs_offset_x, slide.abs_offset_y) # upload the annotation polygon = affine_transform( polygon, [1, 0, 0, -1, 0, slide.image_instance.height]) annotation = Annotation( location=polygon.wkt, id_image=slide.image_instance.id).save() AlgoAnnotationTerm(id_annotation=annotation.id, id_term=label, rate=float(proba)).save()
def testSLDCWorkflowWithOneShotDispatcher(self): # pre build components segmenter = DumbSegmenter() dispatcher = DumbDispatcher() classifier = DumbClassifier() rule = DumbRule() logger = StandardOutputLogger(Logger.DEBUG) builder = SLDCWorkflowBuilder() builder.set_tile_size(512, 768) builder.set_overlap(3) builder.set_distance_tolerance(5) builder.set_n_jobs(5) builder.set_logger(logger) builder.set_parallel_dc(True) builder.set_tile_builder(None) with self.assertRaises(MissingComponentException): builder.get() builder.set_segmenter(segmenter) with self.assertRaises(MissingComponentException): builder.get() builder.set_default_tile_builder() with self.assertRaises(MissingComponentException): builder.get() builder.set_one_shot_dispatcher(dispatcher, {"default": classifier}) with self.assertRaises(InvalidBuildingException): builder.add_classifier(rule, classifier, dispatching_label="default") with self.assertRaises(InvalidBuildingException): builder.add_catchall_classifier(classifier, dispatching_label="default") workflow = builder.get() self.assertIsInstance(workflow, SLDCWorkflow) self.assertEqual(workflow._segmenter, segmenter) self.assertEqual(workflow._n_jobs, 5) self.assertEqual(workflow._tile_overlap, 3) self.assertEqual(workflow._tile_max_height, 512) self.assertEqual(workflow._tile_max_width, 768) self.assertEqual(workflow.logger, logger) self.assertIsInstance(workflow._tile_builder, DefaultTileBuilder) self.assertEqual(workflow._dispatch_classifier._dispatcher, dispatcher) self.assertEqual(len(workflow._dispatch_classifier._classifiers), 1) self.assertEqual(workflow._dispatch_classifier._classifiers[0], classifier)
def testDetectCircleParallel(self): """A test which executes a full workflow on image containing a white circle in the center of an black image in parallel """ # generate circle image w, h = 2000, 2000 image = np.zeros((w, h, 3), dtype="uint8") image = draw_circle(image, 750, (1000, 1000), [129, 129, 129]) # build workflow builder = SLDCWorkflowBuilder() builder.set_n_jobs(2) builder.set_segmenter(CircleSegmenter()) builder.add_catchall_classifier(CircleClassifier()) builder.set_parallel_dc(True) workflow = builder.get() # process image workflow_info = workflow.process(NumpyImage(image)) # Check results self.assertEqual(len(workflow_info.polygons), 1) # Check circle polygon = workflow_info.polygons[0] self.assertEqual(relative_error(polygon.area, np.pi * 750 * 750) <= 0.005, True) self.assertEqual(relative_error(polygon.centroid.x, 1000) <= 0.005, True) self.assertEqual(relative_error(polygon.centroid.y, 1000) <= 0.005, True) assert_array_equal(workflow_info.labels, [1]) assert_array_almost_equal(workflow_info.probas, [1.0]) assert_array_equal(workflow_info.dispatches, ["catchall"]) # check other information timing = workflow_info.timing self.assertEqual(timing.get_phases_hierarchy(), {"workflow.sldc": { "detect": {"load": None, "segment": None, "locate": None}, "merge": None, "dispatch_classify": {"dispatch": None, "classify": None} }})