Ejemplo n.º 1
0
def main():
    
    parser = ArgumentParser(description = "A simulation of a flock of birds.")
    parser.add_argument('--config', '-c', default = 'config.cfg', help = 'select config file')
    arguments = parser.parse_args()

    config = ConfigParser.ConfigParser()
    with open(arguments.config) as config_file:
        config.readfp(config_file)
        no_of_boids = config.getint('boids_initiate', 'no_of_boids')
        position_limits =  json.loads(config.get('boids_initiate', 'position_limits'))
        velocity_limits =  json.loads(config.get('boids_initiate', 'velocity_limits'))
        move_to_middle_strength = config.getfloat('boids_initiate', 'move_to_middle_strength')
        alert_distance = config.getfloat('boids_initiate', 'alert_distance')
        formation_flying_distance = config.getfloat('boids_initiate', 'formation_flying_distance')
        formation_flying_strength = config.getfloat('boids_initiate', 'formation_flying_strength')

        xlim = json.loads(config.get('run_simulation','xlim'))
        ylim = json.loads(config.get('run_simulation', 'ylim'))
        frames = config.getint('run_simulation', 'frames')
        interval = config.getint('run_simulation', 'interval')
            
        boids = Boids(no_of_boids = no_of_boids, position_limits = position_limits,
            velocity_limits = velocity_limits,
            move_to_middle_strength = move_to_middle_strength,
            alert_distance = alert_distance,
            formation_flying_distance = formation_flying_distance,
            formation_flying_strength = formation_flying_strength)
    
        boids.run_simulation(xlim = tuple(xlim), ylim = tuple(ylim), frames = frames,
                          interval = interval)
Ejemplo n.º 2
0
def test_new_flock():
    boids = Boids()
    array = boids.new_flock(np.array([0, 50]), np.array([50, 100]))
    x_array = array[0, :]
    y_array = array[1, :]
    assert_equals(array.shape, (2, 50))
    assert_true((x_array > 0).all() and (x_array < 50).all())
    assert_true((y_array > 50).all() and (y_array < 100).all())
Ejemplo n.º 3
0
def process():
    parser = ArgumentParser(description = "Boid simulator: Simulates birds flying in flocks using the boids model.")
    parser.add_argument('--config', '-c', type=str, default="",  help="Boid simulator YAML configuration file. Defaults are shown and used if not specified.")
    parser.add_argument('--count', type=int, default=0, required=False, help="Overwrite bird count given in cfg file.")
    parser.add_argument('--fly_to_middle_strength', type=float, default=0, required=False, help="Overwrite settings given in cfg file.")
    parser.add_argument('--alert_distance', type=float,default=0, required=False, help="Overwrite settings given in cfg file.")
    parser.add_argument('--formation_flying_distance', type=float,default=0, required=False, help="Overwrite settings given in cfg file.")
    parser.add_argument('--formation_flying_strength', type=float,default=0, required=False, help="Overwrite settings given in cfg file.")
    arguments= parser.parse_args()
    
    #dictionary containing the configuration for the boids simulator
    cfg={}

    #default settings YAML 
    default="""Boids:
  count: 50
  vxlim: [0, 10]
  vylim: [-20, 20]
  xlim: [-450, 50]
  ylim: [300, 600]
Dynamics:
  alert_distance: 100
  fly_to_middle_strength: 0.01
  formation_flying_strength: 0.125
  formation_flying_distance: 10000
Animation:
  frames: 50
  interval: 50
  xlim: [-500, 1500]
  ylim: [-500, 1500]"""

    #open given cfg file within try block to catch wrong filename etc.
    try:
        with open(arguments.config) as cfg_file:
            cfg=yaml.load(cfg_file)

            #check if config fullfills requirements
            if not all (k in cfg.keys() for k in ('Boids', 'Dynamics', 'Animation')):
                raise Exception 
            if not all (k in cfg['Boids'].keys() for k in ('count', 'vylim', 'vxlim', 'xlim', 'ylim')):
                raise Exception
            if not all (k in cfg['Dynamics'].keys() for k in ('formation_flying_distance','alert_distance','fly_to_middle_strength','formation_flying_strength')):
                raise Exception
            if not all (k in cfg['Animation'].keys() for k in ('frames', 'interval', 'ylim', 'xlim')):
                raise Exception
    except:
        #use default settings if no or wrong config file given!
        print "Something went wrong when reading the configuration file. Check that all needed configuration elements are given and that the filename is correct."
        print "Using the default settings! See below for the corresponding YAML file."
        print default
        cfg=yaml.load(StringIO(default))
    
    
    #run boids simulation with given settings
    boids=Boids(cfg, arguments.count, arguments.fly_to_middle_strength, arguments.alert_distance, arguments.formation_flying_distance, arguments.formation_flying_strength)
    boids.simulate()
