viso_plots copy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import hashlib\n",
    "import matplotlib\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import yaml\n",
    "\n",
    "from firebase_admin import db\n",
    "from library.config import get_config_declaration, get_config_options\n",
    "from library.firebase import initialize_app, get_dataset_ref\n",
    "from matplotlib.axes import Axes\n",
    "from os import makedirs\n",
    "from os.path import exists, basename, splitext\n",
    "from typing import Dict, Tuple\n",
    "from library.dataset import get_dataset_path\n",
    "from glob import glob\n",
    "import cv2\n",
    "\n",
    "from library.design_space import get_design_space as get_design_space2, get_pareto_front"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "VIDEO_FILES = [\n",
    "    \"VISO/car/003\",\n",
    "    \"VISO/car/004\",\n",
    "    \"VISO/car/005\",\n",
    "    \"VISO/car/006\",\n",
    "    \"VISO/car/007\",\n",
    "    \"VISO/car/008\",\n",
    "    \"VISO/car/009\",\n",
    "]\n",
    "\n",
    "VIDEO_SCORES = {\n",
    "    \"VISO/car/003\": (0.92, 0.92, 0.84),\n",
    "    \"VISO/car/004\": (0.83, 0.89, 0.85),\n",
    "    \"VISO/car/005\": (0.94, 0.88, 0.91),\n",
    "    \"VISO/car/006\": (0.88, 0.93, 0.86),\n",
    "    \"VISO/car/007\": (0.80, 0.84, 0.80),\n",
    "    \"VISO/car/008\": (0.83, 0.85, 0.81),\n",
    "    \"VISO/car/009\": (0.93, 0.73, 0.78)\n",
    "}\n",
    "\n",
    "initialize_app()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_design_space(\n",
    "    video_file: str, enable_tracking: bool, enable_persist: bool\n",
    "):\n",
    "    X, y, current_idx, known_idx = get_design_space2(video_file, enable_tracking, enable_persist)\n",
    "\n",
    "    with open(\"./config_declaration.yml\", \"rb\") as f:\n",
    "        config_hash = hashlib.md5(f.read()).hexdigest()\n",
    "\n",
    "    sherlock_ref = db.reference(\"sherlock\")\n",
    "\n",
    "    video_file_ref = get_dataset_ref(video_file, sherlock_ref)\n",
    "    config_declaration_ref = video_file_ref.child(config_hash)\n",
    "\n",
    "    if enable_tracking:\n",
    "        tracking_ref = config_declaration_ref.child(\"tracking_enabled\")\n",
    "    else:\n",
    "        tracking_ref = config_declaration_ref.child(\"tracking_disabled\")\n",
    "\n",
    "    if enable_persist:\n",
    "        persist_ref = tracking_ref.child(\"persist_enabled\")\n",
    "    else:\n",
    "        persist_ref = tracking_ref.child(\"persist_disabled\")\n",
    "\n",
    "    current_idx = np.array(current_idx)\n",
    "    current_outputs = np.array(y[current_idx, :])\n",
    "\n",
    "    known_idx = np.array(known_idx)\n",
    "    known_outputs = np.array(y[known_idx, :])\n",
    "        \n",
    "    ypredict, ypredict_idx, = get_pareto_front(video_file, enable_tracking, enable_persist)\n",
    "\n",
    "    return y, current_idx, current_outputs, known_outputs, known_idx, ypredict, ypredict_idx, persist_ref\n",
    "\n",
    "def get_results(\n",
    "    video_file: str,\n",
    "    enable_tracking: bool,\n",
    "    enable_persist: bool,\n",
    "    reference_video_file: str,\n",
    "    ax: Axes,\n",
    "):\n",
    "    if reference_video_file:\n",
    "        reference_video_idx = VIDEO_FILES.index(reference_video_file)\n",
    "\n",
    "    video_idx = VIDEO_FILES.index(video_file)\n",
    "\n",
    "    (\n",
    "        y,\n",
    "        current_idx,\n",
    "        current_outputs,\n",
    "        known_outputs,\n",
    "        known_idx,\n",
    "        ypredict,\n",
    "        ypredict_idx,\n",
    "        storage_ref,\n",
    "    ) = get_design_space(video_file, enable_tracking, enable_persist)\n",
    "\n",
    "    ax.scatter(\n",
    "        current_outputs[:, 0],\n",
    "        current_outputs[:, 1],\n",
    "        c=\"blue\",\n",
    "        marker=\"^\",\n",
    "        label=\"Sampled designs\",\n",
    "    )\n",
    "    ax.scatter(\n",
    "        ypredict[:, 0],\n",
    "        ypredict[:, 1],\n",
    "        c=\"red\",\n",
    "        label=\"Predicted Pareto designs\",\n",
    "    )\n",
    "\n",
    "    if reference_video_file and video_idx != reference_video_idx:\n",
    "        _, _, _, _, _, _, ref_ypredict_idx, _ = get_design_space(\n",
    "            reference_video_file, enable_tracking, enable_persist\n",
    "        )\n",
    "\n",
    "        known_idx_set = {idx for idx in known_idx}\n",
    "        filtered_idx = [idx for idx in ref_ypredict_idx if idx in known_idx_set]\n",
    "        requested_idx = [\n",
    "            int(idx) for idx in ref_ypredict_idx if idx not in known_idx_set\n",
    "        ]\n",
    "\n",
    "        requested_idx_ref = storage_ref.child(\"requested_idx\")\n",
    "        requested_idx_ref.set(requested_idx)\n",
    "\n",
    "        ax.scatter(\n",
    "            y[filtered_idx, 0],\n",
    "            y[filtered_idx, 1],\n",
    "            c=\"orange\",\n",
    "            marker=\"+\",\n",
    "            label=f\"Predicted Pareto designs for Video {reference_video_idx + 1}\",\n",
    "        )\n",
    "\n",
    "    ax.set_title(\n",
    "        f\"Video {video_idx + 1}\"\n",
    "        # + f\" with Tracking {'Enabled' if enable_tracking else 'Disabled'}\"\n",
    "        # + f\" and Persistence {'Enabled' if enable_persist else 'Disabled'}\"\n",
    "        # + \" Design Space\"\n",
    "    )\n",
    "    ax.set(xlabel=\"Recall\", ylabel=\"Precision\")\n",
    "    # ax.label_outer()\n",
    "    # ax.legend()\n",
    "    # plt.legend(bbox_to_anchor=(1.05, 1.05))\n",
    "    # plt.xlabel(\"Recall\")\n",
    "    # plt.ylabel(\"Precision\")\n",
    "    ax.set_xlim(known_outputs[:, 0].min(), known_outputs[:, 0].max())\n",
    "    ax.set_ylim(known_outputs[:, 1].min(), known_outputs[:, 1].max())\n",
    "\n",
    "    # plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_row_col(i: int):\n",
    "    col = i % 3\n",
    "    row = math.floor(i / 3)\n",
    "\n",
    "    return (row, col)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_pareto(enable_tracking: bool, enable_persist: bool):\n",
    "    SMALL_SIZE = 12\n",
    "    MEDIUM_SIZE = 14\n",
    "    BIGGER_SIZE = 16\n",
    "\n",
    "    plt.rc('font', size=SMALL_SIZE)          # controls default text sizes\n",
    "    plt.rc('axes', titlesize=SMALL_SIZE)     # fontsize of the axes title\n",
    "    plt.rc('axes', labelsize=MEDIUM_SIZE)    # fontsize of the x and y labels\n",
    "    plt.rc('xtick', labelsize=SMALL_SIZE)    # fontsize of the tick labels\n",
    "    plt.rc('ytick', labelsize=SMALL_SIZE)    # fontsize of the tick labels\n",
    "    plt.rc('legend', fontsize=SMALL_SIZE)    # legend fontsize\n",
    "    plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title\n",
    "\n",
    "    video_files = [None]\n",
    "    video_files.extend(VIDEO_FILES)\n",
    "\n",
    "    for ref_idx, ref_video_file in enumerate(video_files):\n",
    "        ref_idx -= 1\n",
    "        if ref_idx != -1:\n",
    "            ref_r, ref_c = get_row_col(ref_idx)\n",
    "\n",
    "            if ref_r == 0 and ref_c == 0:\n",
    "                ref_r = 1\n",
    "\n",
    "        fig, axs = plt.subplots(nrows=3, ncols=3, figsize=(12, 8), constrained_layout=True)\n",
    "        fig.delaxes(axs[2][1])\n",
    "        fig.delaxes(axs[2][2])\n",
    "        for i, video_file in enumerate(VIDEO_FILES):\n",
    "            r, c = get_row_col(i)\n",
    "\n",
    "            get_results(\n",
    "                video_file, enable_tracking, enable_persist, ref_video_file, axs[r, c]\n",
    "            )\n",
    "\n",
    "        if ref_idx == -1:\n",
    "            ref_r = 0\n",
    "\n",
    "        handles, labels = axs[ref_r, 0].get_legend_handles_labels()\n",
    "        fig.legend(\n",
    "            handles, labels, loc=\"lower right\", bbox_to_anchor=(0.8, 0.15)\n",
    "        )\n",
    "\n",
    "        makedirs(\"./output/figures\", exist_ok=True)\n",
    "\n",
    "        if ref_idx == -1:\n",
    "            path = f\"./output/figures/fig_viso_{'tracking' if enable_tracking else 'detection'}_pareto\"\n",
    "        else:\n",
    "            path = f\"./output/figures/fig_viso_{'tracking' if enable_tracking else 'detection'}_pareto_ref{ref_idx + 1}\"\n",
    "\n",
    "        # fig.suptitle(f\"{'Tracking' if enable_tracking else 'Detection'}\")\n",
    "        plt.savefig(f\"{path}.pdf\", format=\"pdf\")\n",
    "        plt.savefig(f\"{path}.png\", format=\"png\")\n",
    "\n",
    "plot_pareto(True, False)\n",
    "# plot_pareto(False, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_pareto(enable_tracking: bool, enable_persist: bool):\n",
    "    names = []\n",
    "    idxes = []\n",
    "    recalls = []\n",
    "    precisions = []\n",
    "    f1s = []\n",
    "\n",
    "    for i, video_file in enumerate(VIDEO_FILES):\n",
    "        (\n",
    "            y,\n",
    "            current_idx,\n",
    "            current_outputs,\n",
    "            _,\n",
    "            _,\n",
    "            ypredict,\n",
    "            ypredict_idx,\n",
    "            storage_ref,\n",
    "        ) = get_design_space(video_file, enable_tracking, enable_persist)\n",
    "\n",
    "        for idx, (output) in zip(current_idx, current_outputs):\n",
    "            idx = idx\n",
    "            recall = output[0]\n",
    "            precision = output[1]\n",
    "            f1 = output[2]\n",
    "\n",
    "            names.append(f\"Video {i + 1}\")\n",
    "            idxes.append(idx)\n",
    "            recalls.append(recall)\n",
    "            precisions.append(precision)\n",
    "            f1s.append(f1)\n",
    "\n",
    "    df = pd.DataFrame()\n",
    "    df[\"Video Name\"] = names\n",
    "    df[\"idx\"] = idxes\n",
    "    df[\"Recall\"] = recalls\n",
    "    df[\"Precision\"] = precisions\n",
    "    df[\"F1\"] = f1s\n",
    "\n",
    "    df.to_csv(f\"./output/{'tracking' if enable_tracking else 'detection'}_pareto_front.csv\")\n",
    "\n",
    "# save_pareto(True, False)\n",
    "save_pareto(False, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===Tracking===\n",
      "VISO/car/003\n",
      "\u001b[0m(4548) Max Recall: [0.9089436  0.04412882 0.08417116]\u001b[0m => 0.92\n",
      "\u001b[0m(7101) Max Precision: [0.12760775 0.84806974 0.22183615]\u001b[0m => 0.92\n",
      "\u001b[0m(11107) Max F1: [0.52486429 0.59172763 0.55629402]\u001b[0m => 0.84\n",
      "==========\n",
      "VISO/car/004\n",
      "\u001b[94m(9525) Max Recall: [0.94328815 0.11109107 0.19877268]\u001b[0m => 0.83\n",
      "\u001b[94m(2365) Max Precision: [0.02033471 0.99122807 0.03985188]\u001b[0m => 0.89\n",
      "\u001b[0m(4770) Max F1: [0.72083783 0.68362403 0.70173791]\u001b[0m => 0.85\n",
      "==========\n",
      "VISO/car/005\n",
      "\u001b[94m(7003) Max Recall: [0.94558084 0.09388437 0.17080948]\u001b[0m => 0.94\n",
      "\u001b[0m(10012) Max Precision: [0.558413   0.59164345 0.57454814]\u001b[0m => 0.88\n",
      "\u001b[0m(1228) Max F1: [0.74647618 0.52693177 0.61777848]\u001b[0m => 0.91\n",
      "==========\n",
      "VISO/car/006\n",
      "\u001b[94m(11808) Max Recall: [0.97492884 0.05421877 0.10272471]\u001b[0m => 0.88\n",
      "\u001b[0m(17550) Max Precision: [0.55932946 0.79990599 0.65832742]\u001b[0m => 0.93\n",
      "\u001b[0m(5502) Max F1: [0.75346687 0.69764598 0.72448278]\u001b[0m => 0.86\n",
      "==========\n",
      "VISO/car/007\n",
      "\u001b[94m(7100) Max Recall: [0.95760392 0.07247613 0.13475346]\u001b[0m => 0.8\n",
      "\u001b[94m(6812) Max Precision: [0.04878049 1.         0.09302326]\u001b[0m => 0.84\n",
      "\u001b[0m(3772) Max F1: [0.70004459 0.70539153 0.70270789]\u001b[0m => 0.8\n",
      "==========\n",
      "VISO/car/008\n",
      "\u001b[94m(15790) Max Recall: [0.92079304 0.19150006 0.31706018]\u001b[0m => 0.83\n",
      "\u001b[94m(11576) Max Precision: [0.046875   1.         0.08955224]\u001b[0m => 0.85\n",
      "\u001b[0m(4630) Max F1: [0.63133953 0.78166567 0.69850618]\u001b[0m => 0.81\n",
      "==========\n",
      "VISO/car/009\n",
      "\u001b[0m(8784) Max Recall: [0.86944785 0.27403511 0.41672548]\u001b[0m => 0.93\n",
      "\u001b[94m(1185) Max Precision: [0.08510638 1.         0.15686275]\u001b[0m => 0.73\n",
      "\u001b[0m(17172) Max F1: [0.55515239 0.93368592 0.69629854]\u001b[0m => 0.78\n",
      "==========\n",
      "Average\n",
      "\u001b[94mMax Recall: [0.93151232 0.12019062 0.20357388]\u001b[0m => 0.84\n",
      "\u001b[94mMax Precision: [0.20663526 0.89012104 0.26200026]\u001b[0m => 0.85\n",
      "\u001b[0mMax F1: [0.66174024 0.70295322 0.67111511]\u001b[0m => 0.84\n",
      "==========\n"
     ]
    }
   ],
   "source": [
    "def print_results(enable_tracking: bool, enable_persist: bool):\n",
    "    print(\"=\" * 3 + (\"Tracking\" if enable_tracking else \"Detection\") + \"=\" * 3)\n",
    "\n",
    "    avg_recall = np.zeros(3)\n",
    "    avg_precision = np.zeros(3)\n",
    "    avg_f1 = np.zeros(3)\n",
    "\n",
    "    required_avg_recall = 0.84\n",
    "    required_avg_precision = 0.85\n",
    "    required_avg_f1 = 0.84\n",
    "\n",
    "    for video_file in VIDEO_FILES:\n",
    "        (\n",
    "            _,\n",
    "            _,\n",
    "            _,\n",
    "            _,\n",
    "            _,\n",
    "            ypredict,\n",
    "            ypredict_idx,\n",
    "            storage_ref,\n",
    "        ) = get_design_space(video_file, enable_tracking, enable_persist)\n",
    "\n",
    "        max_recall_idx = np.argmax(ypredict[:, 0])\n",
    "        max_precision_idx = np.argmax(ypredict[:, 1])\n",
    "        max_f1_idx = np.argmax(ypredict[:, 2])\n",
    "\n",
    "        max_recall = ypredict[max_recall_idx, :]\n",
    "        max_precision = ypredict[max_precision_idx, :]\n",
    "        max_f1 = ypredict[max_f1_idx, :]\n",
    "\n",
    "        max_recall_idx = ypredict_idx[max_recall_idx]\n",
    "        max_precision_idx = ypredict_idx[max_precision_idx]\n",
    "        max_f1_idx = ypredict_idx[max_f1_idx]\n",
    "\n",
    "        avg_recall += max_recall\n",
    "        avg_precision += max_precision\n",
    "        avg_f1 += max_f1\n",
    "\n",
    "        recall_color = \"\\033[0m\"\n",
    "        precision_color = \"\\033[0m\"\n",
    "        f1_color = \"\\033[0m\"\n",
    "\n",
    "        recall, precision, f1 = VIDEO_SCORES[video_file]\n",
    "\n",
    "        if max_recall[0] >= recall:\n",
    "            recall_color = \"\\033[94m\"\n",
    "\n",
    "        if max_precision[1] >= precision:\n",
    "            precision_color = \"\\033[94m\"\n",
    "\n",
    "        if max_f1[2] >= f1:\n",
    "            f1_color = \"\\033[94m\"\n",
    "\n",
    "        print(video_file)\n",
    "        print(f\"{recall_color}({max_recall_idx}) Max Recall: {max_recall}\\033[0m => {recall}\")\n",
    "        print(f\"{precision_color}({max_precision_idx}) Max Precision: {max_precision}\\033[0m => {precision}\")\n",
    "        print(f\"{f1_color}({max_f1_idx}) Max F1: {max_f1}\\033[0m => {f1}\")\n",
    "        print(\"=\" * 10)\n",
    "\n",
    "    avg_recall /= 7.0\n",
    "    avg_precision /= 7.0\n",
    "    avg_f1 /= 7.0\n",
    "\n",
    "    recall_color = \"\\033[0m\"\n",
    "    precision_color = \"\\033[0m\"\n",
    "    f1_color = \"\\033[0m\"\n",
    "\n",
    "    recall, precision, f1 = VIDEO_SCORES[video_file]\n",
    "\n",
    "    if avg_recall[0] >= required_avg_recall:\n",
    "        recall_color = \"\\033[94m\"\n",
    "\n",
    "    if avg_precision[1] >= required_avg_precision:\n",
    "        precision_color = \"\\033[94m\"\n",
    "\n",
    "    if avg_f1[2] >= required_avg_f1:\n",
    "        f1_color = \"\\033[94m\"\n",
    "\n",
    "    print(\"Average\")\n",
    "    print(f\"{recall_color}Max Recall: {avg_recall}\\033[0m => {required_avg_recall}\")\n",
    "    print(f\"{precision_color}Max Precision: {avg_precision}\\033[0m => {required_avg_precision}\")\n",
    "    print(f\"{f1_color}Max F1: {avg_f1}\\033[0m => {required_avg_f1}\")\n",
    "    print(\"=\" * 10)\n",
    "\n",
    "print_results(True, False)\n",
    "#print_results(False, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x576 with 7 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "fig, axs = plt.subplots(nrows=3, ncols=3, figsize=(12, 8), constrained_layout=True)\n",
    "fig.delaxes(axs[2][1])\n",
    "fig.delaxes(axs[2][2])\n",
    "\n",
    "for i, video_file in enumerate(VIDEO_FILES):\n",
    "    r, c = get_row_col(i)\n",
    "    video_idx = VIDEO_FILES.index(video_file)\n",
    "\n",
    "    track_ypredict, _ = get_pareto_front(video_file, True, False)\n",
    "    track_ypredict_order = np.argsort(track_ypredict[:, 0])\n",
    "    track_ypredict = track_ypredict[track_ypredict_order, :]\n",
    "\n",
    "    detect_ypredict, _ = get_pareto_front(video_file, False, False)\n",
    "    detect_ypredict_order = np.argsort(detect_ypredict[:, 0])\n",
    "    detect_ypredict = detect_ypredict[detect_ypredict_order, :]\n",
    "\n",
    "    axs[r, c].plot(\n",
    "        track_ypredict[:, 0],\n",
    "        track_ypredict[:, 1],\n",
    "        c=\"red\",\n",
    "        marker=\"o\",\n",
    "        label=\"Spot (Track)\",\n",
    "    )\n",
    "    axs[r, c].hlines(y=track_ypredict[0, 1], xmin=0, xmax=track_ypredict[0, 0], color='red')\n",
    "    axs[r, c].vlines(x=track_ypredict[-1, 0], ymin=0, ymax=track_ypredict[-1, 1], color='red')\n",
    "\n",
    "    axs[r, c].plot(\n",
    "        detect_ypredict[:, 0],\n",
    "        detect_ypredict[:, 1],\n",
    "        c=\"blue\",\n",
    "        marker=\"o\",\n",
    "        label=\"Spot (Detect)\",\n",
    "    )\n",
    "    axs[r, c].hlines(y=detect_ypredict[0, 1], xmin=0, xmax=detect_ypredict[0, 0], color='blue')\n",
    "    axs[r, c].vlines(x=detect_ypredict[-1, 0], ymin=0, ymax=detect_ypredict[-1, 1], color='blue')\n",
    "\n",
    "    axs[r, c].set_title(f\"Video {video_idx + 1}\")\n",
    "    axs[r, c].set(xlabel=\"Recall\", ylabel=\"Precision\")\n",
    "    \n",
    "handles, labels = axs[0, 0].get_legend_handles_labels()\n",
    "fig.legend(\n",
    "    handles, labels, loc=\"lower right\", bbox_to_anchor=(0.8, 0.15)\n",
    ")\n",
    "plt.savefig(\"./output/figures/fig_viso_pr_curve.pdf\", format=\"pdf\")\n",
    "plt.savefig(\"./output/figures/fig_viso_pr_curve.png\", format=\"png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Track: 0.52, Detect 0.52\n",
      "Track: 0.71, Detect 0.64\n",
      "Track: 0.49, Detect 0.64\n",
      "Track: 0.68, Detect 0.76\n",
      "Track: 0.75, Detect 0.62\n",
      "Track: 0.72, Detect 0.76\n",
      "Track: 0.74, Detect 0.73\n",
      "Avg Track:  0.66, Avg Detect:  0.67\n"
     ]
    }
   ],
   "source": [
    "track_areas = []\n",
    "detect_areas = []\n",
    "\n",
    "for i, video_file in enumerate(VIDEO_FILES):\n",
    "    track_ypredict, _ = get_pareto_front(video_file, True, False)\n",
    "    track_ypredict_order = np.argsort(track_ypredict[:, 0])\n",
    "    track_ypredict = track_ypredict[track_ypredict_order, :]\n",
    "\n",
    "    detect_ypredict, _ = get_pareto_front(video_file, False, False)\n",
    "    detect_ypredict_order = np.argsort(detect_ypredict[:, 0])\n",
    "    detect_ypredict = detect_ypredict[detect_ypredict_order, :]\n",
    "\n",
    "    track_area = np.trapz(track_ypredict[:, 1], x=track_ypredict[:, 0])\n",
    "    detect_area = np.trapz(detect_ypredict[:, 1], x=detect_ypredict[:, 0])\n",
    "\n",
    "    track_area += track_ypredict[0, 0] * track_ypredict[0, 1]\n",
    "    detect_area += detect_ypredict[0, 0] * detect_ypredict[0, 1]\n",
    "\n",
    "    track_areas.append(track_area)\n",
    "    detect_areas.append(detect_area)\n",
    "\n",
    "    print(f\"Track: {track_area:.2}, Detect {detect_area:.2}\")\n",
    "\n",
    "avg_track_area = np.average(track_areas)\n",
    "avg_detect_area = np.average(detect_areas)\n",
    "\n",
    "print(f\"Avg Track: {avg_track_area: .2}, Avg Detect: {avg_detect_area: .2}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5.612623580529376, 7.18343443672467)\n"
     ]
    }
   ],
   "source": [
    "min_size = []\n",
    "max_size = []\n",
    "\n",
    "for video_file in VIDEO_FILES:\n",
    "    dataset_path = get_dataset_path(video_file)\n",
    "    ground_truth_path = f\"{dataset_path}/gt/gt.txt\"\n",
    "\n",
    "    gt = pd.read_csv(ground_truth_path).to_numpy()[:, 4:6]\n",
    "    min_size.extend(np.min(gt, axis=1))\n",
    "    max_size.extend(np.max(gt, axis=1))\n",
    "\n",
    "avg_size = (np.average(min_size), np.average(max_size))\n",
    "print(avg_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clamp(value: int, min_value: int, max_value: int):\n",
    "    if value <= min_value:\n",
    "        return min_value\n",
    "\n",
    "    if value >= max_value:\n",
    "        return max_value\n",
    "\n",
    "    return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.17105096922205823\n"
     ]
    }
   ],
   "source": [
    "contrasts = []\n",
    "\n",
    "for video_file in VIDEO_FILES:\n",
    "    dataset_path = get_dataset_path(video_file)\n",
    "    img_path = f\"{dataset_path}/img\"\n",
    "    ground_truth_path = f\"{dataset_path}/gt/gt.txt\"\n",
    "\n",
    "    frames = glob(f\"{img_path}/*.jpg\")\n",
    "    gt = pd.read_csv(ground_truth_path).to_numpy()[:, :6].astype(float)\n",
    "\n",
    "    for frame_path in frames:\n",
    "        frame_number = int(splitext(basename(frame_path))[0])\n",
    "        frame_gt = gt[gt[:, 0] == frame_number, 2:6]\n",
    "        frame_img = cv2.imread(frame_path)\n",
    "\n",
    "        img_height, img_width, _ = frame_img.shape\n",
    "\n",
    "        for x1, y1, width, height in frame_gt:\n",
    "            x2 = x1 + width + width / 2\n",
    "            y2 = y1 + height + height / 2\n",
    "\n",
    "            x1 -= width + width / 2\n",
    "            y1 -= height + width / 2\n",
    "\n",
    "            x1 = clamp(x1, 0, x1)\n",
    "            y1 = clamp(y1, 0, y1)\n",
    "\n",
    "            x1 = round(x1)\n",
    "            y1 = round(y1)\n",
    "\n",
    "            x2 = round(x2)\n",
    "            y2 = round(y2)\n",
    "\n",
    "            x2 = clamp(x2, x2, img_width - 1)\n",
    "            y2 = clamp(y2, y2, img_height - 1)\n",
    "\n",
    "            region = cv2.cvtColor(frame_img[y1:y2, x1:x2, :], cv2.COLOR_BGR2GRAY).flatten().astype(float) / 255.0\n",
    "            contrasts.append(np.std(region))\n",
    "\n",
    "print(np.average(contrasts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(19200, 6)\n"
     ]
    }
   ],
   "source": [
    "X, y, current_idx, known_idx = get_design_space2(VIDEO_FILES[0], True, False)\n",
    "\n",
    "print(X.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "193.35714285714286\n"
     ]
    }
   ],
   "source": [
    "samples = []\n",
    "\n",
    "for video_file in VIDEO_FILES:\n",
    "    _, track_current_idx, _, _, _, _, track_ypredict_idx, _ = get_design_space(video_file, True, False)\n",
    "    _, detect_current_idx, _, _, _, _, detect_ypredict_idx, _ = get_design_space(video_file, False, False)\n",
    "\n",
    "    samples.extend(track_current_idx.shape)\n",
    "    samples.extend(detect_current_idx.shape)\n",
    "\n",
    "print(np.average(samples))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[1], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mlibrary\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdesign_space\u001b[39;00m \u001b[39mimport\u001b[39;00m approximate_pareto\n\u001b[0;32m----> 3\u001b[0m y \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39mmultivariate_normal([\u001b[39m0\u001b[39m, \u001b[39m0\u001b[39m], [[\u001b[39m0.03\u001b[39m, \u001b[39m0\u001b[39m], [\u001b[39m0\u001b[39m, \u001b[39m0.02\u001b[39m]], \u001b[39m80000\u001b[39m)\n\u001b[1;32m      4\u001b[0m y \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mdelete(y, y[:, \u001b[39m0\u001b[39m] \u001b[39m<\u001b[39m \u001b[39m0\u001b[39m, axis\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m)\n\u001b[1;32m      5\u001b[0m y \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mdelete(y, y[:, \u001b[39m1\u001b[39m] \u001b[39m<\u001b[39m \u001b[39m0\u001b[39m, axis\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "from library.design_space import approximate_pareto\n",
    "\n",
    "y = np.random.multivariate_normal([0, 0], [[0.03, 0], [0, 0.02]], 80000)\n",
    "y = np.delete(y, y[:, 0] < 0, axis=0)\n",
    "y = np.delete(y, y[:, 1] < 0, axis=0)\n",
    "\n",
    "ypredict, ypredict_idx, _ = approximate_pareto(y)\n",
    "\n",
    "plt.xlabel(\"X Variable\")\n",
    "plt.ylabel(\"Y Variable\")\n",
    "\n",
    "plt.scatter(y[:, 0], y[:, 1], marker='^')\n",
    "plt.savefig(\"output/pareto_blue.png\")\n",
    "\n",
    "plt.scatter(ypredict[:, 0], ypredict[:, 1], color='red')\n",
    "plt.savefig(\"output/pareto_red.png\")"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "b93de7f5c1adcbd91c4dac5eba592329dbcd80c30145dd72ac63134353aa09bc"
  },
  "kernelspec": {
   "display_name": "Python 3.8.12 ('baboon-tracking-q7VIGxQd-py3.8')",
   "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.8.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "b93de7f5c1adcbd91c4dac5eba592329dbcd80c30145dd72ac63134353aa09bc"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}