Python で Boids を動かす

初心者向けです。numpyの練習問題にはなるかも。

<details><summary> 全体ソースコード</summary>

```python
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import ArtistAnimation

# ==========パラメーター====================
num_of_birds = 100 # 鳥の数
r_min_c = 0.4 # 近づきたい鳥の範囲の内側
r_max_c = 2.2 # 近づきたい鳥の範囲の外側
r_min_s = 0 # 離れたい鳥の範囲の内側
r_max_s = 0.4 # 離れたい鳥の範囲の外側
r_min_a = 0.4 # 整列したい鳥の範囲の内側
r_max_a = 2.2 # 整列したい鳥の範囲の外側
step = 500 # 試行回数
width = 25 # フィールド正方形の１辺
k1 = 1 # 結合係数
k2 = 25 # 分離係数
k3 = 12 # 整列係数
ts = 25 # 描画スピード
v = 0.12 # 鳥の移動スピード
e = 200 # 反発係数
λ = np.pi / 3 # 鳥の視界の範囲

# ==========座標とベクトルをランダム生成===========

pos = np.random.rand(num_of_birds, 2) * (0.6*width - 0.4*width) + 0.4*width # 初期座標。widthの2/5~3/5の間で出現させたい
vec = np.random.rand(num_of_birds, 2) - 0.5  # 初期ベクトル

# ==================4つの関数====================

# 1.距離行列を作る関数
def DISTANCE() :

    global distance # 距離の表であるdistanceはグローバルなオブジェクトとして定義しておく
    
    distance = np.zeros([num_of_birds, num_of_birds]) # 空のndarray配列を(鳥の数)*(鳥の数)で作っておく

    for i in range (num_of_birds) :

        for j in range (i+1, num_of_birds) :

            a = pos[i]
            b = pos[j]
            dist = np.linalg.norm(b-a)

            distance[i, j] = dist

    distance += distance.T



# 2.r_minとr_maxの間の範囲内にいる鳥さんたちの重心を教えてくれる関数 ※Center of Gravityで重心なのでCG
def GetCG(id, r_min, r_max) :
    
    d = distance[id]

    inRange = np.where((d > r_min) & (d < r_max)) [0]

    if len(inRange) == 0 :
    
        cg = pos[id] + ((np.random.rand(2)* 2 - 1) * 0.0002)
        return cg # ドーナツ内に誰もいなかったら、自分の座標を返す

    else :

        cg = np.mean(pos[inRange], axis = 0)
        return cg #ドーナツ内にあったら、それらの座標の平均を返す



# 3.r_minとr_maxの間の範囲内かつ視界にいる鳥さんのベクトルの平均を教えてくれる関数
def GetVEC(id, r_min, r_max) :
    
    d = distance[id]

    inRange = np.where((d > r_min) & (d < r_max)) [0]

    if len(inRange) == 0 :

        return 0

    else :

        passlist = []
        
        for i in range(len(inRange)) :

            line_vec = pos[inRange][i] - pos[id] # 自分と相手を結んだ直線のベクトル

            θ = np.arctan2(line_vec[1], line_vec[0]) # 自分と相手を結んだ直線のベクトルの角度

            φ = np.arctan2(vec[id][1], vec[id][0]) # 自分の現在の進行方向ベクトルの角度

            if ((φ-λ) < θ) & (θ < (φ+λ)) :

                passlist.append([vec[inRange][i]]) # 視界の範囲内に誰かいたら、その誰かの現在の進行方向ベクトルをpasslistに追加

            else :
                pass

        if len(passlist) == 0 :

            return 0
        
        else :

            pg = np.mean(passlist, axis = 0)
            return pg


# 4.鳥が壁に近づいたら、壁と反対方向に反発させるベクトルを計算する関数
def GetRepulsion(id) :

    # 壁との垂直距離
    left = pos[id][0] - 0 # 左壁との距離
    right = width - pos[id][0] # 右壁との距離
    under = pos[id][1] - 0 # 下壁との距離
    upper = width - pos[id][1] # 上壁との距離

    # 壁との距離が1未満だったら、反対方向に反射させる。ベクトルのデカさは距離の2乗に反比例させて、壁に近ければ近いほど反発力を高める
    if (left < 1) : 
        vec_LEFT = np.array([1,0]) / (left**2) 
    else :
        vec_LEFT = 0

    if (right < 1) : 
        vec_RIGHT = np.array([-1,0]) / (right**2) 
    else :
        vec_RIGHT = 0

    if (under < 1) : 
        vec_UNDER = np.array([0,1]) / (under**2) 
    else :
        vec_UNDER = 0

    if (upper < 1) : 
        vec_UPPER = np.array([0,-1]) / (upper**2) 
    else :
        vec_UPPER = 0

    # 4方面それぞれの反発ベクトルを合成
    vec_R =  vec_LEFT + vec_RIGHT + vec_UNDER + vec_UPPER

    return vec_R



# ====================以下メインで動かすところ====================
# まずはArtistanimationの準備
fig = plt.figure() # 描画領域の確保
img_list = [] # パラパラ漫画の1枚1枚を保存する空の容器(list)


p_pos = np.zeros([num_of_birds, 2]) # 一時的に新しい座標を保存しておくための空の容器(ndarray)
p_vec = np.zeros([num_of_birds, 2]) # 一時的に新しいベクトルを保存しておくための空の容器(ndarray)


for n in range(step) : # パラパラ漫画の枚数(step)分回す

    DISTANCE() # 距離行列を作成。stepを経るごとに距離座標は更新される

    for id in range(num_of_birds) : # 鳥の数(num_of_birds)分回す

        # お近づきになりたい鳥さんたちの座標の平均
        Cohesion = GetCG(id = id, r_min = r_min_c, r_max = r_max_c) - pos[id]
        # 距離をおきたい鳥さんたちの座標の平均
        Separation = GetCG(id = id, r_min = r_min_s, r_max = r_max_s) - pos[id]
        # 一緒に行動したい鳥さんたちのベクトルの平均
        Alignment = GetVEC(id = id, r_min = r_min_a, r_max = r_max_a)
        # 壁に対しての反発ベクトル
        Repulsion = GetRepulsion(id = id)


        # 進むべきベクトルを計算して、絶対値で割って単位ベクトル化
        vec_T = vec[id] + k1* Cohesion - k2* Separation + k3* Alignment + e* Repulsion
        vec_T /= np.linalg.norm(vec_T)


        p_pos[id] = pos[id] + vec_T * v # p_posに新しい座標を保存
        p_vec[id] = vec_T  # p_vecに新しいベクトルを保存


    # pos に p_posを代入して座標更新
    pos = p_pos

    # vec に p_vec を代入してベクトル更新
    vec = p_vec

    # x座標、y座標として登録
    x = pos[:, 0]
    y = pos[:, 1]
    img = plt.scatter(x, y, s = 3,  c= 'blue', marker= '1')
    img_list.append([img])

    print("step : ", n) # カウント用

print("finished.") # カウント用

# ArtistAnimation で描画
anim = ArtistAnimation(
    fig = fig,
    artists = img_list,
    interval = ts,
    blit = True
)

plt.xlim(0, width) # x軸方向の描画範囲
plt.ylim(0, width) # y軸方向の描画範囲
plt.show()
```
</details>
コピペしてパラメータを変えるだけでも遊べるので試してみてください。