Ejemplo n.º 4
0
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()
        print mock_get.mock_calls
        mock_get.assert_called_with()
Ejemplo n.º 5
0
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()
        print mock_get.mock_calls
        mock_get.assert_called_with()
Ejemplo n.º 6
0
def test_fly_towards_the_middle():
    data = yaml.load(open(os.path.join(os.path.dirname(__file__), 'fixtures', 'fixture_fly_towards_the_middle.yml')))
    boid_data_before = np.array(data["before"])
    boid_data_after = np.array(data["after"])
    move_to_middle_strength = data["move_to_middle_strength"]

    boids = Boids()
    boids.boids = boid_data_before
    boids.fly_towards_the_middle(boids.boids, move_to_middle_strength)

    np.testing.assert_array_almost_equal(boids.boids, boid_data_after)
Ejemplo n.º 7
0
def test_fly_away_from_nearby_boids():
    data = yaml.load(
        open(os.path.join(os.path.dirname(__file__), 'fixtures', 'fixture_fly_away_from_nearby_boids.yml')))
    boid_data_before = np.array(data["before"])
    boid_data_after = np.array(data["after"])
    alert_distance = data["alert_distance"]
    boids = Boids()
    boids.boids = boid_data_before

    boids.fly_away_from_nearby_boids(boids.boids, alert_distance)
    np.testing.assert_array_almost_equal(boids.boids, boid_data_after)
Ejemplo n.º 8
0
def test_separation():
    data = yaml.load(open(os.path.join(os.path.dirname(__file__), 'fixtures', 'fixture_separation.yml')))
    xcoords = np.array(data["xcoords"])
    ycoords = np.array(data["ycoords"])
    x_separation = np.array(data["x_separation"])
    y_separation = np.array(data["y_separation"])
    separation_distance_squared = np.array(data["separation_distance_squared"])
    boids = Boids(boid_count=data["boid_count"])
    calc_separations, calc_separation_distance_squared = boids.separation((xcoords, ycoords))

    np.testing.assert_array_almost_equal(calc_separations, (x_separation, y_separation))
    np.testing.assert_array_almost_equal(calc_separation_distance_squared, separation_distance_squared)
Ejemplo n.º 9
0
def test_match_speed_with_nearby_boids():
    data = yaml.load(
        open(os.path.join(os.path.dirname(__file__), 'fixtures', 'fixture_match_speed_with_nearby_boids.yml')))
    boid_data_before = np.array(data["before"])
    boid_data_after = np.array(data["after"])
    formation_flying_distance = data["formation_flying_distance"]
    formation_flying_strength = data["formation_flying_strength"]

    boids = Boids()
    boids.boids = boid_data_before
    boids.match_speed_with_nearby_boids(boids.boids, formation_flying_distance, formation_flying_strength)
    np.testing.assert_array_almost_equal(boids.boids, boid_data_after)
Ejemplo n.º 10
0
def test_update_boids():
    data = yaml.load(open(os.path.join(os.path.dirname(__file__), 'fixtures', 'fixture_update_boids_only.yml')))
    boid_data_before = np.array(data["before"])
    boid_data_after = np.array(data["after"])
    boid_count = data["boid_count"]
    boids = Boids(boid_count=boid_count)
    boids.boids = boid_data_before
    with patch.object(boids, 'fly_towards_the_middle') as mocked1:
        with patch.object(boids, 'fly_away_from_nearby_boids') as mocked2:
            with patch.object(boids, 'match_speed_with_nearby_boids') as mocked3:
                boids.update_boids(boids.boids)
                np.testing.assert_almost_equal(boids.boids, boid_data_after)
