assignment2/assignment2.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab Assigment 2 Estimation of Apparent Motion\n",
    "\n",
    "<p style=\"text-align:left;\">\n",
    "    José Pedro Cruz\n",
    "    <span style=\"float:right;\">\n",
    "        up201504646\n",
    "    </span>\n",
    "</p>\n",
    "<p style=\"text-align:left;\">\n",
    "    Martinho Figueiredo\n",
    "    <span style=\"float:right;\">\n",
    "        up201506179\n",
    "    </span>\n",
    "</p>\n",
    "<p style=\"text-align:left;\">\n",
    "    Nuno Nascimento\n",
    "    <span style=\"float:right;\">\n",
    "        up201907933\n",
    "    </span>\n",
    "</p>\n",
    "\n",
    "\n",
    "[![GitHub](https://img.shields.io/badge/github-%23121011.svg?style=for-the-badge&logo=github&logoColor=white)](https://github.com/martinhofigueiredo/VC)\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scheme\n",
    "```mermaid\n",
    "flowchart LR\n",
    "    A[Ingest Footage] -->|mp4 or mpegs| B{Multi Channel?}\n",
    "    B -->|Yes| C[Split into Channels]\n",
    "    B -->|No| D[Gray]-->H\n",
    "    C --> E[R]-->H\n",
    "    C --> F[G]-->H\n",
    "    C --> G[B]-->H\n",
    "    H{Multi Resolution?}-->|Yes|I[n Pyramid DownSampling Average]-->K\n",
    "    H-->|No|J[One Shot]-->K\n",
    "    K{algo} -->|HornShunck| M((.flo file))\n",
    "    K -->|LucasKanade| M\n",
    "```\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benchmarking\n",
    "\n",
    "```mermaid\n",
    "flowchart LR\n",
    "    GT[Ground truth] --> B{BenchMark}\n",
    "    A(Flow Calculated) --> B\n",
    "    B --> AE(Angular Error and Std Dev)\n",
    "    B --> EE(Endpoint Error and Std Dev)\n",
    "```\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization\n",
    "```mermaid\n",
    "flowchart LR\n",
    "    A[import .flo file]-->C{Type}\n",
    "    C-->VF[Vector Field]\n",
    "    C-->MF[Middlebury Flow]\n",
    "    \n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_5475/4116061769.py:7: DeprecationWarning: Please use `convolve` from the `scipy.ndimage` namespace, the `scipy.ndimage.filters` namespace is deprecated.\n",
      "  from scipy.ndimage.filters import convolve as filter2\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import yaml\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import display, clear_output\n",
    "from scipy.ndimage.filters import convolve as filter2\n",
    "import struct\n",
    "import argparse\n",
    "import math\n",
    "from PIL import Image\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: wget in /home/gitpod/.pyenv/versions/3.11.1/lib/python3.11/site-packages (3.2)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "# IMport dataset with public ground truth\n",
    "%pip install wget\n",
    "import os\n",
    "import subprocess\n",
    "import wget\n",
    "import zipfile\n",
    "\n",
    "# Specify the URLs of the files to download\n",
    "url1 = \"https://vision.middlebury.edu/flow/data/comp/zip/other-gt-flow.zip\"\n",
    "url2 = \"https://vision.middlebury.edu/flow/data/comp/zip/other-color-allframes.zip\"\n",
    "url3 = \"https://vision.middlebury.edu/flow/data/comp/zip/eval-color-allframes.zip\"\n",
    "# Specify the destination folder to store the downloaded files\n",
    "destination_folder = \"dataset/\"\n",
    "\n",
    "# Download the files using wget\n",
    "file1 = wget.download(url1, out=destination_folder)\n",
    "file2 = wget.download(url2, out=destination_folder)\n",
    "file3 = wget.download(url3, out=destination_folder)\n",
    "\n",
    "# Unzip the files\n",
    "with zipfile.ZipFile(file1, 'r') as zip_ref:\n",
    "    zip_ref.extractall(destination_folder)\n",
    "\n",
    "with zipfile.ZipFile(file2, 'r') as zip_ref:\n",
    "    zip_ref.extractall(destination_folder)\n",
    "    \n",
    "with zipfile.ZipFile(file3, 'r') as zip_ref:\n",
    "    zip_ref.extractall(destination_folder)\n",
    "\n",
    "# Remove the zip files if needed\n",
    "os.remove(file1)\n",
    "os.remove(file2)\n",
    "os.remove(file3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ingest "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find all jpgs and pngs in a folder and returns a list of their respective path \n",
    "def get_frame_paths(folder_path):\n",
    "    frame_paths = []\n",
    "    for filename in os.listdir(folder_path):\n",
    "        if filename.endswith('.jpg') or filename.endswith('.png'):\n",
    "            frame_path = os.path.join(folder_path, filename)\n",
    "            frame_paths.append(frame_path)\n",
    "    frame_paths.sort()\n",
    "    ##print(frame_paths)\n",
    "    return frame_paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "tags": [
     "Ingest"
    ]
   },
   "outputs": [],
   "source": [
    "# Checks if the inut file is a directory and if it is it will try and get the frames inside the folder\n",
    "# it will check if it is and mp4 and if it is it will read it and create a list of frames\n",
    "def get_input_frames(input_path):\n",
    "    frames = []\n",
    "    if os.path.isdir(input_path):\n",
    "        frame_paths = get_frame_paths(input_path)\n",
    "        #print(f\"{frame_paths}\")\n",
    "        frames = [cv2.imread(frame_path) for frame_path in frame_paths]\n",
    "    else :\n",
    "        #print(\"here\")\n",
    "        if input_path.endswith('.mp4') or input_path.endswith('.mov') :\n",
    "            cap = cv2.VideoCapture(input_path)\n",
    "            frames = []\n",
    "            while True:\n",
    "                ret, frame = cap.read()\n",
    "                if not ret:\n",
    "                    break\n",
    "                frames.append(frame)\n",
    "            cap.release()\n",
    "    return frames"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Algo Config from file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loads a yaml file with the parameters to run the code\n",
    "def load_config(filename):\n",
    "    with open(filename, 'r') as f:\n",
    "        config = yaml.load(f, Loader=yaml.FullLoader)\n",
    "        config['input_path']= os.getcwd()+config['input_path'] # Fix to run in the location it called\n",
    "        #print(config)\n",
    "    return config"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flo file format Aux Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import struct\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def read_flow_field(file_path):\n",
    "    with open(file_path, \"rb\") as f:\n",
    "        # Read .flo header\n",
    "        magic = struct.unpack('f', f.read(4))[0]\n",
    "        width = struct.unpack('i', f.read(4))[0]\n",
    "        height = struct.unpack('i', f.read(4))[0]\n",
    "\n",
    "        # Ensure .flo file format\n",
    "        assert magic == 202021.25, \"Invalid .flo file format.\"\n",
    "\n",
    "        # Read optical flow data\n",
    "        flow_data = np.fromfile(f, np.float32, width * height * 2)\n",
    "        flow_data = flow_data.reshape((height, width, 2))\n",
    "\n",
    "    return flow_data\n",
    "\n",
    "\n",
    "def write_flow_field(file_path, flow_data):\n",
    "    height, width = flow_data.shape[:2]\n",
    "    with open(file_path, \"wb\") as f:\n",
    "        # Write .flo header\n",
    "        f.write(struct.pack('f', 202021.25))\n",
    "        f.write(struct.pack('i', width))\n",
    "        f.write(struct.pack('i', height))\n",
    "\n",
    "        # Write optical flow data\n",
    "        flow_data.flatten().astype(np.float32).tofile(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_angular_error(flow_gt, flow_pred):\n",
    "    flow_gt_norm = np.sqrt(np.sum(flow_gt ** 2, axis=2))\n",
    "    flow_pred_norm = np.sqrt(np.sum(flow_pred ** 2, axis=2))\n",
    "    dot_product = np.sum(flow_gt * flow_pred, axis=2)\n",
    "    cos_theta = np.clip(dot_product / (flow_gt_norm * flow_pred_norm), -1.0, 1.0)\n",
    "    angular_error = np.arccos(cos_theta)\n",
    "    return angular_error\n",
    "\n",
    "def calculate_endpoint_error(flow_gt, flow_pred):\n",
    "    endpoint_error = np.sqrt(np.sum((flow_gt - flow_pred) ** 2, axis=2))\n",
    "    return endpoint_error\n",
    "\n",
    "\n",
    "def calculate_error_statistics(error):\n",
    "    mean_error = np.mean(error)\n",
    "    std_error = np.std(error)\n",
    "    return mean_error, std_error\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original and new files are identical: True\n",
      "Mean Endpoint Error: 0.0\n",
      "Standard Deviation of Endpoint Error: 0.0\n"
     ]
    }
   ],
   "source": [
    "# Example usage\n",
    "original_file = \"/workspace/VC/assignment2/dataset/other-gt-flow/Urban2/flow10.flo\"\n",
    "new_file = \"new.flo\"\n",
    "\n",
    "# Read the original .flo file\n",
    "original_flow = read_flow_field(original_file)\n",
    "\n",
    "# Write the original flow to a new .flo file\n",
    "write_flow_field(new_file, original_flow)\n",
    "\n",
    "# Read the new .flo file\n",
    "new_flow = read_flow_field(new_file)\n",
    "\n",
    "#Sanity check for write and read function\n",
    "\n",
    "# Compare the original and new flow files\n",
    "identical = np.array_equal(original_flow, new_flow)\n",
    "print(\"The original and new files are identical:\", identical)\n",
    "\n",
    "angular_error = calculate_angular_error(original_flow, new_flow)\n",
    "angular_mean, angular_std = calculate_error_statistics(angular_error)\n",
    "\n",
    "#print('Mean Angular Error:', angular_mean)\n",
    "#print('Standard Deviation of Angular Error:', angular_std)\n",
    "\n",
    "endpoint_error = calculate_endpoint_error(original_flow, new_flow)\n",
    "endpoint_mean, endpoint_std = calculate_error_statistics(endpoint_error)\n",
    "\n",
    "print('Mean Endpoint Error:', endpoint_mean)\n",
    "print('Standard Deviation of Endpoint Error:', endpoint_std)\n",
    "os.remove(new_file)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lucas-Kanade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def computeLK_MC(frames, feature_params, lk_params, input_path):\n",
    "    color = np.random.randint(0, 255, (100, 3))\n",
    "    old_frame = frames[0]\n",
    "    #old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)\n",
    "    old_frameB, old_frameG, old_frameR = cv2.split(old_frame)\n",
    "    \n",
    "    p0B = cv2.goodFeaturesToTrack(old_frameB, mask=None, **feature_params)\n",
    "    p0G = cv2.goodFeaturesToTrack(old_frameG, mask=None, **feature_params)\n",
    "    p0R = cv2.goodFeaturesToTrack(old_frameR, mask=None, **feature_params)\n",
    "\n",
    "    maskB = np.zeros_like(old_frame)\n",
    "    maskG = np.zeros_like(old_frame)\n",
    "    maskR = np.zeros_like(old_frame)\n",
    "\n",
    "    for frame_num in frames[1:]:\n",
    "        \n",
    "        current_frame = frame_num\n",
    "        #frame_gray = cv2.cvtColor(frame_num, cv2.COLOR_BGR2GRAY)\n",
    "        current_frameB, current_frameG, current_frameR = cv2.split(frame_num)\n",
    "        \n",
    "        p1B, stB, err = cv2.calcOpticalFlowPyrLK(old_frameB, current_frameB, p0B, None, **lk_params)\n",
    "        p1G, stG, err = cv2.calcOpticalFlowPyrLK(old_frameG, current_frameG, p0G, None, **lk_params)\n",
    "        p1R, stR, err = cv2.calcOpticalFlowPyrLK(old_frameR, current_frameR, p0R, None, **lk_params)\n",
    "        \n",
    "        #print(\"p1: \", np.asarray(p1).shape)\n",
    "        #print(np.asarray(p1).shape)\n",
    "        #print(p1)\n",
    "        if p1B is not None:\n",
    "            \n",
    "            good_newB = p1B[stB==1]\n",
    "            good_oldB = p0B[stB==1]\n",
    "        if p1G is not None:\n",
    "            \n",
    "            good_newG = p1G[stG==1]\n",
    "            good_oldG = p0G[stG==1]\n",
    "        if p1R is not None:\n",
    "            \n",
    "            good_newR = p1R[stR==1]\n",
    "            good_oldR = p0R[stR==1]\n",
    "        \n",
    "        for i, (new, old) in enumerate(zip(good_newB, good_oldB)):\n",
    "            aB, bB = new.ravel()\n",
    "            cB, dB = old.ravel()\n",
    "            maskB = cv2.line(maskB, (int(aB), int(bB)), (int(cB), int(dB)), color[i].tolist(), 2)\n",
    "        for i, (new, old) in enumerate(zip(good_newG, good_oldG)):\n",
    "            aG, bG = new.ravel()\n",
    "            cG, dG = old.ravel()\n",
    "            maskG = cv2.line(maskG, (int(aG), int(bG)), (int(cG), int(dG)), color[i].tolist(), 2)\n",
    "        for i, (new, old) in enumerate(zip(good_newR, good_oldR)):\n",
    "            aR, bR = new.ravel()\n",
    "            cR, dR = old.ravel()\n",
    "            maskR = cv2.line(maskR, (int(aR), int(bR)), (int(cR), int(dR)), color[i].tolist(), 2)\n",
    "        \n",
    "        # Calculate the displacement vectors\n",
    "        flowB = good_newB - good_oldB\n",
    "        flowG = good_newG - good_oldG\n",
    "        flowR = good_newR - good_oldR\n",
    "\n",
    "        # Prepare the flow matrix\n",
    "        flow_dataB = np.zeros((current_frame.shape[0], current_frame.shape[1], 2), dtype=np.float32)\n",
    "        valid_indicesB = np.where((good_oldB[:, 0] >= 0) & (good_oldB[:, 0] < current_frame.shape[1]) &\n",
    "                                (good_oldB[:, 1] >= 0) & (good_oldB[:, 1] < current_frame.shape[0]))\n",
    "        \n",
    "        flow_dataG = np.zeros((current_frame.shape[0], current_frame.shape[1], 2), dtype=np.float32)\n",
    "        valid_indicesG = np.where((good_oldG[:, 0] >= 0) & (good_oldG[:, 0] < current_frame.shape[1]) &\n",
    "                                (good_oldG[:, 1] >= 0) & (good_oldG[:, 1] < current_frame.shape[0]))\n",
    "        \n",
    "        flow_dataR = np.zeros((current_frame.shape[0], current_frame.shape[1], 2), dtype=np.float32)\n",
    "        valid_indicesR = np.where((good_oldR[:, 0] >= 0) & (good_oldR[:, 0] < current_frame.shape[1]) &\n",
    "                                (good_oldR[:, 1] >= 0) & (good_oldR[:, 1] < current_frame.shape[0]))\n",
    "\n",
    "        # Update flow matrix with valid keypoints and their displacement vectors\n",
    "        valid_good_oldB = good_oldB[valid_indicesB].astype(int)\n",
    "        flow_dataB[valid_good_oldB[:, 1], valid_good_oldB[:, 0]] = flowB.squeeze()[valid_indicesB]\n",
    "        \n",
    "        valid_good_oldG = good_oldG[valid_indicesG].astype(int)\n",
    "        flow_dataG[valid_good_oldG[:, 1], valid_good_oldG[:, 0]] = flowG.squeeze()[valid_indicesG]\n",
    "        \n",
    "        valid_good_oldR = good_oldR[valid_indicesR].astype(int)\n",
    "        flow_dataR[valid_good_oldR[:, 1], valid_good_oldR[:, 0]] = flowR.squeeze()[valid_indicesR]\n",
    "\n",
    "        frame_with_flowB = cv2.add(current_frame, maskB)\n",
    "        old_frameB = current_frameB.copy()\n",
    "        p0B = good_newB.reshape(-1,1,2)\n",
    "        \n",
    "        frame_with_flowG = cv2.add(current_frame, maskG)\n",
    "        old_frameG = current_frameG.copy()\n",
    "        p0G = good_newG.reshape(-1,1,2)\n",
    "        \n",
    "        frame_with_flowR = cv2.add(current_frame, maskR)\n",
    "        old_frameR = current_frameR.copy()\n",
    "        p0R = good_newR.reshape(-1,1,2)\n",
    "        \n",
    "    if os.path.isfile(input_path):\n",
    "        file_name, file_extension = os.path.splitext(input_path)\n",
    "        if file_extension.lower() not in ['.png', '.jpg']:\n",
    "            #print(\"File name without extension:\", os.path.basename(file_name))\n",
    "            cv2.imwrite(file_name+'_flow_B.png', frame_with_flowB)\n",
    "            cv2.imwrite(file_name+'_flow_G.png', frame_with_flowG)\n",
    "            cv2.imwrite(file_name+'_flow_R.png', frame_with_flowR)\n",
    "            #write_flow_field(file_name+'_flow_field.flo',mask)\n",
    "            # Save flow data to .flo file\n",
    "            flow_data_mean = (flow_dataB+flow_dataG+flow_dataR)/3\n",
    "            cv2.writeOpticalFlow(file_name+'_flow_field_mean.flo', flow_data_mean)\n",
    "        else:\n",
    "            print(\"The file extension is .png or .jpg\")\n",
    "    else:\n",
    "        directory = input_path.split('dataset\\\\')[1].split('\\\\')\n",
    "        #print(\"Directory after 'dataset\\\\':\", directory[1])\n",
    "        cv2.imwrite(directory[1]+'_flow_B.png', frame_with_flowB)\n",
    "        cv2.imwrite(directory[1]+'_flow_G.png', frame_with_flowG)\n",
    "        cv2.imwrite(directory[1]+'_flow_R.png', frame_with_flowR)\n",
    "        write_flow_field(maskB,directory[1]+'_flow_field_B.flo')\n",
    "        write_flow_field(maskG,directory[1]+'_flow_field_G.flo')\n",
    "        write_flow_field(maskR,directory[1]+'_flow_field_R.flo')\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def computeLK(frames, feature_params, lk_params, input_path):\n",
    "    \n",
    "    color = np.random.randint(0, 255, (100, 3))\n",
    "    old_frame = frames[0]\n",
    "    old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)\n",
    "    p0 = cv2.goodFeaturesToTrack(old_gray, mask=None, **feature_params)\n",
    "\n",
    "    mask = np.zeros_like(old_frame)\n",
    "    height, width, channels = old_frame.shape\n",
    "    mask_flow = np.zeros((height,width,2))\n",
    "    #print(\"DIM: \", mask_flow.shape)\n",
    "\n",
    "    for frame_num in frames[1:]:\n",
    "        \n",
    "        current_frame = frame_num\n",
    "        frame_gray = cv2.cvtColor(frame_num, cv2.COLOR_BGR2GRAY)\n",
    "        \n",
    "        p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)\n",
    "        #print(\"p1: \", np.asarray(p1).shape)\n",
    "        #print(np.asarray(p1).shape)\n",
    "        #print(p1)\n",
    "        if p1 is not None:\n",
    "            \n",
    "            good_new = p1[st==1]\n",
    "            good_old = p0[st==1]\n",
    "        \n",
    "        for i, (new, old) in enumerate(zip(good_new, good_old)):\n",
    "            a, b = new.ravel()\n",
    "            c, d = old.ravel()\n",
    "            mask = cv2.line(mask, (int(a), int(b)), (int(c), int(d)), color[i].tolist(), 2)\n",
    "        \n",
    "        # Calculate the displacement vectors\n",
    "        flow = good_new - good_old\n",
    "\n",
    "        # Prepare the flow matrix\n",
    "        flow_data = np.zeros((frame_gray.shape[0], frame_gray.shape[1], 2), dtype=np.float32)\n",
    "        valid_indices = np.where((good_old[:, 0] >= 0) & (good_old[:, 0] < frame_gray.shape[1]) &\n",
    "                                (good_old[:, 1] >= 0) & (good_old[:, 1] < frame_gray.shape[0]))\n",
    "\n",
    "        # Update flow matrix with valid keypoints and their displacement vectors\n",
    "        valid_good_old = good_old[valid_indices].astype(int)\n",
    "        flow_data[valid_good_old[:, 1], valid_good_old[:, 0]] = flow.squeeze()[valid_indices]\n",
    "\n",
    "    \n",
    "\n",
    "        frame_with_flow = cv2.add(current_frame, mask)\n",
    "        old_gray = frame_gray.copy()\n",
    "        p0 = good_new.reshape(-1,1,2)\n",
    "        \n",
    "    if os.path.isfile(input_path):\n",
    "        file_name, file_extension = os.path.splitext(input_path)\n",
    "        if file_extension.lower() not in ['.png', '.jpg']:\n",
    "            #print(\"File name without extension:\", os.path.basename(file_name))\n",
    "            cv2.imwrite(file_name+'_flow.png', frame_with_flow)\n",
    "            #write_flow_field(file_name+'_flow_field.flo',flow_data)\n",
    "            # Save flow data to .flo file\n",
    "            cv2.writeOpticalFlow(file_name+'_flow_field.flo', flow_data)\n",
    "            #write_flow_field(file_name+'_flow_field.flo',flow_data)\n",
    "        else:\n",
    "            print(\"The file extension is .png or .jpg\")\n",
    "    else:\n",
    "        directory = input_path.split('dataset/')[1].split('/')\n",
    "        #print(\"Directory after 'dataset\\\\':\", directory[1])\n",
    "        cv2.imwrite(directory[1]+'_flow.png', frame_with_flow)\n",
    "        #write_flow_field(mask,directory[1]+'_flow_field.flo')\n",
    "        cv2.writeOpticalFlow(directory[1]+'_flow_field.flo', flow_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(f\"Loading File \\'config_LK.yml\\'\")\n",
    "\n",
    "config = load_config('config_LK.yml')\n",
    "\n",
    "input_path = config['input_path']\n",
    "\n",
    "frames = get_input_frames(config['input_path'])\n",
    "\n",
    "#print(np.asarray(frames).shape)\n",
    "\n",
    "feature_params = dict(\n",
    "    maxCorners=config['max_corners'],\n",
    "    qualityLevel=config['quality_level'],\n",
    "    minDistance=config['min_distance'],\n",
    "    blockSize=config['block_size']\n",
    ")\n",
    "lk_params = dict(\n",
    "    winSize=(config['window_size'], config['window_size']),\n",
    "    maxLevel=config['max_level'],\n",
    "    criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, config['max_iterations'], config['epsilon'])\n",
    ")\n",
    "\n",
    "computeLK(frames, feature_params, lk_params, input_path)\n",
    "#computeLK_MC(frames, feature_params, lk_params, input_path)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = cv2.imread('/workspace/VC/assignment2/dataset/other-data/Urban2/frame07.png')\n",
    "\n",
    "flow = read_flow_field('/workspace/VC/assignment2/dataset/other-gt-flow/Urban2/flow10.flo')\n",
    "\n",
    "warped = cv2.remap(image, flow, None, cv2.INTER_LINEAR)\n",
    "\n",
    "#cv2.imshow('warp', warped)\n",
    "#cv2.waitKey(0)\n",
    "#cv2.destroyAllWindows"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Horn-Shunchk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def computeHS_MC(path, name1, name2, alpha, delta):\n",
    "    \n",
    "    print(\"Computing using: \", name1, \" and \", name2)\n",
    "\n",
    "    beforeImg = cv2.imread(os.path.join(path, name1)).astype(float)\n",
    "    afterImg = cv2.imread(os.path.join(path, name2)).astype(float)\n",
    "\n",
    "    if beforeImg is None:\n",
    "        raise NameError(\"Can't find image: \\\"\" + name1 + '\\\"')\n",
    "    elif afterImg is None:\n",
    "        raise NameError(\"Can't find image: \\\"\" + name2 + '\\\"')\n",
    "\n",
    "    #removing noise\n",
    "    beforeImg  = cv2.GaussianBlur(beforeImg, (5, 5), 0)\n",
    "    afterImg = cv2.GaussianBlur(afterImg, (5, 5), 0)\n",
    "\n",
    "\n",
    "    u_list = []\n",
    "    v_list = []\n",
    "    for i in range(3): # 3channels if this works im dumb\n",
    "        # set up initial values\n",
    "        u = np.zeros((beforeImg.shape[0], beforeImg.shape[1]))\n",
    "        v = np.zeros((beforeImg.shape[0], beforeImg.shape[1]))\n",
    "        fx, fy, ft = get_derivatives(beforeImg[:,:,i], afterImg[:,:,i])\n",
    "        avg_kernel = np.array([[1 / 12, 1 / 6, 1 / 12],\n",
    "                                [1 / 6, 0, 1 / 6],\n",
    "                                [1 / 12, 1 / 6, 1 / 12]], float)\n",
    "        iter_counter = 0\n",
    "        while True:\n",
    "            iter_counter += 1\n",
    "            u_avg = filter2(u, avg_kernel)\n",
    "            v_avg = filter2(v, avg_kernel)\n",
    "            p = fx * u_avg + fy * v_avg + ft\n",
    "            d = 4 * alpha**2 + fx**2 + fy**2\n",
    "            prev = u\n",
    "\n",
    "            u = u_avg - fx * (p / d)\n",
    "            v = v_avg - fy * (p / d)\n",
    "\n",
    "            diff = np.linalg.norm(u - prev, 2)\n",
    "            #converges check (at most 300 iterations)\n",
    "            if  diff < delta or iter_counter > 300:\n",
    "                # #print(\"iteration number: \", iter_counter)\n",
    "                break\n",
    "        u_list.append(u)\n",
    "        v_list.append(v)\n",
    "\n",
    "\n",
    "\n",
    "    u = (u_list[0]+u_list[1]+u_list[2])/3\n",
    "    v = (v_list[0]+v_list[1]+v_list[2])/3\n",
    "        \n",
    "    draw_quiver(u, v, beforeImg, name1, name2)\n",
    "\n",
    "    return u, v\n",
    "\n",
    "\n",
    "def computeHS_MC_V(path, name1, name2, alpha, delta):\n",
    "    \n",
    "    #print(\"Computing using: \", name1, \" and \", name2)\n",
    "\n",
    "    beforeImg = name1\n",
    "    afterImg = name2\n",
    "    if beforeImg is None:\n",
    "        raise NameError(\"Can't find image: \\\"\" + name1 + '\\\"')\n",
    "    elif afterImg is None:\n",
    "        raise NameError(\"Can't find image: \\\"\" + name2 + '\\\"')\n",
    "\n",
    "    #removing noise\n",
    "    beforeImg  = cv2.GaussianBlur(beforeImg, (5, 5), 0)\n",
    "    afterImg = cv2.GaussianBlur(afterImg, (5, 5), 0)\n",
    "\n",
    "\n",
    "    u_list = []\n",
    "    v_list = []\n",
    "    for i in range(3): # 3channels if this works im dumb\n",
    "        # set up initial values\n",
    "        u = np.zeros((beforeImg.shape[0], beforeImg.shape[1]))\n",
    "        v = np.zeros((beforeImg.shape[0], beforeImg.shape[1]))\n",
    "        fx, fy, ft = get_derivatives(beforeImg[:,:,i], afterImg[:,:,i])\n",
    "        avg_kernel = np.array([[1 / 12, 1 / 6, 1 / 12],\n",
    "                                [1 / 6, 0, 1 / 6],\n",
    "                                [1 / 12, 1 / 6, 1 / 12]], float)\n",
    "        iter_counter = 0\n",
    "        while True:\n",
    "            iter_counter += 1\n",
    "            u_avg = filter2(u, avg_kernel)\n",
    "            v_avg = filter2(v, avg_kernel)\n",
    "            p = fx * u_avg + fy * v_avg + ft\n",
    "            d = 4 * alpha**2 + fx**2 + fy**2\n",
    "            prev = u\n",
    "\n",
    "            u = u_avg - fx * (p / d)\n",
    "            v = v_avg - fy * (p / d)\n",
    "\n",
    "            diff = np.linalg.norm(u - prev, 2)\n",
    "            #converges check (at most 300 iterations)\n",
    "            if  diff < delta or iter_counter > 300:\n",
    "                # #print(\"iteration number: \", iter_counter)\n",
    "                break\n",
    "        u_list.append(u)\n",
    "        v_list.append(v)\n",
    "\n",
    "\n",
    "\n",
    "    u = (u_list[0]+u_list[1]+u_list[2])/3\n",
    "    v = (v_list[0]+v_list[1]+v_list[2])/3\n",
    "        \n",
    "    draw_quiver(u, v, beforeImg, name1, name2)\n",
    "\n",
    "    return u, v\n",
    "\n",
    "def computeHS(path, name1, name2, alpha, delta):\n",
    "    \n",
    "    print(\"Computing using: \", name1, \" and \", name2)\n",
    "    beforeImg = cv2.imread(os.path.join(path, name1), cv2.IMREAD_GRAYSCALE)\n",
    "    afterImg = cv2.imread(os.path.join(path, name2), cv2.IMREAD_GRAYSCALE)\n",
    "\n",
    "    if beforeImg is None:\n",
    "        raise NameError(\"Can't find image: \\\"\" + name1 + '\\\"')\n",
    "    elif afterImg is None:\n",
    "        raise NameError(\"Can't find image: \\\"\" + name2 + '\\\"')\n",
    "\n",
    "    beforeImg = cv2.imread(os.path.join(path, name1), cv2.IMREAD_GRAYSCALE).astype(float)\n",
    "    afterImg = cv2.imread(os.path.join(path, name2), cv2.IMREAD_GRAYSCALE).astype(float)\n",
    "\n",
    "    #removing noise\n",
    "    beforeImg  = cv2.GaussianBlur(beforeImg, (5, 5), 0)\n",
    "    afterImg = cv2.GaussianBlur(afterImg, (5, 5), 0)\n",
    "\n",
    "    # set up initial values\n",
    "    u = np.zeros((beforeImg.shape[0], beforeImg.shape[1]))\n",
    "    v = np.zeros((beforeImg.shape[0], beforeImg.shape[1]))\n",
    "    fx, fy, ft = get_derivatives(beforeImg, afterImg)\n",
    "    avg_kernel = np.array([[1 / 12, 1 / 6, 1 / 12],\n",
    "                            [1 / 6, 0, 1 / 6],\n",
    "                            [1 / 12, 1 / 6, 1 / 12]], float)\n",
    "    iter_counter = 0\n",
    "    while True:\n",
    "        iter_counter += 1\n",
    "        u_avg = filter2(u, avg_kernel)\n",
    "        v_avg = filter2(v, avg_kernel)\n",
    "        p = fx * u_avg + fy * v_avg + ft\n",
    "        d = 4 * alpha**2 + fx**2 + fy**2\n",
    "        prev = u\n",
    "\n",
    "        u = u_avg - fx * (p / d)\n",
    "        v = v_avg - fy * (p / d)\n",
    "\n",
    "        diff = np.linalg.norm(u - prev, 2)\n",
    "        #converges check (at most 300 iterations)\n",
    "        if  diff < delta or iter_counter > 300:\n",
    "            # #print(\"iteration number: \", iter_counter)\n",
    "            break\n",
    "\n",
    "    draw_quiver(u, v, beforeImg, name1, name2)\n",
    "\n",
    "    \n",
    "    return [u, v]\n",
    "\n",
    "def computeHS_V(path, name1, name2, alpha, delta):\n",
    "    \n",
    "    print(\"Computing using: \", name1, \" and \", name2)\n",
    "    beforeImg = name1\n",
    "    afterImg = name2\n",
    "    \n",
    "    #removing noise\n",
    "    beforeImg  = cv2.GaussianBlur(beforeImg, (5, 5), 0)\n",
    "    afterImg = cv2.GaussianBlur(afterImg, (5, 5), 0)\n",
    "\n",
    "    # set up initial values\n",
    "    u = np.zeros((beforeImg.shape[0], beforeImg.shape[1]))\n",
    "    v = np.zeros((beforeImg.shape[0], beforeImg.shape[1]))\n",
    "    fx, fy, ft = get_derivatives(beforeImg, afterImg)\n",
    "    avg_kernel = np.array([[1 / 12, 1 / 6, 1 / 12],\n",
    "                            [1 / 6, 0, 1 / 6],\n",
    "                            [1 / 12, 1 / 6, 1 / 12]], float)\n",
    "    iter_counter = 0\n",
    "    while True:\n",
    "        iter_counter += 1\n",
    "        u_avg = filter2(u, avg_kernel)\n",
    "        v_avg = filter2(v, avg_kernel)\n",
    "        p = fx * u_avg + fy * v_avg + ft\n",
    "        d = 4 * alpha**2 + fx**2 + fy**2\n",
    "        prev = u\n",
    "\n",
    "        u = u_avg - fx * (p / d)\n",
    "        v = v_avg - fy * (p / d)\n",
    "\n",
    "        diff = np.linalg.norm(u - prev, 2)\n",
    "        #converges check (at most 300 iterations)\n",
    "        if  diff < delta or iter_counter > 300:\n",
    "            # #print(\"iteration number: \", iter_counter)\n",
    "            break\n",
    "\n",
    "    draw_quiver(u, v, beforeImg, name1, name2)\n",
    "\n",
    "    \n",
    "    return [u, v]\n",
    "\n",
    "def show_image(name, image):\n",
    "    print(\"take this image!!!\")\n",
    "    if image is None:\n",
    "        return\n",
    "\n",
    "    cv2.imshow(name, image)\n",
    "    cv2.waitKey(0)\n",
    "    cv2.destroyAllWindows()\n",
    "    \n",
    "def get_magnitude(u, v):\n",
    "    print(\"getting magnitude...\")\n",
    "    scale = 3\n",
    "    sum = 0.0\n",
    "    counter = 0.0\n",
    "\n",
    "    for i in range(0, u.shape[0], 8):\n",
    "        for j in range(0, u.shape[1],8):\n",
    "            counter += 1\n",
    "            dy = v[i,j] * scale\n",
    "            dx = u[i,j] * scale\n",
    "            magnitude = (dx**2 + dy**2)**0.5\n",
    "            sum += magnitude\n",
    "\n",
    "    mag_avg = sum / counter\n",
    "\n",
    "    return mag_avg\n",
    "\n",
    "def draw_quiver(u,v,beforeImg,name1, name2):\n",
    "    print(\"drawing...\")\n",
    "    scale = 3\n",
    "    ax = plt.figure().gca()\n",
    "    ax.imshow(beforeImg, cmap = 'gray')\n",
    "\n",
    "    magnitudeAvg = get_magnitude(u, v)\n",
    "\n",
    "    for i in range(0, u.shape[0], 8):\n",
    "        for j in range(0, u.shape[1],8):\n",
    "            dy = v[i,j] * scale\n",
    "            dx = u[i,j] * scale\n",
    "            magnitude = (dx**2 + dy**2)**0.5\n",
    "            #draw only significant changes\n",
    "            if magnitude > magnitudeAvg:\n",
    "                ax.arrow(j,i, dx, dy, color = 'red')\n",
    "\n",
    "    plt.draw()\n",
    "    file1 = os.path.splitext(name1)[0]\n",
    "    file2 = os.path.splitext(name2)[0]\n",
    "    plt.savefig('/workspace/VC/assignment2/output/'+file1+file2+'.png')\n",
    "    plt.show()\n",
    "    \n",
    "def get_derivatives(img1, img2):\n",
    "    print(\"derivating...\")\n",
    "    #derivative masks\n",
    "    x_kernel = np.array([[-1, 1], [-1, 1]]) * 0.25\n",
    "    y_kernel = np.array([[-1, -1], [1, 1]]) * 0.25\n",
    "    t_kernel = np.ones((2, 2)) * 0.25\n",
    "\n",
    "    fx = filter2(img1,x_kernel) + filter2(img2,x_kernel)\n",
    "    fy = filter2(img1, y_kernel) + filter2(img2, y_kernel)\n",
    "    ft = filter2(img1, -t_kernel) + filter2(img2, t_kernel)\n",
    "\n",
    "    return [fx,fy, ft]\n",
    "\n",
    "def calculate_aee(u, v, ground_truth_u, ground_truth_v):\n",
    "    error = np.sqrt((u - ground_truth_u)**2 + (v - ground_truth_v)**2)\n",
    "    aee = np.mean(error)\n",
    "    return aee\n",
    "def calculate_aee_std(u, v, ground_truth_u, ground_truth_v):\n",
    "    error = np.sqrt((u - ground_truth_u)**2 + (v - ground_truth_v)**2)\n",
    "    aee_std = np.std(error)\n",
    "    return aee_std\n",
    "def calculate_aae(u, v, ground_truth_u, ground_truth_v):\n",
    "    error_cos = (u * ground_truth_u + v * ground_truth_v +\n",
    "                 1.0) / (np.sqrt(u**2 + v**2 + 1.0) *\n",
    "                         np.sqrt(ground_truth_u**2 + ground_truth_v**2 + 1.0))\n",
    "    error_cos = np.clip(error_cos, -1.0, 1.0)  # Clip values to ensure valid range\n",
    "    angular_error = np.arccos(error_cos)  # Calculate angular error in radians\n",
    "    aae = np.degrees(np.mean(angular_error))  # Convert to degrees and calculate the mean\n",
    "    return aae\n",
    "\n",
    "def calculate_aae_std(u, v, ground_truth_u, ground_truth_v):\n",
    "    error_cos = (u * ground_truth_u + v * ground_truth_v +\n",
    "                 1.0) / (np.sqrt(u**2 + v**2 + 1.0) *\n",
    "                         np.sqrt(ground_truth_u**2 + ground_truth_v**2 + 1.0))\n",
    "    error_cos = np.clip(error_cos, -1.0, 1.0)  # Clip values to ensure valid range\n",
    "    angular_error = np.arccos(error_cos)  # Calculate angular error in radians\n",
    "    aae_std = np.degrees(np.std(angular_error))  # Convert to degrees and calculate the standard deviation\n",
    "    return aae_std\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "derivating...\n"
     ]
    }
   ],
   "source": [
    "#print(f\"Loading File \\'config_HS.yml\\'\")\n",
    "\n",
    "config = load_config('config_HS.yml')\n",
    "\n",
    "input_path = config['input_path']\n",
    "\n",
    "gt_path = '/workspace/VC/assignment2/dataset/other-gt-flow/Urban2/flow10.flo'\n",
    "\n",
    "gt = read_flow_field(gt_path)\n",
    "\n",
    "gt_u = gt[:, :, 0].astype(float) / 255.0  # Normalize u component to [0, 1]\n",
    "gt_v = gt[:, :, 1].astype(float) / 255.0  # Normalize v component to [0, 1]\n",
    "frames = get_input_frames(input_path)\n",
    "#frames = os.listdir(input_path)\n",
    "##print(frames)\n",
    "aee_values = []\n",
    "aee_std_values = []\n",
    "aae_values = []\n",
    "aae_std_values = []\n",
    "for i in range(0,len(frames)-1):\n",
    "    #print(\"CYCLE: \", i)\n",
    "    u, v = computeHS_MC_V(input_path, frames[i], frames[i+1], alpha=15, delta=10**-1)\n",
    "    \n",
    "    aee = calculate_aee(u, v, gt_u, gt_v)\n",
    "    aee_std = calculate_aee_std(u, v, gt_u, gt_v)\n",
    "    print(\"Average End-Point Error: \", aee)\n",
    "    print(\"Standard Deviation: \", aee_std)\n",
    "    aee_values.append(aee)\n",
    "    aee_std_values.append(aee_std)\n",
    "    \n",
    "    aae = calculate_aae(u, v, gt_u, gt_v)\n",
    "    aae_std = calculate_aae_std(u, v, gt_u, gt_v)\n",
    "    print(\"Average Angular Error: \", aae)\n",
    "    print(\"Standard Deviation: \", aae_std)\n",
    "    aae_values.append(aae)\n",
    "    aae_std_values.append(aae_std)\n",
    "    \n",
    "print(\"MEAN AEE: \", np.mean(aee_values))\n",
    "print(\"MEAN STD: \", np.mean(aee_std_values))\n",
    "print(\"MEAN AAE: \", np.mean(aae_values))\n",
    "print(\"MEAN STD: \", np.mean(aae_std_values))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualization"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Done Using [flowvid](https://github.com/diegoroyo/flowvid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[16], line 19\u001b[0m\n\u001b[1;32m     16\u001b[0m rgb_frames \u001b[39m=\u001b[39m fv\u001b[39m.\u001b[39mflow_to_rgb(flo_video)\n\u001b[1;32m     18\u001b[0m out5 \u001b[39m=\u001b[39m fv\u001b[39m.\u001b[39moutput\u001b[39m.\u001b[39mshow_plot(title\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mFlow colors\u001b[39m\u001b[39m'\u001b[39m, framerate\u001b[39m=\u001b[39m\u001b[39m10\u001b[39m)\n\u001b[0;32m---> 19\u001b[0m out5\u001b[39m.\u001b[39;49mshow_all(rgb_frames, show_count\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n",
      "File \u001b[0;32m~/.pyenv/versions/3.11.1/lib/python3.11/site-packages/flowvid/output/plot_show.py:149\u001b[0m, in \u001b[0;36mPlotShow.show_all\u001b[0;34m(self, images, show_count)\u001b[0m\n\u001b[1;32m    147\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_closed:\n\u001b[1;32m    148\u001b[0m         \u001b[39mbreak\u001b[39;00m\n\u001b[0;32m--> 149\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_show(image, i \u001b[39m+\u001b[39;49m \u001b[39m1\u001b[39;49m, n, show_count)\n\u001b[1;32m    151\u001b[0m \u001b[39m# Wait for figure closed\u001b[39;00m\n\u001b[1;32m    152\u001b[0m \u001b[39mwhile\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_closed:\n",
      "File \u001b[0;32m~/.pyenv/versions/3.11.1/lib/python3.11/site-packages/flowvid/output/plot_show.py:119\u001b[0m, in \u001b[0;36mPlotShow._show\u001b[0;34m(self, image, i, n, show_count)\u001b[0m\n\u001b[1;32m    117\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_fig\u001b[39m.\u001b[39mshow()\n\u001b[1;32m    118\u001b[0m \u001b[39mwhile\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_paused \u001b[39mand\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_next \u001b[39m==\u001b[39m \u001b[39m0\u001b[39m \u001b[39mand\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_closed:\n\u001b[0;32m--> 119\u001b[0m     plt\u001b[39m.\u001b[39;49mpause(PlotShow\u001b[39m.\u001b[39;49mTIME_POLL_PAUSE)\n\u001b[1;32m    120\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_next \u001b[39m>\u001b[39m \u001b[39m0\u001b[39m:\n\u001b[1;32m    121\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_next \u001b[39m-\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n",
      "File \u001b[0;32m~/.pyenv/versions/3.11.1/lib/python3.11/site-packages/matplotlib/pyplot.py:584\u001b[0m, in \u001b[0;36mpause\u001b[0;34m(interval)\u001b[0m\n\u001b[1;32m    582\u001b[0m     canvas\u001b[39m.\u001b[39mstart_event_loop(interval)\n\u001b[1;32m    583\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 584\u001b[0m     time\u001b[39m.\u001b[39msleep(interval)\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "\n",
    "import flowvid\n",
    "import numpy as np\n",
    "from IPython.display import HTML\n",
    "\n",
    "import flowvid as fv\n",
    "\n",
    "flo_data = fv.input.flo('/workspace/VC/assignment2/dataset/other-gt-flow/Urban2/flow10.flo')\n",
    "\n",
    "# You can normalize by frame OR the whole video\n",
    "# Normalize each flo file independently\n",
    "flo_frame = fv.normalize_frame(flo_data)\n",
    "# Normalize all flo files at once, applying a clamp/gamma curve\n",
    "flo_video = fv.normalize_video(flo_data, clamp_pct=0.8, gamma=1.5)\n",
    "\n",
    "# Conversion from flow data to RGB\n",
    "rgb_frames = fv.flow_to_rgb(flo_video)\n",
    "\n",
    "out5 = fv.output.show_plot(title='Flow colors', framerate=10)\n",
    "out5.show_all(rgb_frames, show_count=True)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import base64\n",
    "def create_gif_from_folder(folder_path, duration=100, loop=0):\n",
    "    gif_file = os.path.join(os.getcwd()+'/gifs/', f\"{os.path.basename(folder_path)}.gif\")\n",
    "    #print(gif_file)\n",
    "    images = []\n",
    "    png_files = sorted([f for f in os.listdir(folder_path) if f.endswith('.png')])\n",
    "\n",
    "    for file in png_files:\n",
    "        image_path = os.path.join(folder_path, file)\n",
    "        image = Image.open(image_path)\n",
    "        images.append(image)\n",
    "\n",
    "    images[0].save(gif_file, save_all=True, append_images=images[1:], format='GIF', duration=duration, loop=loop)\n",
    "    return gif_file\n",
    "\n",
    "def gif_to_html_image(gif_file):\n",
    "    with open(gif_file, 'rb') as f:\n",
    "        gif_data = f.read()\n",
    "\n",
    "    base64_data = base64.b64encode(gif_data).decode('utf-8')\n",
    "    html_image = f'<img src=\"data:image/gif;base64,{base64_data}\" />'\n",
    "\n",
    "    return html_image\n",
    "\n",
    "\n",
    "# Example usage\n",
    "#folder_path = '/workspace/VC/assignment2/dataset/other-data/Urban2'\n",
    "#create_gif_from_folder(folder_path, duration=200, loop=3)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bench Marking\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "partially initialized module 'pandas' has no attribute 'core' (most likely due to a circular import)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[21], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39m## Not Finished unfortunately :(\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mpandas\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mpd\u001b[39;00m\n\u001b[1;32m      4\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mIPython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdisplay\u001b[39;00m \u001b[39mimport\u001b[39;00m display, Markdown\n\u001b[1;32m      7\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mfind_common_folders\u001b[39m(folder1, folder2):\n",
      "File \u001b[0;32m~/.pyenv/versions/3.11.1/lib/python3.11/site-packages/pandas/__init__.py:138\u001b[0m\n\u001b[1;32m    120\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mpandas\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcore\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mreshape\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mapi\u001b[39;00m \u001b[39mimport\u001b[39;00m (\n\u001b[1;32m    121\u001b[0m     concat,\n\u001b[1;32m    122\u001b[0m     lreshape,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    134\u001b[0m     qcut,\n\u001b[1;32m    135\u001b[0m )\n\u001b[1;32m    137\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mpandas\u001b[39;00m \u001b[39mimport\u001b[39;00m api, arrays, errors, io, plotting, tseries\n\u001b[0;32m--> 138\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mpandas\u001b[39;00m \u001b[39mimport\u001b[39;00m testing\n\u001b[1;32m    139\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mpandas\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mutil\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39m_print_versions\u001b[39;00m \u001b[39mimport\u001b[39;00m show_versions\n\u001b[1;32m    141\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mpandas\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mio\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mapi\u001b[39;00m \u001b[39mimport\u001b[39;00m (\n\u001b[1;32m    142\u001b[0m     \u001b[39m# excel\u001b[39;00m\n\u001b[1;32m    143\u001b[0m     ExcelFile,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    171\u001b[0m     read_spss,\n\u001b[1;32m    172\u001b[0m )\n",
      "File \u001b[0;32m~/.pyenv/versions/3.11.1/lib/python3.11/site-packages/pandas/testing.py:6\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[39mPublic testing utility functions.\u001b[39;00m\n\u001b[1;32m      3\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mpandas\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39m_testing\u001b[39;00m \u001b[39mimport\u001b[39;00m (\n\u001b[1;32m      7\u001b[0m     assert_extension_array_equal,\n\u001b[1;32m      8\u001b[0m     assert_frame_equal,\n\u001b[1;32m      9\u001b[0m     assert_index_equal,\n\u001b[1;32m     10\u001b[0m     assert_series_equal,\n\u001b[1;32m     11\u001b[0m )\n\u001b[1;32m     13\u001b[0m __all__ \u001b[39m=\u001b[39m [\n\u001b[1;32m     14\u001b[0m     \u001b[39m\"\u001b[39m\u001b[39massert_extension_array_equal\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m     15\u001b[0m     \u001b[39m\"\u001b[39m\u001b[39massert_frame_equal\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m     16\u001b[0m     \u001b[39m\"\u001b[39m\u001b[39massert_series_equal\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m     17\u001b[0m     \u001b[39m\"\u001b[39m\u001b[39massert_index_equal\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m     18\u001b[0m ]\n",
      "File \u001b[0;32m~/.pyenv/versions/3.11.1/lib/python3.11/site-packages/pandas/_testing/__init__.py:914\u001b[0m\n\u001b[1;32m    909\u001b[0m     \u001b[39mimport\u001b[39;00m \u001b[39mpytest\u001b[39;00m\n\u001b[1;32m    911\u001b[0m     \u001b[39mreturn\u001b[39;00m pytest\u001b[39m.\u001b[39mraises(expected_exception, match\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m)\n\u001b[0;32m--> 914\u001b[0m cython_table \u001b[39m=\u001b[39m pd\u001b[39m.\u001b[39;49mcore\u001b[39m.\u001b[39mcommon\u001b[39m.\u001b[39m_cython_table\u001b[39m.\u001b[39mitems()\n\u001b[1;32m    917\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_cython_table_params\u001b[39m(ndframe, func_names_and_expected):\n\u001b[1;32m    918\u001b[0m \u001b[39m    \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    919\u001b[0m \u001b[39m    Combine frame, functions from com._cython_table\u001b[39;00m\n\u001b[1;32m    920\u001b[0m \u001b[39m    keys and expected result.\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    932\u001b[0m \u001b[39m        List of three items (DataFrame, function, expected result)\u001b[39;00m\n\u001b[1;32m    933\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n",
      "\u001b[0;31mAttributeError\u001b[0m: partially initialized module 'pandas' has no attribute 'core' (most likely due to a circular import)"
     ]
    }
   ],
   "source": [
    "## Not Finished unfortunately :(\n",
    "\n",
    "import pandas as pd\n",
    "from IPython.display import display, Markdown\n",
    "\n",
    "\n",
    "def find_common_folders(folder1, folder2):\n",
    "    folders1 = set(os.listdir(os.getcwd()+folder1))\n",
    "    folders2 = set(os.listdir(os.getcwd()+folder2))\n",
    "    common_folders = list(folders1.intersection(folders2))\n",
    "    print(f\"Folders that have a ground truth to evaluate:{common_folders}\")\n",
    "    return common_folders\n",
    "\n",
    "\n",
    "\n",
    "def display_results():\n",
    "    # Create an empty dataframe to store the results\n",
    "\n",
    "    paths_to_evalutate = find_common_folders('/dataset/other-data/','/dataset/other-gt-flow/')\n",
    "\n",
    "    lk_df = pd.DataFrame(columns=['Name','Source', 'Processed', 'Average Angular Error','Std Angular Error', 'Average Endpoint Error','Std Endpoint Error'])\n",
    "    hs_df = pd.DataFrame(columns=['Name','Source', 'Processed', 'Average Angular Error','Std Angular Error', 'Average Endpoint Error','Std Endpoint Error'])\n",
    "    \n",
    "    # Iterate through the function calls and store the results\n",
    "    for i, path, in enumerate(paths_to_evalutate):\n",
    "        source_path = os.getcwd()+'/dataset/other-data/'+path\n",
    "        # Add the function name and result to the dataframe\n",
    "        #source_gif = f\"![source]({create_gif_from_folder(source_path, duration=100)})\"\n",
    "        source_gif = gif_to_html_image(create_gif_from_folder(source_path, duration=100))\n",
    "        #lk_df.loc[i+1] = [path,source_gif,'yes','30days',source_gif,'yes','30days']\n",
    "        hs_df.loc[i+1] = [path,source_gif,'yes','30days',source_gif,'yes','30days']\n",
    "\n",
    "    #Display the results as a markdown table\n",
    "    #display(Markdown('# LucasKanade Results\\n\\n'+lk_df.to_markdown(index=False)+'\\n\\n\\n# HornShunck Results\\n\\n'+hs_df.to_markdown(index=False)))\n",
    "    display(Markdown('\\n# HornShunck Results\\n\\n'+hs_df.to_markdown(index=False)))\n",
    "display_results()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lucas Kanade\n",
    "\n",
    "|Sequence|Original|MR|MR+IR|Ours|\n",
    "|:----|:----|:----|:----|:---|\n",
    "|Dimetrodon [1]:|21.23 (21.26)|12.66 (19.05)|12.39 (18.73)||\n",
    "|Grove2 [1]:|28.84 (21.20)|4.5  (9.80)|4.81  (9.58)||\n",
    "|Grove3 [1]:|32.74 (31.50)|9.27  (17.98)|9.  6  (18.21)||\n",
    "|RubberWhale [1]:|18.52 (21.74)|14.23 (21.54)|14.15 (21.66)||\n",
    "|Hydragea  [1]:|27.87 (24.81)|9.27  (18.90)|9.  1  (19.56)||\n",
    "|Urban2 [1]:|45.47 (41.04)|9.19  (18.03)|9.  4  (20.14)||\n",
    "|Urban3  [1]:|48.14 (43.20)|7.74  (20.36)|7.  0  (18.84)||\n",
    "\n",
    "\n",
    "# HornShunck\n",
    "\n",
    "|Sequence|Original|MR|Ours|\n",
    "|:----|:----|:----|:----|\n",
    "|Dimetrodon [1]:|38.13 (20.30)|13.59 (17.33)|\n",
    "|Grove2 [1]:|25.77 (20.66)|7.68  (10.1  )|\n",
    "|Grove3 [1]:|30.78 (30.00)|18.25 (27.33)|\n",
    "|RubberWhale [1]:|22.36 (20.47)|14.37 (20.09)|\n",
    "|Hydragea  [1]:|31.10 (24.65)|12.17 (21.14)|\n",
    "|Urban2  [1]:|43.34 (37.29)|17.89 (26.25)|\n",
    "|Urban3  [1]:|51.51 (34.81)|15.71 (24.78)|"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.11.1"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}