2_3_shape_based_interpol.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "title: [Shape-based interpolation](https://www.researchgate.net/publication/221400411_Efficient_Semiautomatic_Segmentation_of_3D_Objects_in_Medical_Images) (Schenk *et al*.)\n",
    "\n",
    "author: Tiago Ribeiro\n",
    "\n",
    "date: 04/05/2023\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Author: \u001B[1mTiago Ribeiro\u001B[0m\n",
      "\n",
      "Github username: \u001B[1mTiago1Ribeiro\u001B[0m\n",
      "\n",
      "Last updated: 2023-04-04 12:25:35\n",
      "\n",
      "Python implementation: CPython\n",
      "Python version       : 3.10.9\n",
      "IPython version      : 8.11.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from watermark import watermark\n",
    "print(watermark(author=\"\\033[1m\" + \"Tiago Ribeiro\"+ \"\\033[0m\", \n",
    "                github_username=\"\\033[1m\" + \"Tiago1Ribeiro\"+ \"\\033[0m\", \n",
    "                current_date=True, current_time=True, python=True, \n",
    "                updated=True, iversions=True, globals_= globals())\n",
    "                )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T00:38:34.407425Z",
     "start_time": "2024-05-23T00:38:34.344292Z"
    }
   },
   "source": [
    "import os\n",
    "import re\n",
    "from shapely import wkt, multipolygons\n",
    "from glob import glob"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data sources & configurations"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T00:52:04.402709Z",
     "start_time": "2024-05-23T00:52:04.386596Z"
    }
   },
   "source": [
    "DATA_DIR = r\"D:\\BurnedAreaUAV_files\\BurnedAreaUAV_dataset\\BurnedAreaUAV_dataset\"\n",
    "# WKT containing the manually annotated polygons\n",
    "WKT_FILE = os.path.join(DATA_DIR, 'WKT//train_valid.wkt')\n",
    "# Directory to save PNG format annotated polygons\n",
    "PNG_DIR = os.path.join(DATA_DIR, 'PNG//train_pngs')\n",
    "# Directory to save PNG format interpolated polygons\n",
    "# OUT_DIR = \"E://BurnedAreaUAV_files//Interpolation//shape_interpol\"\n",
    "OUT_DIR = r\"C:\\Users\\Utilizador\\Desktop\\output\"\n",
    "# Directories to save PNG format interpolated polygons\n",
    "OUT_DIR_PNG = os.path.join(OUT_DIR, 'PNGs')\n",
    "# Directory to save WKT format interpolated polygons\n",
    "OUT_WKT_FILE = os.path.join(OUT_DIR, \"shape_interpol.wkt\")\n",
    "# configs\n",
    "ORIG_DIMS = (1280, 720)\n",
    "OUT_DIMS = (1280, 720)"
   ],
   "outputs": [],
   "execution_count": 14
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### wkt2masc"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T00:51:13.406725Z",
     "start_time": "2024-05-23T00:51:13.374621Z"
    }
   },
   "source": [
    "def wkt2masc(wkt_file, images_path, orig_dims, out_dims, delete_files=True):\n",
    "    \"\"\" \n",
    "    Converts WKT files to segmentation masks.\n",
    "    Parameters:\n",
    "        wkt_file {str} -- path to the WKT file\n",
    "        images_path {str} -- path to the folder where the masks will be saved\n",
    "        orig_dims {tuple} -- (width, height) original dimensions of the masks \n",
    "        out_dims {tuple} -- (width, height) output dimensions of the masks  \n",
    "    Returns:\n",
    "        Creates PNG images of the masks\n",
    "    \"\"\"\n",
    "\n",
    "    os.makedirs(images_path, exist_ok=True)\n",
    "\n",
    "    if delete_files:\n",
    "        # delete files in the folder, if any\n",
    "        for filename in os.listdir(images_path):\n",
    "            if filename.endswith(\".png\"):\n",
    "                os.remove(os.path.join(images_path, filename))\n",
    "\n",
    "    # open WKT file\n",
    "    wkt = open(wkt_file, 'r')\n",
    "    num_lines = len(wkt.readlines())\n",
    "    cnt = 0\n",
    "    \n",
    "    print(f\"\"\"\n",
    "    {'-'*38}\n",
    "    # \\033[1mProperties of the resulting masks\\033[0m\n",
    "    # Width: {out_dims[0]}, Height: {out_dims[1]}\n",
    "    # Number of masks to create: {num_lines}\n",
    "    {'-'*38}\n",
    "    \"\"\")\n",
    "    \n",
    "    # process each line of the WKT file\n",
    "    with open(wkt_file) as f:\n",
    "        for line in f:\n",
    "            # extract numbers from the line\n",
    "            points = [int(s) for s in re.findall('[0-9]+', line)]\n",
    "            # create empty mask\n",
    "            mask = np.zeros((orig_dims[1],orig_dims[0]), dtype=np.uint8)\n",
    "            # create array with polygon points, with 2 columns (x,y)\n",
    "            arr = np.array(points, dtype=np.int32).reshape((-1,2))\n",
    "            # draw mask\n",
    "            cv2.drawContours(image = mask,\n",
    "                             contours=[arr],\n",
    "                             contourIdx=-1,\n",
    "                             color=(255, 255, 255),\n",
    "                             thickness=-1,  # if > 0, thickness of the contour; if -1, fill object\n",
    "                             lineType=cv2.LINE_AA)\n",
    "            \n",
    "            if out_dims != orig_dims:\n",
    "                # resize frames with Lanczos interpolation\n",
    "                mask = cv2.resize(mask, out_dims, interpolation=cv2.INTER_CUBIC)\n",
    "            # save mask as PNG\n",
    "            cv2.imwrite(os.path.join(images_path, f\"frame_{cnt:06d}.png\"), mask)\n",
    "            cnt += 1\n",
    "            # print progress\n",
    "            print(f\"\\r\\033[1m{cnt}\\033[0m/{num_lines} masks created\", end=\"\\r\")"
   ],
   "outputs": [],
   "execution_count": 10
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WKT to PNG Conversion"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T01:15:03.765804Z",
     "start_time": "2024-05-23T01:15:02.017339Z"
    }
   },
   "source": [
    "wkt2masc(WKT_FILE, OUT_DIR, ORIG_DIMS, OUT_DIMS, delete_files=False)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    --------------------------------------\n",
      "    # \u001B[1mProperties of the resulting masks\u001B[0m\n",
      "    # Width: 1280, Height: 720\n",
      "    # Number of masks to create: 226\n",
      "    --------------------------------------\n",
      "    \n",
      "\u001B[1m226\u001B[0m/226 masks created\r"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shape Based Interpolation Function"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### interpolate_mask"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T00:42:53.737113Z",
     "start_time": "2024-05-23T00:42:51.439864Z"
    }
   },
   "source": [
    "import numpy as np\n",
    "import cv2 \n",
    "from scipy.interpolate import interp1d\n",
    "from rasterio.features import rasterize\n",
    "\n",
    "def interpolate_mask(polygons, start_frame, end_frame, int_instance, int_kind='linear', out_dim=None):\n",
    "    \"\"\"\n",
    "    Interpolates between two segmentation masks using the distances of their respective contours.\n",
    "\n",
    "    Args:\n",
    "    - polygons (list): A list of polygon of shapely polygons for each frame in the video.\n",
    "    - start_frame (int): The index of the first frame to interpolate between.\n",
    "    - end_frame (int): The index of the second frame to interpolate between.\n",
    "    - int_instance (float): The fraction of the distance between start_frame and end_frame to interpolate at.\n",
    "    - int_kind (str): The kind of interpolation to use. Can be one of 'linear',\n",
    "                     'nearest', 'zero', 'slinear','previous', or 'next'. Default is 'linear'.\n",
    "    - out_dim (tuple): The desired output dimensions of the interpolated mask. Default is (720, 1280).\n",
    "\n",
    "    Returns:\n",
    "    - image (numpy array): The interpolated segmentation mask.\n",
    "    \"\"\"\n",
    "    if not isinstance(polygons, list) or len(polygons) < 2:\n",
    "        raise ValueError(\"polygons should be a list of binary masks for at least two frames\")\n",
    "\n",
    "    # Rasterize the binary masks for the start and end frames\n",
    "    img1 = rasterize([polygons[start_frame]], out_shape=(720, 1280))\n",
    "    img2 = rasterize([polygons[end_frame]], out_shape=(720, 1280))\n",
    "\n",
    "    # Find the contours of the binary masks\n",
    "    cnt1, _ = cv2.findContours(image=img1, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE)\n",
    "    cnt2, _ = cv2.findContours(image=img2, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_NONE)\n",
    "\n",
    "    # Compute the distance transform of the masks\n",
    "    mask1_in = np.zeros_like(img1)\n",
    "    cv2.drawContours(image=mask1_in, contours=cnt1, contourIdx=-1, color=255, thickness=-1)\n",
    "    mask1_out = cv2.bitwise_not(mask1_in)\n",
    "    dist1_in = cv2.distanceTransform(mask1_in, distanceType=cv2.DIST_L2,\n",
    "                                    maskSize=cv2.DIST_MASK_PRECISE, dstType=cv2.CV_32F)\n",
    "    dist1_out = cv2.distanceTransform(mask1_out, distanceType=cv2.DIST_L2,\n",
    "                                    maskSize=cv2.DIST_MASK_PRECISE, dstType=cv2.CV_32F)\n",
    "    dist1 = dist1_in - dist1_out\n",
    "    mask2_in = np.zeros_like(img2)\n",
    "    cv2.drawContours(image=mask2_in, contours=cnt2, contourIdx=-1, color=255, thickness=-1)\n",
    "    mask2_out = cv2.bitwise_not(mask2_in)\n",
    "    dist2_in = cv2.distanceTransform(mask2_in, distanceType=cv2.DIST_L2,\n",
    "                                    maskSize=cv2.DIST_MASK_PRECISE, dstType=cv2.CV_32F)\n",
    "    dist2_out = cv2.distanceTransform(mask2_out, distanceType=cv2.DIST_L2,\n",
    "                                    maskSize=cv2.DIST_MASK_PRECISE, dstType=cv2.CV_32F)\n",
    "    dist2 = dist2_in - dist2_out\n",
    "    \n",
    "    # Interpolate the distance transforms using the specified interpolation method\n",
    "    # int_instance_norm = (int_instance - start_frame) / (end_frame - start_frame)\n",
    "    x_int = np.array(int_instance)\n",
    "    x_samples = [0, 1]\n",
    "    dist1_2d = np.reshape(dist1, (720*1280,))\n",
    "    dist2_2d = np.reshape(dist2, (720*1280,))\n",
    "    ifunc = interp1d(x_samples, np.stack((dist1_2d, dist2_2d), axis=1), axis=1, kind=int_kind)\n",
    "    img_int_2d = ifunc(x_int)\n",
    "    img_int = np.reshape(img_int_2d, (720, 1280, 1))\n",
    "\n",
    "    image = np.where(img_int[:,:,0] > 0, 255, 0).astype(np.uint8)\n",
    "\n",
    "    if out_dim is not None:\n",
    "        image = cv2.resize(image, dsize= out_dim, interpolation=cv2.INTER_CUBIC)\n",
    "\n",
    "    return image"
   ],
   "outputs": [],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T00:42:56.358039Z",
     "start_time": "2024-05-23T00:42:56.336123Z"
    }
   },
   "source": [
    "def generate_interpolated_masks(polygons, out_dir, out_dim=None):\n",
    "    \"\"\"\n",
    "    Generates interpolated masks for all frames in the video.\n",
    "\n",
    "    Args:\n",
    "    - polygons (list): A list of polygon of shapely polygons for each frame in the video.\n",
    "    - out_dir (str): The path to the directory to save the interpolated masks to.\n",
    "    - out_dim (tuple): (width, height)The desired output dimensions of the interpolated masks. \n",
    "\n",
    "    Returns:\n",
    "    - None\n",
    "    \"\"\"\n",
    "    if not isinstance(polygons, list) or len(polygons) < 2:\n",
    "        raise ValueError(\"polygons should be a list of binary masks for at least two frames\")\n",
    "\n",
    "    # for each pair of frames, generate 99 interpolated masks\n",
    "    cnt = 0\n",
    "    for i in range(len(polygons) - 1):\n",
    "        for j in range(1, 100):\n",
    "            int_instance = i + j / 100\n",
    "            image = interpolate_mask(polygons, i, i+1, int_instance, out_dim=out_dim)\n",
    "            # jumps one number in frame count every 100 frames\n",
    "            if j == 1:\n",
    "                cnt += 1\n",
    "            cv2.imwrite(os.path.join(out_dir, f\"frame_{cnt:06}.png\"), image)\n",
    "            cnt += 1\n",
    "            # print progress\n",
    "            if j % 10 == 0:\n",
    "                print(f\"Generated frame_{cnt:06}.png\", end=\"\\r\")\n",
    "    print(\"\\nDone.\")"
   ],
   "outputs": [],
   "execution_count": 6
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### frames2video"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T01:16:35.013185Z",
     "start_time": "2024-05-23T01:16:34.981843Z"
    }
   },
   "source": [
    "def frames2video(img_list, nome_ficheiro='video', fps_ = 25, titulo: str = \"\", frame_num_text  = False, font_size: int = 1) -> None:\n",
    "    \"\"\"\n",
    "    Converts a list of images into an AVI file with the same resolution as the first image in the list.\n",
    "    Parameters: - list of PNG, TIFF, JPEG, BMP, WEBP, STK, LSM, or XCF images\n",
    "    - name of the video file\n",
    "    Returns: saves the video in the execution directory\n",
    "    \"\"\"\n",
    "\n",
    "    # stores the dimensions of the first image\n",
    "    img = cv2.imread(img_list[0])\n",
    "    height, width, _ = img.shape\n",
    "    size = (width, height)\n",
    "    num_frames =  len(img_list)\n",
    "\n",
    "    img_array = list()\n",
    "    for i in range(len(img_list)):\n",
    "        img = cv2.imread(img_list[i])\n",
    "        img_array.append(img)\n",
    "        print(f\"1. Appending frames {i+1}/{num_frames}\", end=\"\\r\")\n",
    "        \n",
    "    print(\"2. Creating video writer...\", end=\"\\r\")\n",
    "    video = cv2.VideoWriter(filename= nome_ficheiro + '.avi',\n",
    "                            fourcc=cv2.VideoWriter_fourcc(*'mp4v'), fps = fps_,\n",
    "                            frameSize=size)\n",
    "\n",
    "    for i in range(len(img_array)):\n",
    "        if frame_num_text:\n",
    "\n",
    "            frame_number_text = f\"frame_{i:06d}\"\n",
    "            cv2.putText(img_array[i], frame_number_text, (width-300, 50), \n",
    "                            cv2.FONT_HERSHEY_SIMPLEX,font_size, (255, 100, 100), \n",
    "                            2, cv2.LINE_AA)\n",
    "        if titulo:\n",
    "            cv2.putText(img_array[i], titulo, (50, 50), cv2.FONT_HERSHEY_SIMPLEX,\n",
    "                        font_size, (255, 255, 255), 2, cv2.LINE_AA)\n",
    "        \n",
    "        video.write(img_array[i])\n",
    "        print(f\"3. Writing frames to file {i+1}/{num_frames}\", end=\"\\r\")\n",
    "    video.release()"
   ],
   "outputs": [],
   "execution_count": 18
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T01:16:47.174412Z",
     "start_time": "2024-05-23T01:16:47.097455Z"
    }
   },
   "source": [
    "generate_interpolated_masks(multipolygons, OUT_DIR, out_dim=(1280, 720))"
   ],
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "polygons should be a list of binary masks for at least two frames",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mValueError\u001B[0m                                Traceback (most recent call last)",
      "Cell \u001B[1;32mIn[19], line 1\u001B[0m\n\u001B[1;32m----> 1\u001B[0m \u001B[43mgenerate_interpolated_masks\u001B[49m\u001B[43m(\u001B[49m\u001B[43mmultipolygons\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mOUT_DIR\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mout_dim\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m1280\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m720\u001B[39;49m\u001B[43m)\u001B[49m\u001B[43m)\u001B[49m\n",
      "Cell \u001B[1;32mIn[6], line 14\u001B[0m, in \u001B[0;36mgenerate_interpolated_masks\u001B[1;34m(polygons, out_dir, out_dim)\u001B[0m\n\u001B[0;32m      2\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[0;32m      3\u001B[0m \u001B[38;5;124;03mGenerates interpolated masks for all frames in the video.\u001B[39;00m\n\u001B[0;32m      4\u001B[0m \n\u001B[1;32m   (...)\u001B[0m\n\u001B[0;32m     11\u001B[0m \u001B[38;5;124;03m- None\u001B[39;00m\n\u001B[0;32m     12\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[0;32m     13\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(polygons, \u001B[38;5;28mlist\u001B[39m) \u001B[38;5;129;01mor\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(polygons) \u001B[38;5;241m<\u001B[39m \u001B[38;5;241m2\u001B[39m:\n\u001B[1;32m---> 14\u001B[0m     \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mpolygons should be a list of binary masks for at least two frames\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[0;32m     16\u001B[0m \u001B[38;5;66;03m# for each pair of frames, generate 99 interpolated masks\u001B[39;00m\n\u001B[0;32m     17\u001B[0m cnt \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m0\u001B[39m\n",
      "\u001B[1;31mValueError\u001B[0m: polygons should be a list of binary masks for at least two frames"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3. Writing frames to file 22501/22501\r"
     ]
    }
   ],
   "source": [
    "frames2video(sorted(glob(os.path.join(OUT_DIR, \"*.png\"))), \n",
    "             nome_ficheiro='shape_based_interpol', fps_ = 25*10, \n",
    "             titulo=\"Shape Based Interpolation (10x speed)\", \n",
    "             frame_num_text = True, font_size=1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mask_to_polygons"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T01:16:56.405149Z",
     "start_time": "2024-05-23T01:16:56.382772Z"
    }
   },
   "source": [
    "from shapely.geometry import shape, MultiPolygon\n",
    "from rasterio.features import shapes  \n",
    "from rasterio import Affine        \n",
    "\n",
    "def mask_to_polygons(mask_img):\n",
    "    \"\"\"\n",
    "    Converts segmentation mask to shapely multipolygon.\n",
    "    Adapted from: https://rocreguant.com/convert-a-mask-into-a-polygon-for-images-using-shapely-and-rasterio/1786/\n",
    "    \"\"\"\n",
    "    all_polygons = list()\n",
    "    \n",
    "    for shp, _ in shapes(source=mask_img.astype(np.uint8),mask=(mask_img>0), \n",
    "                             transform=Affine(1.0, 0, 0, 0, 1.0, 0)):\n",
    "        all_polygons.append(shape(shp))\n",
    "\n",
    "    all_polygons = MultiPolygon(all_polygons)\n",
    "\n",
    "    # Sometimes buffer() converts a simple Multipolygon to just a Polygon,\n",
    "    # need to keep it a Multipolygon throughout\n",
    "    if not all_polygons.is_valid:\n",
    "        all_polygons = all_polygons.buffer(0)\n",
    "        if all_polygons.type == 'Polygon':\n",
    "            all_polygons = MultiPolygon([all_polygons])\n",
    "    \n",
    "    return all_polygons"
   ],
   "outputs": [],
   "execution_count": 20
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### msks_paths_to_polygon_list"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T01:17:00.046136Z",
     "start_time": "2024-05-23T01:17:00.030031Z"
    }
   },
   "source": [
    "def msks_paths_to_polygon_list(msks_paths):\n",
    "    \"\"\"\n",
    "    Converts segmentation masks paths list to list of shapely multipolygons.\n",
    "    \"\"\"\n",
    "    pol_list = list()\n",
    "    for img_path in msks_paths:\n",
    "        img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)\n",
    "        polygon = mask_to_polygons(img)\n",
    "        pol_list.append(polygon)\n",
    "    return pol_list"
   ],
   "outputs": [],
   "execution_count": 21
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate list of shapely polygons from the masks\n",
    "polygon_list = msks_paths_to_polygon_list(sorted(glob(os.path.join(OUT_DIR, \"*.png\"))))\n",
    "\n",
    "# convert shapely list polygons to WKT format file\n",
    "with open(OUT_WKT_FILE, 'w') as f:\n",
    "    for polygon in polygon_list:\n",
    "        f.write(polygon.wkt + '\\n')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interpolation of the sampled polygons"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Sources (sampled polygons)"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T01:20:08.396245Z",
     "start_time": "2024-05-23T01:20:08.383279Z"
    }
   },
   "source": [
    "OUT_DIR_SAMPLED_PNG = os.path.join(OUT_DIR, 'PNGs_sampled')\n",
    "# create output directory\n",
    "if not os.path.exists(OUT_DIR_SAMPLED_PNG):\n",
    "    os.makedirs(OUT_DIR_SAMPLED_PNG)\n",
    "# Directory to save WKT format interpolated polygons    \n",
    "OUT_WKT_SAMPLED_FILE = os.path.join(OUT_DIR, \"shape_interpol_sampled.wkt\")\n",
    "# WKT with sampled polygons\n",
    "WKT_FILE_SAMPLED = os.path.join(\"E:/BurnedAreaUAV_files/Interpolation/reference_masks\", \"sampled_masks.txt\")"
   ],
   "outputs": [],
   "execution_count": 23
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-23T01:22:55.780136Z",
     "start_time": "2024-05-23T01:22:55.173191Z"
    }
   },
   "source": [
    "WKT_FILE_SAMPLED = r\"D:\\BurnedAreaUAV_files\\Interpolation\\reference_masks\\sampled_masks.txt\"\n",
    "\n",
    "# read txt file \n",
    "with open(WKT_FILE_SAMPLED, 'r') as f:\n",
    "    polygons = f.readlines()\n",
    "    # extract indexes and polygons\n",
    "    indexes = [int(polygon.split(',')[0]) for polygon in polygons]\n",
    "    polygons = [polygon.split(',', 1)[1][:-1] for polygon in polygons]\n",
    "    # convert polygons to shapely polygons\n",
    "    polygons = [wkt.loads(polygon) for polygon in polygons]"
   ],
   "outputs": [],
   "execution_count": 25
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "cnt = 0\n",
    "for i in range(len(polygons) - 1):\n",
    "    for j in range(indexes[i]*100, indexes[i+1]*100):\n",
    "        int_instance = i + j / 100\n",
    "        image = interpolate_mask(polygons, i, i+1, int_instance, out_dim=OUT_DIMS)\n",
    "        cv2.imwrite(os.path.join(OUT_DIR_SAMPLED_PNG, f\"frame_{cnt:06}.png\"), image)\n",
    "        cnt += 1\n",
    "        # print progress\n",
    "        if j % 10 == 0:\n",
    "            print(f\"Generated frame_{cnt:06}.png\", end=\"\\r\")\n",
    "print(\"\\nDone.\")"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated frame_022491.png\n",
      "Done.\n"
     ]
    }
   ],
   "source": [
    "cnt = 0\n",
    "for i in range(len(polygons)- 1):\n",
    "    for j in range(indexes[i]*100, indexes[i+1]*100):\n",
    "        if j != indexes[i]*100 or j != indexes[i+1]*100:\n",
    "            int_instance = (j-indexes[i]*100)/(indexes[i+1]*100 - indexes[i]*100)\n",
    "            image = interpolate_mask(polygons, i, i+1, int_instance, out_dim=OUT_DIMS)\n",
    "            cnt += 1\n",
    "            cv2.imwrite(os.path.join(OUT_DIR_SAMPLED_PNG, f\"frame_{cnt:06}.png\"), image)\n",
    "        else:\n",
    "            cnt += 1\n",
    "print(\"\\nDone.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated frame_000000.png\n",
      "Generated frame_001900.png\n",
      "Generated frame_002800.png\n",
      "Generated frame_004800.png\n",
      "Generated frame_005600.png\n",
      "Generated frame_007400.png\n",
      "Generated frame_008200.png\n",
      "Generated frame_008700.png\n",
      "Generated frame_010600.png\n",
      "Generated frame_012800.png\n",
      "Generated frame_017300.png\n",
      "Generated frame_019500.png\n",
      "Generated frame_022500.png\n"
     ]
    }
   ],
   "source": [
    "# convert sampled polygons to PNGs\n",
    "for i, polygon in enumerate(polygons):\n",
    "    image = np.zeros(OUT_DIMS[::-1], dtype=np.uint8)\n",
    "    cv2.fillPoly(image, [np.array(polygon.exterior.coords).astype(np.int32)], 255)\n",
    "    cv2.imwrite(os.path.join(OUT_DIR, f\"frame_{(indexes[i]*100):06}.png\"), image)\n",
    "    print(f\"Generated frame_{(indexes[i]*100):06}.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3. Writing frames to file 22501/22501\r"
     ]
    }
   ],
   "source": [
    "frames2video(sorted(glob(os.path.join(OUT_DIR_SAMPLED_PNG, \"*.png\"))), \n",
    "             nome_ficheiro='shape_based_interpol_sampled', fps_ = 25*10, \n",
    "             titulo=\"Shape Based Interpolation - Sampled (10x speed)\", \n",
    "             frame_num_text = True, font_size=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate list of shapely polygons from the masks\n",
    "polygon_list = msks_paths_to_polygon_list(sorted(glob(os.path.join(OUT_DIR_SAMPLED_PNG, \"*.png\"))))\n",
    "\n",
    "# convert shapely list polygons to WKT format file\n",
    "with open(OUT_WKT_SAMPLED_FILE, 'w') as f:\n",
    "    for polygon in polygon_list:\n",
    "        f.write(polygon.wkt + '\\n')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "interpol",
   "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.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}