Ejemplo n.º 11
0
def create_boids(dims):
    if dims == 3:
        bb = BigBoids(
            num_big_boids=1,
            dimensions=3,
            start_center=[1.6, 1.6, 0.5],
            max_velocity2=
            0.001,  # avoids ever-increasing velocity that causes it to escape the screen
            approach_factor=0.001  # velocity at which it approaches the boids
        )
        b = Boids(
            num_boids=1000,
            big_boids=bb,
            dimensions=3,
            start_center=[0.1, 0.1, 0.5],
            rule1_factor=0.0003,  # factor for going to the common center
            rule2_threshold=0.005,  # threshold for birds being close
            rule2_factor=
            0.08,  # speed at which close birds should move outside the threshold
            rule3_factor=
            0.04,  # factor for going at the same velocity as average
            escape_threshold=0.03,  # threshold for a big bird being close
            max_velocity2=
            0.001,  # avoids ever-increasing velocity that causes boids to escape the screen
            rule_direction=0.003  # factor for going to a random direction
        )
    else:
        bb = BigBoids(
            num_big_boids=1,
            dimensions=2,
            start_center=[1.6, 1.6],
            max_velocity2=
            0.0009,  # avoids ever-increasing velocity that causes it to escape the screen
            approach_factor=0.001  # velocity at which it approaches the boids
        )
        b = Boids(
            num_boids=1000,
            big_boids=bb,
            dimensions=2,
            start_center=[0.1, 0.1],
            rule1_factor=0.0003,  # factor for going to the common center
            rule2_threshold=0.001,  # threshold for birds being close
            rule2_factor=
            0.08,  # speed at which close birds should move outside the threshold
            rule3_factor=
            0.06,  # factor for going at the same velocity as average
            escape_threshold=0.01,  # threshold for a big bird being close
            max_velocity2=
            0.0008,  # avoids ever-increasing velocity that causes boids to escape the screen
            rule_direction=0.003  # factor for going to a random direction
        )
    bb.set_boids(b)
    return (b, bb)
Ejemplo n.º 12
0
def test_Boids():
    maxlim = 100
    minlim = -100
    lims = [minlim,maxlim]
    for boid_count in (10, 2):
        boidobject = Boids(boid_count=boid_count,x_positions=lims)
        assert_equals(boidobject.boids_x.size, boid_count)
        assert_equals(boidobject.boids_y.size, boid_count)
        assert_equals(boidobject.boid_x_velocities.size, boid_count)
        assert_equals(boidobject.boid_y_velocities.size, boid_count)
        assert (boidobject.boids_x>=minlim).all() and (boidobject.boids_x<=maxlim).all()

    with assert_raises(ValueError):
        boidobject = Boids(boid_count=-2)
Ejemplo n.º 13
0
def main():
    _ROOT = os.path.abspath(os.path.dirname(__file__))
    defaultconfig = os.path.join(_ROOT, 'config.yml')
    parser = ArgumentParser(description="Boid Flocking Modelling")
    parser.add_argument('--config', default=defaultconfig, help="Configuration file", metavar="FILE")
    parser.add_argument('--saveto', help="Filename to save animation", metavar="FILE")
    args = parser.parse_args()

    try:
        with open(args.config, 'r') as ymlfile:
            configdata = yaml.load(ymlfile)

            boid_count = configdata['Boids_Setup']['boid_count']
            x_positions = configdata['Boids_Setup']['x_positions']
            y_positions = configdata['Boids_Setup']['y_positions']
            x_velocities = configdata['Boids_Setup']['x_velocities']
            y_velocities = configdata['Boids_Setup']['y_velocities']

            move_to_middle_strength = configdata['Flock_Dynamics']['move_to_middle_strength']
            alert_distance = configdata['Flock_Dynamics']['alert_distance']
            formation_flying_distance = configdata['Flock_Dynamics']['formation_flying_distance']
            formation_flying_strength = configdata['Flock_Dynamics']['formation_flying_strength']

            xlim = configdata['Axis_Limits']['xlim']
            ylim = configdata['Axis_Limits']['ylim']

            frames = configdata['Animation']['frames']
            interval = configdata['Animation']['interval']

            saveto = args.saveto #works even if it is None

            boidsobject = Boids(boid_count=boid_count,
                                x_positions=x_positions,
                                y_positions=y_positions,
                                x_velocities=x_velocities,
                                y_velocities=y_velocities,
                                move_to_middle_strength=move_to_middle_strength,
                                alert_distance=alert_distance,
                                formation_flying_distance=formation_flying_distance,
                                formation_flying_strength=formation_flying_strength)
            boidsobject.model(xlim=xlim,
                              ylim=ylim,
                              frames=frames,
                              interval=interval,
                              savefile=saveto)
    except IOError as error:
        print('IOError: No such config file')
    except KeyError as error:
        print('KeyError: Missing parameters in config file')
