Visualization.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "from IPython import display\n",
    "import numpy as np\n",
    "import math\n",
    "import warnings\n",
    "import numpy as np\n",
    "from datetime import datetime\n",
    "import matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example: Matplotlib basics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7fd8076efe50>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "fig = plt.figure()\n",
    "x = np.linspace(0,100,20)\n",
    "y = x**2\n",
    "plt.plot(x,y,color='red')\n",
    "plt.scatter(x,y,color='blue')\n",
    "# plt.xlim(20,40)\n",
    "# plt.ylim(2000,6000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example: updating a plot in place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def updatePlot(obj=None):\n",
    "    fig = plt.figure()\n",
    "    ax = plt.gca()\n",
    "    hdisplay = display.display(\"\", display_id=True)\n",
    "    while obj != 'quit':\n",
    "        obj = input('Enter a number')\n",
    "        if obj == 'quit':\n",
    "            plt.close()\n",
    "            break\n",
    "        n = int(obj)\n",
    "        ax.scatter(n,n**2)\n",
    "        hdisplay.update(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number2\n",
      "Enter a number5\n",
      "Enter a number1\n",
      "Enter a number3\n",
      "Enter a number4\n",
      "Enter a numberquit\n"
     ]
    }
   ],
   "source": [
    "updatePlot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example: kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotRectangle(**kwargs):\n",
    "    fig = plt.figure()\n",
    "    ax = fig.gca()\n",
    "    sq = plt.Rectangle((0,0), 2,2,**kwargs)\n",
    "    ax.add_patch(sq)\n",
    "    ax.set_xlim(-1,3)\n",
    "    ax.set_ylim(-1,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": [
    "plotRectangle(facecolor='purple', edgecolor='green', linewidth=10, alpha=0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task: Visualize Circle class\n",
    "\n",
    "Fill out the plotCircle() method and fill out the init function to allow visualization of your circle class. You should be able to plot multiple circles on the same figure, and update the plot as you update your circle's parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getTime():\n",
    "    now = datetime.now()\n",
    "    current_time = now.strftime(\"%H:%M:%S:%f\")\n",
    "    return current_time\n",
    "\n",
    "class Circle():\n",
    "    \"\"\"\n",
    "    Function to create and edit a circle while calculating parameters and keeping track of previous changes to the circle.\n",
    "    \n",
    "    Parameters:\n",
    "    ----------\n",
    "    radius: Float\n",
    "        Radius of the circle. Default is None.\n",
    "    circum: Float\n",
    "        Circumference of the circle. Default is None.\n",
    "    area: Float\n",
    "        Area of the circle. Default is None.\n",
    "    history: Dict\n",
    "        Dictionary tracking all chnages made to the size of the circle. Keys are the time the change was made and values are the new size (radius, circumference, area). Default is None.\n",
    "    disp: Boolean\n",
    "        Choose whether or not to display the circle. Default is False.\n",
    "        \n",
    "    Returns:\n",
    "    ----------\n",
    "    calcCircle: Float\n",
    "        Calculates and returns the radius, circumference, and area. Updates all three parameters.\n",
    "    calcRadius: Float\n",
    "        Calculates and returns the radius of the circle, and updates the radius parameter.\n",
    "    calcCircum: Float\n",
    "        Calculates and returns the circumference of the circle, and updates the circumference parameter.\n",
    "    calcArea: Float\n",
    "        Calculates and returns the area of the circle, and updates the area parameter.\n",
    "    \"\"\"\n",
    "    def __init__(self, radius = None, circum = None, area = None, history = {},disp=False,ax=None,\n",
    "                 fig=None,hdisplay=None,pos=(0,0),**kwargs):\n",
    "        self.radius = radius\n",
    "        self.circum = circum\n",
    "        self.area = area\n",
    "        self.history = history\n",
    "        self.checkParams()\n",
    "        self.calcCircle()\n",
    "        self.circle = None\n",
    "        \n",
    "        ####### New params for visualization #######\n",
    "        # Assign new inputs to self\n",
    "        self.disp = disp\n",
    "        self.pos = pos\n",
    "        self.kwargs = kwargs\n",
    "        if disp is True:\n",
    "            if fig==None and ax==None and hdisplay==None:\n",
    "                # Initialize new figure\n",
    "                fig = plt.figure()\n",
    "                ax = plt.gca()\n",
    "                hdisplay = display.display(\"\", display_id=True)\n",
    "                ax.set_xlim(self.pos[0]-1.5*self.radius,self.pos[0]+1.5*self.radius)\n",
    "                ax.set_ylim(self.pos[1]-1.5*self.radius,self.pos[1]+1.5*self.radius)\n",
    "                plt.close()\n",
    "            elif fig==None or ax==None or hdisplay==None:\n",
    "                #Raise an error here\n",
    "                raise TypeError('Must pass in all fig, ax, hdisplay or none.')\n",
    "            self.ax = ax\n",
    "            self.fig = fig\n",
    "            self.hdisplay = hdisplay\n",
    "            self.plotCircle()\n",
    "            # Assign figure modifiers to self and call plotCircle\n",
    "\n",
    "    def calcCircle(self):\n",
    "        if self.radius != None:\n",
    "            self.circum = 2*math.pi*self.radius\n",
    "            self.area = math.pi*(self.radius**2)\n",
    "        elif self.circum != None:\n",
    "            self.radius = self.circum/(2*math.pi)\n",
    "            self.area = math.pi*(self.radius**2)\n",
    "        elif self.area != None:\n",
    "            self.radius = math.sqrt(self.area/math.pi)\n",
    "            self.circum = 2*math.pi*self.radius\n",
    "        else:\n",
    "            raise TypeError('All of the parameters are None.')\n",
    "    def checkParams(self):\n",
    "        params = np.asarray([self.radius, self.circum, self.area])\n",
    "        params[params == None] = 0\n",
    "#         print(params)\n",
    "        numSet = sum(x != 0 for x in params)  \n",
    "        if numSet > 1:\n",
    "            if params[1] != params[0]*2*math.pi and params[0] != 0 and params[1] != 0:\n",
    "                warnings.warn('The radius and circumference conflict. Calculating the parameters based on the the radius.')\n",
    "            if params[2] != params[0]**2*math.pi and params[0] != 0 and params[2] != 0:\n",
    "                warnings.warn('The radius and area conflict. Calculating the parameters based on the radius.')\n",
    "            if params[1] != 0 and params[2] != 0 and params[0] == 0:\n",
    "                radTemp = params[1]/(2*math.pi)\n",
    "                areaTemp = radTemp**2*math.pi\n",
    "                if params[2] != areaTemp:\n",
    "                    warnings.warn('The circumference and area conflict. Calculating the paramters based on the circumference.')\n",
    "    def calcRadius(self):\n",
    "        self.calcCircle()\n",
    "        return self.radius\n",
    "    def calcCircum(self):\n",
    "        self.calcCircle()\n",
    "        return self.circum\n",
    "    def calcArea(self):\n",
    "        self.calcCircle()\n",
    "        return self.area\n",
    "    \n",
    "    def expand(self, parameter, factor):\n",
    "        try:\n",
    "            factor = float(factor)\n",
    "        except:\n",
    "            raise TypeError('Enter a number for the factor.')\n",
    "        if factor < 0:\n",
    "            factor *= -1\n",
    "            warnings.warn(f'The entered factor was negative. Calculating based on the additive inverse, {factor}.')\n",
    "        if parameter == \"r\" or parameter == \"c\" or parameter == \"a\":\n",
    "            if parameter == \"r\":\n",
    "                self.radius *= factor\n",
    "                self.circum = None\n",
    "                self.area = None\n",
    "            elif parameter == \"c\":\n",
    "                self.radius = None\n",
    "                self.circum *= factor\n",
    "                self.area = None\n",
    "            elif parameter == \"a\":\n",
    "                self.radius = None\n",
    "                self.circum = None\n",
    "                self.area *= factor\n",
    "            self.calcCircle()\n",
    "            self.history[getTime()] = [self.radius, self.circum, self.area]\n",
    "        else:\n",
    "            raise TypeError('Enter radius (r), circumference (c), or area (a) for the parameter to expand.')\n",
    "        if self.disp is True:\n",
    "            self.plotCircle()\n",
    "    \n",
    "    def plotCircle(self):\n",
    "        if self.circle != None:\n",
    "            self.circle.remove()\n",
    "        self.circle = plt.Circle(self.pos, self.radius, **self.kwargs)\n",
    "        self.ax.add_patch(self.circle)\n",
    "        print(self.circle.figure)\n",
    "        xlim = np.asarray(self.ax.get_xlim())\n",
    "        ylim = np.asarray(self.ax.get_ylim())\n",
    "#         print(xlim[1])\n",
    "#         print(self.pos[0])\n",
    "#         print(abs(xlim[1] - self.pos[0]))\n",
    "#         print(self.radius)\n",
    "        if xlim[0] >= self.pos[0]-1.5*self.radius:\n",
    "            xlim[0] = self.pos[0]-1.5*self.radius\n",
    "        if xlim[1] <= self.pos[0]+1.5*self.radius:\n",
    "            xlim[1] = self.pos[0]+1.5*self.radius\n",
    "        self.ax.set_xlim(xlim)\n",
    "        if ylim[0] >= self.pos[1]-1.5*self.radius:\n",
    "            ylim[0] = self.pos[1]-1.5*self.radius\n",
    "        if ylim[1] <= self.pos[1]+1.5*self.radius:\n",
    "            ylim[1] = self.pos[1]+1.5*self.radius\n",
    "        self.ax.set_ylim(ylim)\n",
    "#         if abs(xlim[0] - self.pos[0]) <= self.radius:\n",
    "#             xlim[0] = self.pos[0]-1.5*self.radius\n",
    "# #             print('1')\n",
    "#         if abs(xlim[1] - self.pos[0]) >= self.radius:\n",
    "#             xlim[1] = self.pos[0]+1.5*self.radius\n",
    "# #             print('2')\n",
    "        \n",
    "#         if abs(ylim[0] - self.pos[1]) <= self.radius:\n",
    "#             ylim[0] = self.pos[1]-1.5*self.radius\n",
    "# #             print('3')\n",
    "#         if abs(ylim[1] - self.pos[1]) >= self.radius:\n",
    "#             ylim[1] = self.pos[1]+1.5*self.radius\n",
    "# #             print('4')\n",
    "        self.ax.set_aspect('equal')\n",
    "        self.hdisplay.update(self.fig)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQMAAAD4CAYAAADo84OlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAaFElEQVR4nO3de5RdZZnn8e9TValKJalQkMqlck/IBQPSIgWIiL24hzQabMRGx9Y1tsTpGVyja9nTzYC9kG7Xau1BemaJYhrFHhctaNsIDrcEGceWWwiSEAJEChPIhZALSci1KlX1zB/Prs4hVCVV55x99rn8PmudVXWu+6299/nVu9/97vc1d0dEpC7rAohIeVAYiAigMBCRhMJARACFgYgkGrIuQK62tjafOXNm1sUQqWrPPvvsDncff/TjZRUGM2fOZOXKlVkXQ6SqmdlrAz2uwwQRARQGIpJQGIgIoDAQkURZNSCKCIADB4Ae4v91M6X4qioMRMrCbuBZ4AXgFWA/YMlzdcBU4BTg/cAc0qjUKwxEMrUZ+AWwgqgRjAFagLac1/QBbwO/BB4GJgJXAB8E6otWEoWBSCZ6gOXAT4ERwBQG/2LXAWOTG8Be4B+B3wCfI8KhcGpAFCm5/cAtwN3AJKCd4f2HbwFmAa8BNwLPF6VUCgORkjoA3Ar8DpgJNOb5OUYESSvwLYoRCAoDkZJx4PvA74FpHGkgLMRoYDzwv4j2h/wpDERK5mngGSIIimk0UcO4g2iLyI/CQKQk3gb+iajaF6NGcLTxRI3jsbw/QWEgUhJPAYeAUSl9fn8bwi+Aw3l9gsJAJHW9wIO8s+9AGpqJ044v5vVuhYFI6l4D9hDH9mkbRfQ/GL7Uw8DMFprZOjPrNLO/Snt5IuWnsFb+4TmBOG05/PlQUg0DM6sHbgMuBxYAnzSzBWkuU6T8rANGlmhZjURj5dvDfmfaNYOzgU53/727dxNdrhanvEyRMrON0oWBEb0Z9w77nWmHwRRgY879Tclj/87MlpjZSjNbuX379pSLI5KFXkrbPOfJMocn7RIOdEL1HQcz7r7U3TvcvWP8+HcN2CpSBUaQz5ezMMO/BjHtMNjEO7tbTQW2pLxMkTIzFThYomU5ccnzicN+Z9ph8Aww18xmmVkjcA1wf8rLFCkzc4HuEi3rINEbcfidm1Idz8Dde8zsOuARolXjB+6+Ns1lipSfKcR/bCedrsi5dgPn5vXO1Ac3cfcHie5XIjVqCnG0vIe45DgtTtRAPpTXu9UDUSR1Biwi/munaS8xUMqcvN6tMBApifcTx/K7Uvp8B3YAV5HvoYjCQKQkmoAlRBikcZpxM/AB4My8P0FhIFIyc4GPEBcu9RXxc3cSoyr/BwppoFQYiJTUHwMfBjZQnBrCduIQ4S+Ii5Typ6HSRUqqHviPRD+Ah4kxDsYe8x0D6yX69I0HvgRMLrhkCgORkqsHPgW8D1hK1BLGM7TxDnqJC5+6gMuAK4lBTQqnMBDJzALg68CTRFec15LHxxDBUEccAnQB+4g+BHVEp6KLibkTikdhIJKp0cQX+wKgE1hPjH/wOke+/CcCZwEnA/MptG1gMAoDkbJQT3zR5wMLMymBziaICKAwEJGEwkBEAIWBiCQUBiICKAxEJKEwEBFAYSAiCYWBiAAphoGZ/b2ZvWxmz5vZvWaW5uBvIlKgNGsGy4HT3P10YibI61NclogUKLUwcPdl7t6T3H2KmElCRMpUqdoMPgc8NNATmmtRpDwUdNWimT0KTBrgqRvc/b7kNTcAPcBdA32Guy8lRnigo6Nj+JPKi0hRFBQG7n7xsZ43s88CVwAXubu+6CJlLLXxDMxsIfCXwB+6+4G0liMixZFmm8G3gRZguZmtMrPbU1yWiBQotZqBu+c3x5OIZEI9EEUEUBiISEJhICKAwkBEEgoDEQEUBiKSUBiICKAwEJGEwkBEAIWBiCQUBiICKAxEJKEwEBFAYSAiCYWBiAAKAxFJKAxEBFAYiEhCYSAiQAnCwMy+YmZuZm1pL0tE8pdqGJjZNOAS4PU0lyMihUu7ZnAr8N8ATaAiUubSnETlo8Bmd19tZmktpjYdPAhvvAE7dsDu3bB9e/z+1ltx6+6Gvj7o7YX6eqirg8ZGOOmkuLW1wfjx0Noav7e3Q3Nz1n+VZCy1uRaB/w5cOoTPWAIsAZg+fXohxalOfX2wcSO8/jq88gqsWwfbtoEZ9M9Y19gYt6YmaGmJAMgNYPcIhv37IyxefDECA458zoQJMH8+zJ0L06fDtGkRIlIzLI0pEM3svcAvgf5p1aYCW4Cz3X3rYO/r6OjwlStXFr08FaerCzo74be/haefhgMH4gs7ciSMGQOjRr3zy14o91jGvn1w6FA8NmYMfOADcMYZcPLJETRSFczsWXfvOPrxVA4T3H0NMCFn4RuADnffkcbyqkJfX/zXf+wxWLUKenqgoQHGjYuqfJrMYPTouPU7dAh+9Sv45S+jpnHGGXDhhTBvnmoMVSq1NgMZor174Zln4MEH47i/uRkmTowgyNLIkTBlSvze0wNr1sCKFRFMf/RHcNZZUXuQqpHKYUK+auowYdu2CIB/+7eoFYwbVxlfrn37YOfOqC2cfz4sWhSNkVIxSnqYIMewezc89BAsXx5fqPb27GsBwzFmTNx6eiLIfv1ruOQSuPxyOOGErEsnBaigvbDCHTgAjz4Kv/hFtOxPnlxZIXC0hgaYOjVCYfnyaFtYvDjaFUaNyrp0kocK3hsrhDusXg3f/35Usdvb4zRgtWhoiNOQXV3ws5/BsmXwZ38Gp59e3DMekjo1C6dp71644w741rciAGbMqK4gyNXUFH/fiBFwyy1Hwk8qhmoGacitDRw4ADNn1s7puJaWOEX55JOxDj7/edUSKkSN7KEldPgw3HXXkdpALfbkq6uLv7uxMWoJ//zPsV6krKlmUExvvw3f/W50950xI84W1LKWlmhMXLYMtmyBL3wBxo7NulQyiBr7l5WijRvha1+LbsQzZyoI+tXXx/pYtw5uvhk2bcq6RDIIhUExrF4dO3p3d/Ta0/HxO5nFachDhyIwn38+6xLJABQGhXr66WgfaG2NXoQyuLa2WE+33BJdsKWsKAwK8fjjcNttMGnSOy/ykcGNHh3r69vfjjMOUjYUBvl68kn43veiJ6EGBhme5ubofHX77XHxk5QFhUE+fvvb2JHb2+PqPhm+kSOjhnDbbfDcc1mXRlAYDN9rr8UOPHGiagSF6r9c+7bbYiQnyZTCYDh274Zbb43jXl2MUxyjRkUo/MM/wJ49WZempikMhqq7O/6DHTgQg4pK8YwbF9cxfOc76qmYIYXBULhHl9rf/S7aCaT42tvh5ZdjPZfRgDu1RGEwFCtWxNiEM2aoQ1FazGL9Pvoo1MpoV2VGYXA8u3fDD38YDV21dsFRqdXVxRmGO+9U+0EG0p5e7Ytmts7M1prZN9NcVirc4Uc/itF81KmoNEaPjvaZu+7S4UKJpTmj0gXAYuB0d+8yswnHe0/ZWbEius3OmpV1SWrLlCnw1FMxAvNZZ2VdmpqRZs3gz4G/c/cuAHffluKyim/PniOHB2onKC2zWO933hmXhUtJpBkG84DzzexpM/t/ZlZZEf/QQ1Fd1eFBNkaPjqscH3kk65LUjDTnWmwATgQ+AJwF/MTMZvtREzWU5VyL27fHiL86jZit9vYI5QsuSH9WKSmsZuDuF7v7aQPc7gM2Af/qYQXQB7xri7r7UnfvcPeO8eUyGcd990XLdiUPZV4NRoyI7XD//VmXpCakeZjwc+BCADObBzQC5T/X4qZN8JvfxCkuyV57e0zUsnlz1iWpemmGwQ+A2Wb2AnA38NmjDxHK0r33xrDfGrasPNTXx/a4776sS1L1UqsHu3s38Om0Pj8V27fH5cnTpmVdEsk1cWKc4t25U6NJpUhd6nI98USc1lJPw/JSVxfb5Yknsi5JVdNe36+7O05jTai8vlE1YcKE2D66qjE1CoN+zz8flydr5KLyNHJkXOb8wgtZl6RqKQz6PfywJvgody0tsZ0kFQoDiCsTX30VTjwx65LIsZx0UowpoS7KqVAYQAyqAboGodz1b59167ItR5VSGEBMhKIxDStDc3NsLyk6hcGhQ7BmjcY1rBQnnQSrVkFXV9YlqToKg1dfhb4+9TisFA0N0Nsb202KSmHQ2am2gkpjpjBIgcLgpZfilJVUjpaWI42+UjS1HQZ9fbB+PYwZk3VJZDjGjDlyeCdFU9thsGNHDHaqcQsqy4gR0X18586sS1JVajsMtmzRCLyV7I03si5BVVEYSGVyVxgUWW2HwbZtMXCGVJ6mpth+UjS1HQY7dkBjY9alkHw0Nsb2k6Kp7TB46y2FQaVqbIztJ0VT22Gwa5cOEypVU5PCoMhSCwMze5+ZPWVmq8xspZmdnday8tLdDQcPqhtypWpoiMFoenqyLknVSLNm8E3ga+7+PuCvk/vl4/DhI2PrSeUxi1t3d9YlqRpphoED/UMHnQCU13k89V6rDtqORZNm17svAY+Y2f8gQueDKS5r+LQTVQdtx6JJc67Fi4Avu/vPzOwTwPeBiwf4jGzmWtThQXXQsPZFU1AYuPu7vtz9zOx/A/81uftT4I5BPmMpsBSgo6OjdH2DtRNVPndtxyJKc01uAf4w+f1C4JUUlzV8DQ26LqHSuesisyJKc01eC/xPM2sADpEcCpSNpqYjo+bo9GLl6emJbThiRNYlqRppzrX4G+DMtD6/YGbQ2hqnppqbsy6NDFd3dwxtr7afoqntA65x43SeulJ1d2sQ2yKr7TBoa9Mou5Wqqyu2nxSNwkA1g8rU3Q3jx2ddiqpS22EwebI6rVSqvj6YNFAXF8lXbYdBe3vWJZB81dVFmEvR1HYYTJoUrdGqHVSW3t7YbhMnZl2SqlLbYTBiBEyZAvv3Z10SGY79+2HaNHU4KrLaDgOAU06BvXuzLoUMx969MH9+1qWoOgqDefN0RqHS9PTA3LlZl6LqKAzmzo3jT12nUBn623cUBkWnMDjhBJg1C/bsybokMhRvvw1z5sDYscd/rQyLwgDggx9UGFSKPXvg3HOzLkVVUhgALFiQdQlkKPoP5bS9UqEwgOh8NG6cTjGWu/37owuy+hekQmEA0YB42WWaoafc7dwJCxfqsuWUKAz6nXNOdHHVOPzlqacnts9ZZ2VdkqqlMOg3dmw0JGoyz/L05pvwoQ9BS0vWJalaCoNcF1wQHZDU56C8uMekNxdckHVJqprCINesWTB9OuzenXVJJNeuXTBjRtwkNQqDXGbw8Y9HGKh2UB7co2/B1Ver4TBlBYWBmV1tZmvNrM/MOo567noz6zSzdWZ2WWHFLKH3vje6uu7cmXVJBOIMz/z5cOqpWZek6hVaM3gB+GPg17kPmtkC4BrgVGAh8B0zq4zxyM3gT/4kroxT7SBb7rBvH3ziE6oVlEBBYeDuL7n7ugGeWgzc7e5d7r4e6ATKa0r2Y5kzB844I1qwJTtbt8KZZ8LJJ2ddkpqQVpvBFGBjzv1NyWPvYmZLzGylma3cvn17SsUZpv62g0OHohVbSu/w4Tizc9VVqhWUyHHDwMweNbMXBrgtPtbbBnhswDq3uy919w537xhfTqPdTp0KH/0obN6cdUlq0+bNsHhxjEQlJXHccaOONbnqMWwCpuXcn0rMvVhZrrgCVq6MxsRx47IuTe3YsSPCeNGirEtSU9I6TLgfuMbMmsxsFjAXWJHSstLT2AjXXhuNiTpcKI3Dh6PR8NprY/1LyRR6avFjZrYJOBd4wMweAXD3tcBPgBeBh4H/4u69hRY2E7NmxeHCpk1Zl6T6ucfhwZVXqoNRBgoaXtbd7wXuHeS5rwNfL+Tzy8YVV8CaNbBli+ZaSNPWrXHmQIcHmVAPxKFobIQvfjF+qqtyOnbtgpEj4brrdHiQEYXBUJ10Enz5yzEG38GDWZemuhw8GO0yX/pSTLMumVAYDMfs2fD5z8fhgsY9KI6eHnjjDfjCF6J9RjKjMBiuc8+NBsXXXotpviR/vb2xHq+8Es6unA6q1UphMFxm0Svu0ktjR9Y8jfnp64v1t3BhhIF6GWZOYZCPujr41KdisI0NGxQIw9XbC+vXw0UXwSc/GetTMqetkK/6evjMZ+Dii2PH1iHD0PT2RoBedhn86Z8qCMqIprEtRH09fPrT0NQEDzwAkyfH6TEZ2KFD0fj6kY/EhWAKgrKiMChUXV1cb9/eDnfeCa2tMWWbvNPu3TFi0ZIlcN55aiMoQ4rmYjCDD38Ybrgh+tZv3Zp1icrL1q1xeHDjjTHCsYKgLCkMimnOHLjpppjxZ8MG9UXo6Yn1MGlSrBcNUlLWFAbF1tYG118fDWSvvx7dbGvRrl2wcSNcfnmsD10CXvYUBmkYOTJOmd14Y/Szr6UOSj098fc2NcFXvxrjSTY1ZV0qGQI1IKZp3jy4+Wb4+c/h4YdhzJioOVTjMbM7bN8ek6MuWhSjFOnMSkVRGKStuTlqCeecA3ffDevWxRmHarogZ9euOFtwyilRE5g9O+sSSR4UBqUye3YcO69dCz/+cXRUamur7LkD9+49MkTZkiWwYEF11npqhMKglMzgtNPi0OHZZ+Gee6K1fdSoCIZK6ITT1xcBcOBAlPm66+D9748OWFLRFAZZqK+Pq/TOPBNefhmWLYPVq+PxCRPKs8Ht0KGYodod/uAP4kKt+fMVAlVEYZCl+vqYNuzUU+OL9vjjsHx5fPHq6mJAlebmbKre7vHff9euqA00N8el2+edB+U0pL0UTUFhYGZXAzcB7wHOdveVyeOXAH8HNALdwF+4+2OFFbXKTZgAH/tY9Ntfvz7GXHziieirADB6dLQvpFVrcI9JS/bujTMCEH0DFi2C00+HmTOhQf87qlmhW7d/rsXvHfX4DuAj7r7FzE4DHmGQGZXkKA0NMfHr3LkRDlu3wosvRsNjZ2fcr6uL/9ajRkU/hqam+DmUNoe+vvjSd3XFzwMHoubhHmEzb160a7znPdFzUA2CNaPQ0ZFfArCjdhh3fy7n7lpgpJk1uXtXIcurOWZxAVR7e1z73z89+RtvRO++9etjgpe33opGvb6+eE/u9nA/8mV3j8BobY2q/rhxcZZj6tS44nLsWH35a1gp6n1XAc8NFgRmtgRYAjB9+vQSFKeCmcUXubU1/nPncj8ysGhPTwRDX198+evqosbR0pJdG4SUveOGgZk9Ckwa4Kkb3P2+47z3VOAbwKWDvcbdlwJLATo6OjQHer7M4rBh1KisSyIVKq25FjGzqcQEK59x91fz+QwRKZ1UermYWSvwAHC9uz+exjJEpLhSmWsRuA6YA3zVzFYltwkFllVEUpTKXIvu/rfA3xby2SJSWhXQGV5ESkFhICKAwkBEEgoDEQEUBiKSUBiICKAwEJGEwkBEAIWBiCQUBiICKAxEJKEwEBFAYSAiCYWBiAAKAxFJKAxEBFAYiEhCYSAigMJARBKFDoh6tZmtNbM+M+sY4PnpZrbPzL5SyHJEJH2F1gz651r89SDP3wo8VOAyRKQEUplrMXnsSuD3wP5CliEipZHKXItmNhr4S+AS4JiHCLlzLQL7zGxdkYvTRswKXQ7KqSxQXuVRWQaWRllmDPRgWnMtfg241d33DVRryJU712IazGylu7+rPSML5VQWKK/yqCwDK2VZ0ppr8Rzg42b2TaAV6DOzQ+7+7Tw+S0RKIJXDBHc/v/93M7sJ2KcgEClvac21WE5SOwTJQzmVBcqrPCrLwEpWFnP3Ui1LRMqYeiCKCKAwEJFEVYTBYN2izewSM3vWzNYkPy8c5P03mdlmM1uV3BYVuyzJc9ebWaeZrTOzywZ5/ywze9rMXjGze8ysMd+yHPW59+T8fRvMbNUgr9uQrK9VZrayGMseZDlDWudmtjBZX51m9lcpleXvzexlM3vezO41s9ZBXpfKujne32hmTcn260z2jZnFWvY7uHvF34D3APOBXwEdOY+fAUxOfj8N2DzI+28CvpJyWRYAq4EmYBbwKlA/wPt/AlyT/H478OcprK9bgL8e5LkNQFsJttlx1zlQn6yn2UBjsv4WpFCWS4GG5PdvAN8o1boZyt8I/Gfg9uT3a4B70tgmVVEzcPeX3P1dPRfd/Tl335LcXQuMNLOmLMoCLAbudvcud18PdAJn577AoofWhcC/JA/9E3BlMcuXLOMTwI+L+bkpORvodPffu3s3cDexHovK3Ze5e09y9ylgarGXcQxD+RsXE/sCxL5xkR2vN18eqiIMhugq4Dl37xrk+euSauIPzOzEFJY/BdiYc39T8liuccDunB1zoNcU6nzgTXd/ZZDnHViWHFYtGeQ1xXK8dT6UdVZsn2Pwi+vSWDdD+Rv//TXJvrGH2FeKKpVOR2nIs1t0/3tPJap/lw7yku8Cf0Ns7L8hqtGfK3JZBkryo8/rDuU1gxpiuT7JsWsF57n7FjObACw3s5fdfbCrUvMuD0Nb5wWtj6GWpX/dmNkNQA9w1yAfU7R1k1u0AR4r6n4xVBUTBp5ft2jMbCpwL/AZd391kM9+M+f1/wj8nxTKsgmYlnN/KrDlqNfsAFrNrCH5DzDQa/Iul5k1EJecn3mMz9iS/NxmZvcS1di8dvihrqdjrPOhrLOilMXMPgtcAVzkycH5AJ9RtHWTYyh/Y/9rNiXb8ATgrQKX+y5VfZiQtAo/AFzv7o8f43XtOXc/RozTUGz3A9ckLcOzgLnAitwXJDvh/wU+njz0WeCYtZ5huhh42d03DfSkmY02s5b+34maVBrrYqjr/BlgbnKGpZFoPLs/hbIsJK6y/ai7HxjkNWmtm6H8jfcT+wLEvvHYYIFVkDRaJUt9I3amTUAX8CbwSPL4jcR4CqtybhOS5+4gae0HfgSsAZ5PVnx7scuSPHcD0XK8Drg85/EHOXLWYzYREp3AT4GmIq6nHwL/6ajHJgMP5ix7dXJbS1Sh09pmA67z3PIk9xcBv0vWWyrlSdb1xpx95Pajy5LmuhnobwRuJsIJYGSyL3Qm+8bsNNaDuiOLCFDlhwkiMnQKAxEBFAYiklAYiAigMBCRhMJARACFgYgk/j9TBhmsMtf/1gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Figure(432x288)\n"
     ]
    }
   ],
   "source": [
    "c = Circle(radius=1, disp=True, color='yellow',alpha=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Figure(432x288)\n"
     ]
    }
   ],
   "source": [
    "c.expand('r',8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Figure(432x288)\n"
     ]
    }
   ],
   "source": [
    "c2 = Circle(radius=4,fig=c.fig,ax=c.ax,hdisplay=c.hdisplay,disp=True,color='red',pos=(-8,-8),alpha=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Figure(432x288)\n"
     ]
    }
   ],
   "source": [
    "c2.expand('r',16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task: Visualize Binary Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "class BinaryTree:\n",
    "    def __init__(self, root=None,ax=None,fig=None,hdisplay=None):\n",
    "        self.root = root\n",
    "        self.ax = ax\n",
    "        self.fig = fig\n",
    "        self.hdisplay = hdisplay\n",
    "    def findParent(self, x, foundParent=None):\n",
    "        if foundParent == None:\n",
    "            foundParent = self.root\n",
    "        if foundParent.hasRight() and x > foundParent.data:\n",
    "            return self.findParent(x, foundParent.rightChild)\n",
    "        if foundParent.hasLeft() and x < foundParent.data:\n",
    "            return self.findParent(x, foundParent.leftChild)\n",
    "        return foundParent\n",
    "    def newNode(self, x):\n",
    "        newParent = self.findParent(x)\n",
    "        if x > newParent.data:\n",
    "            return newParent.setRight(x)\n",
    "        if x < newParent.data:\n",
    "            return newParent.setLeft(x)\n",
    "    def setHeight(self, height):\n",
    "        self.height = height     \n",
    "        \n",
    "\n",
    "class BinaryTreeNode:\n",
    "    def __init__(self, data=None, parent=None, leftChild=None, rightChild=None, disp=False,ax=None,\n",
    "                 fig=None,hdisplay=None,pos=(0,0),width=500,**kwargs):\n",
    "        self.data = data\n",
    "        self.parent = parent\n",
    "        self.leftChild = leftChild\n",
    "        self.rightChild = rightChild\n",
    "        self.width = width\n",
    "        if self.parent == None:\n",
    "            self.depth = 0\n",
    "            self.tree = BinaryTree(root=self,ax=ax,fig=fig,hdisplay=hdisplay)\n",
    "            self.tree.setHeight(0)\n",
    "            self.tree.numNodes = 1\n",
    "        else:\n",
    "            self.depth = parent.depth + 1\n",
    "            self.tree = parent.tree\n",
    "            if self.depth > self.tree.height:\n",
    "                self.tree.setHeight(self.depth)\n",
    "            self.tree.numNodes += 1\n",
    "            \n",
    "        self.disp = disp\n",
    "        self.pos = pos\n",
    "        self.kwargs = kwargs\n",
    "        self.ax = ax\n",
    "        self.fig = fig\n",
    "        self.hdisplay = hdisplay\n",
    "        \n",
    "        self.isDisp = False\n",
    "        if self.disp:\n",
    "            self.makeFig()\n",
    "            self.plotTree()\n",
    "        \n",
    "    def makeFig(self):\n",
    "        if self.tree.fig == None:\n",
    "            if self.fig==None and self.ax==None and self.hdisplay==None:\n",
    "                # Initialize new figure\n",
    "                fig = plt.figure(figsize=(16,10))\n",
    "                ax = plt.gca()\n",
    "                hdisplay = display.display(\"\", display_id=True)\n",
    "                plt.close()\n",
    "            elif self.fig==None or self.ax==None or self.hdisplay==None:\n",
    "                #Raise an error here\n",
    "                raise TypeError('Must pass in all fig, ax, hdisplay or none.')\n",
    "            self.ax = ax\n",
    "            self.fig = fig\n",
    "            self.hdisplay = hdisplay\n",
    "            self.tree.ax = ax\n",
    "            self.tree.fig = fig\n",
    "            self.tree.hdisplay = hdisplay\n",
    "#             print('it got here')\n",
    "        else:\n",
    "            self.ax = self.tree.ax\n",
    "            self.fig = self.tree.fig\n",
    "            self.hdisplay = self.tree.hdisplay\n",
    "#             print('now it got here')\n",
    "    \n",
    "    def setLeft(self, childData):\n",
    "        newpos = (self.pos[0]-self.width/(2**(self.depth+1)),self.pos[1]-10)\n",
    "        self.leftChild = BinaryTreeNode(data=childData, parent=self, pos=newpos, width=self.width, disp=self.disp,ax=self.ax,\n",
    "                 fig=self.fig,hdisplay=self.hdisplay, **self.kwargs)\n",
    "        return self.leftChild\n",
    "    def setRight(self,childData):\n",
    "        newpos = (self.pos[0]+self.width/(2**(self.depth+1)),self.pos[1]-10)\n",
    "        self.rightChild = BinaryTreeNode(data=childData, parent=self, pos=newpos, width=self.width, disp=self.disp,ax=self.ax,\n",
    "                 fig=self.fig,hdisplay=self.hdisplay, **self.kwargs)\n",
    "        return self.rightChild\n",
    "    def children(self):\n",
    "        childList = []\n",
    "        if self.hasLeft():\n",
    "            childList.append(self.leftChild)\n",
    "        if self.hasRight():\n",
    "            childList.append(self.rightChild)\n",
    "        return childList\n",
    "    def hasLeft(self):\n",
    "        if self.leftChild == None:\n",
    "            return False\n",
    "        else:\n",
    "            return True\n",
    "    def hasRight(self):\n",
    "        if self.rightChild == None:\n",
    "            return False\n",
    "        else:\n",
    "            return True\n",
    "    def isRoot(self):\n",
    "        if self.parent == None:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    def plotTree(self):\n",
    "        ###### Fill this in\n",
    "        self.makeFig()\n",
    "        if 'colorscheme' not in self.kwargs.keys():\n",
    "            nodecolor='red'\n",
    "        elif self.kwargs['colorscheme'] == 'byrow':\n",
    "            cmap = matplotlib.cm.get_cmap('Spectral')\n",
    "            nodecolor = cmap((self.depth%5)/4)\n",
    "        elif self.kwargs['colorscheme'] == 'byindex':\n",
    "            cmap = matplotlib.cm.get_cmap('Spectral')\n",
    "            nodecolor = cmap(self.kwargs['nodeIndex']/self.tree.numNodes)\n",
    "        self.ax.scatter(self.pos[0],self.pos[1],zorder=1,s=750, color=nodecolor)\n",
    "        self.ax.text(self.pos[0],self.pos[1],math.trunc(self.data),color='black',verticalalignment='center',horizontalalignment='center',fontsize=14)\n",
    "#         if 'whichfirst' not in self.kwargs.keys():\n",
    "#             if not self.isRoot():\n",
    "#                 self.ax.plot([self.parent.pos[0],self.pos[0]],[self.parent.pos[1],self.pos[1]],color='black',zorder=0)\n",
    "#         elif self.kwargs['whichfirst'] == 'child':\n",
    "#             if self.hasRight():\n",
    "#                 self.ax.plot([self.rightChild.pos[0],self.pos[0]],[self.rightChild.pos[1],self.pos[1]],color='black',zorder=0)\n",
    "#             if self.hasLeft():\n",
    "#                 self.ax.plot([self.leftChild.pos[0],self.pos[0]],[self.leftChild.pos[1],self.pos[1]],color='black',zorder=0)\n",
    "        if self.hasRight() and self.rightChild.isDisp == True:\n",
    "                self.ax.plot([self.rightChild.pos[0],self.pos[0]],[self.rightChild.pos[1],self.pos[1]],color='black',zorder=0)\n",
    "        if self.hasLeft() and self.leftChild.isDisp == True:\n",
    "                self.ax.plot([self.leftChild.pos[0],self.pos[0]],[self.leftChild.pos[1],self.pos[1]],color='black',zorder=0)\n",
    "        if not self.isRoot() and self.parent.isDisp == True:\n",
    "                self.ax.plot([self.parent.pos[0],self.pos[0]],[self.parent.pos[1],self.pos[1]],color='black',zorder=0)\n",
    "        self.ax.set_aspect('auto')\n",
    "        self.hdisplay.update(self.fig)\n",
    "        self.isDisp = True\n",
    "\n",
    "def addNodes(tree):\n",
    "    data = None\n",
    "    while data != 'stop':\n",
    "        data = input('New node data: ')\n",
    "        if data=='stop':\n",
    "            break\n",
    "        tree.newNode(float(data))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New node data: 1\n",
      "New node data: 34\n",
      "New node data: 109\n",
      "New node data: -1\n",
      "New node data: -2\n",
      "New node data: -3\n",
      "New node data: -4\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36m_input_request\u001b[0;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[1;32m    884\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 885\u001b[0;31m                 \u001b[0mident\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreply\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msession\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstdin_socket\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    886\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/jupyter_client/session.py\u001b[0m in \u001b[0;36mrecv\u001b[0;34m(self, socket, mode, content, copy)\u001b[0m\n\u001b[1;32m    802\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 803\u001b[0;31m             \u001b[0mmsg_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msocket\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecv_multipart\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    804\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mzmq\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mZMQError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/zmq/sugar/socket.py\u001b[0m in \u001b[0;36mrecv_multipart\u001b[0;34m(self, flags, copy, track)\u001b[0m\n\u001b[1;32m    474\u001b[0m         \"\"\"\n\u001b[0;32m--> 475\u001b[0;31m         \u001b[0mparts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mflags\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrack\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtrack\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    476\u001b[0m         \u001b[0;31m# have first part already, only loop while more to receive\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32mzmq/backend/cython/socket.pyx\u001b[0m in \u001b[0;36mzmq.backend.cython.socket.Socket.recv\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;32mzmq/backend/cython/socket.pyx\u001b[0m in \u001b[0;36mzmq.backend.cython.socket.Socket.recv\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;32mzmq/backend/cython/socket.pyx\u001b[0m in \u001b[0;36mzmq.backend.cython.socket._recv_copy\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/zmq/backend/cython/checkrc.pxd\u001b[0m in \u001b[0;36mzmq.backend.cython.checkrc._check_rc\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: ",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-eaa78af28563>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mroot\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBinaryTreeNode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdisp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolorscheme\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'byrow'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mtree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBinaryTree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mroot\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mroot\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0maddNodes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtree\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-2-963016e82420>\u001b[0m in \u001b[0;36maddNodes\u001b[0;34m(tree)\u001b[0m\n\u001b[1;32m    147\u001b[0m     \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    148\u001b[0m     \u001b[0;32mwhile\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;34m'stop'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 149\u001b[0;31m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'New node data: '\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    150\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;34m'stop'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    151\u001b[0m             \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mraw_input\u001b[0;34m(self, prompt)\u001b[0m\n\u001b[1;32m    858\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_ident\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    859\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_header\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 860\u001b[0;31m             \u001b[0mpassword\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    861\u001b[0m         )\n\u001b[1;32m    862\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36m_input_request\u001b[0;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[1;32m    888\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    889\u001b[0m                 \u001b[0;31m# re-raise KeyboardInterrupt, to truncate traceback\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 890\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    891\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    892\u001b[0m                 \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "root = BinaryTreeNode(float(100), disp=True, colorscheme='byrow')\n",
    "tree = BinaryTree(root=root)\n",
    "addNodes(tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task: Color by Depth\n",
    "\n",
    "Add functionality to plotTree() that will color the nodes based on their depth."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task: Animate tree traversals\n",
    "\n",
    "Add functionality to your traversal methods, BinaryTreeNode and BinaryTree to support animating the traversals. This should mean that nodes are added to the tree plot as they are visited by the traversal code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "class Queue:\n",
    "    \"This is a queue\"\n",
    "    def __init__(self, size = 0, isEmpty = True):\n",
    "        self.size = size\n",
    "        self.isEmpty = isEmpty\n",
    "        self.data = [None]\n",
    "        self.head = 0\n",
    "        self.tail = 0\n",
    "    def enqueue(self, val):\n",
    "        if None not in self.data:\n",
    "            temp = self.data\n",
    "            self.data = [None] * (2 * len(self.data))\n",
    "            start = self.head\n",
    "            for i,_ in enumerate(temp):\n",
    "                self.data[i] = temp[start%len(temp)]\n",
    "                start += 1\n",
    "            self.head = 0\n",
    "            self.tail = len(temp)\n",
    "        elif self.tail > len(self.data)-1:\n",
    "            self.tail = 0\n",
    "        self.data[self.tail] = val\n",
    "        self.tail += 1\n",
    "        self.isEmpty = False\n",
    "        self.size += 1\n",
    "    def dequeue(self):\n",
    "        if not self.isEmpty:\n",
    "            oldHead = self.data[self.head]\n",
    "            self.data[self.head] = None\n",
    "            self.head = (self.head+1)%len(self.data)\n",
    "            if self.data[self.head] == None:\n",
    "                self.isEmpty = True\n",
    "            self.size -= 1\n",
    "            return oldHead\n",
    "        else:\n",
    "            raise Exception(\"There's no objects here to dequeue.\")\n",
    "\n",
    "def preOrder(node, orderedList=[], disp=False):\n",
    "    orderedList.append(node.data)\n",
    "    if disp:\n",
    "        node.kwargs['colorscheme'] = 'byindex'\n",
    "        node.kwargs['nodeIndex'] = len(orderedList)-1\n",
    "        node.plotTree()\n",
    "    if node.hasLeft():\n",
    "        preOrder(node.leftChild, orderedList, disp=disp)\n",
    "    if node.hasRight():\n",
    "        preOrder(node.rightChild, orderedList, disp=disp)\n",
    "    return orderedList\n",
    "\n",
    "def postOrder(node,orderedList=[],disp=False):\n",
    "    if node.hasLeft():\n",
    "        postOrder(node.leftChild,orderedList,disp=disp)\n",
    "    if node.hasRight():\n",
    "        postOrder(node.rightChild,orderedList,disp=disp)\n",
    "    orderedList.append(node.data)\n",
    "    if disp:\n",
    "        node.kwargs['colorscheme'] = 'byindex'\n",
    "        node.kwargs['nodeIndex'] = len(orderedList)-1\n",
    "#         node.kwargs['whichfirst'] = 'child'\n",
    "        node.plotTree()\n",
    "    return orderedList\n",
    "\n",
    "def inOrder(node,orderedList=[],disp=False):\n",
    "    if node.hasLeft():\n",
    "        inOrder(node.leftChild,orderedList,disp=disp)\n",
    "    orderedList.append(node.data)\n",
    "    if disp:\n",
    "        node.kwargs['colorscheme'] = 'byindex'\n",
    "        node.kwargs['nodeIndex'] = len(orderedList)-1\n",
    "#         node.kwargs['whichfirst'] = 'child'\n",
    "        node.plotTree()\n",
    "    if node.hasRight():\n",
    "        inOrder(node.rightChild,orderedList,disp=disp)\n",
    "    return orderedList\n",
    "\n",
    "def bft(root,disp=False):\n",
    "    orderedList = []\n",
    "    q = Queue()\n",
    "    q.enqueue(root)\n",
    "    while not q.isEmpty:\n",
    "        node = q.dequeue()\n",
    "        orderedList.append(node.data)\n",
    "        if disp:\n",
    "            node.kwargs['colorscheme'] = 'byindex'\n",
    "            node.kwargs['nodeIndex'] = len(orderedList)-1\n",
    "            node.plotTree()\n",
    "        if node.hasLeft() or node.hasRight():\n",
    "            for x in node.children():\n",
    "                q.enqueue(x)\n",
    "    return orderedList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[89.23747276688454,\n",
       " 94.81481481481482,\n",
       " 100.74074074074075,\n",
       " 106.66666666666667,\n",
       " 112.94117647058823,\n",
       " 120.0,\n",
       " 127.5,\n",
       " 133.33333333333334,\n",
       " 139.43355119825708,\n",
       " 148.14814814814815,\n",
       " 157.40740740740742,\n",
       " 166.66666666666669,\n",
       " 176.47058823529414,\n",
       " 187.50000000000003,\n",
       " 199.21875000000003,\n",
       " 200,\n",
       " 200.7843137254902,\n",
       " 213.33333333333334,\n",
       " 226.66666666666669,\n",
       " 240.0,\n",
       " 254.11764705882354,\n",
       " 270.0,\n",
       " 286.875,\n",
       " 300.0,\n",
       " 313.7254901960784,\n",
       " 333.3333333333333,\n",
       " 354.16666666666663,\n",
       " 375.0,\n",
       " 397.05882352941177,\n",
       " 421.875,\n",
       " 448.2421875]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def addRight(node):\n",
    "    val = node.data*(1+((1/2)**(node.depth+1)))\n",
    "#     print(node.depth)\n",
    "    right = node.setRight(val)\n",
    "    return right\n",
    "def addLeft(node):\n",
    "    val = node.data/(1+((1/2)**(node.depth+1)))\n",
    "#     print(node.depth)\n",
    "    left = node.setLeft(val)\n",
    "    return left\n",
    "def populateCompleteTree(rootVal,nNodes):\n",
    "    root = BinaryTreeNode(rootVal)\n",
    "    tree = root.tree\n",
    "    #Write code to populate a binary complete tree with nNodes number of nodes.\n",
    "    leaves = [root]\n",
    "    while root.tree.numNodes < nNodes:\n",
    "        node = leaves.pop(0)\n",
    "        right = addRight(node)\n",
    "        left = addLeft(node)\n",
    "        leaves.append(right)\n",
    "        leaves.append(left)\n",
    "    return root, tree\n",
    "\n",
    "root, tree = populateCompleteTree(200,31)\n",
    "inOrder(root,disp=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def addCompleteTree(rootVal,nNodes):\n",
    "    root = BinaryTreeNode(rootVal)\n",
    "    tree = root.tree\n",
    "    root.plotTree()\n",
    "    #Write code to populate a binary complete tree with nNodes number of nodes.\n",
    "    leaves = [root]\n",
    "    while root.tree.numNodes < nNodes:\n",
    "        node = leaves.pop(0)\n",
    "        left = addLeft(node)\n",
    "        left.plotTree()\n",
    "        right = addRight(node)\n",
    "        right.plotTree()\n",
    "        leaves.append(left)\n",
    "        leaves.append(right)\n",
    "    return root, tree\n",
    "\n",
    "root,tree = addCompleteTree(500,31)"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}