Boids algorithm : A modelisation of murmuration by Yohan Lanier

What is a murmuration ?

yohanlanier — 2021-03-20 14:14:39 UTC

When birds, especially starlings, flock together, we call that phenomenom murmuration. When it occures, thousands of birds fly together, forming various random patterns. It is pretty impressive. During their flight, birds seem connected with each others. You can find out more by watching this pretty cool video by Smarter Every Day :

How do birds behave together ?

yohanlanier — 2021-03-20 14:22:03 UTC

Actually, scientists found out that starling flocks have more in common with physics than with biology ! At least you can easily model a murmuration using physical principles.

Let's take an example with only two starlings : it's easy to understand that assuming they are going to the same place, when one turns the other knows when to turn since they can see each other. They will adjust their speed to stay together. If they are to close, they will move away a little bit etc... You can think of it as two particles attracted to each others but which can't get to close.

The magic of murmuration is that it doesn't occure with two or ten birds but with thousands of them.

Craig Reynold's algorithm

yohanlanier — 2021-03-20 14:31:50 UTC

So how can we model thousands of starlings each connected with the others ? Well Craig Reynold found a way to do it. Here I will describe the most simple way to do it and present a mere implementation of this algorithm using python. Then I will present you various way to improve the algorithm.

First things first, you have to know that the following principles can be apply to birds or fishes or insects or other living creatures, that's why we will refere to them as boids.

I will use the link down below to explain the algorithm. It the original website Craig Reynold used to present his work.

Introduction of the algorithm

yohanlanier — 2021-03-20 14:38:17 UTC

You can think of each boid as a particle which has :

a position
a velocity (you can think of it as a vector which means the boid has a direction and a "speed" at which he travels)
an acceleration which is how its velocity varies in time
a mass (here we will assume all the boids have the exact same weight = 1 kg because it symplifies a lot the implementation)

And the more important things :
Each boid has a range in which he sees other boids : we can call that range the perception range. If some are to far from him it won't interact with them. So each boid will only interact with its nearest neighbours. In a first approach, we'll consider that each boid can see at 360° around him.

So what we want to do in this algorithm is to control the velocity of the boids (hence their position) so that we can move them forming murmuration.

I'll also consider we are in a 2D world in order to simplify drawings an explanations.

1st principle : Alignment

yohanlanier — 2021-03-20 14:50:39 UTC

The original description of this principle is : "steer towards the average heading of local flockmates".

So lets focus on one boid and see how he interacts with others in this principle. Basically what it says is that at every time, the boid "finds" what's the average direction of his neighbours (meaning the boids which are in his perception range) and he aligns its direction with it. Physically it means the boid will align his velociy (which is his direction) with the average velocity of his neighbours.

And this makes a lot of sens if you think to the starlings flocks : locally, all the birds are going in the same direction.

In the end, you can think of that as a "steering alignment force". And as Newton has inveted a really handly law in physics, this force is related to the acceleration of our boid. And in a discrete world, if we chose to have a time step equal to 1 sec, this force is directly related to the velocity of the boid ! So there we have made our first step to model murmuration !

2nd principle : cohesion

yohanlanier — 2021-03-20 15:06:51 UTC

"steer to move toward the average position of local flockmates"

So if we continue to focus on one boid, what this principle says is that, at every time, our boid has to move so that it's next position steers toward the average position of the boids which are in his perception range.

Once again, this makes sens, each starling wants to stay with the flock so he tends to move toward the average position of its neighbours. In that way he never goes to far from the others.

And again you can think of it as an "attractive steering cohesion force". And as we said before, this force is related to the velocity of the boid. And as physics is wonderfull, the sum of the force apply to the boid equals its acceleration (because its mass is 1kg). This means the "attractive steering cohesion force" adds up with the "steering alignment force". This is really convenient for the implementation.

3rd principle : seperation

yohanlanier — 2021-03-21 14:56:04 UTC

"steer to avoid crowding local flockmates"

