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}
}})