def get_rag():
g = hg.get_4_adjacency_graph((4, 4))
vertex_labels = np.asarray(
(1, 1, 5, 5, 1, 1, 5, 5, 1, 1, 3, 3, 1, 1, 10, 10))
return hg.make_region_adjacency_graph_from_labelisation(
g, vertex_labels)
def test_vertex_perimeter_rag(self):
g = hg.get_4_adjacency_graph((2, 3))
vertex_labels = np.asarray(((1, 2, 2), (3, 3, 3)))
rag = hg.make_region_adjacency_graph_from_labelisation(
g, vertex_labels)
ref = np.asarray((2, 3, 3))
res = hg.attribute_vertex_perimeter(rag)
self.assertTrue(np.allclose(ref, res))
def test_contour_length_rag_partition_tree(self):
g = hg.get_4_adjacency_graph((3, 3))
vertex_labels = np.asarray(((0, 1, 1), (0, 2, 2), (3, 2, 4)))
rag = hg.make_region_adjacency_graph_from_labelisation(
g, vertex_labels)
edge_weights = np.asarray((1, 5, 4, 3, 6, 2), dtype=np.float64)
tree, altitudes = hg.bpt_canonical(rag, edge_weights)
ref_attribute = np.asarray([3, 3, 6, 2, 2, 4, 4, 4, 0],
dtype=np.float64)
attribute = hg.attribute_contour_length(tree)
self.assertTrue(np.allclose(ref_attribute, attribute))
def test_saliency(self):
graph = hg.get_4_adjacency_graph((2, 3))
edge_weights = np.asarray((1, 0, 2, 1, 1, 1, 2))
sm = hg.saliency(*hg.bpt_canonical(graph, edge_weights))
self.assertTrue(np.all(sm == edge_weights))
labels = np.asarray(((1, 2, 3), (1, 4, 5)))
rag = hg.make_region_adjacency_graph_from_labelisation(graph, labels)
rag_edge_weights = np.asarray((1, 2, 1, 1, 1, 2))
sm = hg.saliency(*hg.bpt_canonical(rag, rag_edge_weights))
self.assertTrue(np.all(sm == edge_weights))
def test_frontier_length_rag(self):
g = hg.get_4_adjacency_graph((3, 3))
vertex_labels = np.asarray(((0, 1, 1),
(0, 2, 2),
(3, 2, 4)))
rag = hg.make_region_adjacency_graph_from_labelisation(g, vertex_labels)
edge_weights = np.asarray((1, 5, 4, 3, 6, 2))
tree, altitudes = hg.bpt_canonical(rag, edge_weights)
ref_attribute = [0, 0, 0, 0, 0, 1, 2, 1, 4]
attribute = hg.attribute_frontier_length(tree)
self.assertTrue(np.allclose(ref_attribute, attribute))
def test_frontier_strength_rag(self):
g = hg.get_4_adjacency_graph((3, 3))
vertex_labels = np.asarray(((0, 1, 1),
(0, 2, 2),
(3, 2, 4)))
rag = hg.make_region_adjacency_graph_from_labelisation(g, vertex_labels)
rag_edge_weights = np.asarray((1, 5, 4, 3, 6, 2))
tree, altitudes = hg.bpt_canonical(rag, rag_edge_weights)
# tree is [5 5 6 7 6 7 8 8 8]
edge_weights = np.asarray((1, 6, 2, 6, 1, 1, 5, 4, 5, 3, 1, 1), dtype=np.float64)
ref_attribute = [0, 0, 0, 0, 0, 1, 2, 5, 9 / 4]
attribute = hg.attribute_frontier_strength(tree, edge_weights)
self.assertTrue(np.allclose(ref_attribute, attribute))
def test_rag_2d_vertex_perimeter_and_edge_length_simple(self):
shape = (3, 2)
g = hg.get_4_adjacency_graph(shape)
vertex_labels = np.array((1, 2, 3, 3, 4, 4))
rag = hg.make_region_adjacency_graph_from_labelisation(
g, vertex_labels)
vertex_perimeter, edge_length = hg.rag_2d_vertex_perimeter_and_edge_length(
rag)
ref_perimeter = (4, 4, 6, 6)
ref_length = (1, 1, 1, 2)
self.assertTrue(np.all(vertex_perimeter == ref_perimeter))
self.assertTrue(np.all(edge_length == ref_length))
def test_align_hierarchies(self):
g = hg.get_4_adjacency_graph((3, 3))
fine_labels = np.asarray((0, 1, 2, 3, 4, 2, 3, 4, 2), dtype=np.int32)
t = hg.Tree(np.asarray((9, 10, 10, 9, 11, 11, 9, 11, 11, 13, 12, 12, 13, 13), dtype=np.int64))
altitudes = np.asarray((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2), dtype=np.int32)
t2 = hg.Tree(np.asarray((4, 3, 3, 4, 4), dtype=np.int64))
rag = hg.make_region_adjacency_graph_from_labelisation(g, np.asarray((0, 1, 1,
0, 2, 2,
0, 2, 2)))
hg.CptHierarchy.link(t2, rag)
altitudes2 = np.asarray((0, 0, 0, 1, 2), dtype=np.int32)
sm_coarse = np.asarray((2, 0, 0, 1, 1, 2, 0, 0, 0, 0, 2, 0), dtype=np.int32)
sm_coarse_rag = np.asarray((2, 1, 2), dtype=np.int32)
sm_k_ref = np.asarray(((0, 2, 0, 1, 0),
(0, 2, 1, 1, 0),
(0, 2, 0, 0, 0),
(0, 2, 0, 0, 0),
(0, 2, 0, 0, 0)), dtype=np.int32)
# test only one:
res = hg.align_hierarchies(g, fine_labels, (t, altitudes))
res_k = hg.graph_4_adjacency_2_khalimsky(g, res, (3, 3))
self.assertTrue(np.all(res_k == sm_k_ref))
res = hg.align_hierarchies(g, fine_labels, (t2, altitudes2))
res_k = hg.graph_4_adjacency_2_khalimsky(g, res, (3, 3))
self.assertTrue(np.all(res_k == sm_k_ref))
res = hg.align_hierarchies(g, fine_labels, (g, sm_coarse))
res_k = hg.graph_4_adjacency_2_khalimsky(g, res, (3, 3))
self.assertTrue(np.all(res_k == sm_k_ref))
res = hg.align_hierarchies(g, fine_labels, (rag, sm_coarse_rag))
res_k = hg.graph_4_adjacency_2_khalimsky(g, res, (3, 3))
self.assertTrue(np.all(res_k == sm_k_ref))
# test several
res_all = hg.align_hierarchies(g, fine_labels,
((t2, altitudes2), (g, sm_coarse), (t, altitudes), (rag, sm_coarse_rag)))
for res in res_all:
res_k = hg.graph_4_adjacency_2_khalimsky(g, res, (3, 3))
self.assertTrue(np.all(res_k == sm_k_ref))
def test_contour_strength_rag_partition_tree(self):
g = hg.get_4_adjacency_graph((3, 3))
vertex_labels = np.asarray(((0, 1, 1), (0, 2, 2), (3, 2, 4)))
base_edge_weights = np.arange(g.num_edges(), dtype=np.float64)
rag = hg.make_region_adjacency_graph_from_labelisation(
g, vertex_labels)
edge_weights = np.asarray((1, 5, 4, 3, 6, 2))
tree, altitudes = hg.bpt_canonical(rag, edge_weights)
attribute = hg.attribute_contour_strength(tree, base_edge_weights)
ref_perimeter = np.asarray([3, 3, 6, 2, 2, 4, 4, 4, 1],
dtype=np.float64)
ref_weights = np.asarray([11, 7, 42, 16, 20, 18, 22, 22, 0],
dtype=np.float64)
self.assertTrue(np.allclose(ref_weights / ref_perimeter, attribute))
def test_filter_small_node_from_tree_on_rag(self):
g = hg.get_4_adjacency_graph((2, 8))
labels = np.asarray(((0, 1, 2, 3, 4, 5, 6, 7),
(0, 1, 2, 3, 4, 5, 6, 7)))
rag = hg.make_region_adjacency_graph_from_labelisation(g, labels)
edge_weights = np.asarray((0, 2, 0, 0, 1, 0, 0))
tree, altitudes = hg.quasi_flat_zone_hierarchy(rag, edge_weights)
res_tree, res_altitudes = hg.filter_small_nodes_from_tree(tree, altitudes, 5)
sm = hg.saliency(res_tree, res_altitudes, handle_rag=False)
sm_ref = np.asarray((0, 0, 0, 0, 1, 0, 0))
self.assertTrue(np.all(sm == sm_ref))
sm = hg.saliency(res_tree, res_altitudes, handle_rag=True)
sm_ref = np.asarray((0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0))
self.assertTrue(np.all(sm == sm_ref))
def test_horizontal_cut_nodes_rag_delinearization(self):
g = hg.get_4_adjacency_graph((2, 2))
labels = np.array((0, 0, 1, 2))
rag = hg.make_region_adjacency_graph_from_labelisation(g, labels)
tree = hg.Tree((3, 3, 4, 4, 4))
hg.CptHierarchy.link(tree, rag)
altitudes = np.asarray((0, 0, 0, 1, 2))
hch = hg.HorizontalCutExplorer(tree, altitudes)
c = hch.horizontal_cut_from_num_regions(2)
lbls = c.labelisation_leaves(tree)
self.assertTrue(np.all(lbls.shape == (2, 2)))
ref_lbls = np.array((0, 0, 0, 1))
self.assertTrue(hg.is_in_bijection(lbls[:], ref_lbls))
vweights = c.reconstruct_leaf_data(tree, altitudes)
ref_vweights = np.array(((1, 1), (1, 0)))
self.assertTrue(np.all(vweights == ref_vweights))
