def setup_fixtures(fixture):
before = fixture.pop('before')
after = fixture.pop('after')
boids = Boids()
boids.positions = np.array(before[0:2])
boids.velocities = np.array(before[2:4])
return boids,after
def test_init(self, case):
args = case["args"]
b = Boids(**args)
for arg, val in args.items():
self.assertEqual(b.__getattribute__(TestBoids.ARGS_TO_ATTRS[arg]),
val)
self.assertEqual(sum(b.rules.values()), 1)
def __init__(self, config):
self.x_axis = config['x_axis']
self.y_axis = config['y_axis']
self.frames = config['frames']
self.interval = config['interval']
self.boids = Boids(config)
self.plot()
def test_perceive(self, case):
"""
Tests the correctness of perceptual matrix when neighbors are
within or outside of perceptual range
"""
b = Boids(**case[INIT])
b.state = np.asarray(case[ARGS])
self.assertEqual(np.asarray(case[EXPECTED]),
b._perceive())
def test_bad_boids_regression():
regression_data=yaml.load(open(os.path.join(os.path.dirname(__file__),'fixtures','regression.yaml')))
boid_data=np.array(regression_data.pop("before"))
boids = Boids()
boids.positions = boid_data[0:2]
boids.velocities = boid_data[2:4]
boids.update_boids(boids.positions, boids.velocities)
for after,before in zip(regression_data["after"],boid_data):
for after_value,before_value in zip(after,before):
assert_almost_equal(after_value,before_value,delta=0.02)
def test_animate():
with patch.object(Boids, 'update_boids') as mock_get:
new_flock = Boids(2, config_filename)
"""new_flock.positions[0][0] = 0
new_flock.positions[1][0] = 0
new_flock.positions[0][1] = 1
new_flock.positions[1][1] = 0"""
new_flock.animate('something')
print mock_get.mock_calls
mock_get.assert_called_with()
def test_separations_square_distance():
fixtures = yaml.load(open(fixtures_file))
for fixture in fixtures:
fix_separations = fixture.pop('separations_square_distances')
positions = fix_separations['positions']
sq_distances = fix_separations['sq_distances']
fix_separations = fix_separations['separations']
boids = Boids()
boids.positions = np.array(positions)
separations, square_distances = boids.separations_square_distances(boids.positions)
assert_almost_equal(separations.all(),np.array(fix_separations).all())
def test_init(self, case):
"""Verify that all args are passed in correctly."""
ARGS_TO_ATTRS = {
"dims": "dims",
"num_boids": "num_boids",
"environ_bounds": "env_bounds",
"max_velocity": "max_vel",
"max_acceleration": "max_acc",
"perceptual_range": "p_range"
}
args = case[ARGS]
b = Boids(**args)
for arg, val in args.items():
self.assertEqual(b.__getattribute__(ARGS_TO_ATTRS[arg]), val)
self.assertEqual(sum(b.rules.values()), 1)
def test_correct_coordinates(self):
boids = Boids(TestBoids.config)
old_x_coordinates = boids.properties["x_coordinate"][:]
old_y_coordinates = boids.properties["y_coordinate"][:]
old_x_velocities = boids.properties["x_velocity"][:]
old_y_velocities = boids.properties["y_velocity"][:]
boids.correct_coordinates(0)
new_x_coordinates = boids.properties["x_coordinate"][:]
new_y_coordinates = boids.properties["y_coordinate"][:]
new_x_velocities = boids.properties["x_velocity"][:]
new_y_velocities = boids.properties["y_velocity"][:]
self.assertListEqual(old_x_velocities, new_x_velocities)
self.assertListEqual(old_y_velocities, new_y_velocities)
self.assertListEqual(old_x_coordinates[1:], new_x_coordinates[1:])
self.assertListEqual(old_y_coordinates[1:], new_y_coordinates[1:])
self.assertFalse(old_x_coordinates[0] == new_x_coordinates[0])
self.assertFalse(old_y_coordinates[0] == new_y_coordinates[0])
def __init__(self, center: List[int], environ_bounds: List[int]):
self.center = center
self.boids = Boids(num_boids=200,
environ_bounds=environ_bounds,
max_velocity=2,
max_acceleration=1,
perceptual_range=150,
origin=center)
self.cube = Cube(self.center, size=max(environ_bounds))
class Animation(object):
"""
This class creates an animation based on the inputs specified in the config
file.
Parameters
----------
config: yaml file with specified:
- x_axis
- y_axis
- frames
- interval
"""
def __init__(self, config):
self.x_axis = config['x_axis']
self.y_axis = config['y_axis']
self.frames = config['frames']
self.interval = config['interval']
self.boids = Boids(config)
self.plot()
def plot(self):
"""
This method plots the graph of boids.
"""
figure = plt.figure()
axes = plt.axes(xlim=tuple(self.x_axis), ylim=tuple(self.y_axis))
self.scatter = axes.scatter(self.boids.properties["x_coordinate"],
self.boids.properties["y_coordinate"])
anim = animation.FuncAnimation(figure,
self.animate,
frames=self.frames,
interval=self.interval)
plt.show()
def animate(self, frame):
"""
This method updates the graph with the new coordinates of boids.
"""
self.boids.update()
self.scatter.set_offsets(
list(
zip(self.boids.properties["x_coordinate"],
self.boids.properties["y_coordinate"])))
def test_init_boids_state(self, case):
args = case["args"]
b = Boids(**args)
self.assertEqual(b.state.shape,
(args["dims"], args["num_boids"], len(Boids.Attr)))
for idx, limit in zip((Boids.Attr.VEL, Boids.Attr.ACC),
(b.max_vel, b.max_acc)):
self.assertLessEqual(np.max(b.state[:, :, idx]), limit)
for dim in range(b.dims):
self.assertLessEqual(np.max(b.state[dim, :, Boids.Attr.LOC]),
b.env_bounds[dim])
def test_init_boids_state(self, case):
"""Verifies state shape and state values are within bounds."""
args = case[ARGS]
b = Boids(**args)
self.assertEqual(b.state.shape, tuple(case[EXPECTED]))
for idx, limit in zip((Boids.Attr.VEL, Boids.Attr.ACC),
(b.max_vel, b.max_acc)):
self.assertLessEqual(np.max(b.state[:, :, idx]), limit)
for dim in range(b.dims):
self.assertLessEqual(np.max(b.state[dim, :, Boids.Attr.LOC]),
b.env_bounds[dim])
def test_bad_boids_regression():
# open(os.path.join(os.path.dirname(__file__),'boids.py'))
config_filename = os.path.join(os.path.dirname(__file__),
'fixtures/config.yaml')
regression_data = yaml.load(
open(os.path.join(os.path.dirname(__file__), 'fixtures/fixture.yaml')))
boids = Boids(10, config_filename)
boid_data = np.asarray(regression_data["before"])
boids.positions = np.array([boid_data[0], boid_data[1]])
boids.velocities = np.array([boid_data[2], boid_data[3]])
boids.update_boids()
new_boid_data = np.asarray(regression_data["after"])
new_positions = np.asarray([new_boid_data[0], new_boid_data[1]])
new_velocities = np.asarray([new_boid_data[2], new_boid_data[3]])
new_boids = (new_positions, new_velocities)
for after, before in zip(new_positions, boids.positions):
for after_value, before_value in zip(after, before):
assert_almost_equal(after_value, before_value, delta=0.06)
def test_match_speed(
): # Check that velocities match. Should change in y-direction but stay constant in x-direction for input values.
new_flock = Boids(2, config_filename)
new_flock.positions[0][0] = 0
new_flock.positions[1][0] = 10
new_flock.positions[0][1] = 0
new_flock.positions[1][1] = 10
new_flock.velocities[0][0] = 0
new_flock.velocities[0][1] = 0
new_flock.velocities[1][0] = 0
new_flock.velocities[1][1] = 10
old_velocities_x1 = new_flock.velocities[0][0]
old_velocities_x2 = new_flock.velocities[0][1]
old_velocities_y1 = new_flock.velocities[1][0]
old_velocities_y2 = new_flock.velocities[1][1]
new_flock.match_velocity()
assert (old_velocities_x1 == new_flock.velocities[0][0])
assert (old_velocities_x2 == new_flock.velocities[0][1])
assert (old_velocities_y1 < new_flock.velocities[1][0])
assert (old_velocities_y2 > new_flock.velocities[1][1])
def test_distance(self):
boids = Boids(TestBoids.config)
self.assertTrue(boids.distance(0, 1) > 0)
self.assertTrue(boids.distance(0, 0) == 0)
self.assertTrue(type(boids.distance(0, 1)) is float)
def test_update(self):
boids = Boids(TestBoids.config)
boids.update()
self.assertTrue(type(boids.properties) == dict)
def test_properties(self):
boids = Boids(TestBoids.config)
self.assertTrue(type(boids.properties) is dict)
self.assertEqual(len(boids.properties), 4)
self.assertEqual(len(boids.properties["x_coordinate"]),
TestBoids.config["number_of_birds"])
def test_align(self, case):
b = Boids(**case[INIT])
b.state = np.asarray(case[INIT_STATE])
self.assertEqual(np.asarray(case[EXPECTED]),
b.align(np.asarray(case[ARGS])))
def test_avoid_collissions():
new_flock = Boids(2, config_filename)
new_flock.positions[0][0] = 0
new_flock.positions[1][0] = 0
new_flock.positions[0][1] = 1
new_flock.positions[1][1] = 0
new_flock.velocities[0][0] = 0
new_flock.velocities[0][1] = 0
new_flock.velocities[1][0] = 0
new_flock.velocities[1][1] = 0
old_velocities_x1 = new_flock.velocities[0][0]
old_velocities_x2 = new_flock.velocities[0][1]
old_velocities_y1 = new_flock.velocities[1][0]
old_velocities_y2 = new_flock.velocities[1][1]
new_flock.avoid_collisions()
print new_flock.velocities
assert (old_velocities_x1 > new_flock.velocities[0][0])
assert (old_velocities_x2 < new_flock.velocities[0][1])
assert (old_velocities_y1 == 0)
assert (old_velocities_y2 == 0)
def test_zero_boids():
with assert_raises(ValueError) as exception:
new_flock = Boids(0, config_filename)
def test_update_loc(self, case):
b = Boids(**case[INIT])
b.state = np.asarray(case[ARGS], dtype=float)
b._update_loc()
self.assertEqual(np.asarray(case[EXPECTED]), b.state)
def test_update_acc(self, case):
b = Boids(**case[INIT])
b.state = np.asarray(case[INIT_STATE], dtype=float)
b._update_acc(np.asarray(case[ARGS]["acc_delta"]), case[ARGS]["coeff"])
self.assertEqual(np.asarray(case[EXPECTED]), b.state)
def test_bad_input_file():
with assert_raises(IOError) as exception:
new_flock = Boids(10, 'file_that_does_not_exist')
def test_wrong_boid_no_type():
with assert_raises(TypeError) as exception:
new_flock = Boids('string', config_filename)
def test_fly_towards_middle():
new_flock = Boids(2, config_filename)
# Set initial positions
new_flock.positions[0][0] = 0
new_flock.positions[1][0] = 0
new_flock.positions[0][1] = 0
new_flock.positions[1][1] = 10
new_flock.velocities[0][0] = 0
new_flock.velocities[0][1] = 0
new_flock.velocities[1][0] = 0
new_flock.velocities[1][1] = 0
old_position_x1 = new_flock.positions[0][0]
old_position_x2 = new_flock.positions[0][1]
old_position_y1 = new_flock.positions[1][0]
old_position_y2 = new_flock.positions[1][1]
old_velocities_x1 = new_flock.velocities[0][0]
old_velocities_x2 = new_flock.velocities[0][1]
old_velocities_y1 = new_flock.velocities[1][0]
old_velocities_y2 = new_flock.velocities[1][1]
new_flock.fly_to_middle()
assert (old_velocities_x1 == new_flock.velocities[0][0])
assert (old_velocities_x2 == new_flock.velocities[0][1])
assert (old_velocities_y1 < new_flock.velocities[1][0])
assert (old_velocities_y2 > new_flock.velocities[1][1])
def test_initialise():
with patch.object(numpy.random, 'rand') as mock_get:
new_flock = Boids(10, config_filename)
print mock_get.mock_calls
mock_get.assert_called_with(2, 10)
def test_negative_boid_no():
with assert_raises(ValueError) as exception:
new_flock = Boids(-10, config_filename)
