model_scoreboard.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input image\n",
    "# detect text boxes\n",
    "# detect text\n",
    "# return text and positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import os\n",
    "\n",
    "from PIL import Image\n",
    "import cv2\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "import time\n",
    "from collections import OrderedDict\n",
    "import numpy as np\n",
    "import torch\n",
    "import torchvision.transforms as transforms\n",
    "from dotmap import DotMap\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.backends.cudnn as cudnn\n",
    "from torch.autograd import Variable\n",
    "\n",
    "from craft import CRAFT\n",
    "import imgproc\n",
    "import craft_utils\n",
    "\n",
    "from ocr_model import Model\n",
    "from ocr_dataset import RawDataset, AlignCollate\n",
    "from ocr_utils import CTCLabelConverter, AttnLabelConverter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_timer_text(pred_text):\n",
    "        \n",
    "    if len(pred_text) != 4:\n",
    "        return False\n",
    "    # end\n",
    "    \n",
    "    for single_char in pred_text:\n",
    "        if not RepresentsInt_MakeO0(single_char):\n",
    "            return False\n",
    "        # end\n",
    "    # end       \n",
    "    \n",
    "    return True\n",
    "# end\n",
    "\n",
    "def is_period_text(pred_text):\n",
    "        \n",
    "    if len(pred_text) != 3:\n",
    "        return False\n",
    "    # end\n",
    "    \n",
    "    if not RepresentsInt_MakeO0(pred_text[0]):\n",
    "        return False\n",
    "    # end\n",
    "    \n",
    "    if not is_all_chars(pred_text[1:]):\n",
    "        return False\n",
    "    # end    \n",
    "    \n",
    "    return True\n",
    "# end\n",
    "\n",
    "def is_all_chars(pred_text):\n",
    "    is_all_char = True\n",
    "    for temp_char in pred_text:\n",
    "        if RepresentsInt(temp_char):\n",
    "            is_all_char = False\n",
    "            break\n",
    "        # end\n",
    "    #end\n",
    "    \n",
    "    return is_all_chars\n",
    "# end\n",
    "\n",
    "def GetInt(s):\n",
    "    try: \n",
    "        val = int(s)\n",
    "        return val\n",
    "    except ValueError:\n",
    "        if s == 'o':\n",
    "            return 0\n",
    "        # end\n",
    "        return -1\n",
    "    # end\n",
    "# end\n",
    "\n",
    "def RepresentsInt_MakeO0(s):\n",
    "    try: \n",
    "        int(s)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        if s == 'o':\n",
    "            return True\n",
    "        # end\n",
    "        return False\n",
    "    # end\n",
    "# end\n",
    "\n",
    "def RepresentsInt(s):\n",
    "    try: \n",
    "        int(s)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False\n",
    "# end\n",
    "\n",
    "def copyStateDict(state_dict):\n",
    "    if list(state_dict.keys())[0].startswith(\"module\"):\n",
    "        start_idx = 1\n",
    "    else:\n",
    "        start_idx = 0\n",
    "    new_state_dict = OrderedDict()\n",
    "    for k, v in state_dict.items():\n",
    "        name = \".\".join(k.split(\".\")[start_idx:])\n",
    "        new_state_dict[name] = v\n",
    "    return new_state_dict\n",
    "# end\n",
    "\n",
    "def init_craft():\n",
    "     # load net\n",
    "    net = CRAFT()     # initialize\n",
    "    str_trained_model_path = 'dmodel/craft_mlt_25k.pth'\n",
    "    net.load_state_dict(copyStateDict(torch.load(str_trained_model_path)))\n",
    "    \n",
    "    if True:\n",
    "        net = net.cuda()\n",
    "        net = torch.nn.DataParallel(net)\n",
    "        cudnn.benchmark = False\n",
    "\n",
    "    net.eval()\n",
    "    \n",
    "    return net\n",
    "# end\n",
    "\n",
    "def test_net(net, image, text_threshold, link_threshold, low_text, cuda, canvas_size, show_time,mag_ratio):\n",
    "    t0 = time.time()\n",
    "\n",
    "    # resize\n",
    "    img_resized, target_ratio, size_heatmap = imgproc.resize_aspect_ratio(image, canvas_size, interpolation=cv2.INTER_LINEAR, mag_ratio=mag_ratio)\n",
    "    ratio_h = ratio_w = 1 / target_ratio\n",
    "\n",
    "    # preprocessing\n",
    "    x = imgproc.normalizeMeanVariance(img_resized)\n",
    "    x = torch.from_numpy(x).permute(2, 0, 1)    # [h, w, c] to [c, h, w]\n",
    "    x = Variable(x.unsqueeze(0))                # [c, h, w] to [b, c, h, w]\n",
    "    if cuda:\n",
    "        x = x.cuda()\n",
    "\n",
    "    # forward pass\n",
    "    y, _ = net(x)\n",
    "\n",
    "    # make score and link map\n",
    "    score_text = y[0,:,:,0].cpu().data.numpy()\n",
    "    score_link = y[0,:,:,1].cpu().data.numpy()\n",
    "\n",
    "    t0 = time.time() - t0\n",
    "    t1 = time.time()\n",
    "    \n",
    "    # Post-processing\n",
    "    boxes = craft_utils.getDetBoxes(score_text, score_link, text_threshold, link_threshold, low_text)\n",
    "    boxes = craft_utils.adjustResultCoordinates(boxes, ratio_w, ratio_h)\n",
    "\n",
    "    t1 = time.time() - t1\n",
    "    \n",
    "    if show_time : print(\"\\ninfer/postproc time : {:.3f}/{:.3f}\".format(t0, t1))\n",
    "\n",
    "    return boxes\n",
    "# end\n",
    "\n",
    "def init_ocr(opt):\n",
    "    \"\"\" model configuration \"\"\"\n",
    "    if 'CTC' in opt['Prediction']:\n",
    "        converter = CTCLabelConverter(opt['character'])\n",
    "    else:\n",
    "        converter = AttnLabelConverter(opt['character'])\n",
    "    opt['num_class'] = len(converter.character)\n",
    "\n",
    "    if opt['rgb']:\n",
    "        opt['input_channel'] = 3\n",
    "    model = Model(opt)\n",
    "    print('model input parameters', opt['imgH'], opt['imgW'], opt['num_fiducial'], opt['input_channel'], opt['output_channel'],\n",
    "          opt['hidden_size'], opt['num_class'], opt['batch_max_length'], opt['Transformation'], opt['FeatureExtraction'],\n",
    "          opt['SequenceModeling'], opt['Prediction'])\n",
    "\n",
    "    model = torch.nn.DataParallel(model)\n",
    "    if torch.cuda.is_available():\n",
    "        model = model.cuda()\n",
    "\n",
    "    # load model\n",
    "    print('loading pretrained model from %s' % opt['saved_model'])\n",
    "    model.load_state_dict(torch.load(opt['saved_model']))\n",
    "\n",
    "    # prepare data. two demo images from https://github.com/bgshih/crnn#run-demo\n",
    "    # sai removed here\n",
    "\n",
    "    # predict\n",
    "    model.eval()\n",
    "    \n",
    "    return (model, converter)\n",
    "# end    \n",
    "\n",
    "def run_ocr(model, converter, image_tensors, opt):    \n",
    "    batch_size = image_tensors.size(0)\n",
    "    with torch.no_grad():\n",
    "        image = image_tensors.cuda()\n",
    "        # For max length prediction\n",
    "        length_for_pred = torch.cuda.IntTensor([opt['batch_max_length']] * batch_size)\n",
    "        text_for_pred = torch.cuda.LongTensor(batch_size, opt['batch_max_length'] + 1).fill_(0)\n",
    "\n",
    "    if 'CTC' in opt['Prediction']:\n",
    "        preds = model(image, text_for_pred).log_softmax(2)\n",
    "\n",
    "        # Select max probabilty (greedy decoding) then decode index to character\n",
    "        preds_size = torch.IntTensor([preds.size(1)] * batch_size)\n",
    "        _, preds_index = preds.permute(1, 0, 2).max(2)\n",
    "        preds_index = preds_index.transpose(1, 0).contiguous().view(-1)\n",
    "        preds_str = converter.decode(preds_index.data, preds_size.data)\n",
    "\n",
    "    else:\n",
    "        preds = model(image, text_for_pred, is_train=False)\n",
    "\n",
    "        # select max probabilty (greedy decoding) then decode index to character\n",
    "        _, preds_index = preds.max(2)\n",
    "        preds_str = converter.decode(preds_index, length_for_pred)\n",
    "    # end\n",
    "\n",
    "    # print('-' * 80)\n",
    "    # print('image_path\\tpredicted_labels')\n",
    "    # print('-' * 80)\n",
    "    \n",
    "    pred_str_arr = []\n",
    "    \n",
    "    for index, pred in enumerate(preds_str):\n",
    "        if 'Attn' in opt['Prediction']:\n",
    "            pred = pred[:pred.find('[s]')]  # prune after \"end of sentence\" token ([s])\n",
    "        # end\n",
    "        pred_str_arr.append(pred)\n",
    "        # print('img_name<',index, '> pred<',pred, '>')\n",
    "    # end\n",
    "    \n",
    "    return pred_str_arr\n",
    "# end\n",
    "\n",
    "def preprocess_and_convert_to_tensorsarr(img_arr, tw, th):\n",
    "    image_tensors = []\n",
    "    for img in img_arr:\n",
    "        img = Image.fromarray(img)\n",
    "        img = img.resize((tw, th), Image.BICUBIC)\n",
    "        img = transforms.ToTensor()(img)\n",
    "        img.sub_(0.5).div_(0.5)\n",
    "        image_tensors.append(img)\n",
    "    # end\n",
    "    \n",
    "    image_tensors = torch.cat([t.unsqueeze(0) for t in image_tensors], 0)\n",
    "    \n",
    "    return image_tensors\n",
    "# end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_image(image):\n",
    "\n",
    "    qtr_img = image[0:int(image.shape[0]/8), 0:image.shape[1]]      \n",
    "    bboxes = test_net(net, qtr_img, text_threshold, link_threshold, low_text, cuda, canvas_size, show_time, mag_ratio)\n",
    "\n",
    "    b_plot = True\n",
    "    len_boxes = len(bboxes)\n",
    "    crop_img_arr = []\n",
    "\n",
    "    for index, box in enumerate(bboxes):\n",
    "\n",
    "        box = box.astype(np.int32)\n",
    "        x = box[0][0]\n",
    "        w = box[1][0]-box[0][0]\n",
    "        y = box[0][1]\n",
    "        h = box[3][1]-box[0][1]\n",
    "\n",
    "        delta = 0\n",
    "        x = x - delta\n",
    "        y = y - delta\n",
    "        w = w + 2*delta\n",
    "        h = h + 2*delta\n",
    "\n",
    "        if x < 0 or y < 0 or x+w > image.shape[1] or y+h > image.shape[0]:\n",
    "            continue\n",
    "        # end                   \n",
    "\n",
    "        crop_img = image[y:y+h, x:x+w]   \n",
    "        # crop_img_arr.append(crop_img)\n",
    "        crop_img_arr.append(cv2.cvtColor(crop_img, cv2.COLOR_BGR2GRAY))\n",
    "\n",
    "        if b_plot:    \n",
    "            plt.subplot(len_boxes, 1, index+1)\n",
    "            plt.imshow(crop_img)\n",
    "        # end\n",
    "\n",
    "    # end\n",
    "\n",
    "    if b_plot:\n",
    "        plt.show()\n",
    "    # end   \n",
    "    \n",
    "    if len_boxes == 0 or len(crop_img_arr) == 0:\n",
    "        return ([], [])\n",
    "    # end\n",
    "\n",
    "    image_tensors = preprocess_and_convert_to_tensorsarr(crop_img_arr, opt['imgW'], opt['imgH'])\n",
    "\n",
    "    pred_text_arr = run_ocr(ocr_model, ocr_converter, image_tensors, opt)\n",
    "    \n",
    "    if len(pred_text_arr) != len_boxes:\n",
    "        print('boxes len<', len_boxes, '> pred len<', len(pred_text_arr), '>')\n",
    "        # raise('pred and boxes dont match. Not expected to come here')\n",
    "        return ([],[])\n",
    "    # end        \n",
    "    \n",
    "    return (bboxes, pred_text_arr)\n",
    "# end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_boxes_in_straight_line(bboxes, delta_error):\n",
    "    mean_pts = []\n",
    "    last_y = 0\n",
    "    pts_in_line_arr = []\n",
    "    scoreboard_bboxes = []\n",
    "    for index, bbox in enumerate(bboxes):\n",
    "        mean_pt = [0, 0]\n",
    "        for pt in bbox:\n",
    "            mean_pt[0] += pt[0]\n",
    "            mean_pt[1] += pt[1]\n",
    "        # end\n",
    "        mean_pt[0] = mean_pt[0]/4\n",
    "        mean_pt[1] = mean_pt[1]/4\n",
    "        \n",
    "        if mean_pt[1] - last_y > delta_error:\n",
    "            # assumption points are ordered by x\n",
    "            pts_in_line_arr.append(scoreboard_bboxes)\n",
    "            scoreboard_bboxes = []\n",
    "            last_y = mean_pt[1]\n",
    "        # end\n",
    "        scoreboard_bboxes.append(index)        \n",
    "        mean_pts.append(mean_pt)\n",
    "    # end\n",
    "    \n",
    "    pts_in_line_arr.append(scoreboard_bboxes)    \n",
    "    \n",
    "    return  pts_in_line_arr\n",
    "# end\n",
    "\n",
    "def convert_bbox_rect(box):\n",
    "    box = box.astype(np.int32)\n",
    "    x = box[0][0]\n",
    "    w = box[1][0]-box[0][0]\n",
    "    y = box[0][1]\n",
    "    h = box[3][1]-box[0][1]\n",
    "    return [x, y, w, h]\n",
    "# end\n",
    "\n",
    "def is_scoreboard_2(pts_in_line, bboxes, pred_text_arr):\n",
    "    if len(pts_in_line) != 6:\n",
    "        return ({},{})\n",
    "    # end\n",
    "\n",
    "    if not is_all_chars(pred_text_arr[pts_in_line[0]]):\n",
    "        # t1_name is expected to be all strings\n",
    "        return {}\n",
    "    # end\n",
    "\n",
    "    if not RepresentsInt_MakeO0(pred_text_arr[pts_in_line[1]]):\n",
    "        # t1_score is expected to be int\n",
    "        return ({},{})\n",
    "    # end\n",
    "\n",
    "    if not is_period_text(pred_text_arr[pts_in_line[2]]):\n",
    "        # period expected to match the template\n",
    "        return ({},{})\n",
    "    # end\n",
    "    \n",
    "    if not is_timer_text(pred_text_arr[pts_in_line[3]]):\n",
    "        # timer is expected to be 4 numbers \n",
    "        return ({},{})\n",
    "    # end\n",
    "\n",
    "    if not RepresentsInt_MakeO0(pred_text_arr[pts_in_line[4]]):\n",
    "        # t2_score is expected to be int\n",
    "        return ({},{})\n",
    "    # end\n",
    "\n",
    "    if not is_all_chars(pred_text_arr[pts_in_line[5]]):\n",
    "        # t2_name is expected to be all strings\n",
    "        return ({},{})\n",
    "    # end\n",
    "\n",
    "   \n",
    "\n",
    "    scoreboard_bbox = {\n",
    "    't1_name': convert_bbox_rect(bboxes[pts_in_line[0]]),\n",
    "    't1_score': convert_bbox_rect(bboxes[pts_in_line[1]]),\n",
    "    't2_name': convert_bbox_rect(bboxes[pts_in_line[5]]),\n",
    "    't2_score': convert_bbox_rect(bboxes[pts_in_line[4]]),\n",
    "    'period': convert_bbox_rect(bboxes[pts_in_line[2]]),\n",
    "    'timer': convert_bbox_rect(bboxes[pts_in_line[3]])        \n",
    "    }\n",
    "    \n",
    "    scoreboard_values = {\n",
    "    't1_name': pred_text_arr[pts_in_line[0]],\n",
    "    't1_score': GetInt(pred_text_arr[pts_in_line[1]]),\n",
    "    't2_name': pred_text_arr[pts_in_line[5]],\n",
    "    't2_score': GetInt(pred_text_arr[pts_in_line[4]]),\n",
    "    'period': pred_text_arr[pts_in_line[2]],\n",
    "    'timer': pred_text_arr[pts_in_line[3]]        \n",
    "    }\n",
    "    \n",
    "    return (scoreboard_bbox, scoreboard_values)\n",
    "# end\n",
    "\n",
    "def is_scoreboard_1(pts_in_line, bboxes, pred_text_arr):\n",
    "    if len(pts_in_line) != 6:\n",
    "        return ({},{})\n",
    "    # end\n",
    "\n",
    "    if not is_all_chars(pred_text_arr[pts_in_line[0]]):\n",
    "        # t1_name is expected to be all strings\n",
    "        return {}\n",
    "    # end\n",
    "\n",
    "    if not RepresentsInt_MakeO0(pred_text_arr[pts_in_line[1]]):\n",
    "        # t1_score is expected to be int\n",
    "        return ({},{})\n",
    "    # end\n",
    "\n",
    "    if not is_period_text(pred_text_arr[pts_in_line[2]]):\n",
    "        # period expected to match the template\n",
    "        return ({},{})\n",
    "    # end\n",
    "\n",
    "    if not RepresentsInt_MakeO0(pred_text_arr[pts_in_line[3]]):\n",
    "        # t2_score is expected to be int\n",
    "        return ({},{})\n",
    "    # end\n",
    "\n",
    "    if not is_all_chars(pred_text_arr[pts_in_line[4]]):\n",
    "        # t2_name is expected to be all strings\n",
    "        return ({},{})\n",
    "    # end\n",
    "\n",
    "    if not is_timer_text(pred_text_arr[pts_in_line[5]]):\n",
    "        # timer is expected to be 4 numbers \n",
    "        return ({},{})\n",
    "    # end\n",
    "\n",
    "    scoreboard_bbox = {\n",
    "    't1_name': convert_bbox_rect(bboxes[pts_in_line[0]]),\n",
    "    't1_score': convert_bbox_rect(bboxes[pts_in_line[1]]),\n",
    "    't2_name': convert_bbox_rect(bboxes[pts_in_line[4]]),\n",
    "    't2_score': convert_bbox_rect(bboxes[pts_in_line[3]]),\n",
    "    'period': convert_bbox_rect(bboxes[pts_in_line[2]]),\n",
    "    'timer': convert_bbox_rect(bboxes[pts_in_line[5]])        \n",
    "    }\n",
    "    \n",
    "    scoreboard_values = {\n",
    "    't1_name': pred_text_arr[pts_in_line[0]],\n",
    "    't1_score': GetInt(pred_text_arr[pts_in_line[1]]),\n",
    "    't2_name': pred_text_arr[pts_in_line[4]],\n",
    "    't2_score': GetInt(pred_text_arr[pts_in_line[3]]),\n",
    "    'period': pred_text_arr[pts_in_line[2]],\n",
    "    'timer': pred_text_arr[pts_in_line[5]]        \n",
    "    }\n",
    "    \n",
    "    return (scoreboard_bbox, scoreboard_values)\n",
    "# end\n",
    "\n",
    "def did_match(pts_in_line_arr, bboxes, pred_text_arr):\n",
    "    \n",
    "    res = ({}, {})\n",
    "    \n",
    "    for pts_in_line in pts_in_line_arr:\n",
    "        res_1 = is_scoreboard_1(pts_in_line, bboxes, pred_text_arr)           \n",
    "        res_2 = is_scoreboard_2(pts_in_line, bboxes, pred_text_arr)           \n",
    "        if res_1 != ({}, {}):\n",
    "            res = res_1\n",
    "        elif res_2 != ({}, {}):\n",
    "            res = res_2\n",
    "        # end        \n",
    "    # end\n",
    "    \n",
    "    return res\n",
    "    \n",
    "# end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "text_threshold = 0.7\n",
    "low_text = 0.4\n",
    "link_threshold = 0.4\n",
    "canvas_size = 1280\n",
    "mag_ratio = 1.5\n",
    "cuda = True\n",
    "show_time = False\n",
    "no_of_matches_required_for_team_names = 20\n",
    "skip_delta_in_secs = 10\n",
    "i_print_frequency = 100\n",
    "max_pos_error = 2\n",
    "\n",
    "opt = DotMap({\n",
    "    'imgW': 100,\n",
    "    'imgH': 32,\n",
    "    'workers' : 4,\n",
    "    'batch_size' : 192,\n",
    "    'saved_model' : 'dmodel/TPS-ResNet-BiLSTM-Attn.pth',\n",
    "    'batch_max_length' : 25  ,\n",
    "    'rgb' : False,\n",
    "    'character' :'0123456789abcdefghijklmnopqrstuvwxyz',\n",
    "    'sensitive' : False ,\n",
    "    'PAD' : False,\n",
    "    'Transformation' : 'TPS',\n",
    "    'FeatureExtraction' : 'ResNet',\n",
    "    'SequenceModeling' : 'BiLSTM',\n",
    "    'Prediction' : 'Attn',\n",
    "    'num_fiducial' : 20,\n",
    "    'input_channel' : 1,\n",
    "    'output_channel' : 512,\n",
    "    'hidden_size' : 256,\n",
    "    'num_gpu' : torch.cuda.device_count()\n",
    "})\n",
    "\n",
    "cudnn.benchmark = True\n",
    "cudnn.deterministic = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model input parameters 32 100 20 1 512 256 38 25 TPS ResNet BiLSTM Attn\n",
      "loading pretrained model from dmodel/TPS-ResNet-BiLSTM-Attn.pth\n"
     ]
    }
   ],
   "source": [
    "net = init_craft()\n",
    "ocr_model, ocr_converter = init_ocr(opt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ubc', 'alb', '1st', '801', '0', 'canada', 'west', 'hockey']\n"
     ]
    }
   ],
   "source": [
    "# image = imgproc.loadImage('/mnt/disks/d1/s/code/sih/score_extraction/tempcandelete_15-20190407-game12/frame_213011.jpg')\n",
    "image = imgproc.loadImage('/mnt/disks/d1/s/data/apra/tempcandelete/alb_1800.jpg')\n",
    "kernel = np.ones((3,3),np.uint8)\n",
    "dilation = cv2.dilate(image,kernel,iterations = 1)\n",
    "erosion = cv2.erode(image,kernel,iterations = 1)\n",
    "dilation2 = cv2.dilate(erosion,kernel,iterations = 1)\n",
    "out = process_image(dilation)\n",
    "print(out[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pts_in_line_arr = find_boxes_in_straight_line(out[0], 10)\n",
    "did_match(pts_in_line_arr, out[0], out[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "boxes len< 8 > pred len< 7 >\n",
      "processed< 100 > offset< 2790 >\n",
      "processed< 200 > offset< 3790 >\n",
      "processed< 300 > offset< 4790 >\n",
      "boxes len< 10 > pred len< 9 >\n",
      "processed< 400 > offset< 5790 >\n",
      "processed< 500 > offset< 6790 >\n",
      "boxes len< 9 > pred len< 8 >\n",
      "processed< 600 > offset< 7790 >\n"
     ]
    }
   ],
   "source": [
    "video_fullpath = '/mnt/disks/d1/s/data/apra/source/15-20190407-game12_source.mp4'\n",
    "t1_name = 'WAIN'\n",
    "t2_name = 'ADR'\n",
    "\n",
    "# net = init_craft()\n",
    "# ocr_model, ocr_converter = init_ocr(opt)\n",
    "\n",
    "v=cv2.VideoCapture(video_fullpath)\n",
    "\n",
    "i_counter = 0\n",
    "i_offset_in_secs = 1800 # offset in seconds \n",
    "\n",
    "# State Variables\n",
    "cur_team_1_score = 0\n",
    "cur_team_2_score = 0\n",
    "team_1_score_history = {} \n",
    "team_2_score_history = {}\n",
    "\n",
    "while True:\n",
    "    i_counter += 1\n",
    "    v.set(cv2.CAP_PROP_POS_MSEC, i_offset_in_secs*1000)\n",
    "    ret, frame = v.read()    \n",
    "    if ret != True:\n",
    "        break\n",
    "    # end\n",
    "    \n",
    "    img_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n",
    "    bboxes, pred_text_arr = process_image(frame, t1_name, t2_name)\n",
    "    \n",
    "    if i_counter % i_print_frequency == 0:\n",
    "        print('processed<', i_counter, '> offset<', i_offset_in_secs, '>')\n",
    "    # end    \n",
    "    \n",
    "    if len(bboxes) == 0:\n",
    "        i_offset_in_secs += skip_delta_in_secs    \n",
    "        continue\n",
    "    # end\n",
    "    \n",
    "    pts_in_line_arr = find_boxes_in_straight_line(bboxes, 10)        \n",
    "    scoreboard_bbox, scoreboard_values = did_match(pts_in_line_arr, bboxes, pred_text_arr)\n",
    "    \n",
    "    if scoreboard_bbox == {}:\n",
    "        i_offset_in_secs += skip_delta_in_secs    \n",
    "        continue\n",
    "    # end\n",
    "    \n",
    "    if cur_team_1_score != scoreboard_values['t1_score']:\n",
    "        \n",
    "        if scoreboard_values['t1_score'] - cur_team_1_score != 1:\n",
    "            print('t1_score_error prev_score<', cur_team_1_score, '> new_det_score<', scoreboard_values['t1_score'], '>')\n",
    "        # end        \n",
    "        cv2.imwrite('scorechanges/'+ video_fullpath.split('_source')[0] + '_'+str(i_offset_in_secs).zfill(10)+'.jpg', frame)\n",
    "        team_1_score_history[i_offset_in_secs] = scoreboard_values['t1_score']\n",
    "        cur_team_1_score = scoreboard_values['t1_score']\n",
    "    # end\n",
    "    \n",
    "    if cur_team_2_score != scoreboard_values['t2_score']:\n",
    "        if scoreboard_values['t2_score'] - cur_team_2_score != 1:\n",
    "            print('t2_score_error prev_score<', cur_team_2_score, '> new_det_score<', scoreboard_values['t2_score'], '>')\n",
    "        # end\n",
    "        cv2.imwrite('scorechanges/'+ video_fullpath.split('_source')[0] + '_'+str(i_offset_in_secs).zfill(10)+'.jpg', frame)\n",
    "        team_2_score_history[i_offset_in_secs] = scoreboard_values['t2_score']\n",
    "        cur_team_2_score = scoreboard_values['t2_score']\n",
    "    # end                   \n",
    "    \n",
    "    i_offset_in_secs += skip_delta_in_secs    \n",
    "# end\n",
    "\n",
    "print('Completed. Processed<', i_counter, '> offset<', i_offset_in_secs, '>')\n",
    "print(team_1_score_history)\n",
    "print(team_2_score_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [ ] Run for all videos\n",
    "- [ ] Run for entire video\n",
    "- [ ] Find Start Game\n",
    "- [ ] Find End Game\n",
    "- [ ] Track Scoreboard\n",
    "- [ ] Track the 3 periods\n",
    "- [ ] Track No Scoreboard times\n",
    "- [ ] Sanity check - Scoreboard Location should not deviate by much and the team names should be same\n",
    "- [ ] Allow for some misdetections - smoothing window"
   ]
  },
  {
   "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}