Extract_Pie_Table.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "46a82f28",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "\n",
    "from IPython.display import Image, display\n",
    "# from paddleocr import PaddleOCR,draw_ocr\n",
    "from tqdm import tqdm\n",
    "import re\n",
    "import math\n",
    "\n",
    "import cv2\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.cluster import KMeans\n",
    "from collections import Counter\n",
    "# ocr = PaddleOCR(use_angle_cls=True, lang='en', use_gpu=False, ocr_version=\"PP-OCRv3\", enable_mkldnn=True) # need to run only once to download and load model into memory"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d06ca56",
   "metadata": {},
   "source": [
    "## Pie Table Extraction\n",
    "In this section, we develop code to extract the data table from the Pie Image. \n",
    "### Load the Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "feabaf57",
   "metadata": {},
   "outputs": [],
   "source": [
    "# data_path = '/dvmm-filer2/projects/mingyang/semafor/chart_table/data/pie/annotations'\n",
    "data_path = '/Users/kevinz/Desktop/semafor/chart_table/data_download/pie/annotations'\n",
    "test_data_path = '/'.join([data_path, \"instancesPie(1008)_test2019.json\"])\n",
    "#image_path = '/dvmm-filer2/projects/mingyang/semafor/chart_table/data/pie/images/test2019'\n",
    "image_path = '/Users/kevinz/Desktop/semafor/chart_table/data_download/pie/images/test2019'\n",
    "with open(test_data_path, 'r') as f:\n",
    "    test_annotation = json.load(f)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "284217cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['licenses', 'images', 'annotations', 'categories'])\n"
     ]
    }
   ],
   "source": [
    "print(test_annotation.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8bcde079",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'list'>\n",
      "<class 'list'>\n",
      "1923\n",
      "10922\n"
     ]
    }
   ],
   "source": [
    "print(type(test_annotation['images']))\n",
    "print(type(test_annotation['annotations']))\n",
    "print(type(test_annotation['categories']))\n",
    "\n",
    "print(len(test_annotation['images']))\n",
    "print(len(test_annotation['annotations']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "87362453",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'file_name': 'f447ffede2ef85e73a191f8c1ed3f9df_c3RhdGxpbmtzLm9lY2Rjb2RlLm9yZwk5Mi4yNDMuMjMuMTM3.XLS-0-0.png', 'height': 273, 'width': 331, 'id': 73075}\n",
      "{'image_id': 73075, 'category_id': 0, 'bbox': [191.0, 32.0, 285.0, 184.0, 191.0, 137.0], 'area': 11225.039931680858, 'id': 422950}\n",
      "{'supercategory': 'Series', 'id': 0, 'name': 'Series'}\n"
     ]
    }
   ],
   "source": [
    "print(test_annotation['images'][0])\n",
    "print(test_annotation['annotations'][0])\n",
    "print(test_annotation['categories'][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e9fc528f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'image_id': 73099, 'category_id': 0, 'bbox': [229.0, 55.0, 272.0, 69.0, 228.0, 128.0], 'area': 1684.7676261691474, 'id': 423063}, {'image_id': 73099, 'category_id': 0, 'bbox': [272.0, 69.0, 292.0, 168.0, 228.0, 128.0], 'area': 4134.432462409461, 'id': 423064}, {'image_id': 73099, 'category_id': 0, 'bbox': [292.0, 168.0, 157.0, 110.0, 228.0, 128.0], 'area': 7825.700454745565, 'id': 423065}, {'image_id': 73099, 'category_id': 0, 'bbox': [157.0, 110.0, 223.0, 55.0, 228.0, 128.0], 'area': 3360.7264164895582, 'id': 423066}, {'image_id': 73099, 'category_id': 0, 'bbox': [223.0, 55.0, 229.0, 55.0, 228.0, 128.0], 'area': 219.2430844054889, 'id': 423067}]\n"
     ]
    }
   ],
   "source": [
    "#Line Annotation\n",
    "#image_info = [x['id']: {'file_name':x['file_name'], 'height':x['height'], 'width':x['width']} for x in test_annotation['images']]\n",
    "#good sample: [21, 22, 23]\n",
    "sample_info = test_annotation['images'][24]\n",
    "sample_id = sample_info['id']\n",
    "#Find all the annotations:\n",
    "\n",
    "#Display the image\n",
    "sample_img_path = '/'.join([image_path, sample_info['file_name']])\n",
    "display(Image(filename=sample_img_path))\n",
    "\n",
    "#Map Annotations to Image ID\n",
    "AnnotationMap = {}\n",
    "for x in test_annotation['annotations']:\n",
    "    img_id = x['image_id']\n",
    "    AnnotationMap[img_id] = AnnotationMap.get(img_id, []) + [x]\n",
    "    \n",
    "sample_annotation = AnnotationMap[sample_id]\n",
    "print(sample_annotation)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25d3f114",
   "metadata": {},
   "source": [
    "### Detect Text Elements of the Image\n",
    "Extract the Text Elements from Pie Image. \n",
    "\n",
    "1. **Extract Legend**\n",
    "    - Disregard the Numerical Values\n",
    "    - Disregard the bounding box that is not Vertically or Horizontally aligned\n",
    "2. **Extract Title**\n",
    "    - Detected Text that is closest to the Top. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "dded3892",
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: '/dvmm-filer2/projects/mingyang/semafor/chart_table/data/pie/ocr_results/test2019/73099.json'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/m8/435h1kds3r15ck86lqk5fgtw0000gn/T/ipykernel_35365/1978834212.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#Get the OCR of this image\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[0mocr_dir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"/dvmm-filer2/projects/mingyang/semafor/chart_table/data/pie/ocr_results/test2019/{}.json\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msample_id\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[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mocr_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"r\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\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      4\u001b[0m     \u001b[0mocr_texts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/dvmm-filer2/projects/mingyang/semafor/chart_table/data/pie/ocr_results/test2019/73099.json'"
     ]
    }
   ],
   "source": [
    "#Get the OCR of this image\n",
    "ocr_dir = \"/Users/kevinz/Desktop/semafor/chart_table/data_download/pie/ocr_results/test2019/{}.json\".format(sample_id)\n",
    "with open(ocr_dir, \"r\") as f:\n",
    "    ocr_texts = json.load(f)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "532b55c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[60.0, 17.0], [338.0, 18.0], [338.0, 37.0], [60.0, 36.0]], ['2017 Take up in your school', 0.9862290024757385]], [[[261.0, 104.0], [364.0, 105.0], [364.0, 119.0], [261.0, 118.0]], [' Taking Higher Level', 0.9647728800773621]], [[[196.0, 135.0], [224.0, 135.0], [224.0, 149.0], [196.0, 149.0]], ['57%', 0.9677383303642273]], [[[263.0, 129.0], [374.0, 129.0], [374.0, 141.0], [263.0, 141.0]], [' Taking Ordinary Level', 0.9591813683509827]]]\n"
     ]
    }
   ],
   "source": [
    "print(ocr_texts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ea413ab9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[261.0, 104.0], [364.0, 105.0], [364.0, 119.0], [261.0, 118.0]], [' Taking Higher Level', 0.9647728800773621]], [[[263.0, 129.0], [374.0, 129.0], [374.0, 141.0], [263.0, 141.0]], [' Taking Ordinary Level', 0.9591813683509827]]]\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "def hv_alignment(a, b):\n",
    "    #compare the bounding box a and b to check if they are horizontal or vertically aligned\n",
    "    align_thred = 5\n",
    "    align_diff = [abs(a[0][0]-b[0][0]), abs(a[0][1]-b[0][1]), abs(a[2][0]-b[1][0]), abs(a[2][1]-b[2][1])]\n",
    "    if min(align_diff) < align_thred:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "\n",
    "#Extract Legend\n",
    "def extract_legend(ocr_texts):\n",
    "    numerical_pattern = \"(\\d+(\\.\\d+)?%)\"\n",
    "\n",
    "    #Step 1, Get rid of Numerical Value\n",
    "    legend_candidates = []\n",
    "    for candidate in ocr_texts:\n",
    "        candidate_text = candidate[1][0]\n",
    "        if not re.search(numerical_pattern, candidate_text):\n",
    "            legend_candidates.append(candidate)\n",
    "\n",
    "\n",
    "    #Step 2, Group Text based on their Vertical or Horizontal Alignment.\n",
    "    align_map = {}\n",
    "    for i_a,c_a in enumerate(legend_candidates):\n",
    "        align_map[i_a] = []\n",
    "        i_b = i_a+1\n",
    "        for c_b in legend_candidates[i_a+1:]:\n",
    "            if hv_alignment(c_a[0],c_b[0]):\n",
    "                align_map[i_a].append(i_b)\n",
    "            i_b +=1\n",
    "    \n",
    "    legend_groups = []\n",
    "    legend_group = []\n",
    "\n",
    "    for k,v in align_map.items():\n",
    "        if k in legend_group:\n",
    "            continue\n",
    "        if v:\n",
    "            legend_group += v + [k]\n",
    "            for x in v:\n",
    "                legend_group += align_map[x]\n",
    "            legend_group = list(set(legend_group))\n",
    "            legend_groups.append(legend_group)\n",
    "            legend_group = []\n",
    "    if len(legend_groups) == 0:\n",
    "        return []\n",
    "    #Get the final legends\n",
    "    if len(legend_groups) == 1 and len(legend_groups[0]) > 0:\n",
    "        return [legend_candidates[x] for x in legend_groups[0]]\n",
    "    else:\n",
    "        #Pick the one with the maximum elements or maybe the group that has the mapped elements as the gt sectors\n",
    "        legend_groups.sort(key=len)\n",
    "        return [legend_candidates[x] for x in legend_groups[-1]]\n",
    "\n",
    "detected_legends = extract_legend(ocr_texts)\n",
    "print(detected_legends)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26b24090",
   "metadata": {},
   "source": [
    "### Read Data Values\n",
    "In this step, we compute the angles of the sector to estimate the pie area. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2d1b08a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5627880118634262\n",
      "0.43721198813657375\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def determinant(v1, v2):\n",
    "  return v1[0]*v2[1] - v1[1]*v2[0]\n",
    "\n",
    "def dotproduct(v1, v2):\n",
    "  return sum((a*b) for a, b in zip(v1, v2))\n",
    "\n",
    "def length(v):\n",
    "  return math.sqrt(dotproduct(v, v))\n",
    "\n",
    "def angle(v1, v2):\n",
    "  return math.atan2(determinant(v1,v2), dotproduct(v1, v2))\n",
    "\n",
    "def compute_unit(p1,p2):\n",
    "    distance = [p1[0] - p2[0], -(p1[1] - p2[1])]\n",
    "    norm = math.sqrt(distance[0] ** 2 + distance[1] ** 2)\n",
    "    direction = [distance[0] / norm, distance[1] / norm]\n",
    "    return direction\n",
    "\n",
    "def compute_distance(p1,p2):\n",
    "    distance = (p1[0] - p2[0])**2 + (p1[1] - p2[1])**2\n",
    "    return distance\n",
    "    \n",
    "#def estimate_value(sample_annotation):\n",
    "angles = []\n",
    "for sector in sample_annotation:\n",
    "    sector_bbox = sector['bbox']\n",
    "    #print(sector_bbox)\n",
    "    assert len(sector_bbox) == 6\n",
    "    center = [sector_bbox[4],sector_bbox[5]]\n",
    "    sector_p1 = [sector_bbox[0],sector_bbox[1]]\n",
    "    sector_p2 = [sector_bbox[2],sector_bbox[3]]\n",
    "    \n",
    "   \n",
    "   \n",
    "    v1 = compute_unit(sector_p1, center)\n",
    "    v2 = compute_unit(sector_p2, center)\n",
    "\n",
    "    current_angle = angle(v2,v1)\n",
    "    #print(current_angle)\n",
    "    if current_angle < 0:\n",
    "        current_angle = 2*math.pi+current_angle\n",
    "    \n",
    "    value = current_angle/(2*math.pi)\n",
    "    sector['value'] = value\n",
    "    print(value)\n",
    "#print(sample_annotation)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfc927e4",
   "metadata": {},
   "source": [
    "### Map the Legend or the Column Text\n",
    "In this final step we will map the legend text or the other detected Text to each sector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5799560a",
   "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"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "import cv2\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.cluster import KMeans\n",
    "from collections import Counter\n",
    "\n",
    "def get_dominant_color(image, k=4, image_processing_size = None):\n",
    "    \"\"\"\n",
    "    takes an image as input\n",
    "    returns the dominant color of the image as a list\n",
    "    \n",
    "    dominant color is found by running k means on the \n",
    "    pixels & returning the centroid of the largest cluster\n",
    "\n",
    "    processing time is sped up by working with a smaller image; \n",
    "    this resizing can be done with the image_processing_size param \n",
    "    which takes a tuple of image dims as input\n",
    "\n",
    "    >>> get_dominant_color(my_image, k=4, image_processing_size = (25, 25))\n",
    "    [56.2423442, 34.0834233, 70.1234123]\n",
    "    \"\"\"\n",
    "    #resize image if new dims provided\n",
    "    if image_processing_size is not None:\n",
    "        image = cv2.resize(image, image_processing_size, \n",
    "                            interpolation = cv2.INTER_AREA)\n",
    "    \n",
    "    #reshape the image to be a list of pixels\n",
    "    image = image.reshape((image.shape[0] * image.shape[1], 3))\n",
    "\n",
    "    #cluster and assign labels to the pixels \n",
    "    clt = KMeans(n_clusters = k)\n",
    "    labels = clt.fit_predict(image)\n",
    "\n",
    "    #count labels to find most popular\n",
    "    label_counts = Counter(labels)\n",
    "    \n",
    "    \n",
    "    #subset out most popular centroid\n",
    "    #dominant_color = clt.cluster_centers_[label_counts.most_common(1)[0][0]]\n",
    "    dominant_colors = clt.cluster_centers_\n",
    "    return list(dominant_colors)\n",
    "\n",
    "#If Legend Exist and the Length Matched\n",
    "#if detected_legends and len(detected_legends) == len(sample_annotation):\n",
    "#Get the dominant Color for each Legends\n",
    "legends = {}\n",
    "sample_image = cv2.imread(sample_img_path)\n",
    "sample_image = cv2.cvtColor(sample_image, cv2.COLOR_BGR2RGB)\n",
    "for i, dl in enumerate(detected_legends):\n",
    "    legends[i] = {'bbox': dl[0], 'text': dl[1]}\n",
    "    start_point = (int(dl[0][0][0]), int(dl[0][0][1]))\n",
    "    end_point = (int(dl[0][2][0]), int(dl[0][2][1]))\n",
    "    \n",
    "    cropped_image = sample_image[start_point[1]:end_point[1], start_point[0]:end_point[0]]\n",
    "#     plt.imshow(cropped_image)\n",
    "#     print(cropped_image[5,3])\n",
    "#     dominant_colors = get_dominant_color(cropped_image, k=3)\n",
    "#     print(dominant_colors)\n",
    "    legends[i]['cropped_image'] = cropped_image\n",
    "\n",
    "\n",
    "#Find the Color for Each Sector, locate a center point. \n",
    "for sector in sample_annotation:\n",
    "    sector_bbox = sector['bbox']\n",
    "    #Compute the angle again\n",
    "    center = [int(sector_bbox[4]),int(sector_bbox[5])]\n",
    "    sector_p1 = [int(sector_bbox[0]),int(sector_bbox[1])]\n",
    "    sector_p2 = [int(sector_bbox[2]),int(sector_bbox[3])]\n",
    "   \n",
    "    v1 = compute_unit(sector_p1, center)\n",
    "    v2 = compute_unit(sector_p2, center)\n",
    "    \n",
    "   \n",
    "    current_angle = angle(v2,v1)\n",
    "    if current_angle < 0:\n",
    "        current_angle = 2*math.pi+current_angle\n",
    "    \n",
    "    \n",
    "    #rotate v2 counter-clock with for 1/2 current_angle to get the \n",
    "    rotated_v2_x = math.cos(0.5*current_angle)*v2[0] - math.sin(0.5*current_angle)*v2[1]\n",
    "    rotated_v2_y = math.sin(0.5*current_angle)*v2[0] + math.cos(0.5*current_angle)*v2[1]\n",
    "    \n",
    "    #print(rotated_v2_x**2 + rotated_v2_y**2)\n",
    "    radius = math.sqrt(compute_distance(sector_p1, center))\n",
    "    #Remember for Pixel, the y is increased from top to bottom. \n",
    "    pick_point = [int(center[0] + rotated_v2_x*0.5*radius), int(center[1] - rotated_v2_y*0.5*radius)]\n",
    "    \n",
    "    #Plot the pick-point\n",
    "    #Get the color of the pick_point\n",
    "    sample_image_hsv = cv2.cvtColor(sample_image, cv2.COLOR_RGB2HSV)\n",
    "    pick_point_color = sample_image_hsv[pick_point[1],pick_point[0]]\n",
    "    \n",
    "    \n",
    "    pp_color_min = np.array([max(0, pick_point_color[0]-5),max(50,pick_point_color[1]-10),max(50, pick_point_color[2]-10)], np.uint8)\n",
    "    pp_color_max = np.array([pick_point_color[0]+5,min(255, pick_point_color[1]+10),min(255, pick_point_color[2]+10)], np.uint8)\n",
    "    \n",
    "    sector['mapped_column_value'] = None\n",
    "    for k, cl in legends.items():\n",
    "        cl_image = cl[\"cropped_image\"]\n",
    "        cl_hsv_image = cv2.cvtColor(cl_image, cv2.COLOR_RGB2HSV)\n",
    "        frame_threshed = cv2.inRange(cl_hsv_image, pp_color_min, pp_color_max)\n",
    "        \n",
    "\n",
    "        #might satisty two saturation\n",
    "        \n",
    "        if np.count_nonzero(frame_threshed)/(frame_threshed.shape[0]*frame_threshed.shape[1]) > 0.01:\n",
    "            #Find a Map\n",
    "            sector['column_value'] = cl['text'][0]\n",
    "            plt.imshow(cl_image)\n",
    "            plt.show()\n",
    "            plt.imshow(frame_threshed)\n",
    "            plt.show()\n",
    "            break\n",
    "\n",
    "        \n",
    "        \n",
    "                             \n",
    "        \n",
    "\n",
    "                             \n",
    "    \n",
    "#plt.imshow('Binary',thresh_img)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6a26dcb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAADRCAYAAADbq1XqAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAABYWSURBVHhe7d3/q9zWmcfx++fdX5ZdKC0hZUNCaCA0S1sYHEhKQ0rdrHG91IVuW3r9g1Oy2ZLmBxu6/Xq5cZzGxnUcYxvHTV3H3euN67hrb5NrzO3FaOfRlWbOOXqOpKORZqSj9wue5HpGI2mONM9nNF80a4cOHUooiqIoqm6lwQEAQB0EBwAgCMEBAAhCcAAAghAcAIAgBAcAIAjBAQAIQnAAAIIQHACAIAQHACAIwQEACEJwAACCEBwAgCAEBwAgCMEBAAhCcAAAghAcAIAgBAdqu7mxnqytraW1vnEzuzReY7u/fdLnsWe/GH1wbCWTbAcwq3Rn2JoUpl9b30hKd5+bG8n6bPr1pDh7fT2Kpd1W3Ew21rXpPTXZym4XZmwPmK3J4mOGZgiOfhttcJgbXy0lDKxGUiitqWsNneAYChrE6hAc/Tba4EhDwAkHNxis/moeaRi3swLInJ91lGGWr/l7eJZbxbwvbe3cPGCwLARHv402OFRus58lh/mM3m385tGCcV0+r7TZe6apwQyAkAMFggNDRnD0G8FhcV4ymnVq8/LJ9F+26ubeMDisICsut0zt4PAdGSl3xPuAqToqavK+UMZcprtKvvWZX56Nmbv8Bssum785XVo15l++z5Q8UfFsL20bm+vVbOzKnjAplO2srVeqYtrC+oVsw4Axmmk4rqXzjBjBYXJ2ntlOYV6u7LDVO1Kz4FjkqKHObc31Vsu5r+r9dMbMbVDmehSreizMZTZpfhPv8quDuHr+68m6772livAw510Iac/+Vj6W0yrZXuFj59638m1l3R+n7GWXvx+XT1s2v1kpYxw6RmKRcfU9tmJHcBjsHchoLOazHWXHq96RmgRHw6OUjHlffDv3/nq78/Y/yyzeT3Md6zcnazzdGznMeYQ3P3cZdtPyjUuu7vzn15WPh82c1g4xdbnefdBepm89G4/drMr2QWMdlHUzl23Nv2Radz1qjXGDMVp0XK15jQjBkTN3IHeH8O5c+6p3JHMnrBcC1gOnvAOp6gSHj7ls34Ne5mkuo7iKZpN2n92XXWfzrYvwjXvp2FVsS1Od+btjW3adSx8/Lbj9YZ7yHKGY69Jo7JTb6Yz9u3RMK+6HIXyMm4zR4uNatY1jRXCk7GcXhZ1/6cFhr0+9B6+tfnA4990pc9luU8mr+j6XVf0G0qT5FdfNXK/6oVV3/uXLdmj7ldqsqtZZv95cl3bGzsdswHnVX09N+Bg3GaPFx7X+GMWF4LB2DnsHmfE888hV70jmMqqDw5yftrw66r9UNZ9OK19wrK+bt60Ys9LSHrBz5jKjCw5lv1BvX7H/+e6TOa9ug0No4TEtc30r78dc2Xq0NkYtjGvYGMVj5MHh7uyeRmI1weI05S/ZiGKD8LPXqemOWR0c/nUyHxje4JjewFxG3Td4Q/nWRfgewOUPbL0ZaJrMv3zZRfb0W56XTqrWubrBdR8cc9Z+IZUvvOJxZCpbD/26JmO0+Lg2HaOhG3Vw2Dt42Y5c9lpo1c4nzGkqgsN6r6VsncpVBof5IHa6ivnAMK8qPmDM++U2p4D7XML/IPUHrHmbPr/HkbKaqVHWupXtf1Oe+7To2NVafy9j+8/Wqf4+ET7GTcao7XEdj9EGh7nx6zQ2a3qjGfkut9V9wNgPaP/8qgUFhxlQVnBVBceUNb0ddNbYWI1QZPe16j565u8+qzXvo71tpzVbhh10VQ969f5O+S4XZdfpnG2elTss/rG075N1uwXHrt76T2X7krVsc/8y1tdatnU/9schn0eTMW4yRovepvYYRWakwWHvFP4ym7z+AJ+VtdNN+Z5JWuUcUVi3qQ6zMpXBMeU2EK3qPGCs+djdo3zMpKzpNTXmMS1vA/GVu70Uvvtb1jgaNRUnrAv7RarJWC42drXXv2Jft1er/LGXL7PZGHc0Rs5tGo1RZEYaHPUeUFrzNneavNSdp0Fw+J+NhasTHKJ4f6brZKy7+ZjxP2DMZlBvzMKCsbi90vUy1tNcH3c9C8svNA+d7/76x6H8Oj+nmZasX+G+pFU2louNXW3q/q4F4D7tSUtbYxw+RmG3aTxGERlpcCBmw3tg2829Zq4BK0NwIDqDCw7r2br/WTrQFwQHojO04PC/RwT0E8GB6AwrOMrfHwL6iOAAAAQhOAAAQQgOAEAQggMAEITgAAAEITgAAEEIDgBAEIIDABCE4AAABCE4AABBCA4AQBCCAwAQhOAAAAQhOAAAQQgOAEAQggMAEITgAAAEITgAAEEIDgBAEIIDABCE4AAABCE4AABBCA4AQBCCAwAQhOAAAAQhOAAAQQgOAEAQggMAEITggGr3/r3k/uVLs7r80T2rrm3/XzYlgLEhOEZKguHu2TPJjZ8cTy5+/YW03vniY8lb//QPav3jy5ve+vL3zyQvHr+QvLp5PTl55r/TYNl5uJctCUBsCI6R+NsfriXbJ08kV48cTs4+87QaDmWlBUZVffVH55KNX32YvPfHvya7e4+yNQEwdARHxP73wnvJte99N3n7C59TwyCktGAIrZdfu5j84ve3OBoBBo7giMyDW9vJ9WM/Tt596gk1AJqWFgSL1HfevJK8ffkv2VoDGBKCIwLyfoW8DHXuuWfVpt9Gac2/jXr80Kn05ax7n+1m9wZA3xEcA7a3s5O+ud3GS1FVpTX9NuvzB7eSoyeuJnfuP8zuHYC+IjgG6NHfd9MjjLJPQbVdWrPvqggQoN8IjoGRj9A2+VTUoqU1+K5LPt7Lp7GA/iE4BkK+hHfh+Yna1JdRWmNfRj155HT6cV4A/UFw9Jy8LCWfktKa+TJLa+rLLPkoL2+gA/1AcPSYfLR2lUcZZmnNfNkln8A6+8En2egAWBWCo6dub/52qW9+V5XWyFdV8vFd3vsAVofg6Bn5iK1821tr3qssrYGvsg4cO88nr4AVITh6RM4n1eWX+BYprXmvuuSlK944B5aP4OgJOa/UMr7I17S0xt2Hki8OcuoSYLkIjh7oe2hIaU27TyUnTwSwHATHig0hNKS0Zt23ev2tG9moAugSwbFCQwkNKa1R97EID6B7BMeKDCk0pLQm3deSXyEE0B2CYwWGFhpSWoPuc22+/3E22gDaRnAsmXwbfGihIaU15z6XfNqKj+oC3SA4lkjOO9XX72lUldac+14SHtt3H2SjD6AtBMcS9fEb4XVLa8xDqC9//wynJwFaRnAsiZx7SmvIQymtKQ+l5IehALSH4FiCz278aZDva5ilNeQhFW+WA+0hODomJy1cxS/2tV1aMx5S8X4H0B6Co2NXjxxWG/HQSmvGQ6sXj1/ItgqARRAcHZKXqLQmPMTSGvEQi5esgMURHB06/7WvqE14iKU14SGW/Ib5zsO9bAsBaILg6Mjds2fUBjzU0prwUEt+QRBAcwRHB+SLfu8+9YTagIdaWgMect24/Wm2tQCEIjg6sH3yhNp8h1xa8x1yffunl7KtBSAUwdGy3fv3Bv+dDa205jv04qgDaIbgaNmHP/x3tfEOvbTGO/TiqANohuBoUaxHG1Ja442hOOoAwhEcLfrzm2+oTTeG0ppuDMVRBxCO4GhRbJ+kMktrujGUnIrk3me72RYEUAfB0ZLYvrfhltZ0Yyl+ahYIE2VwrK2tpeXKL3evK5u+riuvHFQbbiylNdxY6sCx89lWBFDHaILD92/zct/fVR7euaM225hKa7gxFWfOBeqLLji0QNBo09W9ret/fvlfarONqbRmG1O9unk925oAqowqOOSyvEzmZe51dVz65ktqs42ptGYbU33p6O+yrQmXNl55zd1MNtbnj6+8JlvZ1aabG8m6e8XWJFlb35jOpamtZGLdfvrvtcn0v/Jnxby19WnEXYeWtLZ+7YkqOMymb/6t8V2fXy7/r5qHkPNSxfrdDbO0phFb8XKVThurvIokQNaTjbLu2UkjLAmOKgRHsOiCwy0f7br8MvO6snmI2D9NlZfWNGIrPl2l08YqryInOKTpTR9D8jhaW8sunzXC/aOUdbnQbI7p35Np49+/XXp9SsJg/ti2jyJKgsNqvMo8vMubTj3Jp3Xu0/Q+pvfLauh6cGjz2Jo488vm412etZzViyo4TDL4ppB/+/7WxHqKEbe0phFb8WVAnTZWeRX5jzhubkybrVyRNUJpkrN+aDZH+Xt2tGAEwNZk1tRlXnYvdQIhLSU4tHnUWF56eR4K1vQmJTh885CXz7J1mo1D2fLsO7tyowkOYe5UprJpq5x77lm10cZWWtOIrR4/dCrbqjBpY5VXkRsc0ojnj7u0MaaNV/5tNF+zOVqNUuZnNvV8Xm7jdpu2TJtNY81PmYdneRIs+Xr7pze561AyD5k2/Xu+nuHLW51og2MZ9nZ21CYbY2lNI8bi3FVF2jjlVWQHh3VkkD+jzhuhPOvWnlWXNHJ//3Sb9rwhm/NT5+FZnn0EYLCmNxWDwzuPqfRIY2JcH7y81SE4FvC3P1xTm2yMpTWNGIv3OYq0ccqryA6OtOkZz6Kt4Eivnj7Llr/N5mg1SqORp2HgzGumXnCo8/AuT3r5fNrZ+xnW9CZ9/dR5CAlO872MqbDlrQ7BsYAxfH8jL61pxFj8rGx/WW8oS5N2n93X0MY8QHAsZCxvjEtpTTbGevm1i9nWRe+kz9Dnz8gbPQlvYx4gOBZx4fmJ2mRjLK3Jxlh8ERCoRnAsIObTqLulNdlYa3fvUbaFAWgIjgVoDTbW0hpsrMU3yIFyBEdD8jOxWoONtbQGG2td/uhetpUBaAiOhh7c2lYbbKylNdhY6+3Lf8m2MgANwdHQ/cuX1AYba2kNNtbafP/jbCsD0BAcDd3e/K3aYGMtrcHGWr/4/a1sKwPQEBwNERzx1utv3ci2MgANwdEQwRFvERxAOYKjoTEFxztP/rPaYGMtggMoR3A0NKbgeOPwhtpgYy2CAyhHcDQ0luCQo43HvvUbtcHGWpwhFyhHcDR05/QptdHGVmM72pDi47hAOYKjoTF8j+PtL3wuefZff6k215iL4LBp+0ZeGCeCo6GHd+6oD6SY6tff+je1scZenHLEpu0bec3JDyDNT1deetpy7YeJ5HTnbfw2hszbXIda5003fvSprfUo1dHvgCzxB58IjoYe/X1XfSDFUmM92pDi52Nt2v6RV5HzC4CazhqcBIC57P0wU3+O1WIEx1IQHKP2zhcfUx9MMdRYjzakdh7uZVsYQts/8ipygsM6AsgunzU4o7GbTS/9ezL7GdZ545cGn89rWm7zlaMFt3Hml8k8p+uVroux7P35yOXKz8z61kMuzy6z7pMx//T3xPNVMeeZ0oNj/rOx8/GzfrHQmI82bXE53SE4FnDuuWfVB1MM9dLhk2pTjb2ePHI627rIaftHXkX+Iw75fXEzJLzNVf6eHQEYRwPTEMibt8zL7ZGz+ZtkXtKkrXlOmSFjXldnPQzWffLM37qfKSU4jPtmXa/Nxzetue4dIzgWcOWVg+qDaeh1+oVvqE11DHXg2Pls6yKn7SN5FbnBIQ03f3ZsHF2k/zYarduwZw1Q5mc273xexSZuNtmZ/DKnqdrBI/PN5he8HsoRUyqfpzHvmellTnDI+uTzs+9fcT7eaQvr0B2CYwEfvf4f6oNp6DXWow2pH/z8WrZ1kdP2kbyK7OCwGnT+TDlvcNLUtWfLnoZtN3uNNFcztOS22bN0t6maISPXac23znq498mQTjdRwkzWs/SIw5YeaUznM7veN62yDl0hOBZw9+wZ9cE05Brz0YbUz07rD17UZQdH2syMZ8duk02fPcvfZtOzGuC8YacN152XSwJBm6bQVPdDJZ1uOv9Jvow66yGXu8sozH8qnU572U6/H/P3LaZlziu9T/Z81Gm1degIwbGAvZ0dtfkOuX545D/VhjqW0j6KO3uAGpWrc51LuwzVrDeKpfm6z9r7Rhp539exIYJjQWefeVptwEOsd5/7F7WZjqU+f3Ar2d17lG3ZuZBGn09r3sb3NwI5RxNLenLdmBxNqUdFESA4FnT1yGG1CQ+xxn608eLxC9lWtdVt9uZ02t915wP0HcGxoFhOdjj2ow0p31lxpeGb5eNeZ05fdjtgaAiOBe3ev6c24qHVGE9m6FbdU41oIVAVDGaAECIYOoKjBRe//oLajIdSYzx1uluPHzqVbc1qocFhhkaO8MCQERwt+PObb6gNeSjF0cZmcvTE1WxrFrlNvurfJl9YlN0G6DuCowVDPlMuRxv7VfUylTT6vFy+EPBN65seGAqCoyXnv/YVtTH3vcZ8MsO8OD8VEIbgaMn2yRNqY+5zjfnU6Wa9unk924oA6iA4WiK/zyGNWGvQfS2ONvZr++6DbCsCqIPgaNH1Yz9WG3Qfi6ON/frqj85lWw9AXQRHiz678Se1Sfexxn4yw7zOfvBJtvUA1EVwtOzSN19SG3XfasynTs+Low2gGYKjZUM46uBoY7842gCaITg60PdfBuRog6MNYBEERwf6fNTByQz3i6MNoDmCoyN9Pd362E+dLuU7fTqAegiOjshZc/v2vQ6ONvZ/rOnG7U+zrQSgCYKjQ307+SFHG3xLHGgDwdGxC89P1Ca+7OJkhpvJl47+Tv1pWABhCI6OPbi13YuXrDh1+mby3h//mm0VAIsgOJZg1S9ZcbSxmWz86sNsawBYFMGxJKv8lcCxH20cOHael6iAFhEcS7K3s5OcfeZptbF3WWM/maF8iurO/YfZVgDQBoJjieSLgct+v2Psp07ffP/jbPQBtIXgWLI7p0+pDb6LGvvRBh+9BbpBcKzAsn63Y8xHG0dPXM1GG0DbCI4Vufa976rNvs0a68kMv/3TS9koA+gCwbFCXYbHWE+d/vJrF/kEFdAxgmPFugqPMR5tEBrAchAcPdB2eIzxaENeniI0gOUgOHrixk+OqyHQpMZ2MkPeCAeWi+DoEfmo7qLf8xjbqdP5yC2wfARHz8iXBN996gk1FOrUWI425BvhfLkPWA2Co4fkR6CanI59LEcb8nvh23cfZKMFYNkIjh6Ts+qGvHQ1hpMZyllueRMcWC2Co+fk9zzqHH3Efur0J4+c5vc0gJ4gOAai6ugj5qMNeQN85+FeNhIAVo3gGBB54/zKKwcLoRHr0Yb8jsaN259m9x5AXxAcA3T/8iXrh6FiO5mh/DY4n5gC+ovgGLC7Z88k7x2YRHPqdAIDGAaCIwLypvF33ryiNuMhlHy89uwHn2T3BkDfERwRuffZbvKz0zfTZ+5ag+5TyaekfvDza7yHAQwQwREpOQqRczhJg9Ya9ypKvu0tR0YcXQDDRnCMgDyrlyMR+ZSS1tC7LHkZSj5Oy3cwgHgQHCMj34e4/NG95PW3bqQvFb14/EJ6JKA1/dCSYJLTm8u85aiC714AcSI4kMoDRUqavjT/spIjmHx6eW8FwHgQHACAIAQHACAIwQEACEJwAACCEBwAgCAEBwAgCMEBAAhCcAAAghAcAIAgBAcAIAjBAQAIQnAAAIIQHACAIAQHACAIwQEACEJwAACCEBwAgCAEBwAgCMEBAAhCcAAAghAcAIAgBAcAIMgsOCiKoiiqXh1K/h8QuM/Jpg+AfgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Taking Higher Level: 0.5627880118634262\n",
      " Taking Ordinary Level: 0.43721198813657375\n"
     ]
    }
   ],
   "source": [
    "display(Image(filename=sample_img_path))\n",
    "for result in sample_annotation:\n",
    "    print(f\"{result['column_value']}: {result['value']}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "525ea515",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "chart2table",
   "language": "python",
   "name": "chart2table"
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}