Stampede.ipynb

{
 "metadata": {
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.9"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python389jvsc74a57bd005aff6734a0136c1456f6cababa7509d8ef823a72f9d7deb75637cc690b3e532",
   "display_name": "Python 3.8.9 64-bit"
  },
  "metadata": {
   "interpreter": {
    "hash": "05aff6734a0136c1456f6cababa7509d8ef823a72f9d7deb75637cc690b3e532"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Chaos during a stampede\n",
    "\n",
    "Based on the paper: https://www.sciencedirect.com/science/article/pii/S1569190X20300861?casa_token=eoCj844--UoAAAAA%3AW5IEQVZQbP5ILasesMnahd3iIgfHNXfAWnaI7RsboLHrfqNA-UNxb_pyNF5FIyDN0hoKbjdC-EA "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### To do:\n",
    "Add the density\n",
    "\n",
    "### Ideas:\n",
    "Implement people as class so that we can define their state and position as parts of that class.\n",
    "\n",
    "Use code example below, set all bordercells to 500 (= wall)\n",
    "Use different values for different states of people.\n",
    "Make custom update rules."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### Steps:\n",
    "1. Populate board with random amount of people in random positions\n",
    "2. In each time step, calculate the static floor field Sij, the dynamic floor field Dij and the event floor field Fij with help of the formulas.\n",
    "3. For each pedestrian, determine his/her state and make a decision regarding movement behavior. If the pedestrian is in\n",
    "state Ue,Un or Ae, calculate the transition probability according to Eqs. (15)–(17), respectively. If the pedestrian is in state An, he/\n",
    "she chooses one of the strategies S1, S2 or S3 to evacuate. If the pedestrian is in state C, calculate the probability of him/her\n",
    "getting up again.\n",
    "4. Each pedestrian moves to his/her target cell. If the pedestrian chooses a target cell that is occupied by a fallen pedestrian, he/she will be tripped and become a new fallen pedestrian.\n",
    "5. If the chaos duration is over, uninjured pedestrians regard fallen pedestrians as obstacles and conduct a normal evacuation. There will be no more new fallen pedestrians.\n",
    "6. When multiple pedestrians choose to move to the same target, one pedestrian is randomly selected with equal probability to move to the target cell, and other pedestrians remain in their original cells.\n",
    "7. Determine whether the evacuation is over. If there are still uninjured pedestrians in the room, return to step 2 and repeat the simulation process until all the uninjured pedestrians evacuate from the room.\n",
    "\n",
    "### Variables:\n",
    "\n",
    "S = static floor: describes pedestrian behavior of finding the shortest path to the exit during the evacuation process.\n",
    "D = dynamic floor: represents the interactions among pedestrians in the evacuation process.\n",
    "F = event floor: reflects thhat some pedestrians intend to escape from the stampede location when they are affected by the stampede.\n",
    "A = risk floor field: depicts that pedestrian movement direction affects the risk of being tripped.\n",
    "\n",
    "### evac strategies:\n",
    "S1 = Tries to stay away from the stampede location (Eq 1)\n",
    "S2 = Follows movement of neighbours \n",
    "S3 = keeps moving in same direction until wall is reached, then follows it clockwise or anti clockwise.\n",
    "     when they stay in the same cell for more then 5 time steps, they change the desired direction randomly.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import numpy as np\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def maak_gif(frames, filename = None):\n",
    "    \"\"\"\n",
    "    Maakt een gif.    \n",
    "    Parameters\n",
    "    ----------\n",
    "    frames : list\n",
    "        lijst met numpy arrays van de videoframes\n",
    "    filename : str, optional\n",
    "        Als een bestandsnaam wordt meegegeven, wordt een gif opgeslaan van de video. De default is None.    \"\"\"\n",
    "    print(\"\\nMaken van gif...\")\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.set_aspect('equal')\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "    \n",
    "    im = ax.imshow(frames[0])\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    \n",
    "    def update_img(n):\n",
    "        im.set_data(frames[n])\n",
    "        return ax\n",
    "    \n",
    "    ani = animation.FuncAnimation(fig,update_img,len(frames))\n",
    "    if isinstance(filename,str):\n",
    "        if filename[-4:] != \".gif\":\n",
    "            filename += \".gif\" \n",
    "    else: \n",
    "        filename = \"goudvis.gif\"\n",
    "    ani.save(filename,writer='pillow',fps=10, dpi=100)\n",
    "    print(\"Gif opgeslaan als \"+filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# functions\n",
    "\n",
    "def init_board(board_size,num_people,exit_locs,sight_radius,state_dic, B_exit, B_wall): # TODO: add density\n",
    "    \"\"\" populate board with size r x r with x people\n",
    "        decide where exits are with e list of locations of exits\n",
    "        set remaining walls to 500 \n",
    "        Inputs:\n",
    "            board_size: The size of the board\n",
    "            num_people: The number of people on the board\n",
    "            exit_locs: The locations of the exits given as an array(y,x)\n",
    "            sight_radius: How far the people should be able to see\n",
    "            state_dic: The dictionary of the states and their according number\n",
    "        Outputs:\n",
    "            The board filled with numeric values. Where each state is represented by a certain number\n",
    "            The list of people on the board, this is the list that we can iterate over every time.\n",
    "            Encoding:\n",
    "              0: empty cell\n",
    "              1+: One or more fallen down persons (C)\n",
    "              -1: wall\n",
    "              -2: exit\n",
    "              -3: person in state Ue\n",
    "              -4: person in state Un\n",
    "              -5: person in state Ae\n",
    "              -6: person in state An\n",
    "        \"\"\"\n",
    "\n",
    "    # create board with all walls being 500\n",
    "    board = np.ones((board_size,board_size), dtype = \"int\") * B_wall\n",
    "    board[1:-1,1:-1] = 0\n",
    "\n",
    "    # add the exit locations\n",
    "    board[exit_locs] = B_exit\n",
    "\n",
    "    # calculate all possible locations\n",
    "    locations = [[y,x] for x in range(1,board_size-1) for y in range(1,board_size-1)]\n",
    "\n",
    "    if len(locations) >= num_people:\n",
    "        uniq_locations = random.sample(locations,num_people)\n",
    "    else:\n",
    "        raise ValueError('num_people can not be greater than the number of free spaces on the board')\n",
    "\n",
    "    # add the people to the board\n",
    "    person_list = []\n",
    "\n",
    "    exits = [[exit_locs[0][i], exit_locs[1][i]] for i in range(len(exit_locs[0]))]\n",
    "\n",
    "    for i,location in enumerate(uniq_locations):\n",
    "        # set standard state to 'Un' if exit in range set to 'Ue'\n",
    "        pstate = 'Un'\n",
    "        for exit_loc in exits:\n",
    "            if np.sqrt((exit_loc[0]-location[0])**2+(exit_loc[1]-location[1])**2) <= sight_radius:\n",
    "                pstate = 'Ue'\n",
    "        \n",
    "        person_list.append(Pedestrian(location,pstate))\n",
    "\n",
    "        board[location[0], location[1]] = state_dic[pstate]\n",
    "\n",
    "    return board, np.array(person_list)\n",
    "\n",
    "def update_board(board,person_list,state_dic,chaos,B_exit):\n",
    "    \"\"\" populate board with size r x r with x people\n",
    "        decide where exits are with e list of locations of exits\n",
    "        set remaining walls to 500 \n",
    "        Inputs:\n",
    "            board: The current board\n",
    "            people_list: The list of people on the board\n",
    "            state_dic: The dictionary of the states and their according number\n",
    "            chaos: A boolean indicating if it is chaos\n",
    "        Outputs:\n",
    "            The board filled with numeric values. Where each state is represented by a certain number\n",
    "            The list of people on the board, this is the list that we can iterate over every time.\n",
    "            Encoding:\n",
    "              0: empty cell\n",
    "              1+: One or more fallen down persons (C)\n",
    "              -1: wall\n",
    "              -2: exit\n",
    "              -3: person in state Ue\n",
    "              -4: person in state Un\n",
    "              -5: person in state Ae\n",
    "              -6: person in state An\n",
    "        \"\"\"\n",
    "\n",
    "    # set middle of board to zero\n",
    "    board[board <= state_dic['Ue']] = 0\n",
    "\n",
    "    # set position of people\n",
    "    for person in person_list:\n",
    "        if person.state != 'C':\n",
    "            board[person.location[0], person.location[1]] = state_dic[person.state]\n",
    "        elif not(chaos):\n",
    "            board[person.location[0], person.location[1]] = -1\n",
    "    \n",
    "    fallen_locs = np.where(board > 0)\n",
    "    board[exit_locs] = B_exit\n",
    "\n",
    "    return fallen_locs, board\n",
    "\n",
    "def get_locations(person_list):\n",
    "    return np.array([person.location for person in person_list])\n",
    "\n",
    "def get_directions(board_size,person_list):\n",
    "    directionmap = np.ones((board_size,board_size,2))*2 # we use [2,2] for empty cells since [0,0] is equal to standing still\n",
    "    for person in person_list:\n",
    "        directionmap[person.location[0],person.location[1],:] = person.direction\n",
    "\n",
    "    return directionmap\n",
    "\n",
    "def get_perceptionmask(sight_radius):\n",
    "    \"\"\"Creates a boolean mask selecting all cells within perception range of a person.\n",
    "    This mask is to be applied on a 2*sight_radius+1 x 2*sight_radius+1 grid with the person in question in the middle.\n",
    "\n",
    "    Inputs:\n",
    "    \"\"\"\n",
    "    mask = np.zeros((2*sight_radius+1, 2*sight_radius+1), dtype = \"bool\")\n",
    "    y_m, x_m = sight_radius, sight_radius # Coordinates of midpoints\n",
    "    perceived_cells = [[y, x] for y in range(2*sight_radius+1) for x in range(2*sight_radius+1) if (y-y_m)**2 + (x-x_m)**2 <= sight_radius**2]\n",
    "    perceived_cells = ([cell[0] for cell in perceived_cells], [cell[1] for cell in perceived_cells])\n",
    "    mask[perceived_cells] = True\n",
    "    mask[y_m, x_m] = False # Don't select the cell itself (middle cell)\n",
    "    return mask\n",
    "\n",
    "\n",
    "def init_S(board_size, S_wall, S_exit, obstacle_locs, exit_locs, mu):\n",
    "    \"\"\"Creates the initial static floor field S.\n",
    "    The static floor field describes the path on the grid which is the shortest way to the exit.\n",
    "    All walls are assumed to be on the outside of the grid.\n",
    "    Inputs:\n",
    "      board_size: Length of the square board\n",
    "      S_wall: Value of the static field for a wall or obstacle\n",
    "      S_exit: Value of the static field for the exit\n",
    "      obstacle_locs: Locations of the obstacles on the grid\n",
    "      exit_locs: Locations of the exit\n",
    "      mu: Ratio of distance when travelling to a neighbouring diagonal cell over travelling to a neighbouring cell on a side\n",
    "    \"\"\"\n",
    "    S = np.ones((board_size, board_size)) * np.inf # Initialise array full of +infinity since filling up S is based on selecting minimum values\n",
    "    side_neighbour_mask = np.zeros((3, 3), dtype = bool)\n",
    "    side_neighbour_mask[0, 1] = side_neighbour_mask[1, 0] = side_neighbour_mask[1, -1] = side_neighbour_mask[-1, 1] = True\n",
    "\n",
    "    diag_neighbour_mask = np.zeros((3,3), dtype = bool)\n",
    "    diag_neighbour_mask[0, 0] = diag_neighbour_mask[0, -1] = diag_neighbour_mask[-1, 0] = diag_neighbour_mask[-1, -1] = True\n",
    "\n",
    "    S[exit_locs] = S_exit\n",
    "\n",
    "    curr_cells = [[exit_locs[0][i], exit_locs[1][i]] for i in range(len(exit_locs[0]))]\n",
    "    next_cells = []\n",
    "    done_cells = []\n",
    "\n",
    "\n",
    "    # The exit cells are the only cells on the border to evaluate and require a special treatment (don't select any cells outside of the existing grid)\n",
    "    for y, x in curr_cells:\n",
    "        for i in np.arange(np.maximum(1, y-1), np.minimum(board_size, y+2)):\n",
    "            for j in np.arange(np.maximum(1, x-1), np.minimum(board_size, x+2)):\n",
    "                if (i, j) != (y, x):\n",
    "                    if ((y-i)+(x-j))%2 == 0: # diagonal neighbour\n",
    "                        S[i,j] = np.minimum(S[y, x] + mu, S[i, j])\n",
    "                    else: # side neighbour\n",
    "                        S[i,j] = np.minimum(S[y, x] + 1, S[i, j])\n",
    "\n",
    "                    next_cells += [[i, j]]\n",
    "\n",
    "                    S[:, 0] = S[:, -1] = np.inf\n",
    "                    S[0, :] = S[-1, :] = np.inf\n",
    "                    if obstacle_locs: # => If the list of obstacles isn't empty\n",
    "                        S[obstacle_locs] = np.inf\n",
    "                    S[exit_locs] = S_exit\n",
    "\n",
    "    while next_cells:\n",
    "        done_cells += curr_cells\n",
    "        curr_cells = next_cells\n",
    "        next_cells = []\n",
    "\n",
    "        for y, x in curr_cells:\n",
    "            S[y-1:y+2, x-1:x+2][side_neighbour_mask] = np.minimum(S[y, x] + 1, S[y-1:y+2, x-1:x+2][side_neighbour_mask])\n",
    "            S[y-1:y+2, x-1:x+2][diag_neighbour_mask] = np.minimum(S[y, x] + mu, S[y-1:y+2, x-1:x+2][diag_neighbour_mask])\n",
    "            next_cells += [[y+i, x+j] for i in range(-1, 2) for j in range(-1, 2) if i != 0 or j != 0 if y+i > 0 and y+i < board_size-1 if x+j > 0 and x+j < board_size-1] # Select all neighbouring cells but not the cell itself\n",
    "            S[:, 0] = S[:, -1] = np.inf\n",
    "            S[0, :] = S[-1, :] = np.inf\n",
    "            if obstacle_locs: # => If the list of obstacles isn't empty\n",
    "                S[obstacle_locs] = np.inf\n",
    "            S[exit_locs] = S_exit\n",
    "            \n",
    "        next_cells = np.unique(next_cells, axis = 0).tolist() # Specify axis or the list of lists will be flattened to 1 list\n",
    "        next_cells = [cell for cell in next_cells if not cell in done_cells]\n",
    "\n",
    "    S[S != np.inf] = np.amax(S[S != np.inf]) - S[S != np.inf]\n",
    "\n",
    "    S[S == np.inf] = S_wall\n",
    "    \n",
    "\n",
    "    return S\n",
    "\n",
    "def init_D(board_size):\n",
    "    \"\"\"Creates the initial dynamic floor field D.\n",
    "    The dynamic floor field describes interactions between pedestrians \n",
    "    (i.e. people don't tend to intentionally sprint into eachother when trying to evacuate)\n",
    "    Inputs:\n",
    "      board_size: Length of the square board\n",
    "    \"\"\"\n",
    "    D = np.zeros((board_size, board_size))\n",
    "\n",
    "    return D\n",
    "\n",
    "def update_D(D, locations, locations_prev, diffusion_factor, decay_factor):\n",
    "    \"\"\"Updates the dynamic floor field D.\n",
    "    Inputs:\n",
    "      D: The previous state of the dynamic floor field.\n",
    "      locations: numpy array with current locations of all persons\n",
    "      locations_prev: numpy array with locations of all persons at previous timestep\n",
    "      diffusion_factor (alpha): describes how the dynamic floor field diffuses through the room\n",
    "      decay_factor (delta): describes how the dynamic floor field decays over time\n",
    "    \"\"\"\n",
    "    neighbour_mask = np.ones((3, 3), dtype = bool)\n",
    "    neighbour_mask[1, 1] = False\n",
    "\n",
    "    D_new = np.copy(D)\n",
    "    for i in range(1, D.shape[0]-1):\n",
    "        for j in range(1, D.shape[1]-1):\n",
    "            D_new[i, j] = (1-diffusion_factor)*(1-decay_factor)*D[i, j] + diffusion_factor*(1-decay_factor)/8 * np.sum(D[i-1:i+2, j-1:j+2][neighbour_mask])\n",
    "\n",
    "    updated_locations = locations[np.any(locations_prev != locations,axis=1)]\n",
    "    D_new[updated_locations[:,0], updated_locations[:,1]] += 1\n",
    "    \n",
    "    return D_new\n",
    "\n",
    "def create_dist_mat(board_size, obstacle_locs):\n",
    "    obstacle_dist = np.zeros((0,board_size,board_size))\n",
    "\n",
    "    # initialize the x and y values of the board\n",
    "\n",
    "    x = y = np.arange(board_size)\n",
    "    x = np.reshape(x,(1,board_size))\n",
    "    x = np.matmul(np.ones((board_size,1)),x)\n",
    "    y = np.reshape(y,(board_size,1))\n",
    "    y = np.matmul(y,np.ones((1,board_size)))\n",
    "\n",
    "    # for every obstacle calculate the distance to every point on the board\n",
    "\n",
    "    for i in range(len(obstacle_locs[0])):\n",
    "        dist_mat = np.sqrt(np.square(y - obstacle_locs[0][i]) + np.square(x - obstacle_locs[1][i]))\n",
    "        dist_mat = np.reshape(dist_mat,(1,board_size,board_size))\n",
    "        obstacle_dist = np.vstack((obstacle_dist,dist_mat))\n",
    "\n",
    "    # take the minimal distance to an obstacle for every point on the board\n",
    "\n",
    "    min_dist_mat = np.amin(obstacle_dist,axis=0)\n",
    "\n",
    "    return min_dist_mat\n",
    "\n",
    "def init_F(board_size):\n",
    "    \"\"\"Creates the event floor field F.\n",
    "    The event floor field describes the efect that a person wants to get away from the stampede.\n",
    "    Inputs:\n",
    "      board_size: Length of the square board\n",
    "    \"\"\"\n",
    "    \n",
    "    F = np.zeros((board_size, board_size))\n",
    "    \n",
    "    return F \n",
    "\n",
    "def update_F(board_size, obstacle_locs, Srange):\n",
    "    \"\"\"Updates the event floor field F.\n",
    "    The event floor field describes the efect that a person wants to get away from the stampede.\n",
    "    Inputs:\n",
    "      board_size: Length of the square board\n",
    "      obstacle_locs: Locations of the obstacles/fallen people on the grid\n",
    "    \"\"\"\n",
    "    \n",
    "    F = create_dist_mat(board_size, obstacle_locs)\n",
    "\n",
    "    # give correct values to every point on the board\n",
    "    F[F <= Srange] = -1*np.exp(1/F[F <= Srange])\n",
    "    F[F > Srange] = 0\n",
    "    \n",
    "    return F \n",
    "\n",
    "def calc_tumble(person,sight_radius,ka,kc,board,new_loc):\n",
    "    \"\"\"This function calculates the tumble factor for the move from a persons current position to\n",
    "    Their next position given as [x,y] by new_loc\n",
    "    Inputs:\n",
    "        person: An object of the pedestrian class\n",
    "        sight_radius: How far the humans can see\n",
    "        ka and kc: sensitivity parameters\n",
    "        board: The physical board\n",
    "        new_loc: The wanted new location  \n",
    "    \"\"\"\n",
    "    \n",
    "    if not (board[new_loc] >= 1).all(): # 1+ means there are 1 or more fallen people in the desired cell\n",
    "        return 1\n",
    "    else:\n",
    "        y_person = person.location[0]\n",
    "        x_person = person.location[1]\n",
    "\n",
    "        # Only select cells within grid and not on the border (these are walls)\n",
    "        y_min = max(1, y_person-sight_radius)\n",
    "        y_max = min(board_size-1, y_person+sight_radius+1)\n",
    "        x_min = max(1, x_person-sight_radius)\n",
    "        x_max = min(board_size-1, x_person+sight_radius+1)\n",
    "        neighbouring_cells = board[y_min:y_max, x_min:x_max]\n",
    "\n",
    "        # Only select part of mask that applies to selected cells (if you cut off some cells, the same part of the mask must be cut off)\n",
    "        y_min_mask = y_min - (y_person-sight_radius)\n",
    "        y_max_mask = y_max - (y_person-sight_radius)\n",
    "        x_min_mask = x_min - (x_person-sight_radius)\n",
    "        x_max_mask = x_max - (x_person-sight_radius)\n",
    "        perceptionmask = get_perceptionmask(sight_radius)[y_min_mask:y_max_mask, x_min_mask:x_max_mask]\n",
    "        perceived_cells = neighbouring_cells[perceptionmask]\n",
    "\n",
    "        # perceived_cells that are not 0, -1, -2: other pedestrians\n",
    "        rho_0 = (perceived_cells[perceived_cells <= -3].size + perceived_cells[perceived_cells >= 1].size) / perceived_cells.size \n",
    "\n",
    "        if rho_0 >= 0.64: # more then 4 people/m^2 so trample threshold is exceeded\n",
    "            eps = 1\n",
    "        else:\n",
    "            eps = 0\n",
    "\n",
    "        # theta is de hoek tussen bewegingsrichting van vorige stap en normaal van huidige cell naar cell ij (in het bereik van 0 en 180 graden)\n",
    "        theta = np.arccos(np.dot(np.array(person.direction), np.array([new_loc[i] - person.location[i] for i in range(len(new_loc))]))) % (np.pi/2) \n",
    "        # Assuming directions input as lists rather than numpy arrays\n",
    "        A = np.cos(theta) - 1 # Risk floor field A\n",
    "\n",
    "        alpha = kc*eps*rho_0*np.exp(ka*A)\n",
    "\n",
    "        return alpha\n",
    "\n",
    "\n",
    "def check_state(person,exit_locs,fallen_locs):\n",
    "    # possible state: Ue,Un,Ae,An,C,left\n",
    "    \n",
    "    if person.state != 'C':\n",
    "\n",
    "        exits = [[exit_locs[0][i], exit_locs[1][i]] for i in range(len(exit_locs[0]))]\n",
    "\n",
    "        # set standard state to 'Un' if exit in range set to 'Ue'\n",
    "\n",
    "        pstate = 'Un'\n",
    "\n",
    "        if person.location in exits:\n",
    "            pstate = 'left'\n",
    "        else:\n",
    "            for exit_loc in exits:\n",
    "                if np.sqrt((exit_loc[0]-person.location[0])**2+(exit_loc[1]-person.location[1])**2) <= sight_radius:\n",
    "                    pstate = 'Ue'\n",
    "        \n",
    "        # check if affected and state accordingly\n",
    "        if pstate != 'left' and len(fallen_locs[0]) != 0: # Only have to check for fallen pedestrians in the neighbourhood if there are any\n",
    "            affected = create_dist_mat(board_size, fallen_locs)\n",
    "            affected[affected <= 8] = True\n",
    "            affected[affected > 8] = False\n",
    "\n",
    "            if affected[person.location[0], person.location[1]]:\n",
    "                if pstate == 'Un':\n",
    "                    pstate = 'An'\n",
    "                elif pstate == 'Ue':\n",
    "                    pstate = 'Ae'\n",
    "\n",
    "        person.state = pstate\n",
    "\n",
    "    return person\n",
    "\n",
    "def check_valid4wallhugger(board, location):\n",
    "    y = location[0]\n",
    "    x = location[1]\n",
    "\n",
    "    if board[y, x] != 0:\n",
    "        return False\n",
    "\n",
    "    neighbour_mask = np.ones((3, 3), dtype = bool)\n",
    "    neighbour_mask[1, 1] = False\n",
    "\n",
    "    return -1 in board[y-1:y+2, x-1:x+2][neighbour_mask]\n",
    "\n",
    "def move_direction(person,board,S,D,F,exit_locs,fallen_locs,directionmap,sight_radius,board_size,ks,kd,kf,ka,kc,B_wall):\n",
    "    \"\"\" this function looks at the current state of the person\n",
    "        based on this state it defines it next movement step\n",
    "        then it defines the chance of this step being taken\n",
    "        lastly it chooses the step with the highest probability and takes it.\n",
    "        Input:\n",
    "            person: An object of the pedestrian class\n",
    "            board: The physical board\n",
    "            S: The static floor field\n",
    "            D: The dynamic floor field\n",
    "            F: The event floor field\n",
    "        Ouput:\n",
    "            The adjusted given pedestrian object\n",
    "    \"\"\"\n",
    "\n",
    "    # calc trans prob for every direction, then max trans prob = movement\n",
    "\n",
    "    # TODO: optimize movement to erase the for loop and instead use matrix multiplication\n",
    "\n",
    "    possible_moves = [[y,x] for y in range(-1,2) for x in range(-1,2)]\n",
    "\n",
    "    if person.state != 'C':\n",
    "        y = person.location[0]\n",
    "        x = person.location[1]\n",
    "        pmove = np.zeros((3,3))\n",
    "        #print([x,y])\n",
    "\n",
    "        if person.state == 'Ue':\n",
    "            for i in range(y-1,y+2):\n",
    "                for j in range(x-1,x+2):\n",
    "                    if [i,j] != [y,x]:\n",
    "                        if np.all(np.array([y,x])-np.array([i,j]) == person.direction):\n",
    "                            Iine = 1.2\n",
    "                        else:\n",
    "                            Iine = 1\n",
    "\n",
    "                        pmove[i-(y-1),j-(x-1)] = Iine*np.exp(ks*S[i,j])*(board[i,j] >= B_exit)*(board[i,j] != B_wall)\n",
    "\n",
    "                    else:\n",
    "                        pmove[i-(y-1),j-(x-1)] = 0\n",
    "            \n",
    "            pmove[np.isnan(pmove)] = 0\n",
    "            if np.sum(pmove) == 0: # No legal movements available\n",
    "                pmove[1,1] = 1 # Standing still is the only legal movement\n",
    "            elif np.sum(pmove) == np.inf:\n",
    "                pmove[np.logical_not(np.isinf(pmove))] = 0\n",
    "                pmove[np.isinf(pmove)] = 1\n",
    "            pmove = pmove / np.sum(pmove)\n",
    "            move = possible_moves[np.random.choice(range(9), 1, p = pmove.flatten())[0]] # note: this gives a list in the format of [y_move,x_move]\n",
    "\n",
    "        elif person.state == 'Un':\n",
    "            for i in range(y-1,y+2):\n",
    "                for j in range(x-1,x+2):\n",
    "                    if [i,j] != [y,x]:\n",
    "                        if np.all(np.array([y,x])-np.array([i,j]) == person.direction):\n",
    "                            Iine = 1.2\n",
    "                        else:\n",
    "                            Iine = 1\n",
    "                        pmove[i-(y-1),j-(x-1)] = Iine*np.exp(ks*S[i,j] + kd*D[i,j])*(board[i,j] >= B_exit)*(board[i,j] != B_wall)                            \n",
    "                    else:\n",
    "                        pmove[i-(y-1),j-(x-1)] = 0\n",
    "            \n",
    "            pmove[np.isnan(pmove)] = 0\n",
    "            if np.sum(pmove) == 0: # No legal movements available\n",
    "                pmove[1,1] = 1 # Standing still is the only legal movement\n",
    "            elif np.sum(pmove) == np.inf:\n",
    "                pmove[np.logical_not(np.isinf(pmove))] = 0\n",
    "                pmove[np.isinf(pmove)] = 1\n",
    "            pmove = pmove / np.sum(pmove)\n",
    "            move = possible_moves[np.random.choice(range(9), 1, p = pmove.flatten())[0]] # note: this gives a list in the format of [y_move,x_move]\n",
    "\n",
    "        elif person.state == 'Ae':\n",
    "            for i in range(y-1,y+2):\n",
    "                for j in range(x-1,x+2):\n",
    "                    if [i,j] != [y,x]:\n",
    "                        if np.all(np.array([y,x])-np.array([i,j]) == person.direction):\n",
    "                            Iine = 1.2\n",
    "                        else:\n",
    "                            Iine = 1\n",
    "                        alphaij = calc_tumble(person,sight_radius,ka,kc,board,[i,j])\n",
    "                        pmove[i-(y-1),j-(x-1)] = Iine*np.exp(ks*S[i,j])*(board[i,j] >= B_exit)*(board[i,j] != B_wall)*alphaij\n",
    "\n",
    "                    else:\n",
    "                        pmove[i-(y-1),j-(x-1)] = 0\n",
    "            \n",
    "            pmove[np.isnan(pmove)] = 0\n",
    "            if np.sum(pmove) == 0: # No legal movements available\n",
    "                pmove[1,1] = 1 # Standing still is the only legal movement\n",
    "            elif np.sum(pmove) == np.inf:\n",
    "                pmove[np.logical_not(np.isinf(pmove))] = 0\n",
    "                pmove[np.isinf(pmove)] = 1\n",
    "            pmove = pmove / np.sum(pmove)\n",
    "            move = possible_moves[np.random.choice(range(9), 1, p = pmove.flatten())[0]] # note: this gives a list in the format of [y_move,x_move]\n",
    "\n",
    "        elif person.state == 'An':\n",
    "            if person.evac_strat == 'S1':\n",
    "                for i in range(y-1,y+2):\n",
    "                    for j in range(x-1,x+2):\n",
    "                        if [i,j] != [y,x]:\n",
    "                            if np.all(np.array([y,x])-np.array([i,j]) == person.direction):\n",
    "                                Iine = 1.2\n",
    "                            else:\n",
    "                                Iine = 1\n",
    "                            alphaij = calc_tumble(person,sight_radius,ka,kc,board,[i,j])\n",
    "                            pmove[i-(y-1),j-(x-1)] = Iine*np.exp(ks*S[i,j] + kd*D[i,j] + kf*F[i,j])*(board[i,j] >= B_exit)*(board[i,j] != B_wall)*alphaij\n",
    "                        else:\n",
    "                            pmove[i-(y-1),j-(x-1)] = 0\n",
    "\n",
    "\n",
    "                pmove[np.isnan(pmove)] = 0\n",
    "                if np.sum(pmove) == 0: # No legal movements available\n",
    "                    pmove[1,1] = 1 # Standing still is the only legal movement\n",
    "                elif np.sum(pmove) == np.inf:\n",
    "                    pmove[np.logical_not(np.isinf(pmove))] = 0\n",
    "                    pmove[np.isinf(pmove)] = 1\n",
    "                pmove = pmove / np.sum(pmove)\n",
    "                move = possible_moves[np.random.choice(range(9), 1, p = pmove.flatten())[0]] # note: this gives a list in the format of [y_move,x_move]\n",
    "\n",
    "            elif person.evac_strat == 'S2':\n",
    "                dist_mat = create_dist_mat(board_size, ([person.location[0]],[person.location[1]]))\n",
    "                dist_mat = (dist_mat <= sight_radius)\n",
    "\n",
    "                neighbour_directions = directionmap[dist_mat]\n",
    "                unq, count = np.unique(neighbour_directions, axis=0, return_counts=True)\n",
    "                ind = np.argsort(-count)\n",
    "                if all(unq[ind][0] == [2,2]):\n",
    "                    if len(unq[ind]) > 1:\n",
    "                        move = [int(x) for x in unq[ind][1]]\n",
    "                    else:\n",
    "                        move = list(np.random.randint(-1,2,size=(2)))\n",
    "\n",
    "                else:\n",
    "                    move = [int(x) for x in unq[ind][0]]\n",
    "                \n",
    "                if board[y+move[0],x+move[1]] == B_wall:\n",
    "                    move = [0,0] # maybe change to strategy S3\n",
    "\n",
    "            else:\n",
    "                if person.direction == [0,0]: # Standing still\n",
    "                    person.time_down += 1\n",
    "\n",
    "                if person.time_down >= 5: # They have been standing still for a while so they choose a random new direction\n",
    "                    valid_cells = np.where(board[y-1:y+2, x-1:x+2] == 0) # Choose from locations without other people for the new direction\n",
    "                    if valid_cells[0].size == 0: # There is no valid location to go\n",
    "                        move = [0, 0]\n",
    "                    else:\n",
    "                        valid_directions = [[valid_cells[0][i] - 1, valid_cells[1][i] - 1] for i in range(len(valid_cells[0]))]\n",
    "                        ## -1, -1 since movement is related to position of the person in cell [1,1] in their own neighbourhood\n",
    "\n",
    "                        random_dir_ind = np.random.randint(len(valid_directions))\n",
    "                        move = valid_directions[random_dir_ind]\n",
    "\n",
    "                elif board[y + person.direction[0], x + person.direction[1]] == -1: # wall is reached\n",
    "                    mask = np.array([check_valid4wallhugger(board, [i, j]) for i in range(y-1,y+2) for j in range(x-1,x+2)]).reshape(3,3)\n",
    "                    mask[1,1] = True # Current location is always a valid spot despite it not being empty (the person themselves are there)\n",
    "                    valid_cells = np.where(mask)\n",
    "                    ideal_cell_ind = np.argmax(S[y-1:y+2, x-1:x+2][valid_cells])\n",
    "                    move = [valid_cells[0][ideal_cell_ind]-1, valid_cells[1][ideal_cell_ind]-1]\n",
    "\n",
    "                else:\n",
    "                    move = person.direction\n",
    "        \n",
    "        person.direction = move\n",
    "        person.new_location = [y + move[0], x + move[1]]\n",
    "\n",
    "        if board[y + move[0], x + move[1]] >= 1: # Fallen person on the location they are moving, so they trip\n",
    "            person.state = \"C\"\n",
    "            person.time_down = 0\n",
    "            \n",
    "    else:\n",
    "        person.time_down += 1\n",
    "        if person.time_down < 100: # Prevent factorial from causing an Overflow error\n",
    "            pstand = 1/(np.exp(1)*np.math.factorial(person.time_down))\n",
    "        else:\n",
    "            pstand = 0\n",
    "        if np.random.randint(1,101)/100 <= pstand:\n",
    "            person.state = 'Ue'\n",
    "            person = check_state(person,exit_locs,fallen_locs)\n",
    "            person.time_down = 0\n",
    "\n",
    "    return person\n",
    "\n",
    "def check_stampede(people_list,chaos):\n",
    "    states = np.array([person.state for person in people_list])\n",
    "    print(len(states), chaos)\n",
    "\n",
    "    if np.all(states == 'left') or len(states) == 0: # everybody evacuated\n",
    "        print('ok')\n",
    "        stampede = False\n",
    "    elif np.all((states == 'left') + (states == 'C')) and not(chaos): # all non injured people left and chaos is over\n",
    "        stampede = False\n",
    "    else:\n",
    "        stampede = True\n",
    "    \n",
    "    return stampede\n",
    "\n",
    "def plot_room(board,state_dic,B_exit,B_wall):\n",
    "    color_map = {0: np.array([255, 255, 255]), # white = empty floor\n",
    "             B_exit: np.array([255, 255, 255]), # white = exits\n",
    "             state_dic['Ue']: np.array([0, 255, 0]), # green = Ue\n",
    "             state_dic['Un']: np.array([0, 0, 255]), # blue = Un\n",
    "             state_dic['Ae']: np.array([0, 255, 255]), # cyan = Ae\n",
    "             state_dic['An']: np.array([255, 255, 0]), # yellow = An\n",
    "             state_dic['C']: np.array([255, 0, 0]), # red = C\n",
    "             B_wall: np.array([0, 0, 0])} # black = walls\n",
    "\n",
    "    # make a 3d numpy array that has a color channel dimension   \n",
    "    data_3d = np.ndarray(shape=(board.shape[0], board.shape[1], 3), dtype=int)\n",
    "    for i in range(board.shape[0]):\n",
    "        for j in range(board.shape[1]):\n",
    "            data_3d[i,j] = color_map[int(board[i,j])]\n",
    "    \n",
    "    return data_3d\n",
    "\n",
    "\n",
    "# classes\n",
    "\n",
    "class Pedestrian:\n",
    "  def __init__(self, location, state):\n",
    "    self.evac_strat = random.choices(['S1','S2','S3'],(50,30,20))[0]\n",
    "    self.location = location # gives location as [y,x]\n",
    "    self.state = state \n",
    "    self.direction = [0,0] # showes the last direction moved eg. [1,0] is left and [0,-1] is down\n",
    "    self.new_location = location\n",
    "    self.time_down = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parameters\n",
    "board_size = 30 # size of board \n",
    "num_people = 50 # number of people\n",
    "\n",
    "##b Assigning locations as a tuple of a list with all y-coordinates and a list with all x-coordinates allows for multiple indexing\n",
    "exit_locs = ([int(board_size/2-2), int(board_size/2-1), int(board_size/2), int(board_size/2+1)], [0, 0, 0, 0]) # exit locations (middle of left wall)\n",
    "obstacle_locs = ([],[])\n",
    "fallen_locs = ([],[]) # No obstacles for now\n",
    "\n",
    "S_wall = 500 # 500 in the article but we're smarter\n",
    "S_exit = 1\n",
    "B_wall = -1\n",
    "B_exit = -2\n",
    "mu = 1.5\n",
    "\n",
    "Ts = 1 # occurrence time of the stampede\n",
    "Tc = Ts + 50 # chaos duration\n",
    "\n",
    "kc = 0.5 # sensitivity parameter for tumble factor \n",
    "ka = 1 # sensitivity parameter for tumble factor \n",
    "ks = 5 # sensitivity parameter for the static field\n",
    "kd = 1 # sensitivity parameter for the dynamic field\n",
    "kf = 2 # sensitivity parameter for the event field\n",
    "diffusion_factor = 0.3 # aka alpha\n",
    "decay_factor = 0.3 # aka delta\n",
    "sight_radius = 5 # perception radius for each person\n",
    "\n",
    "Srange = 8 # stampede range\n",
    "\n",
    "state_dic = {'C':1,'left':0,'Ue':-3,'Un':-4,'Ae':-5,'An':-6}\n",
    "# each time step == 0.3s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": [
     "outputPrepend"
    ]
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "ith RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Gif opgeslaan als stampede.gif\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\r\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\r\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\r\n<svg height=\"280.8pt\" version=\"1.1\" viewBox=\"0 0 280.8 280.8\" width=\"280.8pt\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n <metadata>\r\n  <rdf:RDF xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\r\n   <cc:Work>\r\n    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\r\n    <dc:date>2021-05-19T12:09:55.709191</dc:date>\r\n    <dc:format>image/svg+xml</dc:format>\r\n    <dc:creator>\r\n     <cc:Agent>\r\n      <dc:title>Matplotlib v3.4.1, https://matplotlib.org/</dc:title>\r\n     </cc:Agent>\r\n    </dc:creator>\r\n   </cc:Work>\r\n  </rdf:RDF>\r\n </metadata>\r\n <defs>\r\n  <style type=\"text/css\">*{stroke-linecap:butt;stroke-linejoin:round;}</style>\r\n </defs>\r\n <g id=\"figure_1\">\r\n  <g id=\"patch_1\">\r\n   <path d=\"M 0 280.8 \r\nL 280.8 280.8 \r\nL 280.8 0 \r\nL 0 0 \r\nz\r\n\" style=\"fill:none;\"/>\r\n  </g>\r\n  <g id=\"axes_1\">\r\n   <g id=\"patch_2\">\r\n    <path d=\"M 10.7 270.1 \r\nL 273.6 270.1 \r\nL 273.6 7.2 \r\nL 10.7 7.2 \r\nz\r\n\" style=\"fill:#ffffff;\"/>\r\n   </g>\r\n   <g clip-path=\"url(#p071d3c4d1f)\">\r\n    <image height=\"263\" id=\"image184c4028da\" transform=\"scale(1 -1)translate(0 -263)\" width=\"263\" x=\"10.7\" xlink:href=\"data:image/png;base64,\r\niVBORw0KGgoAAAANSUhEUgAAAQcAAAEHCAYAAACjq4OnAAADXElEQVR4nO3aMW7DQAwAwbtA//8y0webKIViCc5M64PMasGCe601C+CLj7sHAJ5JHIAkDkASByCJA5DEAUjiACRxANLxm0cz7qTgney9T9/YHIAkDkASByCJA5DEAUjiACRxAJI4AEkcgCQOQBIHIIkDkMQBSOIAJHEAkjgASRyAJA5AEgcgiQOQxAFI4gAkcQCSOABJHIAkDkASByCJA5DEAUjiACRxAJI4AEkcgCQOQDqu+tDe+8ffZ+aqvwJewOYAJHEAkjgASRyAJA5AEgcgiQOQxAFIlx1BOXKC92JzAJI4AEkcgCQOQBIHIIkDkMQBSOIAJHEAkjgASRyAJA5AEgcgiQOQxAFI4gAkcQCSOABJHIAkDkASByCJA5DEAUjiACRxAJI4AEkcgCQOQBIHIIkDkMQBSOIAJHEAkjgASRyAJA5AEgcgiQOQxAFI4gAkcQCSOABJHIAkDkASByCJA5DEAUjiACRxAJI4AEkcgCQOQBIHIIkDkMQBSOIAJHEAkjgASRyAJA5AOmbm7hmAB7I5AEkcgCQOQBIHIIkDkMQBSOIAJHEAkjgASRyAJA5AEgcgiQOQxAFI4gAkcQCSOABJHIAkDkASByCJA5DEAUjiACRxAJI4AEkcgCQOQBIHIIkDkMQBSOIAJHEAkjgASRyAdOy9Tx/NzAtGAZ7E5gAkcQCSOABJHIAkDkASByCJA5DEAUjiACRxAJI4AEkcgCQOQBIHIIkDkMQBSOIAJHEAkjgASRyAJA5AEgcgiQOQxAFI4gAkcQCSOABJHIAkDkASByCJA5DEAUjiACRxANJx9wBPtff5m5m/nwPuYnMAkjgASRyAJA5AEgcgiQOQxAFI4gAkR1DfcODEf2dzAJI4AEkcgCQOQBIHIIkDkMQBSOIAJHEAkjgASRyAJA5AEgcgiQOQxAFI4gAkcQCSOABJHIAkDkASByCJA5DEAUjiACRxAJI4AEkcgCQOQBIHIIkDkMQBSOIAJHEAkjgASRyAJA5AEgcgiQOQxAFI4gAkcQCSOABJHIAkDkASByCJA5DEAUjiACRxAJI4AEkcgCQOQBIHIIkDkMQBSOIAJHEAkjgASRyAJA5A2mutuXsI4HlsDkASByCJA5DEAUjiACRxAJI4AEkcgPQJe48XEUVtkLkAAAAASUVORK5CYII=\" y=\"-7.1\"/>\r\n   </g>\r\n   <g id=\"patch_3\">\r\n    <path d=\"M 10.7 270.1 \r\nL 10.7 7.2 \r\n\" style=\"fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n   <g id=\"patch_4\">\r\n    <path d=\"M 273.6 270.1 \r\nL 273.6 7.2 \r\n\" style=\"fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n   <g id=\"patch_5\">\r\n    <path d=\"M 10.7 270.1 \r\nL 273.6 270.1 \r\n\" style=\"fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n   <g id=\"patch_6\">\r\n    <path d=\"M 10.7 7.2 \r\nL 273.6 7.2 \r\n\" style=\"fill:none;stroke:#000000;stroke-linecap:square;stroke-linejoin:miter;stroke-width:0.8;\"/>\r\n   </g>\r\n  </g>\r\n </g>\r\n <defs>\r\n  <clipPath id=\"p071d3c4d1f\">\r\n   <rect height=\"262.9\" width=\"262.9\" x=\"10.7\" y=\"7.2\"/>\r\n  </clipPath>\r\n </defs>\r\n</svg>\r\n",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARgAAAEYCAYAAACHjumMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAEFElEQVR4nO3cQU5iQRRAUV6HLTjuRdD730Evwrl7eD3qiSEKhiuK5yRMivJTo5tHqDi7ewAo/Lr3AYDHJTBARmCAjMAAGYEBMsdrNs+Mn5yAc1529+n1ogkGuIXnc4sCA2QEBsgIDJARGCAjMEBGYICMwACZqy7aXcK/f4DHMjMf/lsTDJARGCAjMEBGYICMwAAZgQEyAgNkBAbICAyQERggIzBARmCAjMAAGYEBMgIDZAQGyAgMkBEYICMwQEZggIzAABmBATICA2QEBsgIDJARGCAjMEBGYICMwAAZgQEyAgNkBAbICAyQERggIzBARmCAjMAAGYEBMgIDZAQGyAgMkBEYICMwQEZggIzAABmBATICA2QEBsgIDJARGCAjMEBGYICMwAAZgQEyAgNkBAbICAyQERggIzBARmCAzPHeB3gEM+/v2e3PAV+NCQbICAyQERggIzBARmCAjMAAGYEBMgIDZFy0uwGX6OA8EwyQERggIzBARmCAjMAAGYEBMgIDZAQGyAgMkBEYICMwQEZggIzAABmBATICA2QEBsgIDJARGCAjMEBGYICMwAAZgQEyAgNkBAbICAyQERggIzBARmCAjMAAGYEBMgIDZAQGyAgMkBEYIHNVYE6n02F333wB/GeCATICA2QEBsgIDJARGCAjMEBGYICMwAAZgQEyAgNkBAbICAyQERggIzBARmCAjMAAGYEBMgIDZAQGyAgMkBEYICMwQEZggIzAABmBATICA2QEBsgIDJARGCAjMEBGYICMwAAZgQEyAgNkZncv3zzz7uZrngd8fTNzyba/u/vn9aIJBsgIDJARGCAjMEBGYICMwAAZgQEyAgNkBAbICAyQERggIzBARmCAjMAAGYEBMgIDZAQGyAgMkBEYICMwQEZggIzAABmBATICA2QEBsgIDJARGCAjMEBGYICMwAAZgQEyAgNkBAbICAyQERggIzBARmCAjMAAGYEBMgIDZAQGyAgMkBEYICMwQEZggIzAABmBATICA2QEBsgIDJARGCAjMEBGYICMwAAZgQEyAgNkBAbICAyQERggIzBA5niPD52ZN9/f3U86CVAywQAZgQEyAgNkBAbICAyQERggIzBARmCAzF0u2rlIBz+DCQbICAyQERggIzBARmCAjMAAGYEBMgIDZAQGyAgMkBEYICMwQEZggIzAABmBATICA2QEBsgIDJARGCAjMEBGYICMwAAZgQEyAgNkBAbICAyQERggIzBARmCAjMAAGYEBMgIDZAQGyAgMkDne+oEzc+tHAt+UCQbICAyQERggIzBARmCAjMAAGYEBMgIDZK69aPdyOByei4MA39rvc4uzu599EOCH8BUJyAgMkBEYICMwQEZggIzAABmBATICA2QEBsj8A+rVQIEWP7IqAAAAAElFTkSuQmCC\n"
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "source": [
    "# main function\n",
    "\n",
    "# fill board with people and initialize them\n",
    "\n",
    "board, person_list = init_board(board_size,num_people,exit_locs,sight_radius,state_dic,B_exit,B_wall)\n",
    "\n",
    "# add starting board to stampede clip, this will later be transformed to a gif.\n",
    "\n",
    "stampede_clip = np.zeros((0,board_size,board_size,3))\n",
    "temp = np.reshape(plot_room(board,state_dic,B_exit,B_wall),(1,board_size,board_size,3))\n",
    "stampede_clip = np.vstack((stampede_clip,temp))\n",
    "\n",
    "time = 1\n",
    "\n",
    "stampede = True\n",
    "chaos = False\n",
    "\n",
    "S = init_S(board_size, S_wall, S_exit, obstacle_locs, exit_locs, mu)\n",
    "D = init_D(board_size)\n",
    "F = init_F(board_size)\n",
    "\n",
    "while stampede:\n",
    "    print(time)\n",
    "\n",
    "    if time == Ts:\n",
    "        chaos = True\n",
    "        x = random.randint(0,len(person_list))\n",
    "        person_list[x].state = 'C'\n",
    "        person_list[x].time_down = 0 \n",
    "        c_loc = person_list[x].location\n",
    "        board[c_loc[0],c_loc[1]] = state_dic['C']\n",
    "\n",
    "        steve = Pedestrian([14, 1], \"C\") # Spawn THE FALLEN ONE (for testing purposes)\n",
    "        person_list = np.concatenate((person_list, [steve]))\n",
    "\n",
    "        fallen_locs,board = update_board(board,person_list,state_dic,chaos,B_exit)\n",
    "        F = update_F(board_size, fallen_locs, Srange)\n",
    "        \n",
    "    \n",
    "    if time > Tc and chaos:\n",
    "        chaos = False\n",
    "        S = init_S(board_size, S_wall, S_exit, obstacle_locs, exit_locs, mu)\n",
    "        for person in person_list:\n",
    "            if person.state == 'C':\n",
    "                obstacle_locs[0].append(person.location[0])\n",
    "                obstacle_locs[1].append(person.location[1])\n",
    "\n",
    "    # step 2: iterate over every person in person_list\n",
    "\n",
    "    if time > 1 and len(prev_locations) > 0:\n",
    "        D = update_D(D, locations, prev_locations, diffusion_factor, decay_factor)\n",
    "        fallen_locs,board = update_board(board,person_list,state_dic,chaos,B_exit)\n",
    "    \n",
    "    #plt.imshow(board)\n",
    "    #plt.show()\n",
    "\n",
    "    if time > 1 and fallen_locs != prev_fallen_locs and len(fallen_locs[0]) > 0:\n",
    "        # note that Fij is -inf if there is an obstacle/fallen person on Fij\n",
    "        F = update_F(board_size, fallen_locs, Srange)\n",
    "\n",
    "    prev_fallen_locs = fallen_locs\n",
    "    prev_locations = get_locations(person_list)\n",
    "    directionmap = get_directions(board_size,person_list)\n",
    "\n",
    "    for person in person_list:\n",
    "        \n",
    "        # calculate state of person\n",
    "        person = check_state(person,exit_locs,fallen_locs)\n",
    "        \n",
    "        # if person has been evacuated, remove from person list\n",
    "\n",
    "        if person.state == 'left':\n",
    "            person_list = np.delete(person_list,person_list == person)\n",
    "            prev_locations = np.delete(prev_locations,np.all(prev_locations == person.location, axis = 1),axis=0)\n",
    "        else:\n",
    "            # calculate movement of each person \n",
    "            # or if person.state = 'C' calculate chance of getting up\n",
    "\n",
    "            person = move_direction(person,board,S,D,F,exit_locs,fallen_locs,directionmap,sight_radius,board_size,ks,kd,kf,ka,kc,B_wall)\n",
    "    \n",
    "    next_locations = np.array([person.new_location for person in person_list if person.state != 'C'])\n",
    "    next_loc_person_list = np.array([person for person in person_list if person.state != 'C'])\n",
    "\n",
    "    # find duplicate locations in next_locations list and put in dupes\n",
    "\n",
    "    dupes, count = np.unique(next_locations, axis=0, return_counts=True)\n",
    "    non_dupes = dupes[count == 1]\n",
    "    dupes = dupes[count > 1]\n",
    "    if dupes.size > 0:\n",
    "\n",
    "        for dupe in dupes:\n",
    "            # for all dupes calc which person moves and set its location to new location\n",
    "            # The other persons stay in their original location and thus don't need to be adjusted\n",
    "            people_moving = next_loc_person_list[np.all(next_locations == dupe,axis=1)]\n",
    "            np.random.shuffle(people_moving)\n",
    "            picked = people_moving[0]\n",
    "            picked.location = picked.new_location\n",
    "        \n",
    "        for non_dupe in non_dupes:\n",
    "            # set location to new locations\n",
    "            person_moving = next_loc_person_list[np.all(next_locations == non_dupe,axis=1)][0]\n",
    "            person_moving.location = person_moving.new_location\n",
    "    \n",
    "    else:\n",
    "        for person in next_loc_person_list:\n",
    "            person.location = person.new_location\n",
    "\n",
    "    locations = get_locations(person_list)\n",
    "\n",
    "    # check if stampede is over\n",
    "\n",
    "    stampede = check_stampede(person_list,chaos)\n",
    "\n",
    "    # write current board to total\n",
    "    temp = np.reshape(plot_room(board,state_dic,B_exit,B_wall),(1,board_size,board_size,3))\n",
    "    stampede_clip = np.vstack((stampede_clip,temp))\n",
    "    time += 1\n",
    "    if time == 2000:\n",
    "        break\n",
    "\n",
    "print(f\"The stampede lasted {time} seconds.\")\n",
    "maak_gif(stampede_clip, filename = 'stampede')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}