prepare-512.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.420432Z",
     "iopub.status.busy": "2022-11-22T07:16:13.420037Z",
     "iopub.status.idle": "2022-11-22T07:16:13.604841Z",
     "shell.execute_reply": "2022-11-22T07:16:13.604123Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.420356Z"
    },
    "gradient": {
     "editing": false,
     "id": "f068e2e0-9090-4309-9edc-5848ae2aedc8",
     "kernelId": ""
    },
    "id": "0trJmd6DjqBZ"
   },
   "outputs": [],
   "source": [
    "# Подключаем модули\n",
    "import urllib.request\n",
    "import shutil\n",
    "\n",
    "from math import ceil\n",
    "from io import BytesIO\n",
    "from base64 import b64decode\n",
    "from math import sqrt\n",
    "from os import path, listdir, makedirs\n",
    "from json import load\n",
    "from numpy import zeros, array, int32, uint8\n",
    "# noinspection PyProtectedMember,PyUnresolvedReferences\n",
    "from cv2 import fillPoly, rectangle, circle, imwrite, imread, IMWRITE_PNG_COMPRESSION, resize, cvtColor, COLOR_BGR2RGB, COLOR_BGR2GRAY, COLOR_GRAY2BGR, countNonZero\n",
    "from tqdm import tqdm\n",
    "from PIL import Image\n",
    "from pathlib import Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.606733Z",
     "iopub.status.busy": "2022-11-22T07:16:13.606387Z",
     "iopub.status.idle": "2022-11-22T07:16:13.611405Z",
     "shell.execute_reply": "2022-11-22T07:16:13.610830Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.606710Z"
    }
   },
   "outputs": [],
   "source": [
    "# Все папки проекта и внешний сайт, на котором хранятся все нужные данные для решения\n",
    "root = \"/notebooks\"\n",
    "\n",
    "baseURL = \"https://0v.ru/plan/\"\n",
    "\n",
    "previewTrainMasks = path.join(root, \"preview_train_masks\")\n",
    "splittedTrain = path.join(root, \"splitted_train_512\")\n",
    "\n",
    "testPath = path.join(root, \"test\")\n",
    "splittedTest  = path.join(root, \"splitted_test_512\")\n",
    "\n",
    "jsonDataPath = path.join(root, \"object_detection\")\n",
    "objectsZipFilename = \"object_detection.zip\"\n",
    "objectsZipFilenameAndPath = path.join(root, objectsZipFilename)\n",
    "\n",
    "testZipFilename = \"test.zip\"\n",
    "testZipFilenameAndPath = path.join(root, testZipFilename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.612409Z",
     "iopub.status.busy": "2022-11-22T07:16:13.612184Z",
     "iopub.status.idle": "2022-11-22T07:16:13.615940Z",
     "shell.execute_reply": "2022-11-22T07:16:13.615275Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.612388Z"
    }
   },
   "outputs": [],
   "source": [
    "# Настройки деления изображений на кусочки\n",
    "HEIGHT = 512\n",
    "WIDTH  = 512\n",
    "\n",
    "CHANNELS = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.617009Z",
     "iopub.status.busy": "2022-11-22T07:16:13.616771Z",
     "iopub.status.idle": "2022-11-22T07:16:13.621701Z",
     "shell.execute_reply": "2022-11-22T07:16:13.620722Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.616987Z"
    }
   },
   "outputs": [],
   "source": [
    "# Настройки классов. Синонимы, минимальный процент площади, чтобы маска считалась значимой, список отобранных корректных файлов класса.\n",
    "labels = \\\n",
    "{\n",
    "    \"wall\":   {\"classNumber\": 1, \"synonyms\": [\"wall_common_empty\", \"wall_bearing_empty\"],   \"minPercentForMask\": 0.05, \"goodListFile\": \"good_walls.json\"},\n",
    "    \"window\": {\"classNumber\": 2, \"synonyms\": [\"window_common\", \"windon\", \"window_balcony\"], \"minPercentForMask\": 0.01, \"goodListFile\": \"good_windows_doors.json\"},\n",
    "    \"door\":   {\"classNumber\": 3, \"synonyms\": [\"door_common\", \"door_balcony\"],               \"minPercentForMask\": 0.01, \"goodListFile\": \"good_windows_doors.json\"},\n",
    "}\n",
    "\n",
    "countClasses = len(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.624956Z",
     "iopub.status.busy": "2022-11-22T07:16:13.624605Z",
     "iopub.status.idle": "2022-11-22T07:16:13.630063Z",
     "shell.execute_reply": "2022-11-22T07:16:13.629228Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.624929Z"
    }
   },
   "outputs": [],
   "source": [
    "# Если папок для формирования разделения на кусочки и предпросмотра масок нет, то создаём их\n",
    "if not path.exists(previewTrainMasks):\n",
    "    makedirs(previewTrainMasks)\n",
    "\n",
    "if not path.exists(splittedTrain):\n",
    "    makedirs(splittedTrain)\n",
    "    \n",
    "if not path.exists(splittedTest):\n",
    "    makedirs(splittedTest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.631344Z",
     "iopub.status.busy": "2022-11-22T07:16:13.631032Z",
     "iopub.status.idle": "2022-11-22T07:16:13.648895Z",
     "shell.execute_reply": "2022-11-22T07:16:13.647975Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.631308Z"
    }
   },
   "outputs": [],
   "source": [
    "# Подготавливаем список классов. Формируем словари, загружаем с сайта список правильных изображений.\n",
    "synonyms = {}\n",
    "for label, data in labels.items():\n",
    "    fullNameGoodListFile = path.join(root, data[\"goodListFile\"])\n",
    "    if not path.exists(fullNameGoodListFile):\n",
    "        urllib.request.urlretrieve(baseURL + data[\"goodListFile\"], fullNameGoodListFile)\n",
    "\n",
    "    with open(fullNameGoodListFile) as file:\n",
    "        labels[label][\"goodList\"] = load(file)\n",
    "\n",
    "    for synonym in data[\"synonyms\"]:\n",
    "        synonyms[synonym] = label\n",
    "\n",
    "    if not path.exists(path.join(splittedTrain, label)):\n",
    "        makedirs(path.join(splittedTrain, label))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.650206Z",
     "iopub.status.busy": "2022-11-22T07:16:13.649969Z",
     "iopub.status.idle": "2022-11-22T07:16:13.654557Z",
     "shell.execute_reply": "2022-11-22T07:16:13.653795Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.650182Z"
    }
   },
   "outputs": [],
   "source": [
    "# Загружаем все JSON-файлы для тренировки\n",
    "if not path.exists(objectsZipFilenameAndPath):\n",
    "    urllib.request.urlretrieve(baseURL + objectsZipFilename, objectsZipFilenameAndPath)\n",
    "\n",
    "if not path.exists(jsonDataPath):\n",
    "    makedirs(jsonDataPath)\n",
    "\n",
    "    shutil.unpack_archive(objectsZipFilenameAndPath, jsonDataPath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.655918Z",
     "iopub.status.busy": "2022-11-22T07:16:13.655657Z",
     "iopub.status.idle": "2022-11-22T07:16:13.664802Z",
     "shell.execute_reply": "2022-11-22T07:16:13.664041Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.655893Z"
    }
   },
   "outputs": [],
   "source": [
    "# Функция разбиения изображения и её маски на кусочки. Проверятся также наличие на маске площади, большей, чем указанный процент\n",
    "def splitMaskAndImage(image, mask, filename):\n",
    "    imageHeight, imageWidth = image.shape[:2]\n",
    "\n",
    "    # Идём по высоте и ширине и разбиваем картинку на части\n",
    "    # Если высота или ширина не делится на 256, то дополняем размер\n",
    "    for indexRow in range(int(ceil(imageHeight / HEIGHT))):\n",
    "        for indexColumn in range(int(ceil(imageWidth / WIDTH))):\n",
    "            startX = indexColumn * WIDTH\n",
    "            startY = indexRow * HEIGHT\n",
    "\n",
    "            croppedMask = zeros((HEIGHT, WIDTH, countClasses), dtype = uint8)\n",
    "\n",
    "            destinationHeight, destinationWidth, sourceBottom, sourceRight = getBounds(imageHeight, imageWidth, startX, startY)\n",
    "\n",
    "            croppedMask[0:destinationHeight, 0:destinationWidth, :] = mask[startY:sourceBottom, startX:sourceRight, :]\n",
    "\n",
    "            croppedImage = None\n",
    "\n",
    "            for indexLabel, (labelName, labelData) in enumerate(labels.items()):\n",
    "                if filename + \".json\" in labelData[\"goodList\"]:\n",
    "                    channelCropped = croppedMask[:, :, indexLabel]\n",
    "                    if countNonZero(channelCropped) / channelCropped.size >= labelData[\"minPercentForMask\"]:\n",
    "                        if croppedImage is None:\n",
    "                            croppedImage = zeros((HEIGHT, WIDTH, CHANNELS), dtype = uint8)\n",
    "                            croppedImage[0:destinationHeight, 0:destinationWidth, :] = image[startY:sourceBottom, startX:sourceRight, :]\n",
    "\n",
    "                        # Получаем имя кусочка\n",
    "                        croppedName = path.join(splittedTrain, labelName, filename + \"_\" + str(startX) + \"_\" + str(startY))\n",
    "\n",
    "                        # Сохраняем маску и картинку\n",
    "                        imwrite(croppedName + \".png\", channelCropped, [IMWRITE_PNG_COMPRESSION, 9])\n",
    "                        imwrite(croppedName + \"_preview.png\", croppedImage, [IMWRITE_PNG_COMPRESSION, 9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.666705Z",
     "iopub.status.busy": "2022-11-22T07:16:13.666225Z",
     "iopub.status.idle": "2022-11-22T07:16:13.673313Z",
     "shell.execute_reply": "2022-11-22T07:16:13.672548Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.666680Z"
    }
   },
   "outputs": [],
   "source": [
    "# Функция разбиения изображения на кусочки (для файлов test)\n",
    "def splitImage(image, filename):\n",
    "    image = cvtColor(image, COLOR_BGR2GRAY)\n",
    "    image = cvtColor(image, COLOR_GRAY2BGR)\n",
    "\n",
    "    imageHeight, imageWidth = image.shape[:2]\n",
    "\n",
    "    # Идём по высоте и ширине и разбиваем картинку на части\n",
    "    # Если высота или ширина не делится на 256, то дополняем размер\n",
    "    for indexRow in range(int(ceil(imageHeight / HEIGHT))):\n",
    "        for indexColumn in range(int(ceil(imageWidth / WIDTH))):\n",
    "            startX = indexColumn * WIDTH\n",
    "            startY = indexRow * HEIGHT\n",
    "\n",
    "            cropped = zeros((HEIGHT, WIDTH, CHANNELS), dtype=uint8)\n",
    "\n",
    "            destinationHeight, destinationWidth, sourceBottom, sourceRight = getBounds(imageHeight, imageWidth, startX, startY)\n",
    "            part = image[startY:sourceBottom, startX:sourceRight, :]\n",
    "            part[part == 0] = 1\n",
    "            cropped[0:destinationHeight, 0:destinationWidth, :] = part\n",
    "\n",
    "            # Получаем имя кусочка\n",
    "            croppedName = path.join(splittedTest, filename + \"_\" + str(startX) + \"_\" + str(startY) + \".png\")\n",
    "\n",
    "            # Сохраняем\n",
    "            imwrite(croppedName, cropped, [IMWRITE_PNG_COMPRESSION, 9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.674439Z",
     "iopub.status.busy": "2022-11-22T07:16:13.674217Z",
     "iopub.status.idle": "2022-11-22T07:16:13.680488Z",
     "shell.execute_reply": "2022-11-22T07:16:13.679816Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.674417Z"
    }
   },
   "outputs": [],
   "source": [
    "# Определение границ кусочка, с учётом выхода за пределы границ большого изображения\n",
    "def getBounds(imageHeight, imageWidth, startX, startY):\n",
    "    if startX + WIDTH > imageWidth and startY + HEIGHT > imageHeight:\n",
    "        destinationHeight = imageHeight - startY\n",
    "        destinationWidth = imageWidth - startX\n",
    "        sourceBottom = imageHeight\n",
    "        sourceRight = imageWidth\n",
    "\n",
    "    elif startX + WIDTH > imageWidth:\n",
    "        destinationHeight = HEIGHT\n",
    "        destinationWidth = imageWidth - startX\n",
    "        sourceBottom = startY + HEIGHT\n",
    "        sourceRight = imageWidth\n",
    "\n",
    "    elif startY + HEIGHT > imageHeight:\n",
    "        destinationHeight = imageHeight - startY\n",
    "        destinationWidth = WIDTH\n",
    "        sourceBottom = imageHeight\n",
    "        sourceRight = startX + WIDTH\n",
    "\n",
    "    # если полностью помещается\n",
    "    else:\n",
    "        destinationHeight = HEIGHT\n",
    "        destinationWidth = WIDTH\n",
    "        sourceBottom = startY + HEIGHT\n",
    "        sourceRight = startX + WIDTH\n",
    "\n",
    "    return destinationHeight, destinationWidth, sourceBottom, sourceRight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.681590Z",
     "iopub.status.busy": "2022-11-22T07:16:13.681369Z",
     "iopub.status.idle": "2022-11-22T07:16:13.694900Z",
     "shell.execute_reply": "2022-11-22T07:16:13.694098Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.681567Z"
    }
   },
   "outputs": [],
   "source": [
    "# Формирование и подготовка масок. Выкидываются ломаные линии, линии и точки. Также устраняется перекрытие классов\n",
    "def prepareMask(filename, fullName):\n",
    "    with open(fullName) as file:\n",
    "        data = load(file)\n",
    "\n",
    "    # noinspection PyTypeChecker\n",
    "    image = array(Image.open(BytesIO(b64decode(data[\"imageData\"]))))\n",
    "\n",
    "    if len(image.shape) == 3:\n",
    "        height, width, _ = image.shape\n",
    "        image = cvtColor(image, COLOR_BGR2GRAY)\n",
    "    else:\n",
    "        height, width = image.shape\n",
    "\n",
    "    image = cvtColor(image, COLOR_GRAY2BGR)\n",
    "\n",
    "    maskWidth = data[\"imageWidth\"]\n",
    "    maskHeight = data[\"imageHeight\"]\n",
    "\n",
    "    if height != maskHeight or width != maskWidth:\n",
    "        return None, None\n",
    "\n",
    "    maskPreview = zeros((maskHeight, maskWidth, CHANNELS), dtype = uint8)\n",
    "\n",
    "\n",
    "    def setMask(mask, classNumber, drawFunctionWhite, drawFunctionBlack):\n",
    "        mask[:, :, classNumber - 1] = drawFunctionWhite(array(mask[:, :, classNumber - 1]))\n",
    "        if classNumber != 1:\n",
    "            for index in range(countClasses):\n",
    "                if index != classNumber - 1:\n",
    "                    mask[:, :, index] = drawFunctionBlack(array(mask[:, :, index]))\n",
    "\n",
    "\n",
    "    for shape in data[\"shapes\"]:\n",
    "        label = shape[\"label\"]\n",
    "\n",
    "        if label in synonyms:\n",
    "            label = synonyms[label]\n",
    "\n",
    "        if label in labels:\n",
    "            labelData = labels[label]\n",
    "            classNumber = labelData[\"classNumber\"]\n",
    "\n",
    "            if len(shape[\"points\"]) > 0:\n",
    "                points = array(shape[\"points\"], dtype=int32)\n",
    "                typeShape = shape[\"shape_type\"]\n",
    "                if typeShape == \"polygon\":\n",
    "                    setMask(maskPreview, classNumber, lambda mask: fillPoly(mask, [points], 255), lambda mask: fillPoly(mask, [points], 0))\n",
    "                elif typeShape == \"rectangle\":\n",
    "                    setMask(maskPreview, classNumber, lambda mask: rectangle(mask, points[0], points[1], 255, -1), lambda mask: rectangle(mask, points[0], points[1], 0, -1))\n",
    "                elif typeShape == \"circle\":\n",
    "                    (cx, cy), (px, py) = points[0], points[1]\n",
    "                    center = ((cx + px) // 2, (cy + py) // 2)\n",
    "                    diameter = round(sqrt((cx - px) ** 2 + (cy - py) ** 2))\n",
    "                    setMask(maskPreview, classNumber, lambda mask: circle(mask, center, diameter, 255, -1), lambda mask: circle(mask, center, diameter, 0, -1))\n",
    "                elif typeShape == \"line\" or typeShape == \"linestrip\" or typeShape == \"point\":\n",
    "                    # Такие типы бессмысленны для сегментации, так как имеют нулевую площадь. Маски с ними заведомо неверные\n",
    "                    return\n",
    "                else:\n",
    "                    print(\"Unknown shape type:\", shape[\"shape_type\"], filename)\n",
    "\n",
    "    splitMaskAndImage(image, maskPreview, filename.replace(\".json\", \"\"))\n",
    "\n",
    "    maskPreview = image * 0.5 + maskPreview * 0.9\n",
    "    imwrite(path.join(previewTrainMasks, filename + \".png\"), maskPreview, [IMWRITE_PNG_COMPRESSION, 9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.695949Z",
     "iopub.status.busy": "2022-11-22T07:16:13.695713Z",
     "iopub.status.idle": "2022-11-22T07:16:13.947190Z",
     "shell.execute_reply": "2022-11-22T07:16:13.946267Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.695921Z"
    }
   },
   "outputs": [],
   "source": [
    "# Если в папках для предпросмотра или разбивки файлов train что-то есть, то очищаем эти файлы\n",
    "_ = [file.unlink() for file in Path(previewTrainMasks).glob(\"*\") if file.is_file()]\n",
    "_ = [file.unlink() for file in Path(splittedTrain).glob(\"*\") if file.is_file()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.948605Z",
     "iopub.status.busy": "2022-11-22T07:16:13.948358Z",
     "iopub.status.idle": "2022-11-22T07:16:13.989997Z",
     "shell.execute_reply": "2022-11-22T07:16:13.989010Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.948581Z"
    }
   },
   "outputs": [],
   "source": [
    "# Получаем список всех файлов train\n",
    "listTrainFiles = [filename for filename in listdir(jsonDataPath) if filename.endswith(\"json\") and not filename.startswith(\".\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T07:16:13.993714Z",
     "iopub.status.busy": "2022-11-22T07:16:13.993420Z",
     "iopub.status.idle": "2022-11-22T09:03:54.588415Z",
     "shell.execute_reply": "2022-11-22T09:03:54.587533Z",
     "shell.execute_reply.started": "2022-11-22T07:16:13.993688Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3500/3500 [1:47:40<00:00,  1.85s/it]  \n"
     ]
    }
   ],
   "source": [
    "# Подготавливаем маски train\n",
    "for filename in tqdm(listTrainFiles):\n",
    "    prepareMask(filename, path.join(root, jsonDataPath, filename))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T09:03:54.590297Z",
     "iopub.status.busy": "2022-11-22T09:03:54.589962Z",
     "iopub.status.idle": "2022-11-22T09:03:54.596657Z",
     "shell.execute_reply": "2022-11-22T09:03:54.595610Z",
     "shell.execute_reply.started": "2022-11-22T09:03:54.590261Z"
    }
   },
   "outputs": [],
   "source": [
    "# Скачиваем файлы test. Если для них нет папки, то создаём\n",
    "if not path.exists(testZipFilename):\n",
    "    urllib.request.urlretrieve(baseURL + testZipFilename, testZipFilenameAndPath)\n",
    "\n",
    "if not path.exists(testPath):\n",
    "    makedirs(testPath)\n",
    "\n",
    "    shutil.unpack_archive(testZipFilenameAndPath, testPath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T09:03:54.598092Z",
     "iopub.status.busy": "2022-11-22T09:03:54.597850Z",
     "iopub.status.idle": "2022-11-22T09:03:58.980468Z",
     "shell.execute_reply": "2022-11-22T09:03:58.979637Z",
     "shell.execute_reply.started": "2022-11-22T09:03:54.598069Z"
    }
   },
   "outputs": [],
   "source": [
    "# Если в папке кусочков test есть файлы, то удаляем их\n",
    "_ = [file.unlink() for file in Path(splittedTest).glob(\"*\") if file.is_file()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T09:03:58.982138Z",
     "iopub.status.busy": "2022-11-22T09:03:58.981901Z",
     "iopub.status.idle": "2022-11-22T09:03:58.987935Z",
     "shell.execute_reply": "2022-11-22T09:03:58.986593Z",
     "shell.execute_reply.started": "2022-11-22T09:03:58.982115Z"
    }
   },
   "outputs": [],
   "source": [
    "# Формируем список файлов test\n",
    "listTestFiles = [filename for filename in listdir(testPath) if filename.endswith(\".png\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-11-22T09:03:58.989691Z",
     "iopub.status.busy": "2022-11-22T09:03:58.989402Z",
     "iopub.status.idle": "2022-11-22T09:11:07.147003Z",
     "shell.execute_reply": "2022-11-22T09:11:07.145952Z",
     "shell.execute_reply.started": "2022-11-22T09:03:58.989665Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1500/1500 [07:08<00:00,  3.50it/s]\n"
     ]
    }
   ],
   "source": [
    "Для всех файлов test выполняем разбиение\n",
    "for filename in tqdm(listTestFiles):\n",
    "    splitImage(imread(path.join(testPath, filename)), filename)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}