syches_final.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 76,
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from glob import glob\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.style.use('ggplot')"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-26T20:53:41.477148Z",
     "start_time": "2023-08-26T20:53:40.329823Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "находим изображения"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "outputs": [],
   "source": [
    "relative_path = \"/Users/daria/Downloads/hak2023-main/Data/zn/images/*\"\n",
    "\n",
    "imgs_path = glob(relative_path)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-26T20:53:41.494520Z",
     "start_time": "2023-08-26T20:53:41.478951Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "для тестов возьмем 5 адресов"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "outputs": [
    {
     "data": {
      "text/plain": "['/Users/daria/Downloads/hak2023-main/Data/zn/images/bbb2ec82-ab95-42f9-be90-58c0e35c653c.png',\n '/Users/daria/Downloads/hak2023-main/Data/zn/images/8a7a366c-ae97-45ad-87c4-0f6487b8e9ba.png',\n '/Users/daria/Downloads/hak2023-main/Data/zn/images/74f4b236-c1a7-45a6-b11a-2d5ab5325db3.png',\n '/Users/daria/Downloads/hak2023-main/Data/zn/images/3e9053a6-c5c3-4b21-815a-fb7fdf758150.png',\n '/Users/daria/Downloads/hak2023-main/Data/zn/images/0578d9d6-0353-4a1c-9fad-91e1f2d9864e.png']"
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs_path = imgs_path[:5]\n",
    "imgs_path"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-26T20:53:41.515101Z",
     "start_time": "2023-08-26T20:53:41.489985Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "(раскомм.) изобразить первые 20"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "outputs": [],
   "source": [
    "# fig, axs = plt.subplots(20, 1, figsize=(50, 100))\n",
    "# axs = axs.flatten()\n",
    "# \n",
    "# imgs_to_print = len(imgs_path) if len(imgs_path) < 20 else 20\n",
    "# \n",
    "# for i in range(imgs_to_print):\n",
    "#     axs[i].imshow(plt.imread(imgs_path[i]))\n",
    "#     axs[i].axis('off')\n",
    "#     axs[i].set_title(imgs_path[i].split('/')[-1])\n",
    "# plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-26T20:53:41.565871Z",
     "start_time": "2023-08-26T20:53:41.500109Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "указываем платформу"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "outputs": [],
   "source": [
    "platforms_dict = {'tg': 0, 'vk': 1, 'yt1': 2, 'yt2': 3, 'zn': 4}\n",
    "\n",
    "platform = platforms_dict['zn']"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-26T20:53:41.586399Z",
     "start_time": "2023-08-26T20:53:41.510758Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "детектим текст"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Neither CUDA nor MPS are available - defaulting to CPU. Note: This module is much faster with a GPU.\n"
     ]
    }
   ],
   "source": [
    "import easyocr\n",
    "\n",
    "reader = easyocr.Reader(['ru'], gpu = True)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-26T20:53:45.741895Z",
     "start_time": "2023-08-26T20:53:41.518202Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "заведем массив содержащий имя файла и данные об обнаруженном тексте (~13сек/изображение)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/daria/Downloads/hak2023-main/Data/zn/images/bbb2ec82-ab95-42f9-be90-58c0e35c653c.png\n",
      "/Users/daria/Downloads/hak2023-main/Data/zn/images/8a7a366c-ae97-45ad-87c4-0f6487b8e9ba.png\n",
      "/Users/daria/Downloads/hak2023-main/Data/zn/images/74f4b236-c1a7-45a6-b11a-2d5ab5325db3.png\n",
      "/Users/daria/Downloads/hak2023-main/Data/zn/images/3e9053a6-c5c3-4b21-815a-fb7fdf758150.png\n",
      "/Users/daria/Downloads/hak2023-main/Data/zn/images/0578d9d6-0353-4a1c-9fad-91e1f2d9864e.png\n"
     ]
    }
   ],
   "source": [
    "imgs_data = pd.DataFrame(columns = [\"name\", \"data\"])\n",
    "\n",
    "for i in range(len(imgs_path)):\n",
    "    print(imgs_path[i])\n",
    "    img_path = imgs_path[i]\n",
    "    img_detect = pd.DataFrame(reader.readtext(img_path), columns=[\"bbox\", \"text\", \"conf\"])\n",
    "    img_name = img_path.split('/')[-1]\n",
    "\n",
    "    imgs_data.loc[len(imgs_data)] = {\"name\": img_name, \"data\": img_detect}"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-26T20:53:45.747028Z",
     "start_time": "2023-08-26T20:53:45.742581Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "в зависимости от выбранной платформы выбираем функцию для обработки"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "вспомогательные функции"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "outputs": [],
   "source": [
    "def find_strings_with_percent(strings):\n",
    "    result = []\n",
    "\n",
    "    for s in strings:\n",
    "        if \"%\" in s:\n",
    "            result.append(s)\n",
    "\n",
    "    return result\n",
    "\n",
    "import math\n",
    "def find_rectangle_center(vertices):\n",
    "    x_sum = 0\n",
    "    y_sum = 0\n",
    "    #print(\"f_r_c, vertices:\", vertices)\n",
    "    num_vertices = len(vertices)\n",
    "\n",
    "    for vertex in vertices:\n",
    "        x_sum += vertex[0]\n",
    "        y_sum += vertex[1]\n",
    "\n",
    "    x_center = x_sum / num_vertices\n",
    "    y_center = y_sum / num_vertices\n",
    "\n",
    "    return x_center, y_center\n",
    "\n",
    "def is_digit(string):\n",
    "    if string.isdigit():\n",
    "        return True\n",
    "    else:\n",
    "        try:\n",
    "            float(string)\n",
    "            return True\n",
    "        except ValueError:\n",
    "            return False\n",
    "\n",
    "def get_num_strings(df):\n",
    "    num_strings = []\n",
    "    for t_line in df:\n",
    "        if is_digit(t_line):\n",
    "            num_strings.append(t_line)\n",
    "    return num_strings"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-08-26T20:53:45.746787Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "tg"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "outputs": [],
   "source": [
    "# Нахождение названия метрики на скрине\n",
    "def get_metric_name_coord_tg(df):\n",
    "    # Выбираем строки где есть название метрик и достаем ячейку с координатами\n",
    "    t_line = df.loc[df['text'] == 'VR']['bbox']\n",
    "    if t_line.empty:\n",
    "        print('VR не найден')\n",
    "        t_line = df.loc[df['text'] == 'ERR']['bbox']\n",
    "        if t_line.empty:\n",
    "            print('ERR не найден')\n",
    "            t_line = df.loc[df['text'] == 'ER']['bbox']\n",
    "            if t_line.empty:\n",
    "                print('ER не найден')\n",
    "                return\n",
    "    # Получаем список координат названия\n",
    "    t_coord = t_line.values[0]\n",
    "    return t_coord\n",
    "\n",
    "def get_metric_from_tg(df):\n",
    "    # Нахождение название метрики на скрине\n",
    "    t_coord = get_metric_name_coord_tg(df)\n",
    "\n",
    "    # Теперь, чтобы понять какое из значений - наша метрика, будем находить центры прямоугольников с текстом\n",
    "    # и наименьшее расстояние между названием метрики и строк с процентами\n",
    "\n",
    "    center_text_x, center_text_y = find_rectangle_center(t_coord)\n",
    "\n",
    "    distance_list = []\n",
    "    text_list = []\n",
    "\n",
    "    strings_with_percent = find_strings_with_percent(df['text'])\n",
    "\n",
    "    for metric_text in strings_with_percent:\n",
    "        metric_coord = df.loc[df['text'] == metric_text]['bbox'].values[0]\n",
    "        center_x, center_y = find_rectangle_center(metric_coord)\n",
    "        distance = math.sqrt((center_text_x - center_x)**2 + (center_text_y - center_y)**2)\n",
    "        distance_list.append(distance)\n",
    "        text_list.append(metric_text)\n",
    "\n",
    "    # Находим индекc минимального расстояния и с помощью него ищем нашу метрику\n",
    "    index = distance_list.index(min(distance_list))\n",
    "    print(index)\n",
    "    print('VR =', text_list[index])\n",
    "    return text_list[index]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-26T20:53:45.769334Z",
     "start_time": "2023-08-26T20:53:45.749399Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "zn"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "outputs": [],
   "source": [
    "def get_metric_name_coord_zn(df):\n",
    "    # Выбираем строки где есть название метрик и достаем ячейку с координатами\n",
    "    t_line = df.loc[df['text'] == 'Дочитывания']['bbox']\n",
    "    if t_line.empty:\n",
    "        print('Метрика не найдена')\n",
    "        return\n",
    "    # Получаем список координат названия\n",
    "    t_coord = t_line.values[0]\n",
    "    return t_coord\n",
    "\n",
    "def get_metric_from_zn(df):\n",
    "    # Нахождение название метрики на скрине\n",
    "    t_coord = get_metric_name_coord_zn(df)\n",
    "\n",
    "    # Теперь, чтобы понять какое из значений - наша метрика, будем находить центры прямоугольников с текстом\n",
    "    # и наименьшее расстояние между названием метрики и строк с процентами\n",
    "\n",
    "    centr_text_x, centr_text_y = find_rectangle_center(t_coord)\n",
    "\n",
    "    distance_list = []\n",
    "    text_list = []\n",
    "    num_strings = get_num_strings(df['text'])\n",
    "\n",
    "    for metric_text in num_strings:\n",
    "        metric_coord = df.loc[df['text'] == metric_text]['bbox'].values[0]\n",
    "        center_x, center_y = find_rectangle_center(metric_coord)\n",
    "        distance = math.sqrt((centr_text_x - center_x)**2 + (centr_text_y - center_y)**2)\n",
    "        distance_list.append(distance)\n",
    "        text_list.append(metric_text)\n",
    "\n",
    "    # Находим индекc минимального расстояния и с помощью него ищем нашу метрику\n",
    "    index = distance_list.index(min(distance_list))\n",
    "    return text_list[index]\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-08-26T20:53:45.753612Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "yt просмотры"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "outputs": [],
   "source": [
    "def get_metric_name_coord_yt2(df):\n",
    "    # Выбираем строку где есть название метрик и достаем ячейку с координатами\n",
    "    t_line = df.loc[df['text'] == 'Просмотры']['bbox']\n",
    "    if t_line.empty:\n",
    "        print('Метрика не найдена')\n",
    "        return\n",
    "    # Получаем список координат названия\n",
    "    t_coord = t_line.values[0]\n",
    "    return t_coord\n",
    "\n",
    "def get_matching_str_yt2(df):\n",
    "    import re\n",
    "    pattern = r\"[1-9]*,*[1-9][ ]*(млн|тыс.)*\"\n",
    "    str_l = df['text']\n",
    "    matching_strings = [s for s in str_l if re.match(pattern, s)]\n",
    "    return matching_strings\n",
    "\n",
    "def get_metric_from_yt2(df):\n",
    "    # Нахождение название метрики на скрине\n",
    "    t_coord = get_metric_name_coord_yt2(df)\n",
    "\n",
    "    # Теперь, чтобы понять какое из значений - наша метрика, будем находить центры прямоугольников с текстом\n",
    "    # и наименьшее расстояние между названием метрики и строк с процентами\n",
    "\n",
    "    center_text_x, center_text_y = find_rectangle_center(t_coord)\n",
    "    matching_strings = get_matching_str_yt2(df)\n",
    "    distance_list = []\n",
    "    text_list = []\n",
    "\n",
    "    for metric_text in matching_strings:\n",
    "        metric_coord = df.loc[df['text'] == metric_text]['bbox'].values[0]\n",
    "        center_x, center_y = find_rectangle_center(metric_coord)\n",
    "        distance = math.sqrt((center_text_x - center_x)**2 + (center_text_y - center_y)**2)\n",
    "        distance_list.append(distance)\n",
    "        text_list.append(metric_text)\n",
    "\n",
    "    # Находим индекc минимального расстояния и с помощью него ищем нашу метрику\n",
    "    index = distance_list.index(min(distance_list))\n",
    "    return text_list[index]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-08-26T20:53:45.757660Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "yt подпищеки"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "outputs": [],
   "source": [
    "def get_metric_name_list_yt1(df):\n",
    "    import re\n",
    "    pattern = r\"(.)*[Пп]одписчик[аи]?(ов)?\"\n",
    "    str_l = df['text']\n",
    "    matching_strings = [s for s in str_l if re.match(pattern, s)]\n",
    "    return matching_strings\n",
    "\n",
    "def get_metric_from_yt1(df):\n",
    "    metric_text = get_metric_name_list_yt1(df)\n",
    "\n",
    "    metric_coord = df.loc[df['text'] == metric_text[0]]['bbox'].values[0]\n",
    "\n",
    "    center_text_x, center_text_y = find_rectangle_center(metric_coord)\n",
    "\n",
    "    num_strings = get_num_strings(df['text'])\n",
    "\n",
    "    distance_list = []\n",
    "    text_list = []\n",
    "\n",
    "    for metric_text in num_strings:\n",
    "        metric_coord = df.loc[df['text'] == metric_text]['bbox'].values[0]\n",
    "        center_x, center_y = find_rectangle_center(metric_coord)\n",
    "        distance = math.sqrt((center_text_x - center_x)**2 + (center_text_y - center_y)**2)\n",
    "        distance_list.append(distance)\n",
    "        text_list.append(metric_text)\n",
    "\n",
    "    # Находим индекc минимального расстояния и с помощью него ищем нашу метрику\n",
    "    index = distance_list.index(min(distance_list))\n",
    "    print(text_list[index])\n",
    "    return text_list[index]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-08-26T20:53:45.762321Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "vk features"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "outputs": [],
   "source": [
    "def sum(data:dict) -> int:\n",
    "    sum = 0\n",
    "    for i in data.keys():\n",
    "        print(i)\n",
    "        sum+= data[i]\n",
    "    return sum\n",
    "\n",
    "def find(df, bbox:list) -> list:\n",
    "    \"\"\"\n",
    "    Расширяем область поиска\n",
    "    \"\"\"\n",
    "    bboxes = df.bbox.tolist()\n",
    "    text = df.text.tolist()\n",
    "    for i in range(len(bboxes)):\n",
    "\n",
    "        if (-30 < bbox[0][0] - bboxes[i][0][0] < 40) and  (0 < bbox[0][1]-bboxes[i][0][1] < 100) and text[i].isdigit():\n",
    "            print(bbox[0][0] - bboxes[i][0][0])\n",
    "            return int(text[i])\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "def convert_to_dict(string: str) -> None:\n",
    "    out = string.split()\n",
    "    if len(out) == 2:\n",
    "        try:\n",
    "            out = {out[1]: int(out[0])}\n",
    "            return out\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "        try:\n",
    "            out = {out[0]: int(out[1])}\n",
    "            return out\n",
    "        except:\n",
    "            return None\n",
    "\n",
    "def get_data_vk(df):\n",
    "    REGEXP = r'^[1-9]*[ ]?[Дд]ру|[чн]ик[иа(ов)]*'\n",
    "    use_to = pd.DataFrame(df['text'].str.lower())\n",
    "    use_to['bbox'] = df['bbox']\n",
    "    use_to = use_to.loc[use_to['text'].str.contains(REGEXP)]\n",
    "    tmp = use_to['text'].tolist()\n",
    "    bboxes = use_to['bbox'].tolist()\n",
    "    out = {}\n",
    "\n",
    "    for i in range(len(tmp)):\n",
    "        g = convert_to_dict(tmp[i])\n",
    "        if g:\n",
    "            out.update(g)\n",
    "        else:\n",
    "            check = find(df, bboxes[i])\n",
    "            if check:\n",
    "                out.update({tmp[i]:check})\n",
    "\n",
    "    return out"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-08-26T20:53:45.765734Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "vk user"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "outputs": [],
   "source": [
    "# from roboflow import Roboflow\n",
    "# import cv2 as cv\n",
    "#\n",
    "# \"\"\"\n",
    "# Содержит модель и функцию поиска имени аккаунта (или id)\n",
    "# read_name_id_vk возвращает либо имя, либо id аккаунта\n",
    "# Используется fine-tuned модель MS COCO, обученная с помощью сервиса Roboflow (нужен импорт модуля и API_KEY для доступа к ней)\n",
    "# Функция read_name_id_vk возвращает имя аккаунта либо его id (в зависимости что видно на скрине)\n",
    "# \"\"\"\n",
    "#\n",
    "# rf = Roboflow(api_key=\"fKNgN4TLK6ZSRlRHPdZZ\")\n",
    "# project = rf.workspace().project(\"hak2023_2\")\n",
    "# model = project.version(1).model\n",
    "#\n",
    "# IMG_PATH = ''\n",
    "# nums = 2\n",
    "#\n",
    "#\n",
    "# def read_name_id_vk(data:dict, img_path) -> str:\n",
    "#     \"\"\"\n",
    "#      Функция read_name_id_vk возвращает имя аккаунта либо его id (в зависимости что видно на скрине)\n",
    "#\n",
    "#     \"\"\"\n",
    "#\n",
    "#     if not data['predictions']:\n",
    "#         return\n",
    "#\n",
    "#     if data['predictions'][0]['confidence'] < 0.5:\n",
    "#         print(\"uncertainty\")\n",
    "#         return\n",
    "#\n",
    "#     bbox = data['predictions'][0]\n",
    "#     img = cv.imread(img_path)\n",
    "#\n",
    "#     x = bbox['x'] - bbox['width']//2\n",
    "#     to_x = bbox['x'] + bbox['width']//2\n",
    "#     y = bbox['y'] - bbox['height']//2\n",
    "#     to_y = bbox['y'] + bbox['height']//2\n",
    "#\n",
    "#     cropped_img = img[y: to_y, x:to_x]\n",
    "#\n",
    "#     results = reader.readtext(cropped_img)\n",
    "#     out = results[0][1]\n",
    "#     return out\n",
    "#\n",
    "#\n",
    "# if __name__ == \"__main__\":\n",
    "#     a = model.predict(IMG_PATH, confidence=40, overlap=30).json()\n",
    "#     read_name_id_vk(a, IMG_PATH)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "в зависимости от выбранной платформы будем использовать подходящую функцию"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "outputs": [],
   "source": [
    "result = pd.DataFrame(columns=[\"name\", \"target\"])\n",
    "\n",
    "if platform == platforms_dict['tg']:\n",
    "    func_processing = get_metric_from_tg\n",
    "elif platform == platforms_dict['vk']:\n",
    "    func_processing = get_data_vk\n",
    "elif platform == platforms_dict['yt1']:\n",
    "    func_processing = get_metric_from_yt1\n",
    "elif platform == platforms_dict['yt2']:\n",
    "    func_processing = get_metric_from_yt2\n",
    "elif platform == platforms_dict['zn']:\n",
    "    func_processing = get_metric_from_zn"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-08-26T20:53:45.774386Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "обрабатываем все данные "
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "outputs": [
    {
     "data": {
      "text/plain": "                                       name target\n0  bbb2ec82-ab95-42f9-be90-58c0e35c653c.png    135\n1  8a7a366c-ae97-45ad-87c4-0f6487b8e9ba.png    636\n2  74f4b236-c1a7-45a6-b11a-2d5ab5325db3.png    100\n3  3e9053a6-c5c3-4b21-815a-fb7fdf758150.png    375\n4  0578d9d6-0353-4a1c-9fad-91e1f2d9864e.png    293",
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>name</th>\n      <th>target</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>bbb2ec82-ab95-42f9-be90-58c0e35c653c.png</td>\n      <td>135</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>8a7a366c-ae97-45ad-87c4-0f6487b8e9ba.png</td>\n      <td>636</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>74f4b236-c1a7-45a6-b11a-2d5ab5325db3.png</td>\n      <td>100</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>3e9053a6-c5c3-4b21-815a-fb7fdf758150.png</td>\n      <td>375</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0578d9d6-0353-4a1c-9fad-91e1f2d9864e.png</td>\n      <td>293</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(len(imgs_data)):\n",
    "    result.loc[len(result)] = {'name': imgs_data['name'][i], 'target': func_processing(imgs_data.loc[i]['data'])}\n",
    "\n",
    "result"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-08-26T20:53:45.777267Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "(раскомм.) визуально проверить корректность обнаружения"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1000x1000 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.patches import Rectangle\n",
    "\n",
    "img_path = imgs_path[0]\n",
    "\n",
    "detects = reader.detect(img_path)[0][0]\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 10))\n",
    "ax.imshow(plt.imread(img_path))\n",
    "ax.axis('off')\n",
    "\n",
    "for i in range(len(detects)):\n",
    "    plt.gca().add_patch(Rectangle((detects[i][0],detects[i][2]),\n",
    "                                  detects[i][1] - detects[i][0],\n",
    "                                  detects[i][3] - detects[i][2],\n",
    "                                  edgecolor='red',\n",
    "                                  facecolor='none',\n",
    "                                  lw= 1 ))\n",
    "\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-08-26T20:53:45.779923Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "outputs": [],
   "source": [
    "writer = pd.ExcelWriter(\"output.xlsx\")\n",
    "result.to_excel(writer)\n",
    "writer.save()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-08-26T20:53:45.782229Z"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}