Text_detection_from_image.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from urllib import parse, error\n",
    "import base64\n",
    "import requests\n",
    "import json\n",
    "import cv2\n",
    "import io\n",
    "from google.cloud.vision import types\n",
    "import numpy as np\n",
    "from sklearn.metrics.pairwise import euclidean_distances as ED\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"GOOGLE_APPLICATION_CREDENTIALS\"]=\"/home/quazar07/Desktop/perkins_hackathon/perkins-hackathon-OCR-b116d4935f42.json\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division\n",
    "from google.cloud import vision\n",
    "def detect_text(path):\n",
    "    centroids_list = []\n",
    "    text_list = []\n",
    "    cordinates_list = []\n",
    "    \n",
    "    \"\"\"Detects text in the file.\"\"\"\n",
    "    client = vision.ImageAnnotatorClient()\n",
    "\n",
    "    with io.open(path, 'rb') as image_file:\n",
    "        content = image_file.read()\n",
    "\n",
    "    image = types.Image(content=content)\n",
    "\n",
    "    response = client.text_detection(image=image)\n",
    "    texts = response.text_annotations\n",
    "    print('Texts:')\n",
    "    \n",
    "    for text in texts:\n",
    "        print('\\n\"{}\"'.format(text.description))\n",
    "\n",
    "        vertices = (['({},{})'.format(vertex.x, vertex.y)\n",
    "                    for vertex in text.bounding_poly.vertices])\n",
    "        temp_list = []\n",
    "        for vertex in text.bounding_poly.vertices:\n",
    "            temp_list.append((vertex.x,vertex.y))\n",
    "        cordinates_list.append(temp_list)    \n",
    "        vertices_temp = [(each.x,each.y) for each in text.bounding_poly.vertices]\n",
    "        c_x= 0\n",
    "        c_y= 0\n",
    "        for each in vertices_temp:\n",
    "            c_x+= each[0]\n",
    "            c_y+= each[1]\n",
    "        c_x/=4\n",
    "        c_y/=4\n",
    "        centroids_list.append((c_x,c_y))\n",
    "        text_list.append(text.description)\n",
    "\n",
    "        print('bounds: {}'.format(','.join(vertices)))\n",
    "    return centroids_list,text_list,cordinates_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Texts:\n",
      "\n",
      "\"Custom Power\n",
      "Defrost Soften Melt Cook Level\n",
      "3: 15\n",
      "AM\n",
      "Clock Timer Cook Custom Turntable\n",
      "Time Set On/Off\n",
      "\"\n",
      "bounds: (54,78),(1190,78),(1190,271),(54,271)\n",
      "\n",
      "\"Custom\"\n",
      "bounds: (493,78),(595,78),(595,104),(493,104)\n",
      "\n",
      "\"Power\"\n",
      "bounds: (646,78),(735,78),(735,104),(646,104)\n",
      "\n",
      "\"Defrost\"\n",
      "bounds: (56,94),(156,100),(154,125),(54,119)\n",
      "\n",
      "\"Soften\"\n",
      "bounds: (208,93),(297,98),(295,125),(206,120)\n",
      "\n",
      "\"Melt\"\n",
      "bounds: (368,94),(429,98),(427,123),(366,119)\n",
      "\n",
      "\"Cook\"\n",
      "bounds: (497,108),(580,113),(578,142),(495,137)\n",
      "\n",
      "\"Level\"\n",
      "bounds: (655,112),(728,117),(726,142),(653,138)\n",
      "\n",
      "\"3:\"\n",
      "bounds: (1028,107),(1114,107),(1114,169),(1028,169)\n",
      "\n",
      "\"15\"\n",
      "bounds: (1137,107),(1190,107),(1190,169),(1137,169)\n",
      "\n",
      "\"AM\"\n",
      "bounds: (988,111),(1013,111),(1013,128),(988,128)\n",
      "\n",
      "\"Clock\"\n",
      "bounds: (70,227),(142,225),(143,252),(71,254)\n",
      "\n",
      "\"Timer\"\n",
      "bounds: (212,228),(290,226),(291,252),(213,254)\n",
      "\n",
      "\"Cook\"\n",
      "bounds: (363,210),(430,208),(431,235),(364,237)\n",
      "\n",
      "\"Custom\"\n",
      "bounds: (494,210),(595,208),(596,235),(495,237)\n",
      "\n",
      "\"Turntable\"\n",
      "bounds: (624,210),(756,207),(757,236),(625,239)\n",
      "\n",
      "\"Time\"\n",
      "bounds: (366,243),(430,243),(430,270),(366,270)\n",
      "\n",
      "\"Set\"\n",
      "bounds: (521,244),(566,244),(566,271),(521,271)\n",
      "\n",
      "\"On/Off\"\n",
      "bounds: (645,243),(739,243),(739,270),(645,270)\n"
     ]
    }
   ],
   "source": [
    "path = '/home/quazar07/Desktop/perkins_hackathon/cut_image.png'\n",
    "c,t,coords = detect_text(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n",
      "19\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "print(len(coords))\n",
    "print(len(c))\n",
    "print(len(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "original_coords = list(coords)\n",
    "original_t = list(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_euclidean_distance(x,y):\n",
    "    return(math.pow(x[0]-y[0],2)+math.pow(x[1]-y[1],2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(544.0, 91.0), (690.5, 91.0), (105.0, 109.5), (251.5, 109.0), (397.5, 108.5), (537.5, 125.0), (690.5, 127.25), (1071.0, 138.0), (1163.5, 138.0), (1000.5, 119.5), (106.5, 239.5), (251.5, 240.0), (397.0, 222.5), (545.0, 222.5), (690.5, 223.0), (398.0, 256.5), (543.5, 257.5), (692.0, 256.5)]\n",
      "[u'Custom', u'Power', u'Defrost', u'Soften', u'Melt', u'Cook', u'Level', u'3:', u'15', u'AM', u'Clock', u'Timer', u'Cook', u'Custom', u'Turntable', u'Time', u'Set', u'On/Off']\n"
     ]
    }
   ],
   "source": [
    "print(c[1:])\n",
    "print(t[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_merging_indices(c):\n",
    "    l = len(c)\n",
    "    min_dist =0\n",
    "    if(l>2):\n",
    "        min_dist = get_euclidean_distance(c[1],c[2])\n",
    "        for i in range(1,l):\n",
    "            for j in range(1,l):\n",
    "                if(i!=j):\n",
    "                    if(get_euclidean_distance(c[i],c[j]) < min_dist):\n",
    "                        min_dist = get_euclidean_distance(c[i],c[j])\n",
    "    merging_indices = []\n",
    "    for i in range(1,l):\n",
    "            for j in range(1,l):\n",
    "                if(i!=j):\n",
    "                    if(get_euclidean_distance(c[i],c[j]) < (1.20)*min_dist):\n",
    "                        if((i,j) not in merging_indices and (j,i) not in merging_indices):\n",
    "                            merging_indices.append((i,j))\n",
    "    return merging_indices                        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "# l = len(c)\n",
    "# min_dist =0\n",
    "# if(l>2):\n",
    "#     min_dist = get_euclidean_distance(c[1],c[2])\n",
    "#     for i in range(1,l):\n",
    "#         for j in range(1,l):\n",
    "#             if(i!=j):\n",
    "#                 if(get_euclidean_distance(c[i],c[j]) < min_dist):\n",
    "#                     min_dist = get_euclidean_distance(c[i],c[j])\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [],
   "source": [
    "# merging_indices = []\n",
    "# for i in range(1,l):\n",
    "#         for j in range(1,l):\n",
    "#             if(i!=j):\n",
    "#                 if(get_euclidean_distance(c[i],c[j]) < (1.20)*min_dist):\n",
    "#                     if((i,j) not in merging_indices and (j,i) not in merging_indices):\n",
    "#                         merging_indices.append((i,j))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 6), (2, 7), (13, 16), (14, 17), (15, 18)]\n",
      "Custom\n",
      "Cook\n",
      "()\n",
      "Power\n",
      "Level\n",
      "()\n",
      "Cook\n",
      "Time\n",
      "()\n",
      "Custom\n",
      "Set\n",
      "()\n",
      "Turntable\n",
      "On/Off\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "merging_indices = get_merging_indices(c)\n",
    "print(merging_indices)\n",
    "for each in merging_indices:\n",
    "    print(t[each[0]])\n",
    "    print(t[each[1]])\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print(merging_indices[0][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'list'>\n"
     ]
    }
   ],
   "source": [
    "print(type(coords[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n"
     ]
    }
   ],
   "source": [
    "print(len(original_coords))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_(indices,coords,t):\n",
    "    temp_coords = []\n",
    "    temp_t = []\n",
    "    for each in indices:\n",
    "        x1 = [vertex[0] for \n",
    "              vertex in coords[each[0]]]\n",
    "#         print(coords[each[1]])\n",
    "        x2 = [vertex[0] for vertex in coords[each[1]]]\n",
    "        y1 = [vertex[1] for vertex in coords[each[0]]]\n",
    "        y2 = [vertex[1] for vertex in coords[each[1]]]\n",
    "        x_min =min([min(x1),min(x2)])\n",
    "        x_max = max([max(x1),max(x2)])\n",
    "        y_min = min([min(y1),min(y2)])\n",
    "        y_max = max([max(y1),max(y2)])\n",
    "        temp_coords.append([(x_min,y_min),(x_max,y_min),(x_max,y_max),(x_min,y_max)])\n",
    "        temp_t.append(t[each[0]]+\" \"+t[each[1]])\n",
    "#         coords.pop(each[0])\n",
    "#         coords.pop(each[1])\n",
    "    return temp_coords,temp_t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [],
   "source": [
    "coords = list(original_coords)\n",
    "t = list(original_t)\n",
    "temp_coords,temp_t = merge_(merging_indices)\n",
    "coords.extend(temp_coords)\n",
    "t.extend(temp_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "24\n",
      "[u'Custom Power\\nDefrost Soften Melt Cook Level\\n3: 15\\nAM\\nClock Timer Cook Custom Turntable\\nTime Set On/Off\\n', u'Custom', u'Power', u'Defrost', u'Soften', u'Melt', u'Cook', u'Level', u'3:', u'15', u'AM', u'Clock', u'Timer', u'Cook', u'Custom', u'Turntable', u'Time', u'Set', u'On/Off', u'Custom Cook', u'Power Level', u'Cook Time', u'Custom Set', u'Turntable On/Off']\n"
     ]
    }
   ],
   "source": [
    "print(len(coords))\n",
    "print(len(t))\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_merged_lists(merging_indices,coords,t):\n",
    "    delete_indices = []\n",
    "    for each in merging_indices:\n",
    "        delete_indices.append(each[0])\n",
    "        delete_indices.append(each[1])\n",
    "    new_t = []\n",
    "    new_coords = []\n",
    "    for i in range(len(coords)):\n",
    "        if(i not in delete_indices):\n",
    "            new_coords.append(coords[i])\n",
    "            new_t.append(t[i])\n",
    "    return new_t,new_coords       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 6, 2, 7, 13, 16, 14, 17, 15, 18]\n"
     ]
    }
   ],
   "source": [
    "# delete_indices = []\n",
    "# for each in merging_indices:\n",
    "#     delete_indices.append(each[0])\n",
    "#     delete_indices.append(each[1])\n",
    "# print(delete_indices)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "# new_c =[]\n",
    "new_t = []\n",
    "new_coords = []\n",
    "new_t,new_coords  = get_merged_lists(merging_indices)\n",
    "# for i in range(len(coords)):\n",
    "#     if(i not in delete_indices):\n",
    "#         new_coords.append(coords[i])\n",
    "#         new_t.append(t[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[u'Custom Power\\nDefrost Soften Melt Cook Level\\n3: 15\\nAM\\nClock Timer Cook Custom Turntable\\nTime Set On/Off\\n', u'Defrost', u'Soften', u'Melt', u'3:', u'15', u'AM', u'Clock', u'Timer', u'Custom Cook', u'Power Level', u'Cook Time', u'Custom Set', u'Turntable On/Off']\n"
     ]
    }
   ],
   "source": [
    "print(new_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# gogle_api_key = 'AIzaSyDNVM7f5v60izaMCa9r4pWC__Yz0AcDqSo'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Texts:\n",
      "\n",
      "\"bake\n",
      "broil\n",
      "er clock\n",
      "on-off\n",
      "\"\n",
      "bounds: (262,137),(610,137),(610,374),(262,374)\n",
      "\n",
      "\"bake\"\n",
      "bounds: (272,137),(349,142),(347,175),(270,170)\n",
      "\n",
      "\"broil\"\n",
      "bounds: (262,310),(329,307),(330,341),(263,344)\n",
      "\n",
      "\"er\"\n",
      "bounds: (468,320),(492,321),(491,350),(467,349)\n",
      "\n",
      "\"clock\"\n",
      "bounds: (534,323),(610,326),(609,355),(533,352)\n",
      "\n",
      "\"on-off\"\n",
      "bounds: (417,355),(475,355),(475,374),(417,374)\n"
     ]
    }
   ],
   "source": [
    "path1 = '/home/quazar07/Desktop/perkins_hackathon/opencv_frame_0.png'\n",
    "c1,t1,coords1 = detect_text(path1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {},
   "outputs": [],
   "source": [
    "merging_indices1 = get_merging_indices(c1)\n",
    "# coords = list(original_coords)\n",
    "# t = list(original_t)\n",
    "temp_coords,temp_t = merge_(merging_indices1,coords1,t1)\n",
    "coords1.extend(temp_coords)\n",
    "t1.extend(temp_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[u'bake\\nbroil\\ner clock\\non-off\\n', u'bake', u'broil', u'er', u'clock', u'on-off', u'er on-off']\n"
     ]
    }
   ],
   "source": [
    "print(t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_t1 = []\n",
    "new_coords1 = []\n",
    "new_t1,new_coords1  = get_merged_lists(merging_indices1,coords1,t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[u'bake\\nbroil\\ner clock\\non-off\\n', u'bake', u'broil', u'er', u'clock', u'on-off', u'er on-off']\n",
      "[u'bake\\nbroil\\ner clock\\non-off\\n', u'bake', u'broil', u'clock', u'er on-off']\n",
      "5\n",
      "5\n",
      "[[(262, 137), (610, 137), (610, 374), (262, 374)], [(272, 137), (349, 142), (347, 175), (270, 170)], [(262, 310), (329, 307), (330, 341), (263, 344)], [(534, 323), (610, 326), (609, 355), (533, 352)], [(417, 320), (492, 320), (492, 374), (417, 374)]]\n",
      "[u'bake\\nbroil\\ner clock\\non-off\\n', u'bake', u'broil', u'er', u'clock', u'on-off', u'er on-off']\n",
      "[[(262, 137), (610, 137), (610, 374), (262, 374)], [(272, 137), (349, 142), (347, 175), (270, 170)], [(262, 310), (329, 307), (330, 341), (263, 344)], [(468, 320), (492, 321), (491, 350), (467, 349)], [(534, 323), (610, 326), (609, 355), (533, 352)], [(417, 355), (475, 355), (475, 374), (417, 374)], [(417, 320), (492, 320), (492, 374), (417, 374)]]\n"
     ]
    }
   ],
   "source": [
    "print(t1)\n",
    "print(new_t1)\n",
    "print(len(new_t1))\n",
    "print(len(new_coords1))\n",
    "print(new_coords1)\n",
    "print(t1)\n",
    "print(coords1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_centroid(coords,ind):\n",
    "    avg_x=0\n",
    "    avg_y=0\n",
    "    for each in coords[ind]:\n",
    "        avg_x+=each[0]\n",
    "        avg_y+=each[1]\n",
    "    return((avg_x/4,avg_y/4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_inside(curr,goal_ind,new_coords):\n",
    "    x = curr[0]\n",
    "    y = curr[1]\n",
    "    ax = new_coords[goal_ind][0][0]\n",
    "    ay = new_coords[goal_ind][0][1]\n",
    "    \n",
    "    bx = new_coords[goal_ind][1][0]\n",
    "    by = new_coords[goal_ind][1][1]\n",
    "    \n",
    "    dx = new_coords[goal_ind][2][0]\n",
    "    dy = new_coords[goal_ind][2][1]\n",
    "    \n",
    "    bax = bx - ax\n",
    "    bay = by - ay\n",
    "    dax = dx - ax\n",
    "    day = dy - ay\n",
    "\n",
    "    if ((x - ax) * bax + (y - ay) * bay < 0.0):\n",
    "        return 0\n",
    "    if ((x - bx) * bax + (y - by) * bay > 0.0):\n",
    "        return 0\n",
    "    if ((x - ax) * dax + (y - ay) * day < 0.0):\n",
    "        return 0\n",
    "    if ((x - dx) * dax + (y - dy) * day > 0.0):\n",
    "        return 0\n",
    "\n",
    "    return 1\n",
    "\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "curr = (0,0)\n",
    "is_inside(get_centroid(new_coords1,1),1,new_coords1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gps(curr,goal_ind,coords):\n",
    "    if(is_inside(curr,goal_ind,coords)==1):\n",
    "        print('Reached!')\n",
    "        return\n",
    "    else:\n",
    "        cent = get_centroid(coords,goal_ind)\n",
    "        ans = \"\"\n",
    "        if(curr[1]>=coords[goal_ind][0][1] and curr[1]<=coords[goal_ind][2][1] ):\n",
    "            ans+=\"\"\n",
    "        elif(cent[1]>curr[1]):\n",
    "            ans+=\"down\"\n",
    "        elif(cent[1]<curr[1]):\n",
    "            ans+=\"up\"\n",
    "        if(curr[0]>=coords[goal_ind][0][0] and curr[0]<=coords[goal_ind][1][0] ):\n",
    "            ans+=\"\"\n",
    "        elif(cent[0]>curr[0]):\n",
    "            ans+=\" right\"\n",
    "        elif(cent[0]<curr[0]):\n",
    "            ans+=\" left\"\n",
    "        print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up left\n"
     ]
    }
   ],
   "source": [
    "curr = (630,600)\n",
    "gps(curr,3,new_coords1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {},
   "outputs": [],
   "source": [
    "from difflib import SequenceMatcher\n",
    "def longestcommonsubstring(string1,string2):\n",
    "    match = SequenceMatcher(None, string1, string2).find_longest_match(0, len(string1), 0, len(string2))\n",
    "    return(string1[match.a: match.a + match.size])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_index_from_text(text,t):\n",
    "    max_len = 0\n",
    "    max_ind = -1\n",
    "    for i in range(1,len(t)):\n",
    "#         print(longestSubstringFinder(text,t[i]))\n",
    "        t_len = len(longestcommonsubstring(text,t[i]))\n",
    "#         print(t_len)\n",
    "#         print(t[i])\n",
    "        if(t_len>max_len):\n",
    "            max_len = t_len\n",
    "            max_ind = i\n",
    "    return(max_ind)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(get_index_from_text('ake',new_t1))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}