def test_node_remove_neighbour(test_node: Node):
"""test that we correctly remove nodes from neighbours"""
other = Node(x=1.5, y=0)
test_node.add_neighbour(other)
test_node.remove_neighbour(other)
assert other not in test_node.neighbours
assert other not in test_node._ordered_neighbours
def test_get_angle():
"""test that we can measure angles between nodes"""
node0 = Node(x=0, y=0, label="node0")
node1 = Node(x=1, y=0, label="node1")
node2 = Node(x=1, y=1, label="node2")
# test a few angles
assert node0._get_angle(node1) == deg2rad(0)
assert node0._get_angle(node2) == deg2rad(45)
assert node1._get_angle(node0) == deg2rad(180)
assert node2._get_angle(node0) == deg2rad(180 + 45)
def test_linear_spring_get_resting_length():
"""test that we compute the correct resting length"""
for (x0, y0, x1, y1) in [(0, 0, 0, 0), (0, 0, 1, 1), (
1,
1,
1,
1,
), (1.5, 2.3, 0, 6.7), (-1, 0, -1, 0), (-1, -4.5, 6.7, 100)]:
node0 = Node(x=x0, y=y0, label="node0")
node1 = Node(x=x1, y=y1, label="node1")
linear_spring = LinearSpring(
nodes=(node0, node1),
stiffness=0.1,
)
resting_length = np.sqrt((x1 - x0)**2 + (y1 - y0)**2)
assert resting_length == linear_spring._get_resting_length()
def test_node_order_neighbours():
"""test that we order neighbours correctly"""
node0 = Node(x=0, y=0, label="node0")
node1 = Node(x=1, y=0, label="node1")
node2 = Node(x=1, y=1, label="node2")
node3 = Node(x=0, y=1, label="node3")
# add the nodes out of order
node0.add_neighbour(node3)
node0.add_neighbour(node1)
node0.add_neighbour(node2)
# check that it keeps them ordered
assert ["node1", "node2",
"node3"] == [node.label for node in node0._ordered_neighbours]
def test_angular_spring_get_resting_angle():
"""check that we compute the correct resting angle"""
node0 = Node(x=0, y=0)
node1 = Node(x=1, y=0)
node2 = Node(x=1, y=1)
# test spring at 45 deg
angular_spring = AngularSpring(node_origin=node0,
node_start=node1,
node_end=node2,
stiffness=0.15)
assert angular_spring._get_resting_angle() == np.deg2rad(45)
# same spring, other direction
# angles are signed, anti-clockwise
angular_spring = AngularSpring(node_origin=node0,
node_start=node2,
node_end=node1,
stiffness=0.15)
assert angular_spring._get_resting_angle() == np.deg2rad(360 - 45)
def test_linear_spring_init():
"""test that we can initialize a node"""
node0 = Node(x=0, y=0)
node1 = Node(x=1, y=1)
linear_spring = LinearSpring(
nodes=(node0, node1),
stiffness=0.1,
)
# check types
assert isinstance(linear_spring, LinearSpring)
assert isinstance(linear_spring._nodes, Tuple)
assert isinstance(linear_spring.stiffness, float)
# check storing
_node0, _node1 = linear_spring._nodes
_stiffness = linear_spring.stiffness
assert node0 == _node0
assert node1 == _node1
assert _stiffness == 0.1
def test_angular_spring_init():
"""test that we can instantiate an angular spring"""
node0 = Node(x=0, y=0)
node1 = Node(x=1, y=0)
node2 = Node(x=1, y=1)
angular_spring = AngularSpring(node_origin=node0,
node_start=node1,
node_end=node2,
stiffness=0.15)
# check types
assert isinstance(angular_spring, AngularSpring)
assert isinstance(angular_spring._node_origin, Node)
assert isinstance(angular_spring._node_start, Node)
assert isinstance(angular_spring._node_end, Node)
assert isinstance(angular_spring.stiffness, float)
# check storage
assert angular_spring._node_origin == node0
assert angular_spring._node_start == node1
assert angular_spring._node_end == node2
assert angular_spring.stiffness == 0.15
def test_node_get_adjacent_neighbours():
"""test that we retrieve the right neighbours"""
node0 = Node(x=0, y=0, label="node0")
node1 = Node(x=1, y=0, label="node1")
node2 = Node(x=1, y=1, label="node2")
node3 = Node(x=0, y=1, label="node3")
# add a single node
node0.add_neighbour(node1)
before, after = node0._get_adjacent_neighbours(node1)
assert before == node1
assert after == node1
# add a second node
node0.add_neighbour(node2)
before, after = node0._get_adjacent_neighbours(node2)
assert before == node1
assert after == node1
# add a third node
node0.add_neighbour(node3)
before, after = node0._get_adjacent_neighbours(node2)
assert before == node1
assert after == node3
def test_node_add_neighbour(test_node: Node):
"""test that we add nodes"""
other = Node(x=1.5, y=0)
test_node.add_neighbour(other)
assert other in test_node.neighbours
assert other in test_node._ordered_neighbours
def test_node():
node = Node(x=1.2, y=-3.4, clamped=True, label="test_node")
return node