def test_different_position(self):
graph = Graph()
initial_node = gen_name()
graph.add_node(initial_node, layer=0, position=(0, 0), label='E')
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
P1().apply(graph, [initial_node],
positions=[
(0, 0),
(2, 1.5),
(1.5, 2),
(-0.5, 1.5),
])
# check other nodes
vx_bl = get_node_at(graph, 1, (0, 0))
vx_br = get_node_at(graph, 1, (2, 1.5))
vx_tl = get_node_at(graph, 1, (1.5, 2))
vx_tr = get_node_at(graph, 1, (-0.5, 1.5))
self.assertIsNotNone(vx_bl)
self.assertIsNotNone(vx_br)
self.assertIsNotNone(vx_tl)
self.assertIsNotNone(vx_tr)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
def test_happy_path(self):
graph = Graph()
e1 = gen_name()
e2 = gen_name()
e3 = gen_name()
graph.add_node(e1, layer=1, position=(1.0, 2.0), label='E')
graph.add_node(e2, layer=1, position=(1.0, 1.0), label='E')
graph.add_node(e3, layer=1, position=(2.0, 1.0), label='E')
graph.add_edge(e1, e2)
graph.add_edge(e1, e3)
graph.add_edge(e2, e3)
i = add_interior(graph, e1, e2, e3)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
[i1] = P9().apply(graph, [i])
# if correct number of nodes and edges
self.assertEqual(len(graph.nodes()), 8)
self.assertEqual(len(graph.edges()), 13)
# if cross-layer interior connections
self.assertEqual(graph.nodes[i]['label'], 'i')
self.assertTrue(graph.has_edge(i, i1))
# if new interior has correct label and layer
self.assertEqual(graph.nodes[i1]['label'], 'I')
self.assertEqual(graph.nodes[i1]['layer'], graph.nodes[i]['layer'] + 1)
# if new interior has 3 neighbors
i1_neighbors = get_neighbors_at(graph, i1, graph.nodes[i1]['layer'])
self.assertEqual(len(i1_neighbors), 3)
# if new nodes are in correct positions
new_e1 = get_node_at(graph, 2, (1.0, 2.0))
new_e2 = get_node_at(graph, 2, (1.0, 1.0))
new_e3 = get_node_at(graph, 2, (2.0, 1.0))
self.assertIsNotNone(new_e1)
self.assertIsNotNone(new_e2)
self.assertIsNotNone(new_e3)
# if each vertex has correct label
for n in i1_neighbors:
self.assertEqual(graph.nodes[n]['label'], 'E')
# if each vertex has correct number of neighbors
for n in i1_neighbors:
node_neighbors = get_neighbors_at(graph, n,
graph.nodes[n]['layer'])
self.assertEqual(len(node_neighbors), 3)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
def testMissingEdge(self):
graph = createCorrectGraph()
I2 = get_node_at(graph=graph, layer=2, pos=(2.5, 3.5))
e5 = get_node_at(graph=graph, layer=2, pos=(2.0, 2.0))
graph.remove_edge(I2, e5)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
prod_input = [x for x, y in graph.nodes(data=True) if y['label'] == 'I']
with self.assertRaises(ValueError):
P10().apply(graph, prod_input)
def test_happy_path(self):
graph = Graph()
initial_node = gen_name()
graph.add_node(initial_node, layer=0, position=(0.5, 0.5), label='E')
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
P1().apply(graph, [initial_node])
nodes_data = graph.nodes(data=True)
self.assertEqual(len(graph.nodes()), 7)
self.assertEqual(len(graph.edges()), 13)
# check the initial node
initial_node_data = nodes_data[initial_node]
self.assertEqual(initial_node_data['layer'], 0)
self.assertEqual(initial_node_data['position'], (0.5, 0.5))
self.assertEqual(initial_node_data['label'], 'e')
# check other nodes
vx_bl = get_node_at(graph, 1, (0, 0))
vx_br = get_node_at(graph, 1, (1, 0))
vx_tl = get_node_at(graph, 1, (0, 1))
vx_tr = get_node_at(graph, 1, (1, 1))
self.assertIsNotNone(vx_bl)
self.assertIsNotNone(vx_br)
self.assertIsNotNone(vx_tl)
self.assertIsNotNone(vx_tr)
self.assertEqual(nodes_data[vx_bl]['label'], 'E')
self.assertEqual(nodes_data[vx_br]['label'], 'E')
self.assertEqual(nodes_data[vx_tl]['label'], 'E')
self.assertEqual(nodes_data[vx_tr]['label'], 'E')
vx_i1 = get_node_at(graph, 1, (2 / 3, 1 / 3))
vx_i2 = get_node_at(graph, 1, (1 / 3, 2 / 3))
self.assertIsNotNone(vx_i1)
self.assertIsNotNone(vx_i2)
self.assertEqual(nodes_data[vx_i1]['label'], 'I')
self.assertEqual(nodes_data[vx_i2]['label'], 'I')
self.assertTrue(graph.has_edge(initial_node, vx_i1))
self.assertTrue(graph.has_edge(initial_node, vx_i2))
self.assertTrue(graph.has_edge(vx_tl, vx_tr))
self.assertTrue(graph.has_edge(vx_tr, vx_br))
self.assertTrue(graph.has_edge(vx_br, vx_bl))
self.assertTrue(graph.has_edge(vx_bl, vx_tl))
self.assertTrue(graph.has_edge(vx_bl, vx_tr))
self.assertTrue(graph.has_edge(vx_i1, vx_bl))
self.assertTrue(graph.has_edge(vx_i1, vx_br))
self.assertTrue(graph.has_edge(vx_i1, vx_tr))
self.assertTrue(graph.has_edge(vx_i2, vx_bl))
self.assertTrue(graph.has_edge(vx_i2, vx_tl))
self.assertTrue(graph.has_edge(vx_i2, vx_tr))
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
def __check_prod_input(graph, prod_input):
if len(set(prod_input)) != 3:
raise ValueError('too few interiors')
layer = graph.nodes()[prod_input[0]]['layer']
if any(graph.nodes()[interior]['layer'] != layer
for interior in prod_input[1:]):
raise ValueError('interior vertices come from different layers')
if any(graph.nodes()[interior]['label'] != 'I'
for interior in prod_input):
raise ValueError('interior vertices must have I label')
all_I_neighbours = []
for interior in prod_input:
interior_neighbours = get_neighbors_at(graph, interior, layer)
if len(interior_neighbours) not in [2, 3]:
raise ValueError('wrongly connected interior vertices')
for neighbour in interior_neighbours:
if graph.nodes()[neighbour]['label'] != 'E':
raise ValueError(
'interior vertices can be connect only with E vertices'
)
all_I_neighbours.append(neighbour)
E_vertices = get_vertices_from_layer(graph, layer, "E")
E_vertices_position_prev_layer = []
if any(E_vertice not in all_I_neighbours for E_vertice in E_vertices):
raise ValueError('wrongly connected E vertices')
for E_vertice in E_vertices:
E_vertice_neighbours = get_neighbors_at(graph, E_vertice, layer)
if len([
I_node for I_node in E_vertice_neighbours
if graph.nodes()[I_node]['label'] == "I"
]) not in [1, 2]:
raise ValueError(
'each E vertice must be connected with I vertice')
E_vertice_E_neighbours = [
neighbour for neighbour in E_vertice_neighbours
if graph.nodes()[neighbour]['label'] == "E"
]
if len(E_vertice_E_neighbours) not in [1, 2, 3]:
raise ValueError(
'each E vertice must be connected with at least one E vertice'
)
corresponding_vertice = get_node_at(
graph, layer - 1,
graph.nodes()[E_vertice]['position'])
if corresponding_vertice is not None:
E_vertices_position_prev_layer.append(corresponding_vertice)
if len(E_vertices_position_prev_layer) != 4 and len(
E_vertices_position_prev_layer) != 6:
raise ValueError(
'positions of corresponding vertices between layers are incorrect'
)
corresponding_positions = [
graph.nodes()[E_vertice]['position']
for E_vertice in E_vertices_position_prev_layer
]
noncorresponding_E_vertices = [
E_vertice for E_vertice in E_vertices if graph.nodes()[E_vertice]
['position'] not in corresponding_positions
]
possible_positions = []
for i in range(len(corresponding_positions) - 1):
x1, y1 = corresponding_positions[i]
for j in range(i + 1, len(corresponding_positions)):
x2, y2 = corresponding_positions[j]
possible_positions.append(((x1 + x2) / 2, (y1 + y2) / 2))
for E_vertice in noncorresponding_E_vertices:
x, y = graph.nodes()[E_vertice]['position']
if (x, y) not in possible_positions:
raise ValueError(
'position of noncorresponding vertice is incorrect')
overlapping_vertices = find_overlapping_vertices(graph)
if len(overlapping_vertices) != 4 or \
any(overlapping_vertice1 not in set(all_I_neighbours)
or overlapping_vertice2 not in set(all_I_neighbours)
for overlapping_vertice1, overlapping_vertice2 in overlapping_vertices):
raise ValueError('incorrect shape of graph')
vertices_to_join = set()
for overlapping_vertice1, overlapping_vertice2 in overlapping_vertices:
vertices_to_join.add(overlapping_vertice1)
vertices_to_join.add(overlapping_vertice2)
if len(vertices_to_join) != 4:
raise ValueError('too many overlapping vertices')
vertices_to_join_group1 = [
vertice for vertice in vertices_to_join
if graph.nodes()[vertice]['position'] == graph.nodes()[list(
vertices_to_join)[0]]['position']
]
vertices_to_join_group2 = [
vertice for vertice in vertices_to_join
if vertice not in vertices_to_join_group1
]
if len(vertices_to_join_group1) != 2 or len(
vertices_to_join_group2) != 2:
raise ValueError('too many overlapping vertices')
vertice1_neighbours = get_neighbors_at(graph,
vertices_to_join_group1[0],
layer)
vertice2_neighbours = get_neighbors_at(graph,
vertices_to_join_group1[1],
layer)
vertice3_neighbours = get_neighbors_at(graph,
vertices_to_join_group2[0],
layer)
vertice4_neighbours = get_neighbors_at(graph,
vertices_to_join_group2[1],
layer)
I_neighbours_vertice1 = [
neighbour for neighbour in vertice1_neighbours
if graph.nodes()[neighbour]['label'] == "I"
]
I_neighbours_vertice2 = [
neighbour for neighbour in vertice2_neighbours
if graph.nodes()[neighbour]['label'] == "I"
]
I_neighbours_vertice3 = [
neighbour for neighbour in vertice3_neighbours
if graph.nodes()[neighbour]['label'] == "I"
]
I_neighbours_vertice4 = [
neighbour for neighbour in vertice4_neighbours
if graph.nodes()[neighbour]['label'] == "I"
]
if len(I_neighbours_vertice1) != 1 or len(I_neighbours_vertice2) != 1 or \
len(I_neighbours_vertice3) != 1 or len(I_neighbours_vertice4) != 1:
raise ValueError(
'vertices to join wrongly connected with I vertices')
common_I_neighbour_vertices_to_join = []
if I_neighbours_vertice1 == I_neighbours_vertice3:
common_I_neighbour_vertices_to_join.append(
vertices_to_join_group1[0])
common_I_neighbour_vertices_to_join.append(
vertices_to_join_group2[0])
elif I_neighbours_vertice1 == I_neighbours_vertice4:
common_I_neighbour_vertices_to_join.append(
vertices_to_join_group1[0])
common_I_neighbour_vertices_to_join.append(
vertices_to_join_group2[1])
elif I_neighbours_vertice2 == I_neighbours_vertice3:
common_I_neighbour_vertices_to_join.append(
vertices_to_join_group1[1])
common_I_neighbour_vertices_to_join.append(
vertices_to_join_group2[0])
elif I_neighbours_vertice2 == I_neighbours_vertice4:
common_I_neighbour_vertices_to_join.append(
vertices_to_join_group1[1])
common_I_neighbour_vertices_to_join.append(
vertices_to_join_group2[1])
else:
raise ValueError(
'vertices to join wrongly connected with I vertices')
noncommon_I_neighbour_vertices_to_join = [
vertice for vertice in vertices_to_join
if vertice not in common_I_neighbour_vertices_to_join
]
if len(noncommon_I_neighbour_vertices_to_join) != 2:
raise ValueError(
'vertices to join wrongly connected with I vertices')
if len(
set(common_I_neighbour_vertices_to_join).intersection(
set(noncommon_I_neighbour_vertices_to_join))) != 0:
raise ValueError('vertices to join wrongly connected')
common_vertice1_neighbours = get_neighbors_at(
graph, common_I_neighbour_vertices_to_join[0], layer)
common_vertice2_neighbours = get_neighbors_at(
graph, common_I_neighbour_vertices_to_join[1], layer)
if common_I_neighbour_vertices_to_join[
1] not in common_vertice1_neighbours:
raise ValueError(
'vertices to join with common I neighbour are not connected')
if len(
set(common_vertice1_neighbours).intersection(
set(common_vertice2_neighbours))) not in [1, 2]:
raise ValueError(
'vertices to join with common I neighbour are wrongly connected'
)
noncommon_vertice1_neighbours = get_neighbors_at(
graph, noncommon_I_neighbour_vertices_to_join[0], layer)
noncommon_vertice2_neighbours = get_neighbors_at(
graph, noncommon_I_neighbour_vertices_to_join[1], layer)
if noncommon_I_neighbour_vertices_to_join[
1] in noncommon_vertice1_neighbours:
raise ValueError(
'vertices to join with non-common I neighbour are connected')
if len(
set(noncommon_vertice1_neighbours).intersection(
set(noncommon_vertice2_neighbours))) not in [1, 2]:
raise ValueError(
'vertices to join with common I neighbour are wrongly connected'
)
def test_happy_path(self):
graph = Graph()
e1 = gen_name()
e2 = gen_name()
e3 = gen_name()
graph.add_node(e1, layer=0, position=(1.0, 2.0), label='E')
graph.add_node(e2, layer=0, position=(1.0, 1.0), label='E')
graph.add_node(e3, layer=0, position=(2.0, 1.0), label='E')
graph.add_edge(e1, e2)
graph.add_edge(e1, e3)
graph.add_edge(e2, e3)
i = add_interior(graph, e1, e2, e3)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
[i1, i2] = P2().apply(graph, [i])
self.assertIsNotNone(get_node_at(graph, 1, (1.0, 2.0)))
self.assertIsNotNone(get_node_at(graph, 1, (1.0, 1.0)))
self.assertIsNotNone(get_node_at(graph, 1, (2.0, 1.0)))
self.assertIsNotNone(get_node_at(graph, 1, (1.5, 1.0)))
(i1_x, i1_y) = graph.nodes[i1]['position']
(i2_x, i2_y) = graph.nodes[i2]['position']
self.assertTrue(isclose(i1_x, 1.166666, rel_tol=eps))
self.assertTrue(isclose(i1_y, 1.333333, rel_tol=eps))
self.assertTrue(isclose(i2_x, 1.5, rel_tol=eps))
self.assertTrue(isclose(i2_y, 1.333333, rel_tol=eps))
self.assertEqual(len(graph.nodes()), 10)
self.assertEqual(len(graph.edges()), 19)
self.assertEqual(graph.nodes[i]['label'], 'i')
self.assertTrue(graph.has_edge(i, i1))
self.assertTrue(graph.has_edge(i, i2))
self.assertEqual(graph.nodes[i1]['label'], 'I')
self.assertEqual(graph.nodes[i2]['label'], 'I')
self.assertEqual(graph.nodes[i1]['layer'], graph.nodes[i]['layer'] + 1)
self.assertEqual(graph.nodes[i2]['layer'], graph.nodes[i]['layer'] + 1)
i1_neighbors = get_neighbors_at(graph, i1, graph.nodes[i1]['layer'])
self.assertEqual(len(i1_neighbors), 3)
i2_neighbors = get_neighbors_at(graph, i2, graph.nodes[i2]['layer'])
self.assertEqual(len(i2_neighbors), 3)
common_neighbors = [x for x in i1_neighbors if x in i2_neighbors]
for n in i1_neighbors:
if n not in common_neighbors:
self.assertEqual(graph.nodes[n]['label'], 'E')
self.assertEqual(
len(get_neighbors_at(graph, n, graph.nodes[i1]['layer'])),
3)
for n in i2_neighbors:
if n not in common_neighbors:
self.assertEqual(graph.nodes[n]['label'], 'E')
self.assertEqual(
len(get_neighbors_at(graph, n, graph.nodes[i2]['layer'])),
3)
for c_neighbor in common_neighbors:
self.assertEqual(graph.nodes[c_neighbor]['label'], 'E')
self.assertEqual(
len(
get_neighbors_at(graph, c_neighbor,
graph.nodes[i1]['layer'])), 5)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
def __check_prod_input(graph, prod_input):
if len(set(prod_input)) != 4:
raise ValueError('too few interiors')
layer = graph.nodes()[prod_input[0]]['layer']
if any(graph.nodes()[interior]['layer'] != layer
for interior in prod_input[1:]):
raise ValueError('interior vertices come from different layers')
if any(graph.nodes()[interior]['label'] != 'I'
for interior in prod_input):
raise ValueError('interior vertices must have I label')
all_I_neighbours = []
for interior in prod_input:
interior_neighbours = get_neighbors_at(graph, interior, layer)
if len(interior_neighbours) not in [2, 3]:
raise ValueError('wrongly connected interior vertices')
for neighbour in interior_neighbours:
if graph.nodes()[neighbour]['label'] != 'E':
raise ValueError(
'interior vertices can be connect only with E vertices'
)
all_I_neighbours.append(neighbour)
E_vertices = get_vertices_from_layer(graph, layer, 'E')
E_vertices_position_prev_layer = []
if any(E_vertice not in all_I_neighbours for E_vertice in E_vertices):
raise ValueError('wrongly connected E vertices')
for E_vertice in E_vertices:
E_vertice_neighbours = get_neighbors_at(graph, E_vertice, layer)
if len([
I_node for I_node in E_vertice_neighbours
if graph.nodes()[I_node]['label'] == "I"
]) != 2:
raise ValueError(
'each E vertice must be connected with two I vertices')
E_vertice_E_neighbours = [
neighbour for neighbour in E_vertice_neighbours
if graph.nodes()[neighbour]['label'] == "E"
]
if len(E_vertice_E_neighbours) not in [1, 2, 3, 4]:
print(len(E_vertice_E_neighbours))
raise ValueError(
'each E vertice must be connected with at least one E vertice'
)
corresponding_vertice = get_node_at(
graph, layer - 1,
graph.nodes()[E_vertice]['position'])
if corresponding_vertice is not None:
E_vertices_position_prev_layer.append(corresponding_vertice)
if len(E_vertices_position_prev_layer) != 2 and len(
E_vertices_position_prev_layer) != 4:
raise ValueError(
'positions of corresponding vertices between layers are incorrect'
)
corresponding_positions = [
graph.nodes()[E_vertice]['position']
for E_vertice in E_vertices_position_prev_layer
]
noncorresponding_E_vertices = [
E_vertice for E_vertice in E_vertices if graph.nodes()[E_vertice]
['position'] not in corresponding_positions
]
possible_positions = []
for i in range(len(corresponding_positions) - 1):
x1, y1 = corresponding_positions[i]
for j in range(i + 1, len(corresponding_positions)):
x2, y2 = corresponding_positions[j]
possible_positions.append(((x1 + x2) / 2, (y1 + y2) / 2))
for E_vertice in noncorresponding_E_vertices:
x, y = graph.nodes()[E_vertice]['position']
if (x, y) not in possible_positions:
raise ValueError(
'positions of noncorresponding vertices are incorrect')
overlapping_vertices = find_overlapping_vertices(graph)
if len(overlapping_vertices) != 2 or \
any(overlapping_vertice1 not in set(all_I_neighbours)
or overlapping_vertice2 not in set(all_I_neighbours)
for overlapping_vertice1, overlapping_vertice2 in overlapping_vertices):
raise ValueError('incorrect shape of graph')
vertices_to_join = [
neighbour for neighbour in set(all_I_neighbours)
if graph.nodes()[neighbour]['position'] == graph.nodes()[
overlapping_vertices[0][0]]['position']
]
if len(vertices_to_join) != 2:
raise ValueError('too many overlapping vertices')
vertice1_neighbours = get_neighbors_at(graph, vertices_to_join[0],
layer)
vertice2_neighbours = get_neighbors_at(graph, vertices_to_join[1],
layer)
common_neighbours = set(vertice1_neighbours).intersection(
set(vertice2_neighbours))
if len(common_neighbours) != 2:
raise ValueError('vertices to join wrongly connected')
I_neighbours_vertice1 = [
neighbour for neighbour in vertice1_neighbours
if graph.nodes()[neighbour]['label'] == "I"
]
I_neighbours_vertice2 = [
neighbour for neighbour in vertice2_neighbours
if graph.nodes()[neighbour]['label'] == "I"
]
if len(I_neighbours_vertice1) != 2 or len(I_neighbours_vertice2) != 2:
raise ValueError(
'vertices to join wrongly connected with I vertices')
if len(set(I_neighbours_vertice1).intersection(
I_neighbours_vertice2)) != 0:
raise ValueError('vertices to join have common I neighbour')
def test_happy_path(self):
graph = Graph()
positions = [(1.0, 1.0), (1.0, 2.0), (1.0, 3.0), (2.0, 3.0),
(3.0, 3.0), (2.0, 2.0)]
[e1, e12, e2, e23, e3,
e31] = self.create_nodes(graph, 1, 'E', positions)
self.create_edges_chain(graph, [e1, e12, e2, e23, e3, e31, e1])
i = add_interior(graph, e1, e2, e3)
if visualize_tests:
pyplot.title("Correct input", fontsize=16)
visualize_graph_3d(graph)
pyplot.show()
[i1, i3, i2a, i2b] = P5().apply(graph, [i])
if visualize_tests:
pyplot.title("Correct output", fontsize=16)
visualize_graph_3d(graph)
pyplot.show()
pyplot.title("Correct output (layer = 1)", fontsize=16)
visualize_graph_layer(graph, 1)
pyplot.show()
pyplot.title("Correct output (layer = 2)", fontsize=16)
visualize_graph_layer(graph, 2)
pyplot.show()
# if correct number of nodes and edges
self.assertEqual(len(graph.nodes()), 17)
self.assertEqual(len(graph.edges()), 34)
# if cross-layer interior connections
self.assertEqual(graph.nodes[i]['label'], 'i')
self.assertTrue(graph.has_edge(i, i1))
self.assertTrue(graph.has_edge(i, i3))
self.assertTrue(graph.has_edge(i, i2a))
self.assertTrue(graph.has_edge(i, i2b))
# if new interiors has correct labels and layers
self.assertEqual(graph.nodes[i1]['label'], 'I')
self.assertEqual(graph.nodes[i3]['label'], 'I')
self.assertEqual(graph.nodes[i2a]['label'], 'I')
self.assertEqual(graph.nodes[i2b]['label'], 'I')
self.assertEqual(graph.nodes[i1]['layer'], graph.nodes[i]['layer'] + 1)
self.assertEqual(graph.nodes[i3]['layer'], graph.nodes[i]['layer'] + 1)
self.assertEqual(graph.nodes[i2a]['layer'],
graph.nodes[i]['layer'] + 1)
self.assertEqual(graph.nodes[i2b]['layer'],
graph.nodes[i]['layer'] + 1)
# if each new interior has 3 neighbors
i1_neighbors = get_neighbors_at(graph, i1, graph.nodes[i1]['layer'])
self.assertEqual(len(i1_neighbors), 3)
i3_neighbors = get_neighbors_at(graph, i3, graph.nodes[i3]['layer'])
self.assertEqual(len(i3_neighbors), 3)
i2a_neighbors = get_neighbors_at(graph, i2a, graph.nodes[i2a]['layer'])
self.assertEqual(len(i2a_neighbors), 3)
i2b_neighbors = get_neighbors_at(graph, i2b, graph.nodes[i2b]['layer'])
self.assertEqual(len(i2b_neighbors), 3)
# if new nodes are in correct positions
new_e1 = get_node_at(graph, 2, (1.0, 1.0))
new_e12 = get_node_at(graph, 2, (1.0, 2.0))
new_e2 = get_node_at(graph, 2, (1.0, 3.0))
new_e23 = get_node_at(graph, 2, (2.0, 3.0))
new_e3 = get_node_at(graph, 2, (3.0, 3.0))
new_e31 = get_node_at(graph, 2, (2.0, 2.0))
self.assertIsNotNone(new_e1)
self.assertIsNotNone(new_e12)
self.assertIsNotNone(new_e2)
self.assertIsNotNone(new_e23)
self.assertIsNotNone(new_e3)
self.assertIsNotNone(new_e31)
# if interiors connect with all new 6 vertices
all_neighbors = i1_neighbors + i3_neighbors + i2a_neighbors + i2b_neighbors
all_neighbors = list(dict.fromkeys(all_neighbors)) # remove duplicates
self.assertEqual(len(all_neighbors), 6)
# if each vertex has correct label
for n in all_neighbors:
self.assertEqual(graph.nodes[n]['label'], 'E')
# if each vertex has correct number of neighbors (based on neighbour interiors count)
for n in all_neighbors:
node_neighbors = get_neighbors_at(graph, n,
graph.nodes[n]['layer'])
i_neighbors = [
x for x in node_neighbors if graph.nodes[x]['label'] == 'I'
]
if len(i_neighbors) == 1:
self.assertEqual(len(node_neighbors), 3)
elif len(i_neighbors) == 2:
self.assertEqual(len(node_neighbors), 5)
else: # 4
self.assertEqual(len(node_neighbors), 9)
def test_happy_path(self):
graph = Graph()
e1 = gen_name()
e2 = gen_name()
e3 = gen_name()
e4 = gen_name()
e1_1 = gen_name()
e1_2 = gen_name()
e1_3 = gen_name()
e2_1 = gen_name()
e2_2 = gen_name()
e2_4 = gen_name()
e3_5 = gen_name()
graph.add_node(e1, layer=1, position=(1.0, 1.0), label='E')
graph.add_node(e2, layer=1, position=(2.0, 2.0), label='E')
graph.add_node(e3, layer=1, position=(1.0, 2.0), label='E')
graph.add_node(e4, layer=1, position=(2.0, 1.0), label='E')
graph.add_node(e1_1, layer=2, position=(1.0, 1.0), label='E')
graph.add_node(e1_2, layer=2, position=(2.0, 2.0), label='E')
graph.add_node(e1_3, layer=2, position=(1.0, 2.0), label='E')
graph.add_node(e2_1, layer=2, position=(1.0, 1.0), label='E')
graph.add_node(e2_2, layer=2, position=(2.0, 2.0), label='E')
graph.add_node(e2_4, layer=2, position=(2.0, 1.0), label='E')
graph.add_node(e3_5, layer=2, position=(2.0, 3.0), label='E')
graph.add_edge(e1, e2)
graph.add_edge(e1, e3)
graph.add_edge(e1, e4)
graph.add_edge(e2, e3)
graph.add_edge(e2, e4)
graph.add_edge(e1_1, e1_2)
graph.add_edge(e1_1, e1_3)
graph.add_edge(e1_2, e1_3)
graph.add_edge(e2_1, e2_2)
graph.add_edge(e2_1, e2_4)
graph.add_edge(e2_2, e2_4)
graph.add_edge(e3_5, e1_2)
graph.add_edge(e3_5, e1_3)
i1 = add_interior(graph, e1, e2, e3)
i2 = add_interior(graph, e1, e2, e4)
i1_1 = add_interior(graph, e1_1, e1_2, e1_3)
i2_1 = add_interior(graph, e2_1, e2_2, e2_4)
i3_1 = add_interior(graph, e3_5, e1_2, e1_3)
graph.nodes[i1]['label'] = 'i'
graph.nodes[i2]['label'] = 'i'
graph.add_edge(i1, i1_1)
graph.add_edge(i2, i2_1)
graph.add_edge(i1, i3_1)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
P12().apply(graph, [i1, i2, i1_1, i2_1])
# if correct number of nodes and edges
self.assertEqual(len(graph.nodes()), 14)
self.assertEqual(len(graph.edges()), 30)
# if interiors has correct labels, layers and are connected
self.assertEqual(graph.nodes[i1]['label'], 'i')
self.assertEqual(graph.nodes[i2]['label'], 'i')
self.assertEqual(graph.nodes[i1_1]['label'], 'I')
self.assertEqual(graph.nodes[i2_1]['label'], 'I')
self.assertEqual(graph.nodes[i1]['layer'], 1)
self.assertEqual(graph.nodes[i2]['layer'], 1)
self.assertEqual(graph.nodes[i1_1]['layer'], 2)
self.assertEqual(graph.nodes[i2_1]['layer'], 2)
self.assertTrue(graph.has_edge(i1, i1_1))
self.assertTrue(graph.has_edge(i2, i2_1))
# if each interior has 3 neighbors
i1_neighbors = get_neighbors_at(graph, i1, graph.nodes[i1]['layer'])
self.assertEqual(len(i1_neighbors), 3)
i2_neighbors = get_neighbors_at(graph, i2, graph.nodes[i2]['layer'])
self.assertEqual(len(i2_neighbors), 3)
i1_1_neighbors = get_neighbors_at(graph, i1_1,
graph.nodes[i1_1]['layer'])
self.assertEqual(len(i1_1_neighbors), 3)
i2_1_neighbors = get_neighbors_at(graph, i2_1,
graph.nodes[i2_1]['layer'])
self.assertEqual(len(i2_1_neighbors), 3)
# if nodes in lower layer exists and are correctly connected
new_e1 = get_node_at(graph, 2, (1.0, 1.0))
new_e2 = get_node_at(graph, 2, (2.0, 2.0))
new_e3 = get_node_at(graph, 2, (1.0, 2.0))
new_e4 = get_node_at(graph, 2, (2.0, 1.0))
self.assertIsNotNone(new_e1)
self.assertIsNotNone(new_e2)
self.assertIsNotNone(new_e3)
self.assertIsNotNone(new_e4)
self.assertTrue(graph.has_edge(new_e1, new_e2))
self.assertTrue(graph.has_edge(new_e1, new_e3))
self.assertTrue(graph.has_edge(new_e1, new_e4))
self.assertTrue(graph.has_edge(new_e2, new_e3))
self.assertTrue(graph.has_edge(new_e2, new_e4))
# if lower interiors connect with all 4 vertices
all_neighbors = i1_1_neighbors + i2_1_neighbors
all_neighbors = list(dict.fromkeys(all_neighbors)) # remove duplicates
self.assertEqual(len(all_neighbors), 4)
# if each vertex has correct label
for n in all_neighbors:
self.assertEqual(graph.nodes[n]['label'], 'E')
# if each vertex has correct number of neighbors (based on neighbour interiors count)
for n in all_neighbors:
node_neighbors = get_neighbors_at(graph, n,
graph.nodes[n]['layer'])
i_neighbors = [
x for x in node_neighbors if graph.nodes[x]['label'] == 'I'
]
if len(i_neighbors) == 1:
self.assertEqual(len(node_neighbors), 3)
elif len(i_neighbors) == 2:
self.assertEqual(len(node_neighbors), 5)
else:
self.assertEqual(len(node_neighbors), 7)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
def testOnBiggerGraph(self):
graph = Graph()
initial_node_name = gen_name()
graph.add_node(initial_node_name, layer=0, position=(0.5, 0.5), label='E')
[i1, i2] = P1().apply(graph, [initial_node_name])
[i1_1, i1_2] = P2().apply(graph, [i1], orientation=1)
[i2_1] = P9().apply(graph, [i2], orientation=1)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
[i1_1new, i1_2new, i2_1new] = P10().apply(graph, [i1_1, i1_2, i2_1])
self.assertEqual(len(graph.nodes()), 15)
self.assertEqual(len(graph.edges()), 32)
e = get_node_at(graph=graph, layer=0, pos=(0.5, 0.5))
e1 = get_node_at(graph=graph, layer=1, pos=(0.0, 0.0))
e2 = get_node_at(graph=graph, layer=1, pos=(1.0, 0.0))
e3 = get_node_at(graph=graph, layer=1, pos=(1.0, 1.0))
e4 = get_node_at(graph=graph, layer=1, pos=(0.0, 1.0))
e5 = get_node_at(graph=graph, layer=2, pos=(0.0, 0.0))
e6 = get_node_at(graph=graph, layer=2, pos=(1.0, 0.0))
e7 = get_node_at(graph=graph, layer=2, pos=(1.0, 1.0))
e8 = get_node_at(graph=graph, layer=2, pos=(0.0, 1.0))
e9 = get_node_at(graph=graph, layer=2, pos=(0.5, 0.5))
# check position
self.assertIsNotNone(e)
self.assertIsNotNone(e1)
self.assertIsNotNone(e2)
self.assertIsNotNone(e3)
self.assertIsNotNone(e4)
self.assertIsNotNone(e5)
self.assertIsNotNone(e6)
self.assertIsNotNone(e7)
self.assertIsNotNone(e8)
self.assertIsNotNone(e9)
self.assertEqual(graph.nodes[i1_1new]['position'], graph.nodes[i1_1]['position'])
self.assertEqual(graph.nodes[i1_2new]['position'], graph.nodes[i1_2]['position'])
self.assertEqual(graph.nodes[i2_1new]['position'], graph.nodes[i2]['position']) # ten co jest z prawe
self.assertEqual(graph.nodes[i1_1new]['layer'], graph.nodes[i1_1]['layer'])
self.assertEqual(graph.nodes[i1_2new]['layer'], graph.nodes[i1_2]['layer'])
self.assertEqual(graph.nodes[i2_1new]['layer'], graph.nodes[i2_1]['layer'])
i1_new = get_node_at(graph=graph, layer=1, pos=graph.nodes[i1]['position'])
i2_new = get_node_at(graph=graph, layer=1, pos=graph.nodes[i2]['position'])
self.assertIsNotNone(i1_new)
self.assertIsNotNone(i2_new)
# zero
self.assertTrue(graph.has_edge(e, i1_new))
self.assertTrue(graph.has_edge(e, i2_new))
# first
self.assertTrue(graph.has_edge(e1, e2))
self.assertTrue(graph.has_edge(e1, e3))
self.assertTrue(graph.has_edge(e1, e4))
self.assertTrue(graph.has_edge(e1, i2_new))
self.assertTrue(graph.has_edge(e1, i1_new))
self.assertTrue(graph.has_edge(e2, e3))
self.assertTrue(graph.has_edge(e2, i2_new))
self.assertTrue(graph.has_edge(e3, e4))
self.assertTrue(graph.has_edge(e3, i1_new))
self.assertTrue(graph.has_edge(e3, i2_new))
self.assertTrue(graph.has_edge(e4, i1_new))
# second
self.assertTrue(graph.has_edge(e5, e6))
self.assertTrue(graph.has_edge(e5, e9))
self.assertTrue(graph.has_edge(e5, e8))
self.assertTrue(graph.has_edge(e6, e7))
self.assertTrue(graph.has_edge(e7, e9))
self.assertTrue(graph.has_edge(e7, e8))
self.assertTrue(graph.has_edge(i1_new, i1_1new))
self.assertTrue(graph.has_edge(i1_new, i1_2new))
self.assertTrue(graph.has_edge(i2_new, i2_1new))
self.assertTrue(graph.has_edge(e5, i1_1new))
self.assertTrue(graph.has_edge(e8, i1_1new))
self.assertTrue(graph.has_edge(e9, i1_1new))
self.assertTrue(graph.has_edge(e7, i1_2new))
self.assertTrue(graph.has_edge(e8, i1_2new))
self.assertTrue(graph.has_edge(e9, i1_2new))
self.assertTrue(graph.has_edge(e5, i2_1new))
self.assertTrue(graph.has_edge(e6, i2_1new))
self.assertTrue(graph.has_edge(e7, i2_1new))
# check labels
self.assertEqual(graph.nodes[e]['label'], 'e')
self.assertEqual(graph.nodes[e1]['label'], 'E')
self.assertEqual(graph.nodes[e2]['label'], 'E')
self.assertEqual(graph.nodes[e3]['label'], 'E')
self.assertEqual(graph.nodes[e4]['label'], 'E')
self.assertEqual(graph.nodes[e5]['label'], 'E')
self.assertEqual(graph.nodes[e6]['label'], 'E')
self.assertEqual(graph.nodes[e7]['label'], 'E')
self.assertEqual(graph.nodes[e8]['label'], 'E')
self.assertEqual(graph.nodes[e9]['label'], 'E')
self.assertEqual(graph.nodes[i1_1new]['label'], 'I')
self.assertEqual(graph.nodes[i1_2new]['label'], 'I')
self.assertEqual(graph.nodes[i2_1new]['label'], 'I')
self.assertEqual(graph.nodes[i1_new]['label'], 'i')
self.assertEqual(graph.nodes[i2_new]['label'], 'i')
def testHappyPath(self):
graph = createCorrectGraph()
prod_input = [x for x, y in graph.nodes(data=True) if y['label'] == 'I']
P10().apply(graph, prod_input)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
#test if number of nodes and edges is correct
self.assertEqual(len(graph.nodes()), 10)
self.assertEqual(len(graph.edges()), 16)
e1 = get_node_at(graph=graph, layer=1, pos=(1.0, 2.0))
e2 = get_node_at(graph=graph, layer=1, pos=(3.0, 2.0))
i1 = get_node_at(graph=graph, layer=1, pos=(2.0, 3.0))
i2 = get_node_at(graph=graph, layer=1, pos=(2.0, 1.0))
I1 = get_node_at(graph=graph, layer=2, pos=(1.5, 3.5))
I2 = get_node_at(graph=graph, layer=2, pos=(2.5, 3.5))
e3 = get_node_at(graph=graph, layer=2, pos=(1.0, 2.0))
e4 = get_node_at(graph=graph, layer=2, pos=(3.0, 2.0))
e5 = get_node_at(graph=graph, layer=2, pos=(2.0, 2.0))
I3 = get_node_at(graph=graph, layer=2, pos=(2.5, 0.5))
#check position
self.assertIsNotNone(e1)
self.assertIsNotNone(e2)
self.assertIsNotNone(i1)
self.assertIsNotNone(i2)
self.assertIsNotNone(I1)
self.assertIsNotNone(I2)
self.assertIsNotNone(e3)
self.assertIsNotNone(e4)
self.assertIsNotNone(e5)
self.assertIsNotNone(I3)
#check edges
# upper layer edges
self.assertTrue(graph.has_edge(e1, i1))
self.assertTrue(graph.has_edge(e1, i2))
self.assertTrue(graph.has_edge(e2, i1))
self.assertTrue(graph.has_edge(e2, i2))
self.assertTrue(graph.has_edge(e1, e2))
# interlayer connections
self.assertTrue(graph.has_edge(I1, i1))
self.assertTrue(graph.has_edge(I2, i1))
self.assertTrue(graph.has_edge(I3, i2))
# lower layer connections
self.assertTrue(graph.has_edge(I1, e3))
self.assertTrue(graph.has_edge(I1, e5))
self.assertTrue(graph.has_edge(e3, e5))
self.assertTrue(graph.has_edge(I2, e4))
self.assertTrue(graph.has_edge(I2, e5))
self.assertTrue(graph.has_edge(e4, e5))
self.assertTrue(graph.has_edge(I3, e3))
self.assertTrue(graph.has_edge(I3, e4))
#check labels
self.assertEqual(graph.nodes[e1]['label'], 'E')
self.assertEqual(graph.nodes[e2]['label'], 'E')
self.assertEqual(graph.nodes[i1]['label'], 'i')
self.assertEqual(graph.nodes[i2]['label'], 'i')
self.assertEqual(graph.nodes[I1]['label'], 'I')
self.assertEqual(graph.nodes[I2]['label'], 'I')
self.assertEqual(graph.nodes[e3]['label'], 'E')
self.assertEqual(graph.nodes[e4]['label'], 'E')
self.assertEqual(graph.nodes[e5]['label'], 'E')
self.assertEqual(graph.nodes[I3]['label'], 'I')
def test_happy_path(self):
graph = Graph()
e1_1, e2_1, e3_1, e4_1 = [gen_name() for _ in range(4)]
graph.add_node(e1_1, layer=1, position=(0.0, 0.0), label='E')
graph.add_node(e2_1, layer=1, position=(1.0, 0.0), label='E')
graph.add_node(e3_1, layer=1, position=(0.5, 0.5), label='E')
graph.add_node(e4_1, layer=1, position=(0.0, 1.0), label='E')
graph.add_edge(e1_1, e2_1)
graph.add_edge(e1_1, e3_1)
graph.add_edge(e1_1, e4_1)
graph.add_edge(e2_1, e3_1)
graph.add_edge(e3_1, e4_1)
i1_1 = add_interior(graph, e1_1, e2_1, e3_1)
i2_1 = add_interior(graph, e1_1, e3_1, e4_1)
graph.nodes[i1_1]['label'] = 'i'
graph.nodes[i2_1]['label'] = 'i'
e1_2, e2_2, e3_2, e4_2, e5_2 = [gen_name() for _ in range(5)]
graph.add_node(e1_2, layer=2, position=(0.0, 0.0), label='E')
graph.add_node(e5_2, layer=2, position=(0.0, 0.0), label='E')
graph.add_node(e2_2, layer=2, position=(1.0, 0.0), label='E')
graph.add_node(e3_2, layer=2, position=(0.5, 0.5), label='E')
graph.add_node(e4_2, layer=2, position=(0.0, 1.0), label='E')
graph.add_edge(e1_2, e2_2)
graph.add_edge(e1_2, e3_2)
graph.add_edge(e5_2, e4_2)
graph.add_edge(e5_2, e3_2)
graph.add_edge(e2_2, e3_2)
graph.add_edge(e3_2, e4_2)
i1_2 = add_interior(graph, e1_2, e2_2, e3_2)
i2_2 = add_interior(graph, e5_2, e3_2, e4_2)
graph.add_edge(i1_1, i1_2)
graph.add_edge(i2_1, i2_2)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
P13().apply(graph, [i1_1, i2_1, i1_2, i2_2])
# based on test_p12
# if correct number of nodes and edges
self.assertEqual(len(graph.nodes()), 12)
self.assertEqual(len(graph.edges()), 24)
# if interiors has correct labels, layers and are connected
self.assertEqual(graph.nodes[i1_1]['label'], 'i')
self.assertEqual(graph.nodes[i2_1]['label'], 'i')
self.assertEqual(graph.nodes[i1_1]['layer'], 1)
self.assertEqual(graph.nodes[i2_1]['layer'], 1)
self.assertEqual(graph.nodes[i1_2]['label'], 'I')
self.assertEqual(graph.nodes[i2_2]['label'], 'I')
self.assertEqual(graph.nodes[i1_2]['layer'], 2)
self.assertEqual(graph.nodes[i2_2]['layer'], 2)
self.assertTrue(graph.has_edge(i1_1, i1_2))
self.assertTrue(graph.has_edge(i2_1, i2_2))
# if each interior has 3 neighbors on the corresponding layer
i1_1_neighbors = get_neighbors_at(graph, i1_1,
graph.nodes[i1_1]['layer'])
self.assertEqual(len(i1_1_neighbors), 3)
i2_1_neighbors = get_neighbors_at(graph, i2_1,
graph.nodes[i2_1]['layer'])
self.assertEqual(len(i2_1_neighbors), 3)
i1_2_neighbors = get_neighbors_at(graph, i1_2,
graph.nodes[i1_2]['layer'])
self.assertEqual(len(i1_2_neighbors), 3)
i2_2_neighbors = get_neighbors_at(graph, i2_2,
graph.nodes[i2_2]['layer'])
self.assertEqual(len(i2_2_neighbors), 3)
# if nodes in lower layer exists and are correctly connected
new_e1_2 = get_node_at(graph, 2, (0.0, 0.0))
new_e2_2 = get_node_at(graph, 2, (1.0, 0.0))
new_e3_2 = get_node_at(graph, 2, (0.5, 0.5))
new_e4_2 = get_node_at(graph, 2, (0.0, 1.0))
self.assertIsNotNone(new_e1_2)
self.assertIsNotNone(new_e2_2)
self.assertIsNotNone(new_e3_2)
self.assertIsNotNone(new_e4_2)
self.assertTrue(graph.has_edge(new_e1_2, new_e2_2))
self.assertTrue(graph.has_edge(new_e1_2, new_e3_2))
self.assertTrue(graph.has_edge(new_e1_2, new_e4_2))
self.assertTrue(graph.has_edge(new_e2_2, new_e3_2))
self.assertTrue(graph.has_edge(new_e3_2, new_e4_2))
# if lower interiors connect with all 4 vertices
all_neighbors = i1_2_neighbors + i2_2_neighbors
all_neighbors = list(dict.fromkeys(all_neighbors)) # remove duplicates
self.assertEqual(len(all_neighbors), 4)
# if each vertex has correct label
for n in all_neighbors:
self.assertEqual(graph.nodes[n]['label'], 'E')
# if each vertex has correct number of neighbors (based on neighbour interiors count)
for n in all_neighbors:
node_neighbors = get_neighbors_at(graph, n,
graph.nodes[n]['layer'])
i_neighbors = [
x for x in node_neighbors if graph.nodes[x]['label'] == 'I'
]
if len(i_neighbors) == 1:
self.assertEqual(len(node_neighbors), 3)
elif len(i_neighbors) == 2:
self.assertEqual(len(node_neighbors), 5)
else:
self.assertEqual(len(node_neighbors), 7)
if visualize_tests:
visualize_graph_3d(graph)
pyplot.show()
