main_v1.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Приложения для поиска предметов на изображениях"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## О приложении\n",
    "Данное приложение использует предобученную нейронную сеть ResNet50 для поиска предметов на изображениях. "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Доступные классы:\n",
    "- unlabeled\n",
    "- person\n",
    "- bicycle\n",
    "- car\n",
    "- motorcycle\n",
    "- airplane\n",
    "- bus\n",
    "- train\n",
    "- truck\n",
    "- boat\n",
    "- traffic light\n",
    "- fire hydrant\n",
    "- street sign\n",
    "- stop sign\n",
    "- parking meter\n",
    "- bench\n",
    "- bird\n",
    "- cat\n",
    "- dog\n",
    "- horse\n",
    "- sheep\n",
    "- cow\n",
    "- elephant\n",
    "- bear\n",
    "- zebra\n",
    "- giraffe\n",
    "- hat\n",
    "- backpack\n",
    "- umbrella\n",
    "- shoe\n",
    "- eye glasses\n",
    "- handbag\n",
    "- tie\n",
    "- suitcase\n",
    "- frisbee\n",
    "- skis\n",
    "- snowboard\n",
    "- sports ball\n",
    "- kite\n",
    "- baseball bat\n",
    "- baseball glove\n",
    "- skateboard\n",
    "- surfboard\n",
    "- tennis racket\n",
    "- bottle\n",
    "- plate\n",
    "- wine glass\n",
    "- cup\n",
    "- fork\n",
    "- knife\n",
    "- spoon\n",
    "- bowl\n",
    "- banana\n",
    "- apple\n",
    "- sandwich\n",
    "- orange\n",
    "- broccoli\n",
    "- carrot\n",
    "- hot dog\n",
    "- pizza\n",
    "- donut\n",
    "- cake\n",
    "- chair\n",
    "- couch\n",
    "- potted plant\n",
    "- bed\n",
    "- mirror\n",
    "- dining table\n",
    "- window\n",
    "- desk\n",
    "- toilet\n",
    "- door\n",
    "- tv\n",
    "- laptop\n",
    "- mouse\n",
    "- remote\n",
    "- keyboard\n",
    "- cell phone\n",
    "- microwave\n",
    "- oven\n",
    "- toaster\n",
    "- sink\n",
    "- refrigerator\n",
    "- blender\n",
    "- book\n",
    "- clock\n",
    "- vase\n",
    "- scissors\n",
    "- teddy bear\n",
    "- hair drier\n",
    "- toothbrush"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Как пользоваться программой\n",
    "1. При первом запуске необходимо выбрать папку, где будет производиться поиск. Для этого нажмите на кнопку **Set Directory**. \n",
    "2. Затем вам нужно будет проанализировать изображения. Для этого нужно нажать на кнопку **Analyze images**. Программа изначально работает только с изображениями в формате **png** и **jpg**. \n",
    "3. После вышеперечисленных пунктов, нажмите **Show images**, чтобы увидеть все фото и их метки.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Поиск по фото\n",
    "Программа поддерживает поиск по меткам. \n",
    "Вы можете ввести название объекта в поле **Available classes**, чтобы найти все фото, где программа распознала искомый объект. Так же, вы можете перечислить объекты через запятую, чтобы найти фото, содержащие только их.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Оптимизация\n",
    "В целях оптимизации программа создает файл **labelCache.json**, где хранятся уникальный идентификатор изображения (md5 хеш от названия файла с изображением) и объекты на этом изображении. Это позволяет более реализовать более быстрый поиск и сократить расход ресурсов компьютера.\n",
    "\n",
    "Так же программа создает папку **thumbs**, где хранит миниатюры изображений в **png** формате. Имя миниатюры — это уникальный идентификатор из **labelCache.json**. Именно эти миниатюры выводит программа.\n",
    "\n",
    "Благодаря кешированию нет необходимости каждый раз выбирать папку и анализировать изображения. Если вы уже проиндексировали как-то папки, то при перезапуске приложения достаточно нажать **Show images**, чтобы показать фото. \n",
    "\n",
    "При добавлении новых изображений в папку ее необходимо выбрать и проанализировать, чтобы обновить список фото.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Настройки\n",
    "Настройки хранятся в файле **settings.json**. В нем можно добавить больше поддерживаемых форматов, сменить название для папки с миниатюрами, сменить имя файла с кешем и задать корневую директорию для хранения кеша и настроек."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Requirements\n",
    "asttokens==2.2.1\n",
    "backcall==0.2.0\n",
    "certifi==2022.12.7\n",
    "charset-normalizer==2.1.1\n",
    "colorama==0.4.6\n",
    "comm==0.1.3\n",
    "dearpygui==1.9.1\n",
    "debugpy==1.6.7\n",
    "decorator==5.1.1\n",
    "executing==1.2.0\n",
    "filelock==3.9.0\n",
    "idna==3.4\n",
    "ipykernel==6.23.1\n",
    "ipython==8.14.0\n",
    "jedi==0.18.2\n",
    "Jinja2==3.1.2\n",
    "jupyter_client==8.2.0\n",
    "jupyter_core==5.3.0\n",
    "MarkupSafe==2.1.2\n",
    "matplotlib-inline==0.1.6\n",
    "mpmath==1.2.1\n",
    "nest-asyncio==1.5.6\n",
    "networkx==3.0\n",
    "numpy==1.24.3\n",
    "packaging==23.1\n",
    "parso==0.8.3\n",
    "pickleshare==0.7.5\n",
    "Pillow==9.5.0\n",
    "platformdirs==3.5.3\n",
    "prompt-toolkit==3.0.38\n",
    "psutil==5.9.5\n",
    "pure-eval==0.2.2\n",
    "Pygments==2.15.1\n",
    "python-dateutil==2.8.2\n",
    "pywin32==306\n",
    "pyzmq==25.1.0\n",
    "requests==2.28.1\n",
    "six==1.16.0\n",
    "stack-data==0.6.2\n",
    "sympy==1.11.1\n",
    "torch==2.0.1+cu117\n",
    "torchaudio==2.0.2+cu117\n",
    "torchvision==0.15.2+cu117\n",
    "tornado==6.3.2\n",
    "traitlets==5.9.0\n",
    "typing_extensions==4.4.0\n",
    "urllib3==1.26.13\n",
    "wcwidth==0.2.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dearpygui.dearpygui as dpg\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import hashlib\n",
    "from pathlib import Path\n",
    "from typing import Callable\n",
    "import json\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Функции, которые предоставляет API этого бекенда:\n",
    "# initialize_values - загружает необходимые глобальные переменные, выполнить в начале программы\n",
    "# fit_canvas - вписывает PIL.Image в холст выбранного размера - по центру на прозрачном фоне, это будет полезно при создании основного табличного элемента с выводимыми картинками\n",
    "# generate_thumbs - генерирует эти превью для всех картинок в папке (рекурсивно) и помещает их в папку\n",
    "# ml_import, ml_model_import - импорт библиотек и модели, занимает много времени, потому вынесен в отдельные функции\n",
    "# analyze_image - возвращает уникальные метки объектов, которе модель нашла на изображении\n",
    "# labelcache_write - записать метки в json файл\n",
    "# generate_labels - применяет модель для всех картинок в папке (рекурсивно), записывает результат в глобальную переменную\n",
    "\n",
    "# Файлы, которые создаёт программа:\n",
    "# файл с настройками\n",
    "# файл с кэшированными метками\n",
    "# папка со сгенерированными превью изображений\n",
    "\n",
    "\n",
    "# прога ищет файл settings.json, откуда подгружаются значения этих переменных:\n",
    "# если не нашла, то значения берутся дефолтные\n",
    "APP_SETTINGS = {\n",
    "    'IMG_FILETYPES':['.jpg','.png'], # поддерживаемые типы изображений, надо добавить больше, но нужно тестирование\n",
    "    'THUMBDIR_NAME':'thumbs', # имя папки, в которой хранятся превью изображений\n",
    "    'LABEL_CACHE_NAME':'labelCache', # имя файла, куда кэшируются присвоенные метки\n",
    "    'ROOTPATH':None # корневая папка работы программы, там будут хранится кэш и папка с превью, но не файл настроек\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_values():\n",
    "    \"\"\"Run this first to create all the necessary global variables\\n\n",
    "    Creates global variables:\\n\n",
    "    all_labels - dictionary of ID : labels with all of the analyzed images\\n\n",
    "    all_thumbs - dictionary of ID : path with all of the created thumbs\\n\n",
    "    IMG_FILETYPES - supported image formats\\n\n",
    "    THUMBDIR_NAME - name of the thumbnails directory\\n\n",
    "    LABEL_CACHE_NAME - name of the labelCache file\\n\n",
    "    ROOTPATH - root folder of the program folder, contains everything except for the settings file\\n\n",
    "    ML_IMPORT_DONE - whether ml stuff was already imported, doesn't apply outside jupyter use\\n\\n\n",
    "    Global variable dependencies:\\n\n",
    "    APP_SETTINGS - default values for settings\"\"\"\n",
    "    global all_labels,all_thumbs,APP_SETTINGS\n",
    "    all_labels = {}\n",
    "    all_thumbs = {}\n",
    "\n",
    "    # обновляем настройки, если был найден файл\n",
    "    if Path.is_file(Path('./settings.json')):\n",
    "        APP_SETTINGS = json.load(Path.open(Path('./settings.json'),'r'))\n",
    "    else:\n",
    "        with Path.open(Path('./settings.json'),'w') as f:\n",
    "            json.dump(APP_SETTINGS,f)\n",
    "\n",
    "    global IMG_FILETYPES,THUMBDIR_NAME,LABEL_CACHE_NAME,ROOTPATH,ML_IMPORT_DONE\n",
    "    IMG_FILETYPES = APP_SETTINGS['IMG_FILETYPES']\n",
    "    THUMBDIR_NAME = APP_SETTINGS['THUMBDIR_NAME']\n",
    "    LABEL_CACHE_NAME = APP_SETTINGS['LABEL_CACHE_NAME']\n",
    "    ROOTPATH = APP_SETTINGS['ROOTPATH']\n",
    "    ML_IMPORT_DONE = False\n",
    "\n",
    "    # заплатка для работы в блокноте\n",
    "    if not ROOTPATH:\n",
    "        if '__file__' not in globals():\n",
    "            ROOTPATH = Path('.').absolute()\n",
    "        else:\n",
    "            ROOTPATH = Path(__file__).parent.absolute()\n",
    "\n",
    "    # загружаем уже известные метки, если был найден файл\n",
    "    if Path.is_file(ROOTPATH/(LABEL_CACHE_NAME+'.json')):\n",
    "        all_labels = json.load((ROOTPATH/(LABEL_CACHE_NAME+'.json')).open())\n",
    "\n",
    "    # загружаем все уже созданные превью изображений\n",
    "    if Path.is_dir(ROOTPATH/THUMBDIR_NAME):\n",
    "        all_thumbs = {x.stem:x for x in Path.glob(ROOTPATH/THUMBDIR_NAME,'**/*') if x.suffix in IMG_FILETYPES}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# по умолчанию ID изображения - md5 хэш файла\n",
    "def md5(fname: str | Path) -> str:\n",
    "    hash_md5 = hashlib.md5()\n",
    "    with open(fname, \"rb\") as f:\n",
    "        for chunk in iter(lambda: f.read(4096), b\"\"):\n",
    "            hash_md5.update(chunk)\n",
    "    return hash_md5.hexdigest()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_canvas(image_path: Path, canvas_size: tuple[int,int]) -> Image.Image:\n",
    "    \"\"\"Fits image in a canvas of given size (places it in a center of a transparent canvas, resized to match either width or height of canvas)\\n\n",
    "    Parameters:\\n\n",
    "    image_path - (absolute) path to a given image\\n\n",
    "    canvas_size - size of a canvas to fit that image into\"\"\"\n",
    "    im = Image.open(image_path)\n",
    "    im.thumbnail(canvas_size)\n",
    "    img_canvas=Image.new('RGBA',canvas_size,(0,0,0,0))\n",
    "    center_spot: tuple[int,int] = ((canvas_size[0]-im.size[0])//2,(canvas_size[1]-im.size[1])//2)\n",
    "    img_canvas.paste(im,center_spot)\n",
    "    return img_canvas\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_thumbs(thumb_folder_path: Path, img_foler_path: Path, canvas_size: tuple[int,int], namefunc: Callable[[Path],str] = md5) -> None:\n",
    "    \"\"\"Recursively searches for images in a given folder, creating canvasThumbnail for each of them in a root_path/THUMBDIR_NAME\\n\n",
    "    Parameters:\\n\n",
    "    thumb_folder_path - absotule path to thumb folder (would be created if doesnt exist)\\n\n",
    "    img_folder_path - absolute path to the image search root folder\\n\n",
    "    canvas_size - size of a canvas to fit that image into\\n\n",
    "    namefunc - function, which creates a name of a thumbnail image (default is md5 hash) without extension\\n\n",
    "    Creates global variables:\\n\n",
    "    all_thumbs - dictionary of ID : path with all of the created thumbs\"\"\"\n",
    "    global all_thumbs\n",
    "    if not Path.is_dir(thumb_folder_path): Path.mkdir(thumb_folder_path)\n",
    "    for img_path in Path.glob(img_foler_path,'**/*'):\n",
    "        if img_path.suffix not in IMG_FILETYPES: continue\n",
    "        thumb_name = namefunc(img_path) + '.png'\n",
    "        if not Path.is_file(thumb_folder_path / thumb_name):\n",
    "            fit_canvas(img_path,canvas_size).save(thumb_folder_path / thumb_name) \n",
    "    all_thumbs = {x.stem:x for x in Path.glob(ROOTPATH/THUMBDIR_NAME,'**/*') if x.suffix in IMG_FILETYPES}\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ml_import():\n",
    "    \"\"\"Imports ml modules.\\n\n",
    "    Creates global variables:\\n\n",
    "    torch - torch module\\n\n",
    "    torchvision - torchvision module\"\"\"\n",
    "    global torchvision\n",
    "    global torch\n",
    "    import torchvision\n",
    "    import torch\n",
    "    torch.set_grad_enabled(False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ml_model_import():\n",
    "    \"\"\"Imports ml pretrained model.\\n\n",
    "    Global variable dependencies:\\n\n",
    "    torchvision - torchvision module\\n\n",
    "    Creates global variables:\\n\n",
    "    model - torchvision model\"\"\"\n",
    "    global model\n",
    "    global torchvision\n",
    "    model = torchvision.models.detection.maskrcnn_resnet50_fpn(weights=torchvision.models.detection.MaskRCNN_ResNet50_FPN_Weights.DEFAULT)\n",
    "    model = model.eval().cpu()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "def analyze_image(imgpath: Path) -> list[str]:\n",
    "    \"\"\"Returns unique labels of all of the detected objects in a given image according to model results.\\n\n",
    "    Global variable dependencies:\\n\n",
    "    model - torchvision model\"\"\"\n",
    "    coco_names = torchvision.models.detection.MaskRCNN_ResNet50_FPN_Weights.DEFAULT.meta[\"categories\"]\n",
    "\n",
    "    global model\n",
    "    image = Image.open(imgpath).convert('RGB')\n",
    "    image_tensor = torchvision.transforms.functional.to_tensor(image).cpu()\n",
    "    output = model([image_tensor])[0]\n",
    "\n",
    "    labls = set()\n",
    "\n",
    "    for i in range(len(output['scores'])):\n",
    "        if output['scores'][i] <= 0.5:\n",
    "            continue\n",
    "        labls = labls.union([int(output['labels'][i].cpu().numpy())])\n",
    "    found_labels = [coco_names[x] for x in labls]\n",
    "\n",
    "    return found_labels\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def labelcache_write():\n",
    "    \"\"\"Write all known labels to json file.\\n \n",
    "    Global variable dependencies:\\n\n",
    "    all_labels - dict of ID : labels\"\"\"\n",
    "    global all_labels\n",
    "    with Path.open(ROOTPATH/(LABEL_CACHE_NAME+'.json'),'w') as f:\n",
    "        json.dump(all_labels,f)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_images(img_foler_path: Path) -> int:\n",
    "    \"\"\"Returns number of images found recursively, starting from folder\"\"\"\n",
    "    return len([x for x in Path.glob(img_foler_path,'**/*') if x.suffix in IMG_FILETYPES])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_labels(img_foler_path: Path, idfunc: Callable[[Path],str] = md5, tag: str | None = None) -> None:\n",
    "    \"\"\"Recursively searches for images in a given folder, applying model to each of them\\n\n",
    "    Parameters:\\n\n",
    "    img_folder_path - absolute path to the image search root folder\\n\n",
    "    idfunc - function, which creates an ID of an image (default is md5 hash, must be the same as for the thumbs)\\n\n",
    "    tag - optional tag of DearPyGui element - the function would update that element's value according to analysis progress\\n\n",
    "    Global variable dependencies:\\n\n",
    "    all_labels - dict of ID : list of labels\"\"\"\n",
    "    global all_labels\n",
    "    img_num = count_images(img_foler_path)\n",
    "    curr_img_num = 1\n",
    "    for img_path in Path.glob(img_foler_path,'**/*'):\n",
    "        if img_path.suffix not in IMG_FILETYPES: continue\n",
    "        imgid = idfunc(img_path)\n",
    "        if imgid not in all_labels.keys(): \n",
    "            all_labels[imgid] = analyze_image(img_path)\n",
    "        #print(str(curr_img_num)+'/'+str(img_num)+':', img_path,imgid,all_labels[imgid])\n",
    "        if tag: dpg.set_value(tag,f\"Analysis progress: {curr_img_num}/{img_num}\")\n",
    "        curr_img_num+=1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "def search_image(lable:str)->list:\n",
    "    \"\"\"Search for all thumbs in all_thumbs that are marked with a lable.\\n\n",
    "    Parameters:\\n\n",
    "    lable - lable to search for\n",
    "    Global variable dependencies:\n",
    "    all_labels - dict of ID : list of labels\n",
    "    all_thumbs - dictionary of ID : path with all of the created thumbs\n",
    "    \"\"\"\n",
    "    global all_labels, all_thumbs\n",
    "    searched_labels = lable.split(\",\")\n",
    "    matched_images = []\n",
    "    for key in all_thumbs.keys():\n",
    "        if all(i in all_labels[key] for i in searched_labels):\n",
    "            matched_images.append(key)\n",
    "    return matched_images\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_folder(sender, app_data):\n",
    "    dpg.set_value(\"imgfolderpath\", app_data['file_path_name'])\n",
    "    img_folder_path = app_data['file_path_name']\n",
    "    img_folder_path = Path(img_folder_path)\n",
    "    if not Path.is_dir(img_folder_path):\n",
    "        dpg.set_value('status','error happened')\n",
    "    else:\n",
    "        img_count = count_images(img_folder_path)\n",
    "        dpg.configure_item('countimages',enabled=False)\n",
    "        dpg.set_value('status','generating thumbs')\n",
    "        dpg.set_value('status',str(img_count)+' images found')\n",
    "        dpg.configure_item('countimages',enabled=True)\n",
    "        dpg.configure_item(\"analyzeimages\", enabled=True)\n",
    "\n",
    "def cancel_folder_selection(sender, app_data):\n",
    "    pass\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def start_image_analysis(sender, app_data):\n",
    "    global ML_IMPORT_DONE\n",
    "    dpg.configure_item(sender,enabled=False)\n",
    "    if not ML_IMPORT_DONE:\n",
    "        dpg.set_value('status','importing ml libraries')\n",
    "        ml_import()\n",
    "        dpg.set_value('status','importing ml model')\n",
    "        ml_model_import()\n",
    "        ML_IMPORT_DONE = True\n",
    "    img_folder_path = dpg.get_value('imgfolderpath')\n",
    "    img_folder_path = Path(img_folder_path)\n",
    "    generate_thumbs(ROOTPATH/THUMBDIR_NAME,img_folder_path,(256,256))\n",
    "    generate_labels(img_folder_path,tag='status')\n",
    "    labelcache_write()\n",
    "    dpg.set_value('status','Analysis complete, results saved')\n",
    "    dpg.configure_item(sender,enabled=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_images(sender, app_data):\n",
    "    global all_thumbs,all_labels\n",
    "    for index, _ in enumerate(all_thumbs.keys()):\n",
    "        if dpg.does_alias_exist(f\"texture-{index}\"):\n",
    "            pass\n",
    "        else:\n",
    "            dpg.add_dynamic_texture(width=256, height=256, default_value=[0 for _ in range(256*256*4)], tag=f\"texture-{index}\", parent=\"texture_reg\") \n",
    "    for index, key in  enumerate(all_thumbs.keys()):\n",
    "        img_path = all_thumbs[key]\n",
    "        img_arr = np.true_divide(np.array(Image.open(img_path).convert('RGBA')),255.0)\n",
    "\n",
    "        if(dpg.get_value(f\"texture-{index}\")==[0 for _ in range(256*256*4)]):\n",
    "            dpg.set_value(f\"texture-{index}\", img_arr)\n",
    "            dpg.add_image(f\"texture-{index}\", indent=0, parent=\"img_show\")\n",
    "        else:\n",
    "            dpg.set_value(f\"texture-{index}\", img_arr)\n",
    "\n",
    "        if dpg.does_alias_exist(f\"img-text-{index}\"):\n",
    "            dpg.set_value(f\"img-text-{index}\", \" \".join(all_labels[key]))\n",
    "        else:\n",
    "            dpg.add_text(\" \".join(all_labels[key]),parent=\"img_show\", tag=f\"img-text-{index}\")\n",
    "    dpg.configure_item(\"filter_input\", enabled=True)\n",
    "        \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_callback(sender, filter_string):\n",
    "    filter_string = filter_string.replace(\" \", \"\")\n",
    "    dpg.set_value(\"filter_id\", filter_string)\n",
    "    img_list = search_image(filter_string)\n",
    "    if (img_list):\n",
    "        dpg.configure_item(\"showimage\", enabled=False)\n",
    "        for index, key in  enumerate(all_thumbs.keys()):\n",
    "            dpg.set_value(f\"texture-{index}\", [0 for _ in range(256*256*4)])\n",
    "            dpg.set_value(f\"img-text-{index}\", \"\")\n",
    "        for index, key in  enumerate(img_list):\n",
    "            img_path = all_thumbs[key]\n",
    "            img_arr = np.true_divide(np.array(Image.open(img_path).convert('RGBA')),255.0)\n",
    "\n",
    "            dpg.set_value(f\"texture-{index}\", img_arr)\n",
    "            dpg.set_value(f\"img-text-{index}\", \" \".join(all_labels[key]))\n",
    "    else:\n",
    "        dpg.configure_item(\"showimage\", enabled=True)\n",
    "        for index, key in  enumerate(all_thumbs.keys()):\n",
    "            img_path = all_thumbs[key]\n",
    "            img_arr = np.true_divide(np.array(Image.open(img_path).convert('RGBA')),255.0)\n",
    "\n",
    "            dpg.set_value(f\"texture-{index}\", img_arr)\n",
    "            dpg.set_value(f\"img-text-{index}\", \" \".join(all_labels[key]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "CLASSES = ['unlabeled', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'street sign', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'hat', 'backpack', 'umbrella', 'shoe', 'eye glasses', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket', 'bottle', 'plate', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', 'mirror', 'dining table', 'window', 'desk', 'toilet', 'door', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'blender', 'book', 'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush']\n",
    "def main():\n",
    "    \n",
    "    initialize_values()\n",
    "\n",
    "    dpg.create_context()\n",
    "\n",
    "    with dpg.theme() as disabled_theme:\n",
    "        with dpg.theme_component(dpg.mvButton, enabled_state=False):\n",
    "            dpg.add_theme_color(dpg.mvThemeCol_Button, [29, 29, 29])\n",
    "            dpg.add_theme_color(dpg.mvThemeCol_ButtonHovered, [29, 29, 29])\n",
    "            dpg.add_theme_color(dpg.mvThemeCol_ButtonActive, [29, 29, 29])\n",
    "    dpg.bind_theme(disabled_theme)\n",
    "\n",
    "\n",
    "    dpg.add_file_dialog(directory_selector=True, show=False, callback=select_folder, tag=\"file_dialog_id\", width=700 ,height=400, cancel_callback=cancel_folder_selection)\n",
    "    dpg.add_texture_registry(tag=\"texture_reg\", show=False)\n",
    "    dpg.create_viewport(title='test', width=1280, height=720)\n",
    "\n",
    "\n",
    "\n",
    "    with dpg.window(label=\"Tutorial\",tag='main'):\n",
    "        with dpg.group(horizontal=True):\n",
    "            dpg.add_text(tag='imgfolderpath',default_value='./path_to_images')\n",
    "            dpg.add_button(label=\"Set Directory\", tag='countimages', callback=lambda: dpg.show_item(\"file_dialog_id\"))\n",
    "\n",
    "        dpg.add_button(label='Analyze images',tag='analyzeimages',callback=start_image_analysis, enabled=False)\n",
    "\n",
    "        dpg.add_input_text(label=\"Available classes\", callback=filter_callback, width=221, enabled=False, tag=\"filter_input\")\n",
    "        \n",
    "        with dpg.group(horizontal=False):\n",
    "            with dpg.child_window(height=100, width=256, horizontal_scrollbar=False):\n",
    "                dpg.add_text(\"All classes\")\n",
    "                with dpg.filter_set(id=\"filter_id\"):\n",
    "                    for i in CLASSES:\n",
    "                        dpg.add_text(f\"{i}\", filter_key=f\"{i}\", bullet=True)\n",
    "                        \n",
    "        dpg.add_button(label='Show images',tag='showimage',callback=show_images)\n",
    "        with dpg.group(horizontal=False):\n",
    "            with dpg.child_window(height=-100, width=-1, tag=\"img_show\"):\n",
    "                pass\n",
    "\n",
    "        dpg.add_text(tag='status',default_value='status would be displayed here',wrap=256)\n",
    "\n",
    "    dpg.set_primary_window('main',True)\n",
    "    dpg.setup_dearpygui()\n",
    "    dpg.show_viewport()\n",
    "    dpg.start_dearpygui()\n",
    "    dpg.destroy_context()\n",
    "\n",
    "\n",
    "if __name__=='__main__': main()\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env",
   "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.10.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}