def testSLDCWorkflowWithRuleDispatcher(self):
# pre build components
segmenter = DumbSegmenter()
tile_builder = DefaultTileBuilder()
dispatcher = DumbDispatcher()
classifier1 = DumbClassifier()
classifier2 = DumbClassifier()
rule1 = DumbRule()
rule2 = DumbRule()
builder = SLDCWorkflowBuilder()
builder.set_segmenter(segmenter)
builder.set_tile_builder(tile_builder)
builder.add_classifier(rule1, classifier1)
builder.add_classifier(rule2, classifier2)
with self.assertRaises(InvalidBuildingException):
builder.set_one_shot_dispatcher(dispatcher, {"default": classifier1})
workflow = builder.get()
self.assertIsInstance(workflow, SLDCWorkflow)
self.assertEqual(len(workflow._dispatch_classifier._classifiers), 2)
self.assertEqual(workflow._dispatch_classifier._classifiers[0], classifier1)
self.assertEqual(workflow._dispatch_classifier._classifiers[1], classifier2)
self.assertIsInstance(workflow._dispatch_classifier._dispatcher, RuleBasedDispatcher)
self.assertEqual(len(workflow._dispatch_classifier._dispatcher._rules), 2)
self.assertEqual(workflow._dispatch_classifier._dispatcher._rules[0], rule1)
self.assertEqual(workflow._dispatch_classifier._dispatcher._rules[1], rule2)
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 testWorkflowChainBuilder(self):
segmenter = DumbSegmenter()
dispatcher = DumbDispatcher()
classifier = DumbClassifier()
builder = SLDCWorkflowBuilder()
builder.set_segmenter(segmenter)
builder.set_default_tile_builder()
builder.set_one_shot_dispatcher(dispatcher, {"default": classifier})
workflow1 = builder.get()
builder2 = SSLWorkflowBuilder()
builder2.set_segmenter(segmenter)
builder2.set_default_tile_builder()
workflow2 = builder2.get()
_filter = DefaultFilter()
logger = StandardOutputLogger(Logger.DEBUG)
chain_builder = WorkflowChainBuilder()
chain_builder.set_logger(logger)
with self.assertRaises(MissingComponentException):
chain_builder.get()
chain_builder.set_first_workflow(workflow1, label="first")
chain_builder.add_executor(workflow2, label="second", filter=_filter, n_jobs=2, logger=logger)
chain = chain_builder.get()
self.assertIsInstance(chain, WorkflowChain)
self.assertEqual(chain.logger, logger)
self.assertEqual(chain._first_workflow, workflow1)
self.assertEqual(len(chain._executors), 1)
self.assertEqual(chain._executors[0]._workflow, workflow2)
self.assertEqual(len(chain._labels), 2)
self.assertEqual(tuple(chain._labels), ("first", "second"))
self.assertEqual(len(chain._filters), 1)
self.assertEqual(chain._filters[0], _filter)
def testSLDCWorkflowWithCatchAllClassifier(self):
# pre build components
segmenter = DumbSegmenter()
tile_builder = DefaultTileBuilder()
dispatcher = DumbDispatcher()
classifier = DumbClassifier()
builder = SLDCWorkflowBuilder()
builder.set_segmenter(segmenter)
builder.set_tile_builder(tile_builder)
builder.add_catchall_classifier(classifier)
with self.assertRaises(InvalidBuildingException):
builder.set_one_shot_dispatcher(dispatcher, {"default": classifier})
workflow = builder.get()
self.assertIsInstance(workflow, SLDCWorkflow)
self.assertIsInstance(workflow._dispatch_classifier._dispatcher, RuleBasedDispatcher)
self.assertEqual(len(workflow._dispatch_classifier._classifiers), 1)
self.assertEqual(workflow._dispatch_classifier._classifiers[0], classifier)
self.assertIsInstance(workflow._dispatch_classifier._dispatcher, RuleBasedDispatcher)
self.assertEqual(len(workflow._dispatch_classifier._dispatcher._rules), 1)
self.assertIsInstance(workflow._dispatch_classifier._dispatcher._rules[0], CatchAllRule)
def testWorkflowWithCustomDispatcher(self):
# generate circle image
w, h = 1000, 1000
image = np.zeros((
w,
h,
), dtype="uint8")
image = draw_circle(image, 10, (125, 125),
255) # pi * 10 * 10 -> ~ 314
image = draw_circle(image, 25, (250, 750),
255) # pi * 25 * 25 -> ~ 1963
image = draw_square(image, 26, (250, 250), 255) # 26 * 26 -> 676
image = draw_square(image, 50, (750, 750), 127) # 50 * 50 -> 2500
# build the workflow
builder = SLDCWorkflowBuilder()
builder.set_segmenter(CustomSegmenter())
builder.set_one_shot_dispatcher(CustomDispatcher(1000), {
"BIG": ColorClassifier(),
"SMALL": ColorClassifier()
})
workflow = builder.get()
# execute
results = workflow.process(NumpyImage(image))
# validate number of results
count = len(results)
self.assertEqual(count, 4)
# sort polygons
sorted_idx = sorted(
range(count),
key=lambda i:
(results.polygons[i].centroid.y, results.polygons[i].centroid.x))
# first circle
circle1 = results.polygons[sorted_idx[0]]
self.assertTrue(relative_error(circle1.area, np.pi * 10 * 10) < 0.025)
self.assertTrue(relative_error(circle1.centroid.x, 125) < 0.025)
self.assertTrue(relative_error(circle1.centroid.y, 125) < 0.025)
self.assertEqual(results.dispatches[sorted_idx[0]], "SMALL")
self.assertEqual(results.labels[sorted_idx[0]], ColorClassifier.WHITE)
self.assertAlmostEqual(results.probas[sorted_idx[0]], 1.0)
# first square
square1 = results.polygons[sorted_idx[1]]
self.assertTrue(relative_error(square1.area, 26 * 26) < 0.025)
self.assertTrue(relative_error(square1.centroid.x, 250) < 0.025)
self.assertTrue(relative_error(square1.centroid.y, 250) < 0.025)
self.assertEqual(results.dispatches[sorted_idx[1]], "SMALL")
self.assertEqual(results.labels[sorted_idx[1]], ColorClassifier.WHITE)
self.assertAlmostEqual(results.probas[sorted_idx[1]], 1.0)
# second circle
circle2 = results.polygons[sorted_idx[2]]
self.assertTrue(relative_error(circle2.area, np.pi * 25 * 25) < 0.025)
self.assertTrue(relative_error(circle2.centroid.x, 250) < 0.025)
self.assertTrue(relative_error(circle2.centroid.y, 750) < 0.025)
self.assertEqual(results.dispatches[sorted_idx[2]], "BIG")
self.assertEqual(results.labels[sorted_idx[2]], ColorClassifier.WHITE)
self.assertAlmostEqual(results.probas[sorted_idx[2]], 1.0)
# second square
square2 = results.polygons[sorted_idx[3]]
self.assertTrue(relative_error(square2.area, 50 * 50) < 0.025)
self.assertTrue(relative_error(square2.centroid.x, 750) < 0.025)
self.assertTrue(relative_error(square2.centroid.y, 750) < 0.025)
self.assertEqual(results.dispatches[sorted_idx[3]], "BIG")
self.assertEqual(results.labels[sorted_idx[3]], ColorClassifier.GREY)
self.assertAlmostEqual(results.probas[sorted_idx[3]], 1.0)
# check other information
timing = results.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 testWorkflowWithCustomDispatcher(self):
# generate circle image
w, h = 1000, 1000
image = np.zeros((w, h,), dtype="uint8")
image = draw_circle(image, 10, (125, 125), 255) # pi * 10 * 10 -> ~ 314
image = draw_circle(image, 25, (250, 750), 255) # pi * 25 * 25 -> ~ 1963
image = draw_square(image, 26, (250, 250), 255) # 26 * 26 -> 676
image = draw_square(image, 50, (750, 750), 127) # 50 * 50 -> 2500
# build the workflow
builder = SLDCWorkflowBuilder()
builder.set_segmenter(CustomSegmenter())
builder.set_one_shot_dispatcher(CustomDispatcher(1000), {
"BIG": ColorClassifier(),
"SMALL": ColorClassifier()
})
workflow = builder.get()
# execute
results = workflow.process(NumpyImage(image))
# validate number of results
count = len(results)
self.assertEqual(count, 4)
# sort polygons
sorted_idx = sorted(range(count), key=lambda i: (results.polygons[i].centroid.y, results.polygons[i].centroid.x))
# first circle
circle1 = results.polygons[sorted_idx[0]]
self.assertTrue(relative_error(circle1.area, np.pi * 10 * 10) < 0.025)
self.assertTrue(relative_error(circle1.centroid.x, 125) < 0.025)
self.assertTrue(relative_error(circle1.centroid.y, 125) < 0.025)
self.assertEqual(results.dispatches[sorted_idx[0]], "SMALL")
self.assertEqual(results.labels[sorted_idx[0]], ColorClassifier.WHITE)
self.assertAlmostEqual(results.probas[sorted_idx[0]], 1.0)
# first square
square1 = results.polygons[sorted_idx[1]]
self.assertTrue(relative_error(square1.area, 26 * 26) < 0.025)
self.assertTrue(relative_error(square1.centroid.x, 250) < 0.025)
self.assertTrue(relative_error(square1.centroid.y, 250) < 0.025)
self.assertEqual(results.dispatches[sorted_idx[1]], "SMALL")
self.assertEqual(results.labels[sorted_idx[1]], ColorClassifier.WHITE)
self.assertAlmostEqual(results.probas[sorted_idx[1]], 1.0)
# second circle
circle2 = results.polygons[sorted_idx[2]]
self.assertTrue(relative_error(circle2.area, np.pi * 25 * 25) < 0.025)
self.assertTrue(relative_error(circle2.centroid.x, 250) < 0.025)
self.assertTrue(relative_error(circle2.centroid.y, 750) < 0.025)
self.assertEqual(results.dispatches[sorted_idx[2]], "BIG")
self.assertEqual(results.labels[sorted_idx[2]], ColorClassifier.WHITE)
self.assertAlmostEqual(results.probas[sorted_idx[2]], 1.0)
# second square
square2 = results.polygons[sorted_idx[3]]
self.assertTrue(relative_error(square2.area, 50 * 50) < 0.025)
self.assertTrue(relative_error(square2.centroid.x, 750) < 0.025)
self.assertTrue(relative_error(square2.centroid.y, 750) < 0.025)
self.assertEqual(results.dispatches[sorted_idx[3]], "BIG")
self.assertEqual(results.labels[sorted_idx[3]], ColorClassifier.GREY)
self.assertAlmostEqual(results.probas[sorted_idx[3]], 1.0)
# check other information
timing = results.timing
self.assertEqual(timing.get_phases_hierarchy(), {"workflow.sldc": {
"detect": {"load": None, "segment": None, "locate": None},
"merge": None,
"dispatch_classify": {"dispatch": None, "classify": None}
}})