{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Postprocessing bottom line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "from pathlib import Path\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import pandas as pd\n",
    "from scipy.signal import savgol_filter\n",
    "from scipy.signal import medfilt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of frames in the video: 119\n"
     ]
    }
   ],
   "source": [
    "video_number = \"8\"\n",
    "# Define the relative path to the video file\n",
    "notebook_dir = Path().resolve()\n",
    "project_root = notebook_dir.parent.parent\n",
    "video_path = (\n",
    "    project_root\n",
    "    / \"data\"\n",
    "    / f\"recording_{video_number}\"\n",
    "    / f\"Recording_{video_number}.mp4\"\n",
    ")\n",
    "video_path = str(video_path)\n",
    "\n",
    "# Load the video\n",
    "cap = cv2.VideoCapture(video_path)\n",
    "\n",
    "frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
    "print(f\"Number of frames in the video: {frame_count}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get data (horizontal_lines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     rho     theta\n",
      "0  980.0  1.570796\n",
      "1  980.0  1.570796\n",
      "2  980.0  1.570796\n",
      "3  980.0  1.570796\n",
      "4  980.0  1.570796\n"
     ]
    }
   ],
   "source": [
    "# Define the path to the CSV file\n",
    "input_data_path = (\n",
    "    project_root\n",
    "    / \"notebook\"\n",
    "    / \"lane_detection\"\n",
    "    / \"intermediate_data\"\n",
    "    / f\"horizontal_lines_{video_number}_raw.csv\"\n",
    ")\n",
    "\n",
    "# Load the CSV file into a DataFrame\n",
    "horizontal_lines = pd.read_csv(input_data_path)\n",
    "\n",
    "print(horizontal_lines.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get video movement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average movement video 8: 0.96\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Import data of the movement from Camera_Motion_Test.ipynb \"\"\"\n",
    "avg_movement_list = [0.57, 3.86, 5.18, 0.10, 0.16, 3.26, 0.52, 0.96]\n",
    "avg_movement = avg_movement_list[int(video_number) - 1]\n",
    "print(f\"Average movement video {int(video_number)}: {avg_movement}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funzioni"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Disegna la linea sul frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Disegna la linea sul singolo frame\"\"\"\n",
    "\n",
    "\n",
    "def write_line_on_frame(frame, line):\n",
    "    # Create a copy of the original frame to draw the first line\n",
    "    modified_frame = np.copy(frame)\n",
    "\n",
    "    # Extract the first line's rho and theta\n",
    "    if line:\n",
    "        rho, theta = line\n",
    "        # Calculate the endpoints of the line\n",
    "        a = np.cos(theta)\n",
    "        b = np.sin(theta)\n",
    "        x0 = a * rho\n",
    "        y0 = b * rho\n",
    "        x1 = int(x0 + 1000 * (-b))\n",
    "        y1 = int(y0 + 1000 * (a))\n",
    "        x2 = int(x0 - 1000 * (-b))\n",
    "        y2 = int(y0 - 1000 * (a))\n",
    "\n",
    "        # Draw the first line on the frame\n",
    "        cv2.line(modified_frame, (x1, y1), (x2, y2), (0, 255, 0), 2)\n",
    "\n",
    "    # return the modified frame\n",
    "    return modified_frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotta la traiettoria dei punti "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_trajectory(df):\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    plt.plot(df[\"X\"], -df[\"Y\"], \"o-\", label=\"Cleaned Trajectory\")\n",
    "    plt.xlabel(\"X Coordinate\")\n",
    "    plt.ylabel(\"Y Coordinate\")\n",
    "    plt.title(\"Cleaned Trajectory\")\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_coordinates(\n",
    "    df, title=\"Coordinates Plot\", xlabel=\"X\", ylabel=\"Y\", save_path=None\n",
    "):\n",
    "    # compute the mean and std of the X and Y coordinates\n",
    "    mean_x = df[\"X\"].mean()\n",
    "    std_x = df[\"X\"].std()\n",
    "    mean_y = df[\"Y\"].mean()\n",
    "    std_y = df[\"Y\"].std()\n",
    "    # plot the values of x and y with the mean and std\n",
    "    plt.figure(figsize=(10, 5))\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(df[\"X\"], label=\"X\")\n",
    "    plt.axhline(mean_x, color=\"r\", linestyle=\"--\", label=\"Mean\")\n",
    "    plt.axhline(mean_x + std_x, color=\"g\", linestyle=\"--\", label=\"Mean + Std\")\n",
    "    plt.axhline(mean_x - std_x, color=\"g\", linestyle=\"--\", label=\"Mean - Std\")\n",
    "    plt.title(title)\n",
    "    plt.xlabel(\"Frame\")\n",
    "    plt.ylabel(\"X\")\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(df[\"Y\"], label=\"Y\")\n",
    "    plt.axhline(mean_y, color=\"r\", linestyle=\"--\", label=\"Mean\")\n",
    "    plt.axhline(mean_y + std_y, color=\"g\", linestyle=\"--\", label=\"Mean + Std\")\n",
    "    plt.axhline(mean_y - std_y, color=\"g\", linestyle=\"--\", label=\"Mean - Std\")\n",
    "    plt.title(title)\n",
    "    plt.xlabel(\"Frame\")\n",
    "    plt.ylabel(\"Y\")\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rimuove gli outliers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_outliers(df, threshold=1):\n",
    "    # Ensure 'X' and 'Y' are numeric\n",
    "    df[[\"X\", \"Y\"]] = df[[\"X\", \"Y\"]].apply(pd.to_numeric, errors=\"coerce\")\n",
    "\n",
    "    # Compute the distance between consecutive points\n",
    "    dx = df[\"X\"].diff()\n",
    "    dy = df[\"Y\"].diff()\n",
    "    distances = np.sqrt(dx**2 + dy**2)\n",
    "    # Define outlier threshold\n",
    "    median_dist = distances.mean()\n",
    "    std_dist = distances.std()\n",
    "    print(df)\n",
    "    print(\"Median distance:\", median_dist)\n",
    "    print(\"Standard deviation of distances:\", std_dist)\n",
    "    outlier_threshold = threshold * std_dist * 2\n",
    "\n",
    "    mask = []\n",
    "\n",
    "    for i in range(0, len(distances) - 1):\n",
    "        # Remove points that are  (0, 0)  (the ones that I set when it doesn't detect any line)\n",
    "        if df[\"X\"].iloc[i] == 0 and df[\"Y\"].iloc[i] == 0:\n",
    "            mask.append(i)\n",
    "            prev_index = i - 1\n",
    "            while prev_index in mask and prev_index >= 0:\n",
    "                prev_index -= 1\n",
    "            if prev_index < 0:\n",
    "                print(\"No valid previous index found. Breaking.\")\n",
    "                break\n",
    "            distances[i + 1] = np.sqrt(\n",
    "                (df[\"X\"].iloc[i + 1] - df[\"X\"].iloc[prev_index]) ** 2\n",
    "                + (df[\"Y\"].iloc[i + 1] - df[\"Y\"].iloc[prev_index]) ** 2\n",
    "            )\n",
    "            continue\n",
    "        if distances[i] > outlier_threshold:\n",
    "            # Create a mask to identify the outlier point\n",
    "            mask.append(i)\n",
    "            # convert the next point distance in the distance with respect to the previous point\n",
    "            if i < len(distances) - 1 and i > 0:\n",
    "                # select the previous point as the last point evaluated non present in the mask\n",
    "                prev_index = i - 1\n",
    "                while prev_index in mask and prev_index >= 0:\n",
    "                    prev_index -= 1\n",
    "                if prev_index < 0:\n",
    "                    print(\"No valid previous index found. Breaking.\")\n",
    "                    break\n",
    "                distances[i + 1] = np.sqrt(\n",
    "                    (df[\"X\"].iloc[i + 1] - df[\"X\"].iloc[prev_index]) ** 2\n",
    "                    + (df[\"Y\"].iloc[i + 1] - df[\"Y\"].iloc[prev_index]) ** 2\n",
    "                )\n",
    "                # print('New distance:', distances[i+1], 'for point:', i+1, 'with respect to point:', prev_index)\n",
    "    # Remove the outlier points from the DataFrame\n",
    "    df = df.drop(mask)\n",
    "    print(\"Outliers removed:\", len(mask))\n",
    "\n",
    "    # compute means and standard deviations of points\n",
    "    mean_x = df[\"X\"].mean()\n",
    "    mean_y = df[\"Y\"].mean()\n",
    "    std_x = df[\"X\"].std()\n",
    "    std_y = df[\"Y\"].std()\n",
    "\n",
    "    threshold_std = 1\n",
    "\n",
    "    # Remove points too far from the mean\n",
    "    df = df[\n",
    "        (df[\"X\"] > mean_x - threshold_std * std_x)\n",
    "        & (df[\"X\"] < mean_x + threshold_std * std_x)\n",
    "        & (df[\"Y\"] > mean_y - threshold_std * std_y)\n",
    "        & (df[\"Y\"] < mean_y + threshold_std * std_y)\n",
    "    ]\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_outliers_iterated(df, threshold_factor=1):\n",
    "    # Ensure 'X' and 'Y' are numeric\n",
    "    df[[\"X\", \"Y\"]] = df[[\"X\", \"Y\"]].apply(pd.to_numeric, errors=\"coerce\")\n",
    "\n",
    "    first_iteration = True\n",
    "    exit_threshold = 10000\n",
    "    max_dist = np.inf\n",
    "\n",
    "    # remove the points that are 0,0\n",
    "    df = df[(df[\"X\"] != 0) | (df[\"Y\"] != 0)]\n",
    "\n",
    "    # Compute the distance between consecutive points\n",
    "    dx = df[\"X\"].diff()\n",
    "    dy = df[\"Y\"].diff()\n",
    "\n",
    "    # compute distances\n",
    "    df[\"distance\"] = np.sqrt(dx**2 + dy**2)\n",
    "\n",
    "    while max_dist > exit_threshold:\n",
    "        # set the threshold to exit the while\n",
    "        if first_iteration:\n",
    "            first_iteration = False\n",
    "            mean_dist = np.mean(df[\"distance\"])\n",
    "            std = np.std(df[\"distance\"])\n",
    "            print(\"media:\", mean_dist, \"std:\", std)\n",
    "            if std > mean_dist:\n",
    "                exit_threshold = std\n",
    "            else:\n",
    "                exit_threshold = 2 * mean_dist\n",
    "\n",
    "        # set the threshold for outliers removal\n",
    "        if threshold_factor > 1:\n",
    "            threshold_dist = threshold_factor * np.mean(df[\"distance\"])\n",
    "        else:\n",
    "            threshold_dist = 1 * np.mean(df[\"distance\"])\n",
    "\n",
    "        # outliers removal\n",
    "        df = df[\n",
    "            (df[\"distance\"] < threshold_dist) & df[\"distance\"].notna()\n",
    "        ]  # the first value is considered as correct\n",
    "\n",
    "        # Compute the distance between consecutive points\n",
    "        dx = df[\"X\"].diff()\n",
    "        dy = df[\"Y\"].diff()\n",
    "\n",
    "        # compute distances\n",
    "        df[\"distance\"] = np.sqrt(dx**2 + dy**2)\n",
    "\n",
    "        # get the max distance\n",
    "        max_dist = np.max(df[\"distance\"])\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_outliers_xy(df):\n",
    "    # compute the mean and std of the X and Y coordinates\n",
    "    mean_x = df[\"X\"].mean()\n",
    "    std_x = df[\"X\"].std()\n",
    "    mean_y = df[\"Y\"].mean()\n",
    "    std_y = df[\"Y\"].std()\n",
    "\n",
    "    # set the threshold\n",
    "    threshold_x = std_x * 2\n",
    "    threshold_y = std_y * 2\n",
    "    # remove outliers: remove the points that have a distance on each axis with respect to the previous point greater than the threshold\n",
    "    mask = []\n",
    "    for i in range(len(df.index.values)):\n",
    "        if df[\"X\"].iloc[i] == 0 and df[\"Y\"].iloc[i] == 0:\n",
    "            mask.append(df.index.values[i])\n",
    "            continue\n",
    "        # compute the first feasible previous index\n",
    "        prev_index = i - 1\n",
    "        while df.index.values[prev_index] in mask and prev_index >= 0:\n",
    "            prev_index -= 1\n",
    "        if (\n",
    "            abs(df[\"X\"].iloc[i] - df[\"X\"].iloc[prev_index]) > threshold_x\n",
    "            or abs(df[\"Y\"].iloc[i] - df[\"Y\"].iloc[prev_index]) > threshold_y\n",
    "        ) and prev_index >= 0:\n",
    "            mask.append(df.index.values[i])\n",
    "\n",
    "    # Remove the outlier points from the DataFrame\n",
    "    df = df.drop(mask)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "filtro a media mobile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def median_filter(df, kernel_size=3):\n",
    "    \"\"\"\n",
    "    Smooths the X and Y coordinates using a median filter to reduce noise.\n",
    "    \"\"\"\n",
    "    # Apply a median filter to smooth the coordinates (kernel size 5 by default)\n",
    "    df[\"X\"] = medfilt(df[\"X\"], kernel_size=kernel_size)\n",
    "    df[\"Y\"] = medfilt(df[\"Y\"], kernel_size=kernel_size)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Smoothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Savitzky_Golay_filter(df, window_length=5, polyorder=1):\n",
    "    \"\"\"\n",
    "    Smooths the X and Y coordinates using Savitzky-Golay filter to reduce noise.\n",
    "    \"\"\"\n",
    "    df[\"X\"] = savgol_filter(df[\"X\"], window_length=window_length, polyorder=polyorder)\n",
    "    df[\"Y\"] = savgol_filter(df[\"Y\"], window_length=window_length, polyorder=polyorder)\n",
    "\n",
    "    # # Round the smoothed coordinates to integers\n",
    "    # df['X'] = df['X'].round().astype(int)\n",
    "    # df['Y'] = df['Y'].round().astype(int)\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interpola i punti per ricavere quelli mancanti (eliminati precedentemente perchè errati)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "def interpolate_missing_coordinates(df, end_frame, start_frame=0):\n",
    "    \"\"\"\n",
    "    Interpolate the missing coordinates between the frames from start_frame to end_frame.\n",
    "    Ensures a smooth trajectory by interpolating both X and Y coordinates.\n",
    "    \"\"\"\n",
    "    # Create a DataFrame with all frames from start_frame to end_frame\n",
    "    all_frames = pd.DataFrame({\"Frame\": range(start_frame, end_frame + 1)})\n",
    "\n",
    "    # Merge with the original dataframe\n",
    "    df_full = pd.merge(all_frames, df, on=\"Frame\", how=\"left\")\n",
    "\n",
    "    # Interpolate the missing 'X' and 'Y' coordinates (linear interpolation)\n",
    "    df_full[\"X\"] = df_full[\"X\"].interpolate(method=\"linear\")\n",
    "    df_full[\"Y\"] = df_full[\"Y\"].interpolate(method=\"linear\")\n",
    "\n",
    "    # Fill any remaining NaN values using forward and backward filling\n",
    "    df_full[\"X\"] = df_full[\"X\"].bfill().ffill()\n",
    "    df_full[\"Y\"] = df_full[\"Y\"].bfill().ffill()\n",
    "\n",
    "    # Apply smoothing to ensure a smooth trajectory\n",
    "    df_full = Savitzky_Golay_filter(df_full)\n",
    "\n",
    "    return df_full"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calcola il punto di intersezione di ogni linea con la linea ortogonale che passa per l'origine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_intersections(horizontal_lines):\n",
    "    # Calcola il punto  per ogni linea\n",
    "    intersection_points = []\n",
    "\n",
    "    for rho, theta in zip(horizontal_lines[\"rho\"], horizontal_lines[\"theta\"]):\n",
    "        # Calcola i coefficienti della linea\n",
    "        x = np.cos(theta) * rho\n",
    "        y = np.sin(theta) * rho\n",
    "\n",
    "        # Aggiungi il punto  alla lista\n",
    "        intersection_points.append((x, y))\n",
    "\n",
    "    return intersection_points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_intersection_cartesian(horizontal_lines):\n",
    "    intersection_points = []\n",
    "\n",
    "    for x1, y1, x2, y2 in horizontal_lines[[\"x1\", \"y1\", \"x2\", \"y2\"]].values:\n",
    "        # Calculate the line coefficients (a, b, c) for ax + by + c = 0\n",
    "        a = y2 - y1\n",
    "        b = x1 - x2\n",
    "        c = x2 * y1 - x1 * y2\n",
    "\n",
    "        # Calculate the intersection with the orthogonal line passing through the origin\n",
    "        # The orthogonal line has equation bx - ay = 0\n",
    "        denominator = a**2 + b**2\n",
    "        if denominator == 0:\n",
    "            intersection_points.append((0, 0))\n",
    "            continue  # Skip degenerate lines\n",
    "\n",
    "        x = -a * c / denominator\n",
    "        y = -b * c / denominator\n",
    "\n",
    "        # Append the intersection point\n",
    "        intersection_points.append((x, y))\n",
    "\n",
    "    return intersection_points"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recompute the lines from the points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lines_from_point(points_interpolated):\n",
    "    # Riconversione dei punti in linee (rho e theta)\n",
    "    reconverted_lines = []\n",
    "\n",
    "    for x, y in points_interpolated[[\"X\", \"Y\"]].values:\n",
    "        rho = np.sqrt(x**2 + y**2)  # Distanza dall'origine\n",
    "        theta = np.arctan2(y, x)  # Angolo rispetto all'asse x\n",
    "        reconverted_lines.append((rho, theta))\n",
    "    return reconverted_lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lines_from_point_cartesian(points_interpolated, length=1000):\n",
    "    # Generate lines (as two points) orthogonal to the origin-point vector, passing through the point\n",
    "    reconverted_lines = []\n",
    "\n",
    "    for x, y in points_interpolated[[\"X\", \"Y\"]].values:\n",
    "        # Orthogonal direction to vector (x, y)\n",
    "        dx = -y\n",
    "        dy = x\n",
    "\n",
    "        # Normalize direction vector\n",
    "        norm = (dx**2 + dy**2) ** 0.5\n",
    "        dx /= norm\n",
    "        dy /= norm\n",
    "\n",
    "        # Generate two points along the orthogonal line centered at (x, y)\n",
    "        x1 = x + dx * length / 2\n",
    "        y1 = y + dy * length / 2\n",
    "        x2 = x - dx * length / 2\n",
    "        y2 = y - dy * length / 2\n",
    "\n",
    "        reconverted_lines.append(((x1, y1), (x2, y2)))\n",
    "\n",
    "    return reconverted_lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Main"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     Frame             X      Y\n",
      "0        0  6.000769e-14  980.0\n",
      "1        1  6.000769e-14  980.0\n",
      "2        2  6.000769e-14  980.0\n",
      "3        3  6.000769e-14  980.0\n",
      "4        4  6.000769e-14  980.0\n",
      "..     ...           ...    ...\n",
      "114    114  6.000769e-14  980.0\n",
      "115    115  6.000769e-14  980.0\n",
      "116    116  6.000769e-14  980.0\n",
      "117    117  6.000769e-14  980.0\n",
      "118    118  6.000769e-14  980.0\n",
      "\n",
      "[119 rows x 3 columns]\n",
      "Median distance: 0.1694915254237288\n",
      "Standard deviation of distances: 1.2963135419615373\n",
      "Outliers removed: 1\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get the intersection points\n",
    "intersection_points = get_intersections(horizontal_lines)\n",
    "# remove outliers\n",
    "# Create a DataFrame from intersection_points\n",
    "points_df = pd.DataFrame(intersection_points, columns=[\"X\", \"Y\"])\n",
    "points_df[\"Frame\"] = range(len(points_df))\n",
    "# plot_trajectory(points_df)\n",
    "plot_coordinates(points_df, title=\"Raw Coordinates Plot\")\n",
    "\n",
    "# Reorder columns to have 'Frame', 'X', 'Y'\n",
    "points_df = points_df[[\"Frame\", \"X\", \"Y\"]]\n",
    "\n",
    "# Remove outliers\n",
    "points_cleaned = remove_outliers(points_df)\n",
    "\n",
    "# plot_trajectory(points_cleaned)\n",
    "plot_coordinates(points_cleaned, title=\"Cleaned Coordinates Plot\")\n",
    "\n",
    "if avg_movement > 1:\n",
    "    # Smooth the trajectory to reduce noise\n",
    "    points_smoothed = median_filter(points_cleaned)\n",
    "    # plot_trajectory(points_smoothed)\n",
    "    plot_coordinates(points_smoothed, title=\"Smoothed Coordinates Plot\")\n",
    "\n",
    "    # Interpolate missing coordinates\n",
    "    points_interpolated = interpolate_missing_coordinates(\n",
    "        points_smoothed, len(points_df) - 1\n",
    "    )\n",
    "    plot_coordinates(points_interpolated, title=\"Interpolated Coordinates Plot\")\n",
    "    # plot\n",
    "    # plot_trajectory(points_interpolated)\n",
    "    # print(\"len(points_interpolated):\", len(points_interpolated))\n",
    "    # print('mean:', points_interpolated['X'].mean(), points_interpolated['Y'].mean())\n",
    "\n",
    "    reconverted_lines = lines_from_point(points_interpolated)\n",
    "else:\n",
    "    # get the mean point because I'm assuming the video still\n",
    "    mean_point = points_cleaned.mean()\n",
    "    # print('mean point:', mean_point)\n",
    "\n",
    "    # create a list of length of the original df where each element is mean_point\n",
    "    mean_point_list = [mean_point] * len(intersection_points)\n",
    "    mean_point_df = pd.DataFrame(mean_point_list, columns=[\"X\", \"Y\"])\n",
    "\n",
    "    reconverted_lines = lines_from_point(mean_point_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "cannot convert float NaN to integer",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mValueError\u001b[39m                                Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[105]\u001b[39m\u001b[32m, line 19\u001b[39m\n\u001b[32m     17\u001b[39m     \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mEnd of video or failed to read the frame at iteration\u001b[39m\u001b[33m\"\u001b[39m, frame_index)\n\u001b[32m     18\u001b[39m     \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m19\u001b[39m modified_frame = \u001b[43mwrite_line_on_frame\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvideo_frame\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreconverted_lines\u001b[49m\u001b[43m[\u001b[49m\u001b[43mframe_index\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m     21\u001b[39m \u001b[38;5;66;03m# Write the modified frame to the output video\u001b[39;00m\n\u001b[32m     22\u001b[39m out.write(modified_frame)\n",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[91]\u001b[39m\u001b[32m, line 14\u001b[39m, in \u001b[36mwrite_line_on_frame\u001b[39m\u001b[34m(frame, line)\u001b[39m\n\u001b[32m     12\u001b[39m x0 = a * rho\n\u001b[32m     13\u001b[39m y0 = b * rho\n\u001b[32m---> \u001b[39m\u001b[32m14\u001b[39m x1 = \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mx0\u001b[49m\u001b[43m \u001b[49m\u001b[43m+\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m1000\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43m-\u001b[49m\u001b[43mb\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m     15\u001b[39m y1 = \u001b[38;5;28mint\u001b[39m(y0 + \u001b[32m1000\u001b[39m * (a))\n\u001b[32m     16\u001b[39m x2 = \u001b[38;5;28mint\u001b[39m(x0 - \u001b[32m1000\u001b[39m * (-b))\n",
      "\u001b[31mValueError\u001b[39m: cannot convert float NaN to integer"
     ]
    }
   ],
   "source": [
    "# Reset the video to the beginning\n",
    "cap.set(cv2.CAP_PROP_POS_FRAMES, 0)\n",
    "\n",
    "# Define the codec and create a VideoWriter object to save the modified frames\n",
    "output_path = (\n",
    "    project_root\n",
    "    / \"data\"\n",
    "    / f\"recording_{video_number}\"\n",
    "    / \"Adjusted_Bottom_line_video.mp4\"\n",
    ")\n",
    "fourcc = cv2.VideoWriter_fourcc(*\"mp4v\")  # Use 'mp4v' codec for MP4 format\n",
    "fps = int(cap.get(cv2.CAP_PROP_FPS))\n",
    "frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n",
    "frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n",
    "out = cv2.VideoWriter(str(output_path), fourcc, fps, (frame_width, frame_height))\n",
    "\n",
    "# Loop through each frame in the video\n",
    "frame_index = 0\n",
    "while frame_index < len(reconverted_lines):\n",
    "    ret, video_frame = cap.read()\n",
    "    if not ret:\n",
    "        print(\"End of video or failed to read the frame at iteration\", frame_index)\n",
    "        break\n",
    "    modified_frame = write_line_on_frame(video_frame, reconverted_lines[frame_index])\n",
    "\n",
    "    # Write the modified frame to the output video\n",
    "    out.write(modified_frame)\n",
    "\n",
    "    # Increment the frame index\n",
    "    frame_index += 1\n",
    "\n",
    "# Release the video capture and writer objects\n",
    "# cap.release()\n",
    "\n",
    "out.release()\n",
    "\n",
    "print(f\"Adjusted video saved to {output_path}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reconverted lines saved to C:\\Users\\miche\\OneDrive\\Documenti\\GitHub\\bowling-analysis\\notebook\\lane_detection\\intermediate_data\\lane_lines\\horizontal_lines_5.csv\n"
     ]
    }
   ],
   "source": [
    "# Convert reconverted_lines to a DataFrame\n",
    "reconverted_lines_df = pd.DataFrame(reconverted_lines, columns=[\"rho\", \"theta\"])\n",
    "\n",
    "# Define the path to save the reconverted lines\n",
    "output_path_lines = (\n",
    "    project_root\n",
    "    / \"notebook\"\n",
    "    / \"lane_detection\"\n",
    "    / \"intermediate_data\"\n",
    "    / \"lane_lines\"\n",
    "    / f\"horizontal_lines_{video_number}.csv\"\n",
    ")\n",
    "\n",
    "# Save the DataFrame to a CSV file\n",
    "reconverted_lines_df.to_csv(output_path_lines, index=False)\n",
    "\n",
    "print(f\"Reconverted lines saved to {output_path_lines}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cap.release()"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}