cellular automata/Cellular Automata.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Intro\" data-toc-modified-id=\"Intro-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Intro</a></span></li><li><span><a href=\"#1D-Automata\" data-toc-modified-id=\"1D-Automata-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>1D Automata</a></span><ul class=\"toc-item\"><li><span><a href=\"#Animation\" data-toc-modified-id=\"Animation-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Animation</a></span></li></ul></li><li><span><a href=\"#Conway’s-Game-Of-Life\" data-toc-modified-id=\"Conway’s-Game-Of-Life-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Conway’s Game Of Life</a></span><ul class=\"toc-item\"><li><span><a href=\"#Animation-in-Matplotlib\" data-toc-modified-id=\"Animation-in-Matplotlib-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Animation in Matplotlib</a></span><ul class=\"toc-item\"><li><span><a href=\"#Interactive-Animation\" data-toc-modified-id=\"Interactive-Animation-3.1.1\"><span class=\"toc-item-num\">3.1.1&nbsp;&nbsp;</span>Interactive Animation</a></span></li></ul></li><li><span><a href=\"#Game-of-Life-3D\" data-toc-modified-id=\"Game-of-Life-3D-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Game of Life 3D</a></span></li><li><span><a href=\"#Performances-Profiling\" data-toc-modified-id=\"Performances-Profiling-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Performances Profiling</a></span></li></ul></li><li><span><a href=\"#Multiple-Neighborhood-CA\" data-toc-modified-id=\"Multiple-Neighborhood-CA-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Multiple Neighborhood CA</a></span><ul class=\"toc-item\"><li><span><a href=\"#Performances-Profiling\" data-toc-modified-id=\"Performances-Profiling-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Performances Profiling</a></span></li><li><span><a href=\"#Generate-Video\" data-toc-modified-id=\"Generate-Video-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Generate Video</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intro\n",
    "Cellular Automata are discrete mathematical models of Artificial Life.\n",
    "*Discrete* because they exist in a discrete space, for example a 2D cell grid for 2-Dimensional automata.\n",
    "\n",
    "Other primary properties of a cellular automaton:\n",
    "* **dimensionality** of the space/world it lives in\n",
    "* **evolutionary rules**\n",
    "* **neighborhood**. For example in a 2D setting *Moore Neighboorhood* consists of the 8 surrounding cells.\n",
    "* finite number of **states**\n",
    "\n",
    "Also in general updates are applied instantly to all units."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-05T09:23:01.383493Z",
     "start_time": "2022-01-05T09:23:00.565219Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "from PIL import Image, ImageDraw\n",
    "import tqdm\n",
    "from pathlib import Path\n",
    "\n",
    "\n",
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1D Automata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Automaton_1D:\n",
    "    def __init__(self, n: int, states: int=2):\n",
    "        \"\"\"\n",
    "        1D Automaton\n",
    "        :param n: number of cells\n",
    "        \"\"\"\n",
    "        self.n = n\n",
    "        self.space = np.zeros(n, dtype=np.uint8)\n",
    "        self.space[n//2] = 1\n",
    "        #np.array([0,0,0,0,1,0,0,0,0,0])#np.random.choice(2, n)\n",
    "    \n",
    "    def update(self, rule: dict):\n",
    "        \"\"\"\n",
    "        Update automaton state\n",
    "        \"\"\"\n",
    "        tmp_space = self.space.copy()\n",
    "        for i in range(self.n):\n",
    "            neighbours = self.get_neighbours(i)\n",
    "            tmp_space[i] = rule[\"\".join([str(s) for s in neighbours])]\n",
    "        self.space = tmp_space\n",
    "        \n",
    "    def get_neighbours(self, i: int):\n",
    "        if i == 0:\n",
    "            return np.insert(self.space[:2], 0, self.space[-1])\n",
    "        elif i == self.n - 1:\n",
    "            return np.insert(self.space[-2:], 2, self.space[0])\n",
    "        else: \n",
    "            return self.space[max(0, i-1):i+2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "rule_0 = {'111': 1, '110': 1, '101': 1, '100': 1, '011': 1, '010': 1, '001': 1, '000': 0}\n",
    "rule_sierpinski = {'111': 0, '110': 1, '101': 0, '100': 1, '011': 1, '010': 0, '001': 1, '000': 0}\n",
    "rule_x = {'111': 0, '110': 0, '101': 0, '100': 1, '011': 1, '010': 1, '001': 1, '000': 0}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Animation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "automaton_size = 100\n",
    "automaton_1d = Automaton_1D(automaton_size)\n",
    "nb_frames = 100\n",
    "\n",
    "img = Image.new('RGB', (automaton_size, nb_frames), 'white')\n",
    "draw = ImageDraw.Draw(img)\n",
    "fig, ax = plt.subplots(dpi=50, figsize=(5, 5))\n",
    "#im = ax.imshow(img)\n",
    "plt.axis('off')\n",
    "\n",
    "def animate(i, automaton, draw, img):\n",
    "    space_img = Image.fromarray(automaton_1d.space.reshape(1, automaton_size)*255)\n",
    "    img.paste(space_img, (0, i)) #mask=space_img\n",
    "    ax.imshow(img)\n",
    "    automaton.update(rule_x)\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, frames=nb_frames, interval=1, \n",
    "                              fargs=[automaton_1d, draw, img])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conway’s Game Of Life"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Game Of Life (GOL) is possibly one of the most notorious examples of a cellular automata.\n",
    "\n",
    "Defined by mathematician John Horton Conway, it plays out on a two dimensional grid for which each cell can be in one of two possible states. Starting from an initial grid configuration the system evolves at each unit step taking into account only the immediate preceding configuration. If for each cell we consider the eight surrounding cells as neighbors, the system transition can be defined by four simple rules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-10-05T11:23:20.411901",
     "start_time": "2017-10-05T11:23:20.400901"
    }
   },
   "outputs": [],
   "source": [
    "class ConwayGOL_2D:\n",
    "    def __init__(self, N):\n",
    "        \"\"\"\n",
    "        2D Conway Game of Life\n",
    "        :param N: grid side size (resulting grid will be a NxN matrix)\n",
    "        \"\"\"\n",
    "        self.N = N\n",
    "        self.grid = np.random.choice(2, (N,N))\n",
    "    \n",
    "    def update(self):\n",
    "        \"\"\"\n",
    "        Update status of the grid\n",
    "        \"\"\"\n",
    "        tmpGrid = self.grid.copy()\n",
    "        for i in range(self.N):\n",
    "            for j in range(self.N):\n",
    "                neighbours = self.grid[max(0, i-1):min(i+2,self.N), max(0, j-1):min(j+2,self.N)].sum()\n",
    "                neighbours -= self.grid[i, j]\n",
    "                if self.grid[i, j] == 1:\n",
    "                    if neighbours > 3 or neighbours < 2:\n",
    "                        tmpGrid[i, j] = 0\n",
    "                elif neighbours == 3:\n",
    "                    tmpGrid[i, j] = 1\n",
    "        self.grid = tmpGrid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Animation in Matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-10-05T11:23:24.260121",
     "start_time": "2017-10-05T11:23:24.148115"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "gol = ConwayGOL_2D(100)\n",
    "\n",
    "fig, ax = plt.subplots(dpi=100, figsize=(5, 4))\n",
    "im = ax.imshow(gol.grid, cmap='Greys', interpolation='nearest')\n",
    "plt.axis('off')\n",
    "\n",
    "def animate(i):\n",
    "    gol.update()\n",
    "    im.set_data(gol.grid)\n",
    "\n",
    "#ani = animation.FuncAnimation(fig, animate, frames=1000, interval=100).save('basic_animation.mp4', writer=animation.FFMpegFileWriter(fps=30))\n",
    "animation.FuncAnimation(fig, animate, frames=1000, interval=100)\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interactive Animation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-10-05T11:23:29.400415",
     "start_time": "2017-10-05T11:23:29.394415"
    }
   },
   "outputs": [],
   "source": [
    "from ipywidgets import interact, widgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-10-05T11:23:42.340155",
     "start_time": "2017-10-05T11:23:42.330155"
    }
   },
   "outputs": [],
   "source": [
    "def run_conwayGOL_2D(size):\n",
    "    gol = ConwayGOL_2D(size)\n",
    "\n",
    "    fig, ax = plt.subplots(dpi=100, figsize=(5, 4))\n",
    "    im = ax.imshow(gol.grid, cmap='Greys', interpolation='nearest')\n",
    "    plt.axis('off')\n",
    "\n",
    "    def animate(i):\n",
    "        gol.update()\n",
    "        im.set_data(gol.grid)\n",
    "\n",
    "    return animation.FuncAnimation(fig, animate, frames=1000, interval=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-10-05T11:23:42.995193",
     "start_time": "2017-10-05T11:23:42.882186"
    }
   },
   "outputs": [],
   "source": [
    "from ipywidgets import interact, widgets\n",
    "interact(run_conwayGOL_2D, size=(10,100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Game of Life 3D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regarding the grid structure and neighbors counting is purely a matter of using a 3-dimensional numpy array and related indexing.\n",
    "For the rules, original GOL ones are not so stable for a 3D setup."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-02T11:23:13.485874",
     "start_time": "2017-07-02T11:23:13.463873"
    }
   },
   "outputs": [],
   "source": [
    "class ConwayGOL_3D:\n",
    "    def __init__(self, N):\n",
    "        \"\"\"\n",
    "        3D Conway Game of Life\n",
    "        :param N: 3D grid side size (resulting grid will be a NxNxN matrix)\n",
    "        \"\"\"\n",
    "        self.N = N\n",
    "        self.grid = np.random.choice(2, (N,N,N))\n",
    "    \n",
    "    def update(self):\n",
    "        \"\"\"\n",
    "        Update status of the grid\n",
    "        \"\"\"\n",
    "        tmpGrid = self.grid.copy()\n",
    "        for z in range(self.N):\n",
    "            for y in range(self.N):\n",
    "                for x in range(self.N):\n",
    "                    neighbours = self.grid[max(0, z-1):min(z+2,self.N),\n",
    "                                           max(0, y-1):min(y+2,self.N), \n",
    "                                           max(0, x-1):min(x+2,self.N)].sum()\n",
    "                    neighbours -= self.grid[z, y, x]\n",
    "                    if self.grid[z, y, x] == 1:\n",
    "                        if neighbours > 3 or neighbours < 2:\n",
    "                            tmpGrid[z, y, x] = 0\n",
    "                    elif neighbours == 3:\n",
    "                        tmpGrid[z, y, x] = 1\n",
    "        self.grid = tmpGrid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performances Profiling\n",
    "Relying on the utility code for generic CA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-04T20:23:55.766734Z",
     "start_time": "2022-01-04T20:23:55.343455Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "from Automaton import AutomatonND"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-04T20:23:56.622802Z",
     "start_time": "2022-01-04T20:23:56.591866Z"
    }
   },
   "outputs": [],
   "source": [
    "rule = {'neighbours_count_born': 3,  # count required to make a cell alive\n",
    "        'neighbours_maxcount_survive': 3,  # max number (inclusive) of neighbours that a cell can handle before dying\n",
    "        'neighbours_mincount_survive': 2,  # min number (inclusive) of neighbours that a cell needs in order to stay alive\n",
    "            }\n",
    "\n",
    "nb_rows = nb_cols = 400"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-04T20:23:57.998238Z",
     "start_time": "2022-01-04T20:23:57.269588Z"
    }
   },
   "outputs": [],
   "source": [
    "%%prun -s cumulative -l 30 -r\n",
    "# We profile the cell, sort the report by \"cumulative\n",
    "# time\", limit it to 30 lines\n",
    "\n",
    "ca_2d = AutomatonND((nb_rows, nb_cols), rule, seed=11)\n",
    "simulation_steps = 100\n",
    "for step in tqdm.tqdm(range(simulation_steps)):\n",
    "    ca_2d.update()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-04T20:24:22.672224Z",
     "start_time": "2022-01-04T20:24:22.552300Z"
    }
   },
   "outputs": [],
   "source": [
    "plt.imshow(ca_2d.grid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiple Neighborhood CA\n",
    "Expands further on CA like GOL by considering more neighbors or multiple combinations of neighbors.\n",
    "\n",
    "See [Multiple Neighborhood Cellular Automata (MNCA) ](https://slackermanz.com/understanding-multiple-neighborhood-cellular-automata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-07T10:41:05.106252Z",
     "start_time": "2022-01-07T10:41:04.802733Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import cv2\n",
    "from PIL import Image as IMG\n",
    "\n",
    "from Automaton import AutomatonND, MultipleNeighborhoodAutomaton, get_kernel_2d_square\n",
    "from mnca_utils import *\n",
    "from ds_utils.video_utils import generate_video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-07T18:37:26.932641Z",
     "start_time": "2022-01-07T18:37:26.856499Z"
    }
   },
   "outputs": [],
   "source": [
    "configs = [\n",
    "    {'neighbours_count_born': [0.300, 0.350],  \n",
    "            'neighbours_maxcount_survive': [0.350, 0.400],  \n",
    "            'neighbours_mincount_survive': [0.750, 0.850],  \n",
    "            },\n",
    "]\n",
    "\n",
    "kernels = [\n",
    "    get_circle_grid(17, 17, radius_minmax=[2,10]),\n",
    "    \n",
    "]\n",
    "\n",
    "nb_rows = nb_cols = 200\n",
    "\n",
    "mnca = MultipleNeighborhoodAutomaton((nb_rows, nb_cols), configs=configs, kernels=kernels, seed=11)\n",
    "grid = get_circle_grid(mnca.shape[0], mnca.shape[1], radius_minmax=[0,50])\n",
    "mnca.set_init_grid(grid)\n",
    "simulation_steps = 40\n",
    "\n",
    "fig, ax = plt.subplots(dpi=100, figsize=(5, 4))\n",
    "im = ax.imshow(mnca.grid, cmap='Greys', interpolation='nearest')\n",
    "plt.axis('off')\n",
    "\n",
    "def animate(i):\n",
    "    mnca.update()\n",
    "    im.set_data(mnca.grid)\n",
    "    \n",
    "animation.FuncAnimation(fig, animate, frames=simulation_steps, interval=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performances Profiling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-08T08:30:43.587249Z",
     "start_time": "2022-01-08T08:30:42.996279Z"
    }
   },
   "outputs": [],
   "source": [
    "%%prun -s cumulative -l 30 -r\n",
    "# We profile the cell, sort the report by \"cumulative\n",
    "# time\", limit it to 30 lines\n",
    "\n",
    "configs = [\n",
    "    {'neighbours_count_born': [0.300, 0.350],  \n",
    "            'neighbours_maxcount_survive': [0.350, 0.400],  \n",
    "            'neighbours_mincount_survive': [0.750, 0.850],  \n",
    "            },\n",
    "    {'neighbours_count_born': [0.430, 0.550],  \n",
    "            'neighbours_maxcount_survive': [0.100, 0.280],  \n",
    "            'neighbours_mincount_survive': [0.120, 0.150],  \n",
    "            },\n",
    "]\n",
    "\n",
    "kernels = [\n",
    "    get_circle_grid(17, 17, radius_minmax=[2,10]),\n",
    "    get_circle_grid(9, 9, radius_minmax=[1,3]),\n",
    "    \n",
    "]\n",
    "\n",
    "nb_rows = nb_cols = 200\n",
    "simulation_steps = 40\n",
    "\n",
    "mnca = MultipleNeighborhoodAutomaton((nb_rows, nb_cols), configs=configs, kernels=kernels, seed=11)\n",
    "grid = get_circle_grid(mnca.shape[0], mnca.shape[1], radius_minmax=[0,50])\n",
    "mnca.set_init_grid(grid)\n",
    "\n",
    "for _ in range(simulation_steps):\n",
    "    mnca.update()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate Video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-11T11:29:14.569710Z",
     "start_time": "2022-01-11T11:29:14.529364Z"
    }
   },
   "outputs": [],
   "source": [
    "def base_frame_gen(frame_count, automaton):\n",
    "    automaton.update()\n",
    "    img = cv2.normalize(automaton.grid, None, 255, 0, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-11T12:34:32.895991Z",
     "start_time": "2022-01-11T12:33:11.565285Z"
    }
   },
   "outputs": [],
   "source": [
    "nb_rows = nb_cols = 300\n",
    "simulation_steps = 120\n",
    "\n",
    "automaton_name = 'mca_6polygon_kernel_fill_radinc'\n",
    "out_path = Path.home() / f'Documents/graphics/generative_output/mnca/{automaton_name}/{nb_rows}x{nb_cols}_{simulation_steps}'\n",
    "out_path.mkdir(exist_ok=False, parents=True)\n",
    "\n",
    "img_num = [25,3,6,9,10,11,12,15,16,17]\n",
    "with open(str(out_path / 'logs.txt'), 'w+') as f:\n",
    "    for i in range(10):\n",
    "        configs = [\n",
    "            {'neighbours_count_born': [0.300, 0.350],  \n",
    "                    'neighbours_maxcount_survive': [0.350, 0.400],  \n",
    "                    'neighbours_mincount_survive': [0.750, 0.850],  \n",
    "                    },\n",
    "#         {'neighbours_count_born': [0.430, 0.550],  \n",
    "#                 'neighbours_maxcount_survive': [0.100, 0.280],  \n",
    "#                 'neighbours_mincount_survive': [0.120, 0.150],  \n",
    "#                 },\n",
    "        ]\n",
    "        \n",
    "#         grid1 = get_polygon_mask(17, 17, 4, 4, fill=0)\n",
    "#         grid2 = get_polygon_mask(17, 17, 4, 1, fill=0)\n",
    "#         grid3 = get_polygon_mask(17, 17, 4, 10, fill=0)\n",
    "#         hexa_grid = (grid1 | grid2 | grid3)\n",
    "#         img_path = Path.home() / 'Documents/graphics/generative_output/flat_hexa_logo/9/run_{img_num[i]}.png'\n",
    "#         hexa_grid = get_image_init_grid(img_path, (17, 17))\n",
    "        \n",
    "        kernels = [\n",
    "            #hexa_grid,\n",
    "            get_polygon_mask(17, 17, segments=6, radius=i+1, fill=1)\n",
    "            #get_circle_grid(17, 17, radius_minmax=[1+i,5+i]),\n",
    "            #get_circle_grid(9, 9, radius_minmax=[1,3]),\n",
    "\n",
    "        ]\n",
    "        automaton = MultipleNeighborhoodAutomaton((nb_rows, nb_cols), configs=configs, kernels=kernels, seed=i)\n",
    "        img_path = Path.home() / 'Documents/graphics/generative_output/flat_hexa_logo/9/run_{img_num[i]}.png'\n",
    "        #grid = get_image_init_grid(img_path, automaton.shape)\n",
    "        #grid = get_perlin_grid(automaton.shape, 50, seed=i)\n",
    "        grid = get_circle_grid(automaton.shape[0], automaton.shape[1], radius_minmax=[0,80])\n",
    "        automaton.set_init_grid(grid)\n",
    "        generate_video(str(out_path/f'run_{i}.mp4'), (automaton.shape[1], automaton.shape[0]),\n",
    "                       frame_gen_fun = lambda i: base_frame_gen(i, automaton),\n",
    "                       nb_frames = simulation_steps, is_color=False)\n",
    "        f.write(str(configs) + '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-01-11T12:22:29.959495Z",
     "start_time": "2022-01-11T12:22:29.887694Z"
    }
   },
   "outputs": [],
   "source": [
    "grid = get_polygon_mask(17, 17, segments=120, radius=6, fill=0)\n",
    "plt.imshow(grid)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "hide_input": false,
  "kernelspec": {
   "display_name": "Data Science",
   "language": "python",
   "name": "ds"
  },
  "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.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "30px",
    "width": "252px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "229.006px"
   },
   "toc_section_display": "block",
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}