# Boidsって何？
[wikipedia](https://ja.wikipedia.org/wiki/%E3%83%9C%E3%82%A4%E3%83%89_(%E4%BA%BA%E5%B7%A5%E7%94%9F%E5%91%BD))先生曰く
> ボイド(Boids)は、アメリカのアニメーション・プログラマ、クレイグ・レイノルズが考案・作製した**人工生命シミュレーションプログラム**らしいです。名称は「鳥もどき(bird-oid)」から。

仰々しく**人工生命**と言われるとSFっぽさが出ますが、そこまで高度なことをするワケではないです。プログラミングで生物の群れっぽいものがシミュレーションできるぜ！というノリです。具体的には、下のgifみたいなものが出来上がります。

![完成版.gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/0764a67e-13d5-6001-1eb8-ec83909531f5.gif)



初めて見た人は、おそらく「おお～本物の生物っぽい！」という感想を抱くと思います。でも、Boidsの面白ポイントはそこではありません。本当に凄いのは、一見複雑そうに見える群れの動きを

- **結合（Cohesion）**
- **分離（Separation）**
- **整列（Alignment）**

という3つの単純なルールのみで再現しているところです。つまり、**3つの基本原理から演繹的に生物の行動を模倣できます**。


# 全体的な仕組み
Boids は群れ全体をプログラムすることで生まれるものではなく、前述した３ルールを鳥1匹ずつに付与することで、結果的に生まれるものです。

具体的には、鳥1匹ずつに結合ベクトル、分離ベクトル、整列ベクトルを含ませて、進行方向を決定するだけでOK。以下では1匹の鳥に注目して、それぞれのルールをざっくり確認していきます。


### 結合ベクトル
<img width="400" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/70ad48bc-9381-b127-97e9-cf9d33773ec0.png">

群れるからには、鳥と鳥とが近づかなければいけません。したがって、任意の距離にいる鳥の集団を群れと認識して、その集団に近づいていくようにプログラムすればいいワケです。実際には図のように、ドーナツ領域の中にいる鳥の重心を求め（重心を群れの中心とみなす）、重心に向かって進む方向を接近ベクトルとします。


### 分離ベクトル
<img width="400" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/e081659f-0b97-4cec-cbbe-241f98b1dc52.png">

群れだからといって近づきすぎると、鳥と鳥とが衝突してしまいます。そこで、ソーシャルディスタンスを取らせる必要が出てきます。三密回避。原理としては接近ベクトルの真逆。ドーナツ領域の中にいる鳥の重心を求め、それに対して遠ざかる方向を回避ベクトルとします。


### 整列ベクトル
<img width="400" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/9ee5d6be-fd8b-27eb-4ce6-4ea64d341d13.png">

近づいたり離れたりするだけでは、群れにはなり得ません。周囲の行動に合わせて動く愚かな大衆に仕立て上げる必要があります。ドーナツ領域を考えるまでは接近・回避と同じですが、重心ではなくベクトルの合成を行います。


### 最終的な進行方向
<img width="600" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/002ec634-f823-65c6-4be1-da74807b66d1.png">

結合・分離・整列の3つのベクトルを今までの進行方向ベクトルに足し合わせることで、次に進むべきトータルの進行方向ベクトルが得られます。

実際には、鳥が壁にぶつかったときに跳ね返るための反発ベクトルも考慮し、最後に絶対値で割って単位ベクトル化してから用います（つまり純粋に方向だけを表すようにする）。詳細は後ほど。


### pythonで鳥をどうやって動かすか
鳥が動き回る様子をどのようにpythonで実装するのかというと、座標（数学で使うようなxy座標）の上に鳥を1匹ずつ”点”としてプロットし、プロットした紙をパラパラ漫画みたく連続でめくってアニメーションにするという手法を用います。

具体的に説明してみます。鳥1匹ずつにそれぞれ

- 現在の場所を表す座標：`pos(x, y)`
- 進行方向を表すベクトル：`vec(x, y)`

の2つを持たせます。

例えば、現在の位置が pos (1, 2)  方向ベクトルが vec (3, 4) だったとしたら、(1+3, 2+4) の計算（場所の座標に方向ベクトルを足す）により、次の座標は (4, 6) に決定されます。このように1回の計算ごとに鳥の座標が少しずつズレていくので、パラパラ漫画にすると鳥が移動しているように見えることになります。


# 実装
## 0. 座標と進行方向ベクトル
前項で説明した通り、鳥1匹に対して、「座標」と「進行方向ベクトル」という2つの要素を持たせます。
具体的には、鳥1匹ずつに`id`で**背番号**をふり、その番号ごとに
- 座標：`pos[id]`
- 進行方向ベクトル：`vec[id]`

を設定します。以下のコードでは、初期座標と初期ベクトルを一定の範囲内にランダム生成しています。
```python
import numpy as np

width = 25 # フィールド正方形の１辺の長さ。つまりx座標とy座標のとりうる範囲

num_of_birds = 100 # 鳥の数。とりあえず100匹にしておく

pos = np.random.rand(num_of_birds, 2) * (0.6*width - 0.4*width) + 0.4*width # 初期座標をランダム生成する
vec = np.random.rand(num_of_birds, 2) - 0.5 # 初期ベクトルをランダム生成する
```
`pos`について詳しく説明します。
まず`np.random.rand()`で**0.0以上1.0未満**の乱数を発生させることができます。
ここでは引数を`(num_of_birds, 2)`にしているので、ランダムな`[x, y]`の二次元配列の組が`num_of_birds`個、つまり100個生成されたことになります。
<img width="600" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/00349428-c19a-c7c6-300a-78b23b6c564a.png">

このままでは　0 ≦ x ＜ 1,　0 ≦ y ＜ 1　の小さな正方形内に鳥が生成されてしまうので、フィールド中心辺りに生成されるように処理を行わなければなりません。
そこで`* (0.6*width - 0.4*width) + 0.4*width`という計算をしています。原理は下の図。
<img width="700" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/18cb2ce2-b1bc-e9d7-af70-350f05bffa9b.png">

まず 1 × 1 の正方形内の鳥の座標を (0.2 × width) × (0.2 × width) に拡大するために
`* (0.6*width - 0.4*width)`を行い、
次に正方形をフィールドの中心にスライド移動するために`+ 0.4*width`を行っています。
鳥の初期位置を自分でカスタマイズしたければ、ここらへんの数値をいじればOK。

`vec` の生成も`pos`とほぼ同じだけど、めんどくさいので説明は省略。


## 1. 距離行列を作る
結合・分離・整列ベクトルを求めるためには、まずは鳥どうしの距離を計算しておく必要があります。先に距離をすべて計算しておくことで、1匹の鳥に対して他の鳥が「近いのか」「遠いのか」を判別することができます。

最初はA～Eの5匹で考えてみます。Aに注目すると、他の鳥との距離は A-B, A-C, A-D, A-E の4種類があり、これはB~Eの鳥に注目したときでも同様です。表にすると下のようになります。

<img width="300" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/82f3315d-8468-4235-ed9c-31905be0623f.png">

次にA～Eの鳥それぞれに座標を設定してみます。$${A(1, 2)　B(3, 4)　C(5, 6)　D(7, 8)　E(9, 10)}$$とすると、例えばA-B間の距離は$${\sqrt{(3-1)^2+(4-2)^2} = 2.8}$$　になります。表に反映させるとこんな感じ。

<img width="300" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/a6ef7775-b94f-f3a9-7f47-cbb168d8a642.png">

以上で距離行列は完成。
説明を簡単にするために5匹の鳥A～Eに登場してもらいましたが、実際のコーディングでは鳥の位置を`pos`で行います。


距離行列は`DISTANCE()`という専用の関数で作ることにします。
距離行列そのものは、`distance`というグローバル変数に保存します。
```python
def DISTANCE() :

    global distance # 距離行列の表であるdistanceはグローバルなオブジェクトとして定義しておく
    
    distance = np.zeros([num_of_birds, num_of_birds]) # 空のndarray配列を(鳥の数)*(鳥の数)で作っておく

    for i in range (num_of_birds) :

        for j in range (i+1, num_of_birds) :

            a = pos[i] # 表の横列
            b = pos[j] # 表の縦列

            dist = np.linalg.norm(b-a) # 座標間の距離を計算

            distance[i, j] = dist # 距離行列の表のマスに代入

    distance += distance.T # 表の上半分を反転させて、下半分のマスを埋める
```
詳しく見ていきます。
まずは、距離行列を保存する`distance`にあらかじめ**空の表**を作っておきます。
`np.zeros()`で空のndarray配列を作ることができ、
引数を`[num_of_birds, num_of_birds]`にすることで、（鳥の数）×（鳥の数）の表が用意されます。

次に、for文2つで`i`と`j`を回して、鳥の座標どうしの距離計算を行います。
上のコードでは2匹の鳥の座標をそれぞれ`a`と`b`でいったん置き換え、
a-b間の距離を`np.linalg()`で計算してから表のマス`distance[i, j]`に代入しています。

ここまでの計算で、下のような距離行列が出来上がります。
<img width="700" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/32e2c6c8-b419-7e55-ed1a-09bb661ac918.png">
見ての通り、for文2つを回しただけでは表の上半分しか埋まっていません。そこで下半分を埋める処理を行います。
`distance += distance.T` によって、もともとの`distamce` の行と列を入れ替えた`distance.T`が追加されます。

以上により、下のような距離行列が完成。
<img width = "400" src = "https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/dcfab617-7fd2-1912-78e6-6a8fe764fc97.png">


### 2. 仲間の場所の平均を求める
「全体的な仕組み」の項で記したように、鳥は自分の周囲にドーナツ状の領域を展開して、その領域内にいる仲間に対して近づいたり、あるいは遠ざかったりします。どちらにせよドーナツ状領域を展開して仲間の座標の重心を求めるところまでは同じ処理になるので、
`GetCG (id, r_min, r_max)`という関数を作りモジュールとして使えるようにしておきます。
引数に指定している`id`は鳥1匹ずつに割り振られた背番号、
`r_min`はドーナツの内径、
`r_max`はドーナツの外径を表します。
<img width = "400" src = "https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/69681215-bed2-f676-5b33-2b56d5e127ae.png">
まずはドーナツ領域内にいる鳥の座標のインデックス（位置）を取得するところから。
```python
# 2.[r_minとr_maxの間の範囲内にいる鳥さんたちの重心を教えてくれる関数]  ※Center of Gravityで重心なのでCG
def GetCG(id, r_min, r_max) :
    
    d = distance[id]

    inRange = np.where((d > r_min) & (d < r_max)) [0]
```
以降では分かりやすさを重視して、以下のような具体的な値を仮設置した距離行列で考えていきます。
<img width = "300" src = "https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/c3234653-4778-a84c-de05-5cbaa04c926e.png">
まず、距離行列の中から`distance[id]`を抜き出し、`d`に格納します。
例えば`id = 2`で考えると、`d`には`pos[2]`と他の鳥との距離の配列である
`[5.6, 2.8, 0, 2.8]`という1次元配列が格納されることになります。
<img width="300" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/ad44b0fe-9bf8-6b21-4879-796250b3f5ef.png">
次に`np.where((d > r_min) & (d < r_max)) [0]`
によって、`d`の中からドーナツ領域の範囲内、つまり`r_min`と`r_max`の間にいる鳥のインデックス（位置）を探し、`inRange`の中に格納します。

インデックス（位置）だと分かりにくいですが、つまりは**最初から数えて何番目か**のことです。
具体的に考えてみます。`id = 2`, `r_min = 2`, `r_max = 3`の場合、
`[5.6, 2.8, 0, 2.8]`の中から2より大きく3未満の値、すなわち2.8が選ばれます。そして2.8は最初から数えて1番目と3番目なので、最終的に`inRnage` には`[1, 3]`がインデックスとして格納されることになります。
<img width="400" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/eeb71b46-919c-7f9a-f280-6992d28c7153.png">
（※今回のようにnp.where()の引数に条件文だけを指定すると、ndarrayのタプルとして結果が返ってくる。
仮に`[0]`を抜いて`np.where((d > r_min) & (d < r_max))`にしてみると、
`array([1, 3], dtype=int64)`という結果が返ってくる。必要なのは最初の1次元配列`[1, 3]`だけなので`[0]`を付けてスライスしている。）

このようにして得られたインデックス`inRange`は、鳥に割り振られた番号と一致しています。
つまり、`inRrange`とは、**ドーナツ領域内にいる鳥の背番号( = id )が並んだ配列です。**
したがって、`pos[inRange]`によって、ドーナツ領域内にいる鳥の実際の座標を求めることができます。
例によって`id = 2`で考えると、`inRange`は`[1, 3]`なので、`pos[1]`と`pos[3]`の座標である`[3, 4]`と`[7, 8]`を得ることができます。
<img width = "300" src = "https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/b0855c9e-490c-ba26-8d5d-134401fd9830.png">
ドーナツ領域にいる鳥の座標が分かったので、ようやく重心を求めることができるようになった。。。とその前に、例外処理をしておく必要があります。
例外とはすなわち、`inRange == 0`の場合、つまりドーナツ領域内に鳥がいない状況のことです。
そのような場合、鳥はその場から動かないことになってしまいます。別にじっとしていてもらっても構わないのですが、その場にうずくまってしまうのはあまり鳥の群れっぽくないので、少しモゾモゾしてもらうことにします。
つまり、自分の座標を少しだけランダムにずらします。
```python
    # ドーナツ内に仲間の鳥がいなかったら、自分の座標をランダムにずらしたものを返す
    if len(inRange) == 0 :

            cg = pos[id] + ((np.random.rand(2) * 2 - 1) * 0.0002) # 0.0002は適当に決めた

            return cg 
```
`np.random.rand(2)`では0以上1未満の（x、y）座標が生成されるので、そのまま足すだけでは右上方向に移動するようになってしまいます。4方向に均等に移動するためには、まず`* 2`で移動範囲を拡張し、次に`- 1`で移動範囲の中心を`pos[id]`に合わせる必要があります。
以下の図では、`pos[id]`を(0, 0)と設定して説明しています。
<img width = "700" src = "https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/e8a779da-a8cf-afcb-26a4-38c5b52c7f8c.png">
※図内の不等号を間違えて`0<`にしているが、「0以上」なので正しくは`0≦`。

（`* 0.0002`は**適当に決めた**。数字を変えれば、鳥のモゾモゾ具合を調節できる。）


例外処理が終わったので、ようやく重心の計算に入ります。
といっても、重心の計算自体はドーナツ領域内の鳥の座標の平均値を出せばいいだけなので、
配列要素の平均値を出す関数`np.mean()`に`pos[inRange]`を渡してあげればいいだけ。
```python
    #ドーナツ内にいる鳥の座標の平均を返す
    else :
            cg = np.mean(pos[inRange], axis = 0)

            return cg 
```
`axis = 0`を引数に指定しているのは、x座標どうし、y座標どうしの平均を出すため。


## 3. 仲間の進行方向の平均を求める
<img width="400" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/9ee5d6be-fd8b-27eb-4ce6-4ea64d341d13.png">

結合・分離ベクトルは重心だけで計算できるが、整列ベクトルを計算するためには仲間の進行方向も必要になります。そこで、ドーナツ範囲内にいる仲間の鳥の進行方向ベクトルを取得し、それらの平均を返す関数を
`GetVEC(id, r_min, r_max)`として作っておきます。

ドーナツ領域内にいる仲間の鳥の座標のインデックスを`inRange`として取得し、例外処理をするところまでは、重心とまったく同じ。
```python
λ = np.pi / 3 # 視野の角度

def GetVEC(id, r_min, r_max) :
    
    d = distance[id]

    inRange = np.where((d > r_min) & (d < r_max)) [0]

    if len(inRange) == 0 :

        return 0
```
※前項の`GetCG()`では、ドーナツ領域内に誰もいなかった場合に自分の座標をランダムにずらしていたが、今回は特に何もしない。なので`return 0`にしている。

ここから少し処理が異なってきます。

自分が群れの中の鳥になった想像してください。実際に仲間の鳥の動きに合わせようとするのなら、単に近くにいる仲間ではなく、目の前にいる仲間の動きに注目するはずです。
それを実現するためには、単なるドーナツ領域を設定するだけではなく、「視野」の要素が必要になります。
そこで、以下の図のように扇形の領域を追加し、**ドーナツ領域内でかつ、扇型領域内**の鳥の進行方向ベクトルを取得することにします。
<img width="400" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/e575e287-7a28-6261-4c2c-f057676fa645.png">
扇形領域は、下図のように設定。
<img width="700" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3277515/15d85e98-0f32-1d13-3de4-c25b8b1c1626.png">
要するに **θ・φ・λ** の3つを先に計算しておき、$${φ-λ<θ<φ+λ}$$の条件を満たす鳥をあぶり出してやればOK。
```python
    else :

        passlist = [] # 空のリスト。ここに視野にいる鳥の進行方向ベクトルを追加していく
        
        for i in range(len(inRange)) :

            line_vec = pos[inRange][i] - pos[id] # 自分と相手を結んだ直線のベクトル

            θ = np.arctan2(line_vec[1], line_vec[0]) # 自分と相手を結んだ直線のベクトルの角度

            φ = np.arctan2(vec[id][1], vec[id][0]) # 自分の現在の進行方向ベクトルの角度

            if ((φ-λ) < θ) & (θ < (φ+λ)) :

                passlist.append([vec[inRange][i]]) # 視野にいた鳥の進行方向ベクトルをpasslistに追加

            else :
                pass
```
`inRange`はドーナツ領域内にいる鳥たちの背番号の配列なので
`for`文の中で`pos[inRange][i]`とし、1匹ずつ取り出して計算しています。
そして`for`で背番号を回していく中で、条件に合格した鳥のベクトルだけ抜き出します。
抜き出してきたベクトルはとりあえず`passlist`の中に`.append()`で放り込んでいく（ベクトルの平均はあとで計算する）、、、というのが大まかな流れです。

θ と φ の計算には`np.arctan2()`を使用しています。この関数は、引数に（y成分、x成分）を放り込むと、そのベクトルの偏角を返してくれる便利なヤツ。引数の順番が **y成分、x成分** になっていることに注意する必要があります。

`for`を抜けると、ドーナツ領域内でかつ扇形領域内にいる鳥の進行方向ベクトルの全てが`passlist`の中に保存された状態になります。
したがって、それらの平均を求めるためには、前項同様`np.mean()`に`passlist`を放り込めばOK。
```python
        if len(passlist) == 0 : # 例外処理

            return 0
        
        else :

            pg = np.mean(passlist, axis = 0) # ベクトル平均の計算

            return pg

```
ドーナツ領域内にはいたが扇形領域の外だった鳥のために、`if len(passlist) == 0`で例外処理を行っています。


## 4. 壁に近づいたら反発させる
Boidsアルゴリズム自体は、これまで作ってきた関数だけで完成させることができます。しかし、このままでは鳥がグラフの外に飛び立ってしまい、描画できなくなってしまうことがあります。そこで描画領域内に鳥を閉じ込めるために、鳥が壁に近づいたら反射せる関数を`GetRepulsion(id)`として用意しておきます。
```python
def GetRepulsion(id) :

    # 壁との垂直距離
    left = pos[id][0] - 0 # 左壁との距離
    right = width - pos[id][0] # 右壁との距離
    under = pos[id][1] - 0 # 下壁との距離
    upper = width - pos[id][1] # 上壁との距離

    # 壁との距離が1未満だったら、反対方向に反射させる。ベクトルのデカさは距離の2乗に反比例させて、壁に近ければ近いほど反発力を高める
    if (left < 1) : 
        vec_LEFT = np.array([1,0]) / (left**2) 
    else :
        vec_LEFT = 0

    if (right < 1) : 
        vec_RIGHT = np.array([-1,0]) / (right**2) 
    else :
        vec_RIGHT = 0

    if (under < 1) : 
        vec_UNDER = np.array([0,1]) / (under**2) 
    else :
        vec_UNDER = 0

    if (upper < 1) : 
        vec_UPPER = np.array([0,-1]) / (upper**2) 
    else :
        vec_UPPER = 0

    # 4方面それぞれの反発ベクトルを合成
    vec_R =  vec_LEFT + vec_RIGHT + vec_UNDER + vec_UPPER

    return vec_R

```
条件分岐を冗長に書いているせいで長ったらしいですが、原理は極めて単純。壁との垂直距離が1未満になったら、その壁と反対方向に働くベクトルを距離の2乗に反比例するように生成しているだけです。

距離の2乗に反比例させているのは、いわゆる**逆2乗の法則**というヤツ。物理ﾅﾆﾓﾜｶﾗﾅｲﾏﾝなので詳しくないが、自然界の物理現象に多くみられるらしい。これをやっとけば、とりあえず自然物っぽく見えるようになる。（過去の偉人が自然の中から導き出した"真理"を使って自然物をシミュレーションできるというのは、プログラミングで得られるカタルシスの1つなんじゃない？と初心者ながら思ってみたり...）

## 5. mainで動かす
関数を全部作り終わったので、mainで鳥を動かしていきます。
### おまじない
ArtistAnimation でパラパラ漫画的な感じでアニメーションを動かすのだが、最初でその準備をしておく必要がある。ArtistAnimation については後で詳しく説明するので、現時点ではおまじないだと思ってもらって構いません。
```python
import matplotlib.pyplot as plt
from matplotlib.animation import ArtistAnimation

fig = plt.figure() # 描画領域の確保
img_list = [] # パラパラ漫画の1枚1枚を保存する空の容器(list)
```
1行目の`fig`はガチのおまじないなので気にしなくて大丈夫。
2行目の`img_list`は少し知っておく必要があります。ArtistAnimationはパラパラ漫画だとしつこく言っていますが、パラパラ漫画にするための1枚ずつのグラフをため込んでおく保存容器が必要になります。それがこの`img_lilst`。後でこの箱の中身をパラパラめくることになります。

### 一時的な保存容器
以降では鳥の背番号`id`を`for`で回しながら距離行列`distance`の中身を計算していくことになりますが、ここで逐一`pos[id]`や`vec[id]`を更新してしまうと、`id`の背番号によって更新される順番ができてしまい、実際の座標と距離行列の間に齟齬が生じてしまいます。
これを防ぐためには、`for`を抜けてすべての`pos[id]` `vec[id]`を計算し終えた後に、距離座標`distance`を**一気に更新する必要があります**。そこで、以下のような仮の保存容器の中に一時保存しておき、後から一気に`pos` `vec`を更新することにします。
```python
p_pos = np.zeros([num_of_birds, 2]) # 一時的に新しい座標を保存しておくための空の容器(ndarray)
p_vec = np.zeros([num_of_birds, 2]) # 一時的に新しいベクトルを保存しておくための空の容器(ndarray)
```

### Boidsの本質的なソースコード
ここからようやくBoidsアルゴリズムの本質的な内容になります。本記事の一番最初に記した「Boidsって何？」の項を思い出しながら見てほしいです。

```python
r_min_c = 0.4 # 近づきたい鳥の範囲の内側
r_max_c = 2.2 # 近づきたい鳥の範囲の外側
r_min_s = 0 # 離れたい鳥の範囲の内側
r_max_s = 0.4 # 離れたい鳥の範囲の外側
r_min_a = 0.4 # 整列したい鳥の範囲の内側
r_max_a = 2.2 # 整列したい鳥の範囲の外側

k1 = 1 # 結合係数
k2 = 25 # 分離係数
k3 = 12 # 整列係数
e = 200 # 反発係数

v = 0.12 # 鳥の移動スピード

step = 500 # 試行回数（パラパラ漫画の枚数）


for n in range(step) : # パラパラ漫画の枚数(step)分回す

    DISTANCE() # 距離行列を作成。stepを経るごとに距離座標は更新される

    for id in range(num_of_birds) : # 鳥の数(num_of_birds)分回す

        # お近づきになりたい鳥さんたちの座標の平均
        Cohesion = GetCG(id = id, r_min = r_min_c, r_max = r_max_c) - pos[id]
        # 距離をおきたい鳥さんたちの座標の平均
        Separation = GetCG(id = id, r_min = r_min_s, r_max = r_max_s) - pos[id]
        # 一緒に行動したい鳥さんたちのベクトルの平均
        Alignment = GetVEC(id = id, r_min = r_min_a, r_max = r_max_a)
        # 壁に対しての反発ベクトル
        Repulsion = GetRepulsion(id = id)


        # 進むべきベクトルを計算して、絶対値で割って単位ベクトル化
        vec_T = vec[id] + k1* Cohesion - k2* Separation + k3* Alignment + e* Repulsion
        vec_T /= np.linalg.norm(vec_T)


        p_pos[id] = pos[id] + vec_T * v # p_posに新しい座標を保存
        p_vec[id] = vec_T  # p_vecに新しいベクトルを保存


    pos = p_pos # 座標を一気に更新
    vec = p_vec # ベクトルを一気に更新


    # x座標、y座標として登録し、散布図にプロット
    x = pos[:, 0]
    y = pos[:, 1]
    img = plt.scatter(x, y, s = 3,  c= 'blue', marker= '1')
    img_list.append([img]) # 出来上がった散布図1枚を、img_list の中に保存
```
一番外側の`for i in range (step)`の中で、1枚の散布図を作成することになります。

散布図を作成するにあたり、まず最初に鳥の座標`pos`をもとに`DISTANCE()`で距離行列を作成します。

距離行列ができたら`for id in range(num_of_birds)` で`id`を回しながら、鳥1匹についての進行方向ベクトルを計算します。その計算過程で今まで作ってきた関数を使用します。すなわち、以下の4つです。

- **結合ベクトル** : `Cohesion = GetCG() - pos[id]`
- **分離ベクトル** : `Separation = GetCG() - pos[id]`
- **整列ベクトル** : `Alignment = GetVEC()`
- **反発ベクトル** : `Repulsion = GetRepulsion()`

`GetCG()`が返すのはベクトルではなくただの重心の座標なので、
`Cohesion`と`Separation`では`- pos[id]`によってベクトル化していることに注意。

4つのベクトルが計算し終わったら、それぞれに重み（**k1, k2, k3, e**）をかけて足し合わせ、
最終的な進行方向である`vec_T`を算出する。`vec_T`は絶対値で割ることで、正規化します。

そして`vec_T`に移動速度`v`をかけたものを現在の座標`pos[id]`に足すことで、次の座標を算出します。このとき、次の座標は一旦`p_pos`に仮置きしておきます。
また、`vec_T`はそのまま次の進行方向ベクトルになるので、`vec_T`単体で`p_vec`に保存しておきます。

以上のベクトル計算が全部の鳥で終わると、1つ目の`for`を抜けます。
ここで`pos = p_pos` `vec = p_vec`により座標・進行方向ベクトルを一気に更新。これによって、パラパラ漫画の次の1ページを作る際に、距離行列`distance`も一気に更新されることになります。

最後に、新しくなった`pos`の座標をグラフ上にプロットして、散布図を作成します。
散布図の作成には、matplotlib の`plt.scatter()`を用いています。引数が意味しているのは、それぞれ以下の通り。
- `x, y` : プロットしたい点のx座標、y座標
- `s` : 点の大きさ
- `c` : 点の色
- `marker` : 点の形

このようにして完成した散布図`img`を、本項の最初に作っておいた`img_list`の中に`.append()`によって追加。

以上の工程を、パラパラ漫画の枚数`step`分だけ繰り返します。

全部終わると、`img_list`の中にすべての散布図がため込まれた状態になっています。あとはここから中身を取り出してパラパラめくれば、アニメーションの完成。

### ArtistAnimation で描画
matplotlibについては分かりやすいネット記事が死ぬほどたくさん転がっている（YouTubeに動画もある）ので、わざわざこの項を読む必要はないです。ただしこの記事は自分の備忘録も兼ねているので、今回使っている要素に関しては最低限説明しておこうと思います。

今回使用している **ArtistAnimation**は先にフレームを全部作り置きしておき、一気にパラパラ漫画みたくめくってアニメーションにする仕組みです（**溜めて解放理論**）。

ArtistAnimation で基本になるのは、以下に記す`anim`オブジェクト。

`anim = ArtistAnimation(
    fig,
    artists,
    interval,
    blit
)`

引数に指定されているのは、それぞれ
- `fig` : 描画領域
- `artists` : グラフ画像をため込んだリスト
- `interval` : フレームをパラパラめくる間隔
- `blit` : Trueにするとアニメーションが最適化されるらしい（よく分かんない）

1つ目の`fig`と4つ目の`blit`はほぼおまじないみたいなもので、3つ目の`interval`も定数として指定すればいい。
ちゃんと理解しなければいけないのは、2つ目の`artists`。ここに前項で作った`img_list`を渡します。
```python
ts = 25 # フレーム間隔

anim = ArtistAnimation(
    fig = fig,
    artists = img_list, # さっき作った散布図のリストを渡している
    interval = ts,
    blit = True
)
```
あとはグラフの描画範囲を指定して、Show ! すれば完成。
```python
plt.xlim(0, width) # x軸方向の描画範囲
plt.ylim(0, width) # y軸方向の描画範囲
plt.show()
```
完成。

# 終わりに
パラメータだけかき集めると、こんな感じ
```python
# ==========パラメータ====================
num_of_birds = 100 # 鳥の数
step = 500 # 試行回数
width = 25 # フィールド正方形の１辺
ts = 25 # 描画スピード
r_min_c = 0.4 # 近づきたい鳥の範囲の内側
r_max_c = 2.2 # 近づきたい鳥の範囲の外側
r_min_s = 0 # 離れたい鳥の範囲の内側
r_max_s = 0.4 # 離れたい鳥の範囲の外側
r_min_a = 0.4 # 整列したい鳥の範囲の内側
r_max_a = 2.2 # 整列したい鳥の範囲の外側
k1 = 1 # 結合係数
k2 = 25 # 分離係数
k3 = 12 # 整列係数
v = 0.12 # 鳥の移動スピード
e = 200 # 反発係数
λ = np.pi / 3 # 鳥の視界の範囲
# ===========================================
```
数値設定は実際にシミュレーションを繰り返している中で「なんか群れっぽくなった！」と思ったものを適当に採用しています。いろいろ変えて遊んでみるとおもしろいよ。