Ejemplo n.º 14
0
def boid(config_name='config.yaml'):
    config = yaml.load(
        open(os.path.join(os.path.dirname(__file__), config_name)))
    flock_1 = Boids(
        Boids_total=config['boid_count'],
        dimension_limits=config['dimension_limits'],
        velocity_limits=config['velocity_limits'],
        Limits=config['Limits'],
        move_to_middle_strength=config['move_to_middle_strength'],
        alert_distance=config['alert_distance'],
        formation_flying_distance=config['formation_flying_distance'],
        formation_flying_strength=config['formation_flying_strength'],
        frames=config['frames'],
        interval=config['interval'])

    flock_1.show_sim()
Ejemplo n.º 15
0
def create_boids_3D(nboids=1000, nbig=1, use_process=False):
    bb = BigBoids(
        num_big_boids=nbig,
        dimensions=3,
        start_center=[-1.0, -1.0, 0.0],
        max_velocity2=
        1.0,  # avoids ever-increasing velocity that causes it to escape the screen
        approach_factor=1.0,  # velocity at which it approaches the boids
        dt=dt)
    b = Boids(
        num_boids=nboids,
        big_boids=bb,
        dimensions=3,
        start_center=[0.5, 0.5, 0.5],
        rule1_factor=1.9,  # factor for going to the common center
        rule2_threshold=0.01,  # threshold for birds being close
        rule2_factor=
        5.0,  # speed at which close birds should move outside the threshold
        rule3_factor=8.0,  # factor for going at the same velocity as average
        escape_threshold=0.014,  # threshold for a big bird being close
        min_velocity2=0.2,  # avoids too much passivity
        max_velocity2=
        1.0,  # avoids ever-increasing velocity that causes boids to escape the screen
        rule_direction=1.0,  # factor for going to a random direction
        bounds_factor=1.1,
        dt=dt,
        num_neighbors=60,
        # escape_factor = 0.3,
        enforce_bounds=True,
        in_random_direction=False,
        use_global_velocity_average=False,
        use_process=use_process)

    bb.set_boids(b)
    return (b, bb)
Ejemplo n.º 16
0
def test_bad_boids_regression():
    regression_data = yaml.load(
        open(os.path.join(os.path.dirname(__file__), 'fixtures',
                          'fixture.yml')))
    boid_data = np.array(regression_data["before"])
    Boids().update_boids(boid_data)
    after_data = np.array(regression_data["after"])
    for after, before in zip(after_data, boid_data):
        for after_value, before_value in zip(after, before):
            np.testing.assert_almost_equal(after_value, before_value)
Ejemplo n.º 17
0
def main():

    parser = ArgumentParser(description="A simulation of a flock of birds.")
    parser.add_argument('--config',
                        '-c',
                        default='config.cfg',
                        help='select config file')
    arguments = parser.parse_args()

    config = ConfigParser.ConfigParser()
    with open(arguments.config) as config_file:
        config.readfp(config_file)
        no_of_boids = config.getint('boids_initiate', 'no_of_boids')
        position_limits = json.loads(
            config.get('boids_initiate', 'position_limits'))
        velocity_limits = json.loads(
            config.get('boids_initiate', 'velocity_limits'))
        move_to_middle_strength = config.getfloat('boids_initiate',
                                                  'move_to_middle_strength')
        alert_distance = config.getfloat('boids_initiate', 'alert_distance')
        formation_flying_distance = config.getfloat(
            'boids_initiate', 'formation_flying_distance')
        formation_flying_strength = config.getfloat(
            'boids_initiate', 'formation_flying_strength')

        xlim = json.loads(config.get('run_simulation', 'xlim'))
        ylim = json.loads(config.get('run_simulation', 'ylim'))
        frames = config.getint('run_simulation', 'frames')
        interval = config.getint('run_simulation', 'interval')

        boids = Boids(no_of_boids=no_of_boids,
                      position_limits=position_limits,
                      velocity_limits=velocity_limits,
                      move_to_middle_strength=move_to_middle_strength,
                      alert_distance=alert_distance,
                      formation_flying_distance=formation_flying_distance,
                      formation_flying_strength=formation_flying_strength)

        boids.run_simulation(xlim=tuple(xlim),
                             ylim=tuple(ylim),
                             frames=frames,
                             interval=interval)
Ejemplo n.º 18
0
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)
Ejemplo n.º 19
0
def process():
    """ 
	Description: A function to communicate with the command line. This function is linked with the setup.py file.
	"""
    parser = ArgumentParser(description="The Boids Flocking Bird Simulation")
    parser.add_argument("--config", "-c", help="Config file", default="config.cfg")
    args = parser.parse_args()

    config = ConfigParser.ConfigParser()
    with open(args.config) as f:
        config.readfp(f)
        # pull boids config data
        count = config.getint("Boids", "count")
        position_limits = json.loads(config.get("Boids", "position_limits"))
        velocity_limits = json.loads(config.get("Boids", "velocity_limits"))
        # pull boid dynamics config data
        move_to_middle_strength = config.getfloat("Dynamics", "move_to_middle_strength")
        alert_distance = config.getfloat("Dynamics", "alert_distance")
        formation_flying_distance = config.getfloat("Dynamics", "formation_flying_distance")
        formation_flying_strength = config.getfloat("Dynamics", "formation_flying_strength")
        # pull display config data (for animation)
        xlim = tuple(json.loads(config.get("Display", "xlim")))
        ylim = tuple(json.loads(config.get("Display", "ylim")))
        frames = config.getint("Display", "frames")  # check if should be float!
        interval = config.getint("Display", "interval")  # check if can be float!

        boids = Boids(
            count,
            position_limits,
            velocity_limits,
            move_to_middle_strength,
            alert_distance,
            formation_flying_distance,
            formation_flying_strength,
        )
        boids.deploy_simulation(xlim, ylim, frames, interval)
Ejemplo n.º 20
0
def process():
    parser = ArgumentParser(description='Simulate boids')
    parser.add_argument('boid_no', type=int, help='Number of boids')
    parser.add_argument('config_file', help='Configuration file')
    parser.add_argument('--example_view',
                        '-ex',
                        help='View config file example',
                        action='store_true')
    #parser.add_argument('--generate_example', '-gen', type = str, help = 'Generate config.yaml example file in current directory.')
    #parser.add_argument('--save', '-s', type =str, help = 'Save animation as .mp4 file. Input is the filename.')

    arguments = parser.parse_args()

    #   print 'Boids -- Simulating animal flocking behaviour. \n Input -h for help. '
    #gen = (x for x in args_iterate if type(x) == None)

    #for x in gen:

    if arguments.example_view:
        print 'The following is an example yaml config file. Copy the test below and past it into a file called filename.yaml. Make sure that the indentation is preserved.  \n \n - position: \n \t xmin: ' "-450" ' \n \t  xmax: "50" \n \t ymin: "300" \n \t ymax: "600" \n \n  - velocity: \n \t vxmin: "0" \n \t vxmax: "10" \n \t vymin: "-20"\n \t vymax: "20"'
        quit()
    """
    if arguments.generate_example:
        __location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))

        if not os.path.exists(__location__ + arguments.generate_example):
            os.makedirs(path)

        quit()
    """

    new_flock = Boids(arguments.boid_no, arguments.config_file)
    anim = animation.FuncAnimation(new_flock.figure,
                                   new_flock.animate,
                                   frames=50,
                                   interval=50)
    plt.show()
    """
Ejemplo n.º 21
0
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)
Ejemplo n.º 22
0
from matplotlib import pyplot as plt
from matplotlib import animation
import yaml
import os

# Load plot config from plot_config.yml
plot_config = yaml.load(open(os.path.join(os.path.dirname(__file__), 'plot_config.yml')))
xlim_max = plot_config["xlim_max"]
xlim_min = plot_config["xlim_min"]
ylim_max = plot_config["ylim_max"]
ylim_min = plot_config["ylim_min"]
framesT = plot_config["frames"]
intervalT = plot_config["interval"]

# Create a Boid object (ie a flock of boids)
my_boids = Boids()

# Create a plot figure
figure = plt.figure()
axes = plt.axes(xlim=(xlim_min, xlim_max), ylim=(ylim_min, ylim_max))
scatter = axes.scatter(my_boids.get_boids()[0], my_boids.get_boids()[1])


# A function to run the simulation and update the plot
def animate(frame):
    my_boids.update_boids()
    scatter.set_offsets(zip(my_boids.get_boids()[0], my_boids.get_boids()[1]))

# Animate the plot
anim = animation.FuncAnimation(figure, animate, frames=framesT, interval=intervalT)
Ejemplo n.º 23
0
def test_negative_boid_no():
    with assert_raises(ValueError) as exception:
        new_flock = Boids(-10, config_filename)
Ejemplo n.º 24
0
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)
Ejemplo n.º 25
0
def test_zero_boids():
    with assert_raises(ValueError) as exception:
        new_flock = Boids(0, config_filename)
Ejemplo n.º 26
0
if __name__ == '__main__':
    print("Starting boids.")

    parser = argparse.ArgumentParser(
        description="Implementing Craig Reynold's Boids.")

    # adding arguments
    parser.add_argument('--num-boids', dest='N', required=False)
    args = parser.parse_args()

    N = 100
    if args.N:
        N = int(args.N)

    boids = Boids(N)

    fig = plt.figure()
    ax = plt.axes(xlim=(0, width), ylim=(0, height))
    # plt.plot([300,20],[300,50])

    body, = ax.plot([], [], markersize=10, c='k', marker='o', ls='None')
    head, = ax.plot([], [], markersize=4, c='r', marker='o', ls='None')
    ani = animation.FuncAnimation(fig,
                                  tick,
                                  fargs=(body, head, boids),
                                  interval=50)

    # cid = fig.canvas.mpl_connect('button_press_event', boids.button_press)

    plt.show()
Ejemplo n.º 27
0
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)
Ejemplo n.º 28
0
matplotlib.use('agg')

import numpy as np
import rendermpl

from boids import Boids
from rules import Separation, Alignment, Cohesion, Drag

N = 400
dims = 2

boids = Boids(
    N,
    dims=dims,
    rules=[
        Separation(.1, 1),
        #Drag(.5),
        Alignment(.1, 4),
        Cohesion(.1, 4),
    ])

#xx, yy = np.meshgrid(np.linspace(0,1,20), np.linspace(0,1,20))

#boids.velocity[(yy<.5).ravel(),0] = 1
#boids.velocity[(yy>=.5).ravel(),0] = -1

#boids.position = np.random.random((N,dims)).astype(float)
boids['position'] = np.random.random((N, dims)).astype(float)

boids['velocity'][boids['position'][:, 1] < 0.5, 0] = 1
boids['velocity'][boids['position'][:, 1] <= 0.5, 0] = -1
Ejemplo n.º 29
0
import yaml
import sys
sys.path.append("..") # Adds higher directory to python modules path.

from boids import Boids

boids=Boids({})
before=boids.positions.tolist() + boids.velocities.tolist()
#boids.update_boids()
boids.velocities += boids._match_speed_nearby(10000,0.125)
boids.positions += boids.velocities
after=boids.positions.tolist() + boids.velocities.tolist()
fixture={"before":before,"after":after}
fixture_file=open("fixtures/matchSpeed.yml",'w')
fixture_file.write(yaml.dump(fixture))
fixture_file.close()
Ejemplo n.º 30
0
def test_bad_input_file():
    with assert_raises(IOError) as exception:
        new_flock = Boids(10, 'file_that_does_not_exist')
Ejemplo n.º 31
0
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)
Ejemplo n.º 32
0
def test_wrong_boid_no_type():
    with assert_raises(TypeError) as exception:
        new_flock = Boids('string', config_filename)
Ejemplo n.º 33
0
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])
Ejemplo n.º 34
0
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])
Ejemplo n.º 35
0
def boid(config_name = 'config.yaml'):
    config = yaml.load(open(os.path.join(os.path.dirname(__file__),config_name)))
    flock_1 = Boids(Boids_total =config['boid_count'], dimension_limits = config['dimension_limits'], velocity_limits = config['velocity_limits'], Limits = config['Limits'], move_to_middle_strength = config['move_to_middle_strength'], alert_distance = config['alert_distance'], formation_flying_distance = config['formation_flying_distance'], formation_flying_strength = config['formation_flying_strength'], frames = config['frames'], interval = config['interval'])


    flock_1.show_sim()
Ejemplo n.º 36
0
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])
Ejemplo n.º 37
0
# File to capture fixtures
from boids import Boids
import copy
import yaml
import numpy as np
import os

filename = os.path.join(os.path.dirname(__file__), 'new_fixtures.yaml')
#yaml.load(open(filename))

new_flock = Boids(10, 'config.yaml')
old_positions = copy.deepcopy(new_flock.positions)
old_velocities = copy.deepcopy(new_flock.velocities)

with open(filename, "w") as f:
    yaml.dump(old_positions, f, default_flow_style=True)
    yaml.dump(old_velocities, f, default_flow_style=True)

doc = yaml.load(open(filename))

print doc

#npzfile = np.load('new_fixtures.npz')
#np.save(npzfile, old_positions)
#np.save('new_fixtures.yml', old_velocities)
#test = np.load('new_fixtures.npz')
Ejemplo n.º 38
0
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])
# -----------------------------------------------------------------------------

# Setup world
num_boids = 1000
WORLD_SIZE = [0, options['world_width'], 0, options['world_height']]
world = World(WORLD_SIZE)
filename = f"{num_boids}_plot.png"

# Setup plot
NUM_COLOURS = options['num_colours']
cmap = plotting.ColourMap(options)
plot = plotting.Plotter(options, world)

# Setup Boids
boids = Boids(num_boids, world, options)
boids.generate_boids(options, distribution='random')

# -----------------------------------------------------------------------------


def triang_ver():
    boids.triangulate_boids()
    boids.make_neighbourhoods()


# ----------------------------------- Main ------------------------------------

triang_ver()

for i in range(num_boids):
Ejemplo n.º 40
0
import yaml
from boids import Boids
from copy import deepcopy
import numpy as np

boids = Boids()
before = deepcopy(boids.boids)

move_to_middle = 0.01
boids.fly_towards_the_middle(boids.boids, move_to_middle)
after = boids.boids
fixture = {
    "before": np.array(before).tolist(),
    "after": np.array(after).tolist(),
    "move_to_middle_strength": move_to_middle
}
fixture_file = open("fixture_fly_towards_the_middle.yml", 'w')
fixture_file.write(yaml.dump(fixture))
fixture_file.close()

boids = Boids()
before = deepcopy(boids.boids)
alert_distance = 100
boids.fly_away_from_nearby_boids(boids.boids, alert_distance)
after = boids.boids
fixture = {
    "before": np.array(before).tolist(),
    "after": np.array(after).tolist(),
    "alert_distance": alert_distance
}
fixture_file = open("fixture_fly_away_from_nearby_boids.yml", 'w')
Ejemplo n.º 41
0
from matplotlib import pyplot as plt
from matplotlib import animation
from boids import Boids

# Deliberately terrible code for teaching purposes
repulsion = 100
attraction = 0.01
speed = 10000
acceleration = 0.125
model = Boids(50, repulsion, attraction, speed, acceleration)
model.initialise_random()

figure = plt.figure()
axes = plt.axes(xlim=(-500,1500), ylim=(-500,1500))
scatter = axes.scatter( [boid.x for boid in model.boids],\
                        [boid.y for boid in model.boids] )

def animate(frame):
    model.update_boids()
    scatter.set_offsets(zip([boid.x for boid in model.boids], \
                            [boid.y for boid in model.boids]))

anim = animation.FuncAnimation(figure, animate, frames=50, interval=50)

if __name__ == "__main__":
    plt.show()
Ejemplo n.º 42
0
def main():

    parser = ArgumentParser(description = "Simulation of flocking birds")
    parser.add_argument('--config', '-c', help = 'Config file', default='config.cfg')
    args = parser.parse_args()

    try:
        defaults = {
            'count': '50',
            'position_limits': '[-450, 300, 50, 600]',
            'velocity_limits': '[0, -20, 10, 20]',

            'xlim': '[-500, 1500]',
            'ylim': '[-500, 1500]',

            'frames'  : '50',
            'interval': '50',

            'move_to_middle_strength': '0.01',
            'alert_distance': '100',
            'formation_flying_distance': '10000',
            'formation_flying_strength': '0.125'
        }

        config = ConfigParser.SafeConfigParser(defaults)
        with open(args.config) as f:
            config.readfp(f)

            count = config.getint('Boids', 'count')
            position_limits =  json.loads(config.get('Boids', 'position_limits'))
            velocity_limits =  json.loads(config.get('Boids', 'velocity_limits'))
            frames = config.getint('Animation', 'frames')
            interval = config.getint('Animation', 'interval')
            xlim = json.loads(config.get('Axis', 'xlim'))
            ylim = json.loads(config.get('Axis', 'ylim'))
            move_to_middle_strength = config.getfloat('Dynamics', 'move_to_middle_strength')
            alert_distance = config.getfloat('Dynamics', 'alert_distance')
            formation_flying_distance = config.getfloat('Dynamics', 'formation_flying_distance')
            formation_flying_strength = config.getfloat('Dynamics', 'formation_flying_strength')

            boid = Boids(boid_count = count,
                         position_limits = position_limits,
                         velocity_limits = velocity_limits,
                         move_to_middle_strength = move_to_middle_strength,
                         alert_distance = alert_distance,
                         formation_flying_distance = formation_flying_distance,
                         formation_flying_strength = formation_flying_strength)
            boid.simulate(frames = frames,
                          interval = interval,
                          xlim = tuple(xlim),
                          ylim = tuple(ylim))
    except IOError as e:
        print 'Warning: Config file not found. Default: config.cfg. Can be changed with option --config'
        print 'Running with default values.'
        boid = Boids()
        boid.simulate()
    except ConfigParser.NoSectionError as e:
        print 'Warning: Invalid config file. Make sure all sections ([Boids], [Axis], [Animation], [Dynamics]) are present.'
        print e
        print 'Running with default values.'
        boid = Boids()
        boid.simulate()
# Python libraries
import time

# Code from local files
from boids import Boids

# ----------------------------------- setup -----------------------------------

num_points = 100
max_neighbour_dist = 100
world_size = [0, 1000, 0, 1000]
boids = Boids(num_points, world_size, max_neighbour_dist)
boids.generate_members()

openmp_threads = 1

# ------------------------------------ main -----------------------------------

print('Comparing cython implementations of the linear search nearest '
      'neighbour algorithm')
print(f'Finding the neighbours of {num_points} generated points...')

print('Execution time for make_neighbourhoods function, pure python linear '
      'search algorithm:')
START = time.time()
boids.make_neighbourhoods()
elapsed = time.time() - START
print(f'\t {elapsed*1000:0.2f} ms')

print('Execution time for make_neighbourhoods_cython function, cythonised '
      'linear search algorithm:')