folyam_en.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "# from sage.graphs.graph_plot import GraphPlot\n",
    "# from shapely.geometry import LineString\n",
    "from copy import deepcopy\n",
    "#from networkx.drawing.nx_pydot import graphviz_layout\n",
    "from networkx.drawing.nx_agraph import graphviz_layout\n",
    "from ipywidgets import HBox,VBox\n",
    "from ipywidgets.widgets import IntSlider,Textarea,Label,interactive,Button, Dropdown\n",
    "from matplotlib.ticker import AutoMinorLocator\n",
    "from networkx.drawing.nx_agraph import graphviz_layout\n",
    "from IPython.display import HTML\n",
    "\n",
    "from matplotlib.patches import ConnectionStyle\n",
    "\n",
    "from shutil import rmtree\n",
    "import os\n",
    "from IPython.display import display, FileLink"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    " if (code_show){\n",
    " $('div.input').hide();\n",
    " } else {\n",
    " $('div.input').show();\n",
    " }`\n",
    " code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "The raw code for this IPython notebook is by default hidden for easier reading.\n",
    "To toggle on/off the raw code, click <a href=\"javascript:code_toggle()\">here</a>.''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "algoritmus=[u'The current flow. Create the Temporary Graph!',\n",
    "           u'Is there a directed path in the Temporary Graph from S to T?',\n",
    "           u'\\t There is an augmenting path! Augment and go back to the start',\n",
    "           u'\\t There is NO augmenting path! Calculate the reachable vertices from S!',\n",
    "           u'Calculate the size of the cut!']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_all(index):\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "graph_select=Dropdown(\n",
    "    options=[('ZH_2018/5',0)('Szabad',1)],\n",
    "    value=0,\n",
    "    description='Gráfválasztás:',\n",
    "    layout={'width': 'max-content'},\n",
    "    style={'description_width': 'initial'}\n",
    ")\n",
    "\n",
    "pelda_grafok={0:'S:A5,B2,C6,E9\\n'\n",
    "              1:''}\n",
    "def trig(b):\n",
    "    input_graph.value=pelda_grafok[graph_select.value]\n",
    "graph_select.observe(trig ,names='value')\n",
    "graph_select"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# d_inc={'S':{'A':{'cap':5},'B':{'cap':2},'C':{'cap':6},'E':{'cap':9}},\n",
    "#        'A':{'B':{'cap':5},'T':{'cap':4}},\n",
    "#        'B':{'T':{'cap':10},'E':{'cap':2}},\n",
    "#        'C':{'B':{'cap':3},'D':{'cap':3}},\n",
    "#        'D':{'T':{'cap':5}},\n",
    "#        'E':{'D':{'cap':6},'T':{'cap':2}}}\n",
    "# G=nx.DiGraph(d_inc)\n",
    "# print(G.nodes())\n",
    "# G.get_edge_data('S','A')\n",
    "# forras='S'\n",
    "# nyelo='T'\n",
    "# pos_G=nx.spring_layout(G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flow_value(f):\n",
    "    return sum([f[(forras,u)] for u in G.neighbors(forras)])\n",
    "def cut_value(X):\n",
    "    return sum([G.get_edge_data(*e)['cap'] for e in G.edges if (e[0] in X) and (e[1] not in X)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0cd0c4bcce0d4c68bc6137070f0ea441",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Graph picker:', layout=Layout(width='max-content'), options=(('Jegyzet 2.14', 0), ('Gy9/…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph_select=Dropdown(\n",
    "    options=[('Jegyzet 2.14', 0), ('Gy9/2',1),('Gy9/4',2),('Gy9/6',3),('Empty',4)],\n",
    "    value=0,\n",
    "    description='Graph picker:',\n",
    "    layout={'width': 'max-content'},\n",
    "    style={'description_width': 'initial'}\n",
    ")\n",
    "pelda_grafok={0:['S:A5,B2,C6,E9\\nA:B5,T4\\nB:T10,E2\\nC:B3,D3\\nD:T5\\nE:D6,T2',{'S':(0,0),'A':(1,6),'B':(3,5),'C':(2,1.5),'D':(4,1.5),'E':(6,0),'T':(5,6)}],\n",
    "              1:['S:A7,D2\\nA:B2,F5\\nB:C5,F2\\nC:T6\\nD:A4,E5\\nE:A3,B3,F3\\nF:C1,T3',{'S':(0,1),'A':(1,1),'B':(2,1),'C':(3,1),'D':(0,0),'E':(1,0),'F':(2,0), 'T':(3,0)}],\n",
    "              2:['S:a11,d13,e4\\na:b6,f7\\nb:c9\\nc:T14\\nd:c2,e7\\ne:b4,f5\\nf:T13',{'S':(0,0),'a':(1,1),'b':(2,1),'c':(3,1),'d':(1,-1),'e':(2,-1),'f':(3,-1),'T':(4,0)}],\n",
    "              3:['S:A15,B6,C3,F2\\nA:D2,G9\\nB:D3,C11\\nC:F7,E9\\nD:T5\\nE:T21,D3\\nF:E7,G4\\nG:E4',{'S':(0,4),'A':(4,4),'F':(0,0),'G':(4,0),'T':(2,2),'B':(2,3.5),'C':(0.5,2),'D':(3.5,2),'E':(2,0.5)}],\n",
    "              4:['',{}]\n",
    "             }\n",
    "input_graph_pos={}\n",
    "def trig(b):\n",
    "    global input_graph_pos\n",
    "    input_graph.value=pelda_grafok[graph_select.value][0]\n",
    "    input_graph_pos=pelda_grafok[graph_select.value][1]\n",
    "graph_select.observe(trig ,names='value')\n",
    "forras='S'\n",
    "nyelo='T'\n",
    "\n",
    "graph_select\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_graph = Label(\"Graph adjacency list+ Weights.\\n Example:\\n\\tA:B1,C2,D5\")\n",
    "input_graph = Textarea(value=pelda_grafok[graph_select.value][0],layout={'height': '55mm'})\n",
    "input_graph_pos=pelda_grafok[graph_select.value][1]\n",
    "#input_graph = Textarea(value='S:A5,B2,C6,E9\\nA:B5,T4\\nB:T10,E2\\nC:B3,D3\\nD:T5\\nE:D6,T2',layout={'height': '55mm'})\n",
    "\n",
    "label_fonat = Label(\"Augmenting pathes.\\n Example line: S,A,B,T:1\")\n",
    "input_fonat = Textarea(layout={'height': '55mm'})\n",
    "\n",
    "input_display = HBox([VBox([label_graph,input_graph]),VBox([label_fonat,input_fonat])])\n",
    "\n",
    "def textarea_reader(input_text,mode=\"fonat\"):\n",
    "    if mode==\"fonat\":\n",
    "        if len(input_text)==0:\n",
    "            return {}\n",
    "        edgelist = []\n",
    "        split = input_text.split(\"\\n\")\n",
    "        for line in split:\n",
    "            if len(line.split(':'))<2:\n",
    "                print(\"Pay attention! Empty/long lines, colon?\")\n",
    "                #print(\"Figyelj a bemenetre! Üres/hosszú sorok, kettospont?\")\n",
    "                return\n",
    "            else:\n",
    "                a,k = line.split(\":\")\n",
    "                #print(k)\n",
    "                try:\n",
    "                    k=int(k)\n",
    "                    L=a.split(',')\n",
    "                    edgelist+=[(L[i],L[i+1],k) for i in range(len(L)-1)]\n",
    "                except:\n",
    "                    print(\"Only integer is used for augmenting!\")\n",
    "                    #print(\"Egesz szammal novelunk csak\")\n",
    "                    return\n",
    "        sf={(e[0],e[1]):0 for e in edgelist}\n",
    "        for e in edgelist:\n",
    "            sf[(e[0],e[1])]+=e[2]\n",
    "        return sf\n",
    "    if mode==\"graph\":\n",
    "        if len(input_text)<4:\n",
    "            print(\"Empty/short input!\")\n",
    "            #print(\"Üres/rövid bemenet!\")\n",
    "            return\n",
    "        d_inc = {}\n",
    "        split = input_text.split(\"\\n\")\n",
    "        for elem in split:\n",
    "            if \":\" not in elem:\n",
    "                print(\"Too short/empty line, is there colon?\")\n",
    "                #print(\"Túl rövid/üres sor, van kettőspont?\")\n",
    "                return\n",
    "            a,b_dict = elem.split(\":\")\n",
    "            if b_dict==\"\":\n",
    "                b_dict={}\n",
    "                d_inc[a]=b_dict\n",
    "            else:\n",
    "                try:\n",
    "                    #b_list = [int(e) for e in b_list.split(\",\")]\n",
    "                    b_dict = {e[0]:{'cap':int(e[1:])} for e in b_dict.split(\",\")}\n",
    "                    d_inc[a]=b_dict\n",
    "                except:\n",
    "                    print(\"Bad format!\")\n",
    "                    #print(\"Rossz formátum!\")\n",
    "                    return\n",
    "        return d_inc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_globals():\n",
    "    \n",
    "    d_inc = textarea_reader(input_graph.value,mode=\"graph\")\n",
    "#    d_inc={'S':{'A':{'cap':5},'B':{'cap':2},'C':{'cap':6},'E':{'cap':9}},\n",
    "#       'A':{'B':{'cap':5},'T':{'cap':4}},\n",
    "#       'B':{'T':{'cap':10},'E':{'cap':2}},\n",
    "#       'C':{'B':{'cap':3},'D':{'cap':3}},\n",
    "#       'D':{'T':{'cap':5}},\n",
    "#       'E':{'D':{'cap':6},'T':{'cap':2}}}\n",
    "    G=nx.DiGraph(d_inc)\n",
    "    \n",
    "    f_akt={e:0 for e in G.edges()}\n",
    "    sf=textarea_reader(input_fonat.value,mode='fonat')\n",
    "    #print(sf)\n",
    "    for e in sf:\n",
    "        f_akt[e]+=sf[e]\n",
    "    return G, f_akt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "563941297ac641acbe9d2a39ea307c95",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(VBox(children=(Label(value='Graph adjacency list+ Weights.\\n Example:\\n\\tA:B1,C2,D5'), Textarea…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "input_display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pos_G=input_graph_pos\n",
    "G=init_globals()[0]\n",
    "f_akt=init_globals()[1]\n",
    "\n",
    "fig=plt.figure()\n",
    "nx.draw_networkx_edges(G,pos=pos_G)\n",
    "nx.draw_networkx_labels(G,pos=pos_G)\n",
    "nx.draw_networkx_edge_labels(G,pos=pos_G,edge_labels={e:(f_akt[e],G.get_edge_data(*e)['cap']) for e in G.edges()},label_pos=0.6)\n",
    "nx.draw_networkx_nodes(G,pos=pos_G,node_size=400,node_color=\"red\")\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#f_akt={e:0 for e in G.edges()}\n",
    "#print(f_akt)\n",
    "#pos_G={'S':(0,0),'A':(1,6),'B':(3,5),'C':(2,1.5),'D':(4,1.5),'E':(6,0),'T':(5,6)}\n",
    "pos_G=input_graph_pos\n",
    "G=init_globals()[0]\n",
    "f_akt=init_globals()[1]\n",
    "b_found_alternating_path=True\n",
    "counter=0\n",
    "d_movie={}\n",
    "\n",
    "while(b_found_alternating_path):\n",
    "    d_temp={}\n",
    "    #Aktualis flow abrazolasa\n",
    "    d_temp[\"graph\"]=(G,pos_G)\n",
    "    d_temp['flow_value']=flow_value(f_akt)\n",
    "    d_temp['akt_flow']=deepcopy(f_akt)\n",
    "    d_temp[\"code_index\"]=0\n",
    "    d_movie[counter]=d_temp\n",
    "    counter+=1\n",
    "\n",
    "    #temp graf epitese\n",
    "    d_temp=deepcopy(d_temp)\n",
    "    \n",
    "    d_temp_elek=[]\n",
    "    H=nx.DiGraph()\n",
    "    for e in G.edges:\n",
    "        if G.get_edge_data(*e)['cap']>f_akt[e]:\n",
    "            d_temp_elek.append((*e,{'gap':G.get_edge_data(*e)['cap']-f_akt[e],'color':'blue','elore':1,'original':e}))\n",
    "            \n",
    "        if f_akt[e]>0:\n",
    "            d_temp_elek.append((e[1],e[0],{'gap': f_akt[e], 'color':'red','elore':-1,'original':e}))\n",
    "    H.add_edges_from(d_temp_elek)\n",
    "    \n",
    "    d_temp['tempgraph']=(H,pos_G)\n",
    "    d_temp['code_index']=1\n",
    "    d_movie[counter]=d_temp\n",
    "    counter+=1\n",
    "\n",
    "#     \n",
    "    #BFS az forras csucsbol\n",
    "    d_temp=deepcopy(d_temp)\n",
    "    Q=[forras]\n",
    "    volt={u:False for u in H.nodes()}\n",
    "    honnan={u:'*' for u in H.nodes()}\n",
    "    volt[forras]=True\n",
    "    while(len(Q)>0):\n",
    "        akt=Q.pop(0)\n",
    "        \n",
    "        L_new=[v for v in H.neighbors(akt) if volt[v]==False]\n",
    "        Q+=L_new\n",
    "        for u in L_new:\n",
    "            volt[u]=True\n",
    "            honnan[u]=akt\n",
    "    \n",
    "    b_found_alternating_path=(nyelo in [u for u in volt if volt[u]])\n",
    "    \n",
    "    if(b_found_alternating_path):\n",
    "        #Javito ut meghatarozasa es a javitas merteke\n",
    "        L=[]\n",
    "        akt=nyelo\n",
    "        while(akt!='*'):\n",
    "            L.append(akt)\n",
    "            akt=honnan[akt]\n",
    "        L.reverse()\n",
    "        L_edges=[(L[i],L[i+1]) for i in range(len(L)-1)]\n",
    "        \n",
    "        augmenting_size=min([H.get_edge_data(*e)['gap'] for e in L_edges])\n",
    "        \n",
    "\n",
    "        d_temp['augmenting_path']=L_edges\n",
    "        d_temp['augmenting_size']=augmenting_size\n",
    "        d_temp['code_index']=2\n",
    "        d_movie[counter]=d_temp\n",
    "        counter+=1\n",
    "        #Javitas\n",
    "        for e in L_edges:            \n",
    "            f_akt[H.get_edge_data(*e)['original']]+=H.get_edge_data(*e)['elore']*augmenting_size\n",
    "    else:\n",
    "        X=[u for u in H.nodes() if volt[u]]\n",
    "        \n",
    "       \n",
    "        d_temp['cut']=X\n",
    "        d_temp['code_index']=3\n",
    "        d_movie[counter]=d_temp\n",
    "        counter+=1\n",
    "        \n",
    "        \n",
    "        d_temp=deepcopy(d_temp)\n",
    "        d_temp={}\n",
    "        d_temp[\"flow_value\"] = flow_value(f_akt)\n",
    "        d_temp['graph']=(G,pos_G)\n",
    "        d_temp['cut']=X\n",
    "        d_temp['code_index']=4\n",
    "        d_temp[\"akt_flow\"] = deepcopy(f_akt)\n",
    "        d_movie[counter]=d_temp\n",
    "        counter+=1\n",
    "        d_temp=deepcopy(d_temp)\n",
    "        d_temp['cut_value']=cut_value(X)\n",
    "        d_temp['leaving_edges']=[e for e in G.edges if (e[0] in X) and (e[1] not in X)]\n",
    "        d_movie[counter]=d_temp\n",
    "        counter+=1\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_all(index):\n",
    "    fig,ax = plt.subplots(2,2,figsize=(25,14))\n",
    "    plt.subplots_adjust(wspace=0.05)\n",
    "    \n",
    "    G,pos_G = d_movie[index][\"graph\"]\n",
    "    code_index = d_movie[index][\"code_index\"]    \n",
    "    \n",
    "\n",
    "\n",
    "    ax[0,0].set_axis_off()\n",
    "    ax[1,0].set_axis_off()\n",
    "    ax[0,1].set_axis_off()\n",
    "    ax[1,1].set_axis_off()\n",
    "    \n",
    "    # graf\n",
    "    nx.draw_networkx_edges(G,pos=pos_G,ax=ax[0,0])\n",
    "    nx.draw_networkx_labels(G,pos=pos_G,ax=ax[0,0])\n",
    "    nx.draw_networkx_edge_labels(G,pos=pos_G,\n",
    "                                 edge_labels={e:(d_movie[index][\"akt_flow\"][e],\n",
    "                                                 G.get_edge_data(*e)['cap']) for e in G.edges()},\n",
    "                                 label_pos=0.7,\n",
    "                                 font_size=14,\n",
    "                                 ax=ax[0,0])\n",
    "    nx.draw_networkx_nodes(G,pos=pos_G,node_size=400,node_color=\"red\",ax=ax[0,0])\n",
    "    \n",
    "    \n",
    "    # jobb felso, algoritmus\n",
    "    \n",
    "    for i,line in enumerate(algoritmus):\n",
    "        tab_offset=0.2\n",
    "        dy=0.1\n",
    "        starting_height=1\n",
    "        fs = 17\n",
    "        if i!=code_index:\n",
    "            if line[0]==\"\\t\":\n",
    "                ax[0,1].annotate(line[1:],(0+tab_offset,starting_height-dy*i),fontsize=fs)\n",
    "            else:\n",
    "                ax[0,1].annotate(line,(0,starting_height-dy*i),fontsize=fs)\n",
    "        else:\n",
    "            if line[0]==\"\\t\":\n",
    "                ax[0,1].annotate(line[1:],(0+tab_offset,starting_height-dy*i),fontsize=fs,weight=\"bold\")\n",
    "            else:\n",
    "                ax[0,1].annotate(line,(0,starting_height-dy*i),fontsize=fs,weight=\"bold\")\n",
    "    ax[0,1].set_ylim(0,1.2)\n",
    "    \n",
    "    if \"flow_value\" in d_movie[index]:\n",
    "        ax[0,1].annotate(\"Current flow value: \"+str(d_movie[index][\"flow_value\"]), \n",
    "            (0,starting_height-7*dy),fontsize=fs)\n",
    "    \n",
    "    # tempgraph\n",
    "        # bal also\n",
    "    if \"tempgraph\" in d_movie[index]:\n",
    "        H,pos_H = d_movie[index][\"tempgraph\"]\n",
    "\n",
    "        \n",
    "        nx.draw_networkx_edges(H, pos=pos_H, \n",
    "                           connectionstyle=\"arc3,rad=0.1\",\n",
    "                           edge_color=[H.get_edge_data(*e)['color'] for e in H.edges()],\n",
    "                           edge_labels={e:H.get_edge_data(*e)['gap'] for e in H.edges()},\n",
    "                           label_pos=0.7,\n",
    "                           font_size=14,\n",
    "                           ax=ax[1,0])\n",
    "        nx.draw_networkx_labels(H,pos=pos_H,ax=ax[1,0])\n",
    "        nx.draw_networkx_nodes(G,pos=pos_G,node_size=400,node_color=\"red\",ax=ax[1,0])\n",
    "    #     nx.draw_networkx_edge_labels(H,pos=pos_G,\n",
    "    #                                   edge_labels={e:H.get_edge_data(*e)['gap'] for e in H.edges()},\n",
    "    #                                   connectionstyle=\"arc3,rad=0.1\",\n",
    "    #                                   label_pos=0.7)\n",
    "\n",
    "    if \"augmenting_size\" in d_movie[index]:\n",
    "        ax[1,1].annotate(\"Augmenting size: \"+str(d_movie[index][\"augmenting_size\"]) + \".\",\n",
    "            (0,starting_height-dy),fontsize=17)\n",
    "        ax[1,1].annotate(\"Augmenting path: \"+ \",\".join([str(t) for t in d_movie[index][\"augmenting_path\"]]), \n",
    "            (0,starting_height-2*dy),fontsize=17)\n",
    "        ax[1,1].set_ylim(0,1.2)\n",
    "\n",
    "\n",
    "    #     print(javitas_merteke,':',L)\n",
    "    \n",
    "    # 2-es tempgraf\n",
    "    \n",
    "    # augmenting_path\n",
    "    # augmenting_size\n",
    "    # code_index\n",
    "        L = list(set([n for t in d_movie[index][\"augmenting_path\"] for n in t]))\n",
    "        L_edges = d_movie[index][\"augmenting_path\"]\n",
    "    \n",
    "        nx.draw_networkx_edges(G,pos=pos_G,ax=ax[0,0])\n",
    "        nx.draw_networkx_labels(G,pos=pos_G,ax=ax[0,0])\n",
    "        nx.draw_networkx_edge_labels(\n",
    "            G,\n",
    "            pos=pos_G,\n",
    "            edge_labels={e:(d_movie[index][\"akt_flow\"][e],G.get_edge_data(*e)['cap']) for e in G.edges()},\n",
    "            label_pos=0.7,font_size=14,ax=ax[0,0])\n",
    "        nx.draw_networkx_nodes(G,pos=pos_G,node_size=400,node_color=\"red\",ax=ax[0,0])\n",
    "    #         fig=plt.figure()\n",
    "        nx.draw_networkx_edges(H, pos=pos_G, \n",
    "                           connectionstyle=\"arc3,rad=0.1\",\n",
    "                           edge_color=[H.get_edge_data(*e)['color'] for e in H.edges()],\n",
    "                           edge_labels={e:H.get_edge_data(*e)['gap'] for e in H.edges()},\n",
    "                           label_pos=0.7,ax=ax[1,0])\n",
    "        nx.draw_networkx_labels(H,pos=pos_G,ax=ax[1,0])\n",
    "        nx.draw_networkx_nodes(G,pos=pos_G,\n",
    "                               nodelist=L,\n",
    "                               node_size=400,node_color=\"lightgreen\",ax=ax[1,0])\n",
    "        nx.draw_networkx_nodes(G,pos=pos_G,\n",
    "                               nodelist=[u for u in G.nodes() if u not in L],\n",
    "                               node_size=400,node_color=\"red\",ax=ax[1,0])\n",
    "        nx.draw_networkx_edges(H, pos=pos_G, \n",
    "                           connectionstyle=\"arc3,rad=0.1\",\n",
    "                           edgelist=L_edges,\n",
    "                           edge_color=[H.get_edge_data(*e)['color'] for e in L_edges],\n",
    "                           edge_labels={e:H.get_edge_data(*e)['gap'] for e in L_edges},\n",
    "                           width=5,\n",
    "                           label_pos=0.7,ax=ax[1,0])\n",
    "        nx.draw_networkx_edge_labels(H,pos=pos_G, edgelist=L_edges,\n",
    "                                  edge_labels={e:H.get_edge_data(*e)['gap'] for e in L_edges},\n",
    "                                  connectionstyle=\"arc3,rad=0.1\",\n",
    "                                  font_size=14,\n",
    "                                  label_pos=0.7,ax=ax[1,0])\n",
    "\n",
    "    \n",
    "    if \"cut\" in d_movie[index]:\n",
    "        # 3-as tipusu tempgraf, utolso fazis\n",
    "\n",
    "        # vagas\n",
    "        # code_index\n",
    "\n",
    "        nx.draw_networkx_edges(G,pos=pos_G,ax=ax[0,0])\n",
    "        nx.draw_networkx_labels(G,pos=pos_G,ax=ax[0,0])\n",
    "        nx.draw_networkx_edge_labels(G,pos=pos_G,\n",
    "                                     edge_labels={e:(d_movie[index][\"akt_flow\"][e],\n",
    "                                                     G.get_edge_data(*e)['cap']) for e in G.edges()},\n",
    "                                     label_pos=0.7,font_size=14,ax=ax[0,0])\n",
    "        \n",
    "        if \"tempgraph\" not in d_movie[index]:\n",
    "            X = d_movie[index][\"cut\"]\n",
    "            nx.draw_networkx_nodes(G,pos=pos_G,node_size=400,nodelist=X,node_color=\"lightblue\",ax=ax[0,0])\n",
    "            nx.draw_networkx_nodes(G,pos=pos_G,node_size=400,nodelist=[u for u in G.nodes() if u not in X],node_color=\"red\",ax=ax[0,0])\n",
    "        else:\n",
    "            nx.draw_networkx_nodes(G,pos=pos_G,node_size=400,node_color=\"red\",ax=ax[0,0])\n",
    "\n",
    "            nx.draw_networkx_edges(H, pos=pos_G, \n",
    "                               connectionstyle=\"arc3,rad=0.1\",\n",
    "                               edge_color=[H.get_edge_data(*e)['color'] for e in H.edges()],\n",
    "                               edge_labels={e:H.get_edge_data(*e)['gap'] for e in H.edges()},\n",
    "                               label_pos=0.7,ax=ax[1,0])\n",
    "\n",
    "            nx.draw_networkx_labels(H,pos=pos_G,ax=ax[1,0])\n",
    "            X = d_movie[index][\"cut\"]\n",
    "            nx.draw_networkx_nodes(G,pos=pos_G,node_size=400,nodelist=X,node_color=\"lightblue\",ax=ax[1,0])\n",
    "            nx.draw_networkx_nodes(G,pos=pos_G,node_size=400,nodelist=[u for u in G.nodes() if u not in X],node_color=\"red\",ax=ax[1,0])\n",
    "\n",
    "#         print('Talalt vagas: ',X)\n",
    "#         print('Talalt vagas erteke:',vagas_ertek(X))\n",
    "    \n",
    "    # cut_value\n",
    "    if \"leaving_edges\" in d_movie[index]:\n",
    "        nx.draw_networkx_edges(G,pos=pos_G,edgelist=d_movie[index][\"leaving_edges\"],width=5,ax=ax[0,0])\n",
    "        X = d_movie[index][\"cut\"]\n",
    "        nx.draw_networkx_nodes(G,pos=pos_G,node_size=400,nodelist=X,node_color=\"lightblue\",ax=ax[0,0])\n",
    "        nx.draw_networkx_nodes(G,pos=pos_G,node_size=400,nodelist=[u for u in G.nodes() if u not in X],node_color=\"red\",ax=ax[0,0])\n",
    "        \n",
    "        ax[0,1].annotate(\"Cut value: \"+str(d_movie[index][\"cut_value\"]), \n",
    "            (0,starting_height-8*dy),fontsize=17)\n",
    "    \n",
    "    # leaving_edges - megvastagitani az grafban az utolso abranremmi\n",
    "    \n",
    "    # minden informacio egy abran, az eredeti graf egy masik rajzolasa\n",
    "    \n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1b76fcaf3faa4e198baf2e2adcd24371",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='index', max=25), Output()), _dom_classes=('widget-intera…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "interactive(plot_all,index=IntSlider(0,0,len(d_movie.keys())-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_movie_pdf(handler):\n",
    "    if 'figs' in os.listdir('.'):\n",
    "        rmtree('figs')\n",
    "    os.mkdir('figs')\n",
    "    for kepsorszam in d_movie:\n",
    "        fig=plot_all(kepsorszam)\n",
    "        fig.savefig('figs/f_'+str(kepsorszam).zfill(3)+'.pdf',density=300)\n",
    "        plt.close()\n",
    "\n",
    "    os.system('qpdf --empty --pages figs/f*.pdf -- f_movie.pdf')\n",
    "\n",
    "    local_file = FileLink('./f_movie.pdf', result_html_prefix=\"Concatenated slides in one PDF: \")\n",
    "    display(local_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6659c1c54cbd4712b08786ba18fc76e0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Concatenate slides!', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n",
      "/home/bokanyie/.anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"density\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  import sys\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "Concatenated slides in one PDF: <a href='./f_movie.pdf' target='_blank'>./f_movie.pdf</a><br>"
      ],
      "text/plain": [
       "/home/bokanyie/teaching/visualization_of_algs/f_movie.pdf"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b = Button(description = \"Concatenate slides!\")\n",
    "b.on_click(create_movie_pdf)\n",
    "b"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}