Last but not least, we don't want our boid to collapse with his nieghbours. One way to do that is to consider that our boid will steer away from its neighbours in such a way that the steering force is inversly proportional to the distance between them.

If you think about it that makes sens : if a flockmate is far the starling won't really have to avoid him but if it is close enough, it will pay attention to avoid it.

Once again you can think of that as a "repulsive steering seperation force" which will merely add up with the two previous forces we wrote !

So there we are ! All we have to do now is to apply this principles to all the boids at the same time which is pretty easy to do in any programming language !

For all the equation lovers here !

yohanlanier — 2021-03-21 15:17:36 UTC

Newton's law :

m \times a = F_{alignment} + F_{cohesion} + F_{seperation}

But we consider we live in a world where the mass of everything is 1kg so :

m=1kg

Then we will discretize time and get the velocity (considering a time step equal to 1 sec) :

\frac{v_i - v_{i-1}}{\Delta t} = a_i = F_{alignment} + F_{cohesion} + F_{seperation} \Rightarrow v_i = v_{i-1} + F_{alignment} + F_{cohesion} + F_{seperation}

And identically we can have the position of our boids :

\frac{p_i - p_{i-1}}{\Delta t} = v_i \Rightarrow p_i = p_{i-1} + v_i

One will see that this physics equations are pretty easy to write in any programming language. All we have to do is to write these equations for each boid. The real difficulty is to write the expressions of the forces.

References :

yohanlanier — 2021-03-21 15:33:41 UTC

I put here all the links I've read to write this padlet AND code the simulation you can see on the videos :

https://imagecomputing.net/damien.rohmer/publications/2002_2006_student_work/2004_boids/rapport/boids_3eti_rohmer.pdf
https://www.youtube.com/watch?v=mhjuuHl6qHM
https://www.red3d.com/cwr/boids/
https://www.youtube.com/watch?v=4LWmRuB-uNU
https://eater.net/boids
https://medium.com/better-programming/boids-simulating-birds-flock-behavior-in-python-9fff99375118

Adding some features

yohanlanier — 2021-03-21 15:38:17 UTC

I wanted to add some features to the algortihm I wrote so by surfing on the internet, I found many things I could add to my simulation. I choosed 2 things :

I added obstacles that the boids would have to avoid
I added the possibility to have a "leader boid" which would be followed by all the other boids

You could add many other things such as the fact that birds don't see at 360° around them so you might want to implement that etc... or you could argue that birds have different masses than 1kg and implement that and see the effects etc..

Playing with the parameters + warnings

yohanlanier — 2021-03-21 15:44:30 UTC

There are so many things you can play with to give various comportements to your flock !

For instance :

maximum cohesion force
maximum speration force
maximum alignment force
maximum speed

**Warnings**
One would say that python isn't the most convenient language to do such animations because it is pretty slow and "live animations" are not smooth. He would be right. Even if the code could be improve using numba or by refactoring it (Some may have noticed that we don't have to check all the boids of the block for each boid, which is pretty long to do, but we can limit ourselve to check only the neighbours of each boid... I didn't do that here) python isn't the ideal language. But matplotlib was fine to edit the animations and I had it installed on my laptop so I used it + I wanted to practice python.

A simulation I made with the explained principles

yohanlanier — 2021-03-21 15:52:18 UTC

Adding a leader boid with a random trajectory (the blue dot)

yohanlanier — 2021-03-21 15:54:49 UTC

Github repo for the code

yohanlanier — 2021-03-21 15:56:23 UTC

Yet to come

An illustration of the seperation principle

yohanlanier — 2021-03-21 16:14:05 UTC

All the boids stay seperated from each others

An illustration of the cohesion principle

yohanlanier — 2021-03-21 16:19:33 UTC

Eventually if we wait long enough, all the boids would form one group and would stop moving

An illustration of the alignment principle

yohanlanier — 2021-03-21 16:24:43 UTC

Eventually if we wait long enough, all the boids will have the same velocity (meaning direction and speed)