WTC-Red-Maze.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import random\n",
    "import math\n",
    "from typing import List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load sample and extract patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "pixels = [[255, 255, 255, 255], [255, 0, 0, 0], [255, 0, 138, 0], [255, 0, 0, 0]]\n",
    "input_size = (4, 4)\n",
    "output_size = (50, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[255, 255, 255, 255], [255, 0, 0, 0], [255, 0, 138, 0], [255, 0, 0, 0]]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQcAAAD8CAYAAAB6iWHJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAMrElEQVR4nO3df6jd9X3H8edrLqXDOrIRN7P80MLCpBX80UuqCCPr6tAgpH/IiH/UIoNLxQ4LEykbOPbf8I/C1KITKjNQ2hVsXejSFVccKszW2xAzNXULTvFiWKK1iUFZiXvvj/NVDrefm8Sc7/nec3ufDzjc7/d8P/m+P4fcvHLO9/s933eqCkla6tdWegKSZpPhIKnJcJDUZDhIajIcJDUZDpKafn2SP5zkt4F/BC4BXgH+tKreaox7BXgbeA84VVVzk9SVNH2TvnP4CvDDqtoG/LBbX84fVdUVBoO0OkwaDruAR7rlR4DPTbg/STMik1whmeTnVbV+bP2tqvqtxrj/Bt4CCvj7qnroNPucB+YBzj///E9deuml5zw/Saf3yiuv8MYbb6S17YzHHJL8K3BRY9NffYg5XFtVryf5HeDxJD+tqidbA7vgeAhgbm6uFhYWPkQZSR/G3Nzyn/LPGA5V9dnltiX5nyQbq+pIko3A0WX28Xr382iS7wLbgWY4SJoNkx5z2At8oVv+AvBPSwckOT/JBe8vA38CPD9hXUlTNmk4/C1wXZL/Aq7r1knye0n2dWN+F3g6yXPAj4F/rqp/mbCupCmb6DqHqnoT+OPG868DO7vll4HLJ6kjaXheISmpyXCQ1GQ4SGoyHCQ1GQ6SmgwHSU2Gg6Qmw0FSk+EgqclwkNRkOEhqMhwkNRkOkpoMB0lNhoOkJsNBUpPhIKnJcJDU1Es4JLk+yUtJDif5pa5XGbm3234wyVV91JU0PROHQ5LzgK8BNwCfAG5O8oklw24AtnWPeeCBSetKmq4+3jlsBw5X1ctV9QvgW4za5I3bBeypkWeA9V2fC0kzqo9w2AS8Nra+2D33YcdImiF9hEOrz97SBpxnM2Y0MJlPspBk4dixYxNPTtK56SMcFoEtY+ubgdfPYQww6pVZVXNVNXfhhRf2MD1J56KPcHgW2Jbk40k+Auxm1CZv3F7glu6sxdXA8ao60kNtSVMyUccrgKo6leRLwA+A84CHq+qFJF/stj8I7GPUAesw8A5w66R1JU3XxOEAUFX7GAXA+HMPji0XcHsftSQNwyskJTUZDpKaDAdJTYaDpCbDQVKT4SCpyXCQ1GQ4SGoyHCQ1GQ6SmgwHSU2Gg6Qmw0FSk+EgqclwkNRkOEhqMhwkNRkOkpoMB0lNQ/XK3JHkeJID3ePuPupKmp6JbzA71ivzOkb9KZ5NsreqXlwy9KmqunHSepKG0cfdpz/olQmQ5P1emUvDQZ2k1QBMmi1D9coEuCbJc0m+n+STy+3MdnjSbBiqV+Z+4OKquhy4D3hsuZ3ZDk+aDYP0yqyqE1V1slveB6xLsqGH2pKmZJBemUkuSvdBO8n2ru6bPdSWNCVD9cq8CbgtySngXWB31yJP0ozKLP8bnZubq4WFhZWeRu88W6FZUlXNX0ivkJTUZDhIajIcJDUZDpKaDAdJTYaDpCbDQVKT4SCpyXCQ1GQ4SGoyHCQ1GQ6SmgwHSU2Gg6Qmw0FSk+EgqclwkNRkOEhq6qsd3sNJjiZ5fpntSXJv1y7vYJKr+qgraXr6eufwD8D1p9l+A7Cte8wDD/RUV9KU9BIOVfUk8LPTDNkF7KmRZ4D1STb2UVvSdAx1zOFsW+bZDk+aEUOFw9m0zBs9aTs8aSYMFQ5nbJknabYMFQ57gVu6sxZXA8er6shAtSWdg4nb4QEk+SawA9iQZBH4a2AdfNAObx+wEzgMvAPc2kddSdPTSzhU1c1n2F7A7X3UkjQMr5CU1GQ4SGoyHCQ1GQ6SmgwHSU2Gg6Qmw0FSk+EgqclwkNRkOEhqMhwkNRkOkpoMB0lNhoOkJsNBUpPhIKnJcJDUZDhIahqqHd6OJMeTHOged/dRV9L09HIPSUbt8O4H9pxmzFNVdWNP9SRN2VDt8CStMn29czgb1yR5jlEzmzur6oXWoCTzjJrtsnXr1gGnpz7cc889Kz2FqbjrrrtWegqDG+qA5H7g4qq6HLgPeGy5gbbDk2bDIOFQVSeq6mS3vA9Yl2TDELUlnZtBwiHJRUnSLW/v6r45RG1J52aodng3AbclOQW8C+zuumBJmlFDtcO7n9GpTkmrhFdISmoyHCQ1GQ6SmgwHSU2Gg6Qmw0FSk+EgqclwkNRkOEhqMhwkNRkOkpoMB0lNhoOkJsNBUpPhIKnJcJDUZDhIajIcJDVNHA5JtiR5IsmhJC8kuaMxJknuTXI4ycEkV01aV9J09XEPyVPAX1TV/iQXAD9J8nhVvTg25gZgW/f4NPBA91PSjJr4nUNVHamq/d3y28AhYNOSYbuAPTXyDLA+ycZJa0uanl6POSS5BLgS+NGSTZuA18bWF/nlAHl/H/NJFpIsHDt2rM/pSfoQeguHJB8DHgW+XFUnlm5u/JFm3wrb4UmzoZdwSLKOUTB8o6q+0xiyCGwZW9/MqKGupBnVx9mKAF8HDlXVV5cZthe4pTtrcTVwvKqOTFpb0vT0cbbiWuDzwH8kOdA995fAVvigHd4+YCdwGHgHuLWHupKmaOJwqKqnaR9TGB9TwO2T1pI0HK+QlNRkOEhqMhwkNRkOkpoMB0lNhoOkJsNBUpPhIKnJcJDUZDhIajIcJDUZDpKaDAdJTYaDpCbDQVKT4SCpyXCQ1GQ4SGoaqh3ejiTHkxzoHndPWlfSdA3VDg/gqaq6sYd6kgYwVDs8SatMRjeG7mlno3Z4TwKXjXe9SrKDUdObRUbNbO6sqheW2cc8MA+wdevWT7366qu9zW9WjFp9SLOhqpq/kEO1w9sPXFxVlwP3AY+dZqK2w5NmwCDt8KrqRFWd7Jb3AeuSbOijtqTpGKQdXpKLunEk2d7VfXPS2pKmZ6h2eDcBtyU5BbwL7K4+D3ZI6t1Q7fDuB+6ftJak4XiFpKQmw0FSk+EgqclwkNRkOEhqMhwkNRkOkpoMB0lNhoOkJsNBUpPhIKnJcJDUZDhIajIcJDUZDpKaDAdJTYaDpCbDQVJTHzeY/WiSHyd5rmuH9zeNMUlyb5LDSQ4muWrSupKmq48bzP4v8JmqOtndov7pJN+vqmfGxtwAbOsenwYe6H5KmlF9tMOr93tSAOu6x9I7S+8C9nRjnwHWJ9k4aW1J09NXU5vzutvSHwUer6ofLRmyCXhtbH0R+2lKM62XcKiq96rqCmAzsD3JZUuGtG5d3+xbkWQ+yUKShWPHjvUxPUnnoNezFVX1c+DfgOuXbFoEtoytb2bUULe1D3tlSjOgj7MVFyZZ3y3/BvBZ4KdLhu0FbunOWlwNHK+qI5PWljQ9fZyt2Ag8kuQ8RmHz7ar6XpIvwgft8PYBO4HDwDvArT3UlTRFfbTDOwhc2Xj+wbHlAm6ftJak4XiFpKQmw0FSk+EgqclwkNRkOEhqMhwkNRkOkpoMB0lNhoOkJsNBUpPhIKnJcJDUZDhIajIcJDUZDpKaDAdJTYaDpCbDQVKT4SCpaahemTuSHE9yoHvcPWldSdM1VK9MgKeq6sYe6kkaQB93ny7gTL0yJa0yfbxzoOtZ8RPg94GvNXplAlyT5DlGna7urKoXltnXPDDfrZ5M8lIfczwLG4A3Bqo1JF/X6jPka7t4uQ0Z/cffj67z1XeBP6+q58ee/03g/7qPHjuBv6uqbb0V7kGShaqaW+l59M3XtfrMymsbpFdmVZ2oqpPd8j5gXZINfdaW1K9BemUmuShJuuXtXd03J60taXqG6pV5E3BbklPAu8Du6vPzTD8eWukJTImva/WZidfW6zEHSb86vEJSUpPhIKlpzYdDkuuTvJTkcJKvrPR8+pLk4SRHkzx/5tGrR5ItSZ5Icqi7XP+OlZ5TH87mawiDz2ktH3PoDqL+J3AdsAg8C9xcVS+u6MR6kOQPGV25uqeqLlvp+fQlyUZgY1XtT3IBo4vvPrfa/866s3nnj38NAbij8TWEwaz1dw7bgcNV9XJV/QL4FrBrhefUi6p6EvjZSs+jb1V1pKr2d8tvA4eATSs7q8nVyEx9DWGth8Mm4LWx9UV+BX7R1ooklwBXAq3L9VedJOclOQAcBR5f5msIg1nr4ZDGc2v3c9YqkuRjwKPAl6vqxErPpw9V9V5VXQFsBrYnWdGPg2s9HBaBLWPrmxl9MUwzrPtM/ijwjar6zkrPp2/LfQ1haGs9HJ4FtiX5eJKPALuBvSs8J51Gd+Du68ChqvrqSs+nL2fzNYShrelwqKpTwJeAHzA6sPXt5b5Kvtok+Sbw78AfJFlM8mcrPaeeXAt8HvjM2J3Fdq70pHqwEXgiyUFG/2k9XlXfW8kJrelTmZKWt6bfOUhanuEgqclwkNRkOEhqMhwkNRkOkpoMB0lN/w9FPRI+bolgrwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(pixels, cmap=\"gray\") # create plt\n",
    "print(pixels)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pattern:\n",
    "    def __init__(self, pixels):\n",
    "        self.pixels = pixels\n",
    "        \n",
    "    def __len__(self):\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_all_rotations(pixelMatrix):\n",
    "    \"\"\"\n",
    "    Return original array as well as rotated by 90, 180 and 270 degrees in the form of tuples\n",
    "    \"\"\"\n",
    "    pixelMatrix_rotated_1 = [[pixelMatrix[j][i] for j in range(len(pixelMatrix))] for i in range(len(pixelMatrix[0])-1,-1,-1)]\n",
    "    pixelMatrix_rotated_2 = [[pixelMatrix_rotated_1[j][i] for j in range(len(pixelMatrix_rotated_1))] for i in range(len(pixelMatrix_rotated_1[0])-1,-1,-1)]\n",
    "    pixelMatrix_rotated_3 = [[pixelMatrix_rotated_2[j][i] for j in range(len(pixelMatrix_rotated_2))] for i in range(len(pixelMatrix_rotated_2[0])-1,-1,-1)]\n",
    "    return tuple(tuple(row) for row in pixelMatrix), \\\n",
    "            tuple(tuple(row) for row in pixelMatrix_rotated_1), \\\n",
    "            tuple(tuple(row) for row in pixelMatrix_rotated_2), \\\n",
    "            tuple(tuple(row) for row in pixelMatrix_rotated_3)\n",
    "\n",
    "N = 2 # pattern size\n",
    "patterns = []\n",
    "weights = {} # dict pattern -> occurence\n",
    "probability = {} # dict pattern -> probability\n",
    "for y in range(input_size[0]-(N-1)): # row \n",
    "    for x in range(input_size[1]-(N-1)): # column\n",
    "        pattern = []\n",
    "        for k in pixels[y:y+N]:\n",
    "            pattern.append([int(i) for i in k[x:x+N]]) # change array to int really quick\n",
    "        pattern_rotations = get_all_rotations(pattern)\n",
    "        \n",
    "        for rotation in pattern_rotations:\n",
    "            if rotation not in weights:\n",
    "                weights[rotation] = 1\n",
    "            else:\n",
    "                weights[rotation] += 1\n",
    "        \n",
    "        patterns.extend(pattern_rotations)\n",
    "        \n",
    "# remove duplicates\n",
    "patterns_without_duplicates = []\n",
    "for patt in patterns:\n",
    "    if patt not in patterns_without_duplicates:\n",
    "        patterns_without_duplicates.append(patt)\n",
    "patterns = patterns_without_duplicates\n",
    "\n",
    "sum_of_weights = 0\n",
    "for weight in weights:\n",
    "    sum_of_weights += weights[weight]\n",
    "\n",
    "for pattern in patterns:\n",
    "    probability[pattern] = weights[pattern] / sum_of_weights\n",
    "    \n",
    "# convert patterns from tuples into Pattern objects\n",
    "patterns = [Pattern(p) for p in patterns]\n",
    "weights = {pattern:weights[pattern.pixels] for pattern in patterns}\n",
    "probability = {pattern:probability[pattern.pixels] for pattern in patterns}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 12 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# show \n",
    "plt.figure(figsize=(10,10))\n",
    "for m in range(len(patterns)):\n",
    "    axs = plt.subplot(4, math.ceil(len(patterns)/4), m+1)\n",
    "    axs.imshow(patterns[m].pixels, cmap=\"gray\", vmin=0, vmax=255)\n",
    "    axs.set_xticks([])\n",
    "    axs.set_yticks([])\n",
    "    plt.title(\"weight: %.0f prob: %.2f\"%(weights[patterns[m]], probability[patterns[m]]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Index data structure describing rules for placing patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "UP = (0, -1)\n",
    "LEFT = (-1, 0)\n",
    "DOWN = (0, 1)\n",
    "RIGHT = (1, 0)\n",
    "UP_LEFT = (-1, -1)\n",
    "UP_RIGHT = (1, -1)\n",
    "DOWN_LEFT = (-1, 1)\n",
    "DOWN_RIGHT = (1, 1)\n",
    "dirs = [UP, DOWN, LEFT, RIGHT, UP_LEFT, UP_RIGHT, DOWN_LEFT, DOWN_RIGHT]\n",
    "\n",
    "def valid_dirs(pos):\n",
    "    x, y = pos\n",
    "    \n",
    "    valid_directions = []\n",
    "\n",
    "    if x == 0:\n",
    "        valid_directions.extend([RIGHT])\n",
    "        if y == 0:\n",
    "            valid_directions.extend([DOWN, DOWN_RIGHT])\n",
    "        elif y == output_size[1]-1:\n",
    "            valid_directions.extend([UP, UP_RIGHT])\n",
    "        else:\n",
    "            valid_directions.extend([DOWN, DOWN_RIGHT, UP, UP_RIGHT])\n",
    "    elif x == output_size[0]-1:\n",
    "        valid_directions.extend([LEFT])\n",
    "        if y == 0:\n",
    "            valid_directions.extend([DOWN, DOWN_LEFT])\n",
    "        elif y == output_size[1]-1:\n",
    "            valid_directions.extend([UP, UP_LEFT])\n",
    "        else:\n",
    "            valid_directions.extend([DOWN, DOWN_LEFT, UP, UP_LEFT])\n",
    "    else:\n",
    "        valid_directions.extend([LEFT, RIGHT])\n",
    "        if y == 0:\n",
    "            valid_directions.extend([DOWN, DOWN_LEFT, DOWN_RIGHT])\n",
    "        elif y == output_size[1]-1:\n",
    "            valid_directions.extend([UP, UP_LEFT, UP_RIGHT])\n",
    "        else: \n",
    "            valid_directions.extend([UP, UP_LEFT, UP_RIGHT, DOWN, DOWN_LEFT, DOWN_RIGHT])\n",
    "    \n",
    "    return valid_directions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Index:\n",
    "    \"\"\"\n",
    "    Tells which combinations of patterns are allowed for all patterns\n",
    "    \n",
    "    data (dict):\n",
    "        pattern -> posible_connections (dict):\n",
    "                    relative_position -> patterns (list)\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, patterns: List[Pattern]):\n",
    "        self.data = {}\n",
    "        for pattern in patterns:\n",
    "            self.data[pattern] = {}\n",
    "            for d in dirs: \n",
    "                self.data[pattern][d] = []\n",
    "    \n",
    "    def add_rule(self, pattern: Pattern, relative_position: tuple, next_pattern: Pattern):\n",
    "        self.data[pattern][relative_position].append(next_pattern)\n",
    "        \n",
    "        \n",
    "    def check_possibility(self, pattern: Pattern, check_pattern: Pattern, relative_pos: tuple):\n",
    "        if isinstance(pattern, list):\n",
    "            pattern = pattern[0]\n",
    "            \n",
    "        return check_pattern in self.data[pattern][relative_pos]\n",
    "\n",
    "index = Index(patterns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_offset_tiles(pattern: Pattern, offset: tuple):\n",
    "    if offset == (0, 0):\n",
    "        return pattern.pixels\n",
    "    if offset == (-1, -1):\n",
    "        return tuple([pattern.pixels[1][1]])\n",
    "    if offset == (0, -1):\n",
    "        return tuple(pattern.pixels[1][:])\n",
    "    if offset == (1, -1):\n",
    "        return tuple([pattern.pixels[1][0]])\n",
    "    if offset == (-1, 0):\n",
    "        return tuple([pattern.pixels[0][1], pattern.pixels[1][1]])\n",
    "    if offset == (1, 0):\n",
    "        return tuple([pattern.pixels[0][0], pattern.pixels[1][0]])\n",
    "    if offset == (-1, 1):\n",
    "        return tuple([pattern.pixels[0][1]])\n",
    "    if offset == (0, 1):\n",
    "        return tuple(pattern.pixels[0][:])\n",
    "    if offset == (1, 1):\n",
    "        return tuple([pattern.pixels[0][0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate rules for Index and save them\n",
    "rules_num = 0\n",
    "for pattern in patterns:\n",
    "    for d in dirs:\n",
    "        for pattern_next in patterns:\n",
    "            # here's checking all offsets \n",
    "            overlap = get_offset_tiles(pattern_next, d)\n",
    "            og_dir = tuple([d[0]*-1, d[1]*-1])\n",
    "            part_of_og_pattern = get_offset_tiles(pattern, og_dir)\n",
    "            if (overlap) == (part_of_og_pattern):\n",
    "                index.add_rule(pattern, d, pattern_next)\n",
    "                rules_num+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Show data in Index\n",
    "# print(f\"There are {rules_num} rules\")\n",
    "\n",
    "# for d in index.data:\n",
    "#     print(f'Pattern {d.pixels}')\n",
    "#     for pos in index.data[d]:\n",
    "#         print(f' Pos {pos}')\n",
    "#         for pattern in index.data[d][pos]:\n",
    "#             print(f' {pattern.pixels}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define coefficients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_wave_function(size):\n",
    "    \"\"\"\n",
    "    Initialize wave function of the size 'size' where in each tile no patterns are foridden yet.\n",
    "    Coefficients describe what patterns can occur in each tile. At the beggining, at every possition there is full set\n",
    "    of patterns available\n",
    "    \"\"\"\n",
    "    \n",
    "    coefficients = []\n",
    "    \n",
    "    for col in range(size[0]):\n",
    "        row = []\n",
    "        for r in range(size[1]):\n",
    "            row.append(patterns)\n",
    "        coefficients.append(row)\n",
    "    return coefficients\n",
    "\n",
    "coefficients = initialize_wave_function(output_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utility functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_fully_collapsed():\n",
    "    \"\"\"\n",
    "    Check if wave function is fully collapsed meaning that for each tile available is only one pattern\n",
    "    \"\"\"\n",
    "    for col in coefficients:\n",
    "        for entry in col:\n",
    "            if(len(entry)>1):\n",
    "                return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_possible_patterns_at_position(position):\n",
    "    \"\"\"\n",
    "    Return possible patterns at position (x, y)\n",
    "    \"\"\"\n",
    "    x, y = position\n",
    "    possible_patterns = coefficients[x][y]\n",
    "    return possible_patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_shannon_entropy(position):\n",
    "    \"\"\"\n",
    "    Calcualte the Shannon Entropy of the wavefunction at position (x, y)\n",
    "    \"\"\"\n",
    "    x, y = position\n",
    "    entropy = 0\n",
    "    \n",
    "    # A cell with one valid pattern has 0 entropy\n",
    "    if len(coefficients[x][y]) == 1:\n",
    "        return 0\n",
    "    \n",
    "    for pattern in coefficients[x][y]:\n",
    "        entropy += probability[pattern] * math.log(probability[pattern], 2)\n",
    "    entropy *= -1\n",
    "    \n",
    "    # Add noise to break ties and near-ties\n",
    "    entropy -= random.uniform(0, 0.1)\n",
    "    return entropy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_min_entropy_pos():\n",
    "    \"\"\"\n",
    "    Return position of tile with the lowest entropy\n",
    "    \"\"\"\n",
    "    minEntropy = None\n",
    "    minEntropyPos = None\n",
    "    \n",
    "    for x, col in enumerate(coefficients):\n",
    "        for y, row in enumerate(col):\n",
    "            entropy = get_shannon_entropy((x, y))\n",
    "            \n",
    "            if entropy == 0:\n",
    "                continue\n",
    "            \n",
    "            if minEntropy is None or entropy < minEntropy:\n",
    "                minEntropy = entropy\n",
    "                minEntropyPos = (x, y)\n",
    "    return minEntropyPos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algorithm itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def observe():\n",
    "    # Find the lowest entropy\n",
    "    min_entropy_pos = get_min_entropy_pos()\n",
    "    \n",
    "    if min_entropy_pos == None:\n",
    "        print(\"All tiles have 0 entropy\")\n",
    "        return\n",
    "    \n",
    "    # Choose a pattern at lowest entropy position which is most frequent in the sample\n",
    "    possible_patterns = get_possible_patterns_at_position(min_entropy_pos)\n",
    "    \n",
    "    # calculate max probability for patterns that are left\n",
    "    max_p = 0\n",
    "    for pattern in possible_patterns:\n",
    "        if max_p < probability[pattern]:\n",
    "            max_p == probability[pattern]\n",
    "    \n",
    "    \n",
    "    semi_random_pattern = random.choice([pat for pat in possible_patterns if probability[pat]>=max_p])\n",
    "    \n",
    "    # Set this pattern to be the only available at this position\n",
    "    coefficients[min_entropy_pos[0]][min_entropy_pos[1]] = semi_random_pattern\n",
    "    \n",
    "    return min_entropy_pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def propagate(min_entropy_pos):\n",
    "    stack = [min_entropy_pos]\n",
    "    \n",
    "    \n",
    "    while len(stack) > 0:\n",
    "        pos = stack.pop()\n",
    "        \n",
    "        possible_patterns = get_possible_patterns_at_position(pos)\n",
    "        \n",
    "        # Iterate through each location immediately adjacent to the current location\n",
    "        for d in valid_dirs(pos):\n",
    "            adjacent_pos = (pos[0] + d[0], pos[1] + d[1])\n",
    "            possible_patterns_at_adjacent = get_possible_patterns_at_position(adjacent_pos)\n",
    "            \n",
    "            # Iterate over all still available patterns in adjacent tile \n",
    "            # and check if pattern is still possible in this location\n",
    "            if not isinstance(possible_patterns_at_adjacent, list):\n",
    "                possible_patterns_at_adjacent = [possible_patterns_at_adjacent]\n",
    "            for possible_pattern_at_adjacent in possible_patterns_at_adjacent:\n",
    "                if len(possible_patterns) > 1:\n",
    "                    is_possible = any([index.check_possibility(pattern, possible_pattern_at_adjacent, d) for pattern in possible_patterns])\n",
    "                else:\n",
    "                    is_possible = index.check_possibility(possible_patterns, possible_pattern_at_adjacent, d)\n",
    "                    \n",
    "                \"\"\"\n",
    "                If the tile is not compatible with any of the tiles in the current location's wavefunction\n",
    "                then it's impossible for it to ever get choosen so it needs to be removed from the other\n",
    "                location's wavefunction\n",
    "                \"\"\"\n",
    "                if not is_possible:\n",
    "                    x, y = adjacent_pos\n",
    "                    coefficients[x][y] = [patt for patt in coefficients[x][y] if patt.pixels != possible_pattern_at_adjacent.pixels]\n",
    "                        \n",
    "                    if adjacent_pos not in stack:\n",
    "                        stack.append(adjacent_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "while not is_fully_collapsed():\n",
    "    min_entropy_pos = observe()\n",
    "    propagate(min_entropy_pos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Post process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "final_pixels = []\n",
    "\n",
    "for i in coefficients:\n",
    "    row = []\n",
    "    for j in i:\n",
    "        if isinstance(j, list):\n",
    "            first_pixel = j[0].pixels[0][0]\n",
    "        else:\n",
    "            first_pixel = j.pixels[0][0]\n",
    "        row.append(first_pixel)\n",
    "    final_pixels.append(row)\n",
    "    \n",
    "plt.imshow(final_pixels, cmap=\"gray\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}