positions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "import json\n",
    "from pathlib import Path\n",
    "from typing import List, Optional, Tuple\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pedpy\n",
    "import plotly.graph_objects as go\n",
    "import shapely\n",
    "from jupedsim.internal.notebook_utils import animate\n",
    "from shapely import from_wkt\n",
    "import math\n",
    "\n",
    "print(f\"PedPy version: {pedpy.__version__}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the WKT string for the polygon\n",
    "geometry = from_wkt(\n",
    "    \"POLYGON ((-8.88 -7.63, 8.3 -7.63, 8.3 27.95, -8.88 27.95, -8.88 -7.63), (-3.54 -1.13, -3.57 19.57, -1.52 19.57, -1.37 19.71, -1.37 21.09, -1.52 21.23, -1.67 21.23, -1.67 21.18, -1.545 21.18, -1.4200000000000002 21.065, -1.4200000000000002 19.735, -1.545 19.62, -3.6199999999999997 19.62, -3.59 -1.13, -3.54 -1.13), (3.57 -0.89, 3.64 19.64, 1.47 19.57, 1.32 19.71, 1.32 21.09, 1.47 21.23, 1.62 21.23, 1.62 21.18, 1.4949999999999999 21.18, 1.37 21.065, 1.37 19.735, 1.4949999999999999 19.62, 3.69 19.69, 3.6199999999999997 -0.89, 3.57 -0.89), (0.67 19.57, 0.82 19.71, 0.82 21.09, 0.67 21.23, 0.38 21.23, 0.23 21.09, 0.23 19.71, 0.38 19.57, 0.67 19.57), (-0.42 19.57, -0.27 19.71, -0.27 21.09, -0.42 21.23, -0.72 21.23, -0.87 21.09, -0.87 19.71, -0.72 19.57, -0.42 19.57))\"\n",
    ")\n",
    "filenames = [\n",
    "    # \"../trajectories_croma/1C060_cam6_cam5_frameshift0_Combined.txt\", # low motivation\n",
    "    # \"../trajectories_croma/1C070_cam6_cam5_frameshift0_Combined.txt\", # low motivation\n",
    "    \"../trajectories_croma/2C070_cam6_cam5_frameshift0_Combined.txt\",  # high motivation\n",
    "    \"../trajectories_croma/2C120_cam6_cam5_frameshift0_Combined.txt\",  # high motivation\n",
    "    # \"../trajectories_croma/2C130_cam6_cam5_frameshift0_Combined.txt\", # low motivation\n",
    "    # \"../trajectories_croma/2C150_cam6_cam5_frameshift0_Combined.txt\", # low motivation\n",
    "]\n",
    "\n",
    "\n",
    "def read_json_file(file_path):\n",
    "    with open(file_path, \"r\") as file:\n",
    "        data = json.load(file)\n",
    "    return data\n",
    "\n",
    "\n",
    "def get_first_frame_pedestrian_passes_line(filename: str, passing_line_y: float = 20):\n",
    "    \"\"\"\n",
    "    Return the first frame when a pedestrian passes the specified horizontal line.\n",
    "    Also return the DataFrame of whole trajectories.\n",
    "    60 -> 19.71\n",
    "    70 ->\n",
    "    \"\"\"\n",
    "    df = pd.read_csv(\n",
    "        filename, sep=\"\\t\", names=[\"id\", \"frame\", \"x\", \"y\", \"z\", \"m\"], comment=\"#\"\n",
    "    )\n",
    "    df = df.sort_values([\"frame\", \"id\"])\n",
    "    df[\"y_diff\"] = df.groupby(\"id\")[\"y\"].diff()\n",
    "    crossing_frame = df[(df[\"y\"] >= passing_line_y) & (df[\"y_diff\"] > 0)][\"frame\"].min()\n",
    "    if pd.isna(crossing_frame):\n",
    "        return df, None\n",
    "    else:\n",
    "        return df, int(crossing_frame)\n",
    "\n",
    "\n",
    "def plot_trajectories_around_frame(\n",
    "    df: pd.DataFrame,\n",
    "    target_frame: int,\n",
    "    num_frames: int = 10,\n",
    "    title: str = \"\",\n",
    "    geometry: Optional[shapely.Geometry] = None,\n",
    "    inifile: str = \"files/inifile.json\",\n",
    "    plot_all_pedestrians: bool = False,\n",
    ") -> None:\n",
    "    \"\"\"Plot trajectories for num_frames before and after the target frame.\"\"\"\n",
    "    fig, axes = create_figure()\n",
    "\n",
    "    plot_pedestrian_trajectories(\n",
    "        df,\n",
    "        target_frame,\n",
    "        plot_all_pedestrians=plot_all_pedestrians,\n",
    "        num_frames=num_frames,\n",
    "    )\n",
    "    plot_walkable_area(geometry)\n",
    "    plot_doors_and_destinations(inifile)\n",
    "    set_plot_properties(title)\n",
    "    plt.savefig(f\"files/figures/{title}.pdf\")\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def filter_dataframe(\n",
    "    df: pd.DataFrame, target_frame: int, num_frames: int\n",
    ") -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Filter the dataframe to include only the frames around the target frame.\n",
    "\n",
    "    Parameters:\n",
    "    df (pd.DataFrame): The input DataFrame containing trajectory data.\n",
    "    target_frame (int): The frame number to center the filter around.\n",
    "    num_frames (int): The number of frames to include before and after the target frame.\n",
    "\n",
    "    Returns:\n",
    "    pd.DataFrame: A filtered DataFrame containing only the frames within the specified range.\n",
    "    \"\"\"\n",
    "    start_frame = max(target_frame - num_frames, df[\"frame\"].min())\n",
    "    end_frame = min(target_frame + num_frames, df[\"frame\"].max())\n",
    "    return df[(df[\"frame\"] >= start_frame) & (df[\"frame\"] <= end_frame)]\n",
    "\n",
    "\n",
    "def create_figure(num_rows=1, num_cols=1, fig_width=20, fig_height=20):\n",
    "    \"\"\"Create and return a figure and axes for plotting.\"\"\"\n",
    "    return plt.subplots(num_rows, num_cols, figsize=(fig_width, fig_height))\n",
    "\n",
    "\n",
    "def plot_pedestrian_trajectories(\n",
    "    df: pd.DataFrame,\n",
    "    target_frame: int,\n",
    "    num_frames=10,\n",
    "    plot_all_pedestrians: bool = False,\n",
    "):\n",
    "    \"\"\"Plot the trajectories of all pedestrians in the filtered dataframe.\"\"\"\n",
    "    start_frame = max(target_frame - num_frames, df[\"frame\"].min())\n",
    "    end_frame = min(target_frame + num_frames, df[\"frame\"].max())\n",
    "    print(f\"{num_frames = }\", start_frame, end_frame)\n",
    "    filtered_df = df[(df[\"frame\"] >= start_frame) & (df[\"frame\"] <= end_frame)]\n",
    "    ids = np.unique(filtered_df[\"id\"])\n",
    "    for ped in ids:\n",
    "        ped_data = df[df[\"id\"] == ped]\n",
    "        for frame in range(start_frame, end_frame + 1):\n",
    "            color = \"red\" if frame == target_frame else \"gray\"\n",
    "            # color = \"red\" if ped == 11 else \"gray\"\n",
    "            zorder = 10 if frame == target_frame else 1\n",
    "            frame_data = ped_data[\n",
    "                (ped_data[\"frame\"] == frame)\n",
    "            ]  # & (ped_data['y']>18.7) & (ped_data['id'].isin([13,11]))]\n",
    "            if not frame_data.empty:\n",
    "                plt.plot(\n",
    "                    frame_data[\"x\"],\n",
    "                    frame_data[\"y\"],\n",
    "                    \".-\",\n",
    "                    zorder=zorder,\n",
    "                    color=color,\n",
    "                    # label=f\"Ped {ped} at frame {frame}\",\n",
    "                    # label=f\"{ped}\",\n",
    "                )\n",
    "\n",
    "        if plot_all_pedestrians:\n",
    "            plt.plot(\n",
    "                ped_data[\"x\"],\n",
    "                ped_data[\"y\"],\n",
    "                label=f\"Ped {ped}\",\n",
    "                color=\"black\",\n",
    "                alpha=0.5,\n",
    "                lw=0.2,\n",
    "            )\n",
    "\n",
    "\n",
    "def plot_walkable_area(geometry: shapely.Geometry, axes: Optional[plt.Axes] = None):\n",
    "    \"\"\"Plot the walkable area defined by the given geometry.\"\"\"\n",
    "\n",
    "    walkable_area = pedpy.WalkableArea(geometry)\n",
    "    pedpy.plot_walkable_area(walkable_area=walkable_area, axes=axes)\n",
    "\n",
    "\n",
    "def plot_doors_and_destinations(inifile: str):\n",
    "    \"\"\"Plot doors and destinations from the inifile.\"\"\"\n",
    "    data = read_json_file(inifile)\n",
    "    # plot_doors(data)\n",
    "    plot_destinations(data)\n",
    "\n",
    "\n",
    "def plot_time_distance(measurement_line, traj, title):\n",
    "    speed = pedpy.compute_individual_speed(traj_data=traj, frame_step=5)\n",
    "\n",
    "    df_time_distance = pedpy.compute_time_distance_line(\n",
    "        traj_data=traj, measurement_line=measurement_line\n",
    "    )\n",
    "    pedpy.plot_time_distance(\n",
    "        time_distance=df_time_distance,\n",
    "        frame_rate=traj.frame_rate,\n",
    "        speed=speed,\n",
    "        title=title,\n",
    "    )\n",
    "\n",
    "\n",
    "def plot_doors(data: dict):\n",
    "    \"\"\"Plot doors from the inifile data.\"\"\"\n",
    "    motivation_doors = data[\"motivation_parameters\"][\"motivation_doors\"]\n",
    "    width = data[\"motivation_parameters\"][\"width\"]\n",
    "    for door in motivation_doors:\n",
    "        vertices = door[\"vertices\"]\n",
    "        x_vals, y_vals = zip(*vertices)\n",
    "        plt.plot(x_vals, y_vals, label=f\"Door {door['id']}\", color=\"red\", lw=2)\n",
    "        center_x, center_y = np.mean(x_vals), np.mean(y_vals)\n",
    "        plt.plot(center_x, center_y, marker=\"o\", color=\"b\")\n",
    "        circle = plt.Circle(\n",
    "            (center_x, center_y), width, color=\"b\", alpha=0.3, fill=True\n",
    "        )\n",
    "        plt.gca().add_artist(circle)\n",
    "\n",
    "\n",
    "def plot_destinations(data: dict):\n",
    "    \"\"\"Plot destinations from the inifile data.\"\"\"\n",
    "    for destination in data[\"destinations\"]:\n",
    "        vertices = destination[\"vertices\"]\n",
    "        polygon = plt.Polygon(\n",
    "            vertices,\n",
    "            closed=True,\n",
    "            fill=True,\n",
    "            edgecolor=\"r\",\n",
    "            facecolor=\"lightblue\",\n",
    "            label=f\"Exit {destination['id']}\",\n",
    "        )\n",
    "        plt.gca().add_patch(polygon)\n",
    "        centroid = [sum(x) / len(vertices) for x in zip(*vertices)]\n",
    "        plt.text(\n",
    "            centroid[0],\n",
    "            centroid[1],\n",
    "            f\"{destination['id']}\",\n",
    "            ha=\"center\",\n",
    "            va=\"center\",\n",
    "            fontsize=10,\n",
    "            color=\"black\",\n",
    "        )\n",
    "\n",
    "\n",
    "def set_plot_properties(title: str):\n",
    "    \"\"\"Set the properties of the plot.\"\"\"\n",
    "    plt.xlim(-7, 7)\n",
    "    plt.xlabel(\"X Position\")\n",
    "    plt.ylabel(\"Y Position\")\n",
    "    plt.title(f\"{title}.\")\n",
    "    plt.gca().set_aspect(\"equal\")\n",
    "    # plt.legend()\n",
    "\n",
    "\n",
    "def print_agent_info(\n",
    "    df: pd.DataFrame, filename: str, frame_after_decrease: Optional[int]\n",
    ") -> None:\n",
    "    \"\"\"Print information about the number of agents and the frame after the decrease.\"\"\"\n",
    "    print(f\"Agents: {len(df['id'].unique())}\")\n",
    "    print(f\"{filename}\")\n",
    "    print(f\"{frame_after_decrease = }\")\n",
    "\n",
    "\n",
    "def extract_title(filename: str) -> str:\n",
    "    \"\"\"Extract the title from the filename (before the first underscore).\"\"\"\n",
    "    return Path(filename).stem.split(\"_\")[0]\n",
    "\n",
    "\n",
    "def write_frame_data_to_file(\n",
    "    df: pd.DataFrame, frame_after_decrease: int, filename: str\n",
    ") -> None:\n",
    "    \"\"\"Write the frame data to a CSV file.\"\"\"\n",
    "    frame_data: pd.DataFrame = df[df[\"frame\"] == frame_after_decrease]\n",
    "    tuple_list: List[Tuple[float, float]] = [\n",
    "        tuple(x) for x in frame_data[[\"x\", \"y\"]].to_numpy()\n",
    "    ]\n",
    "    title: str = extract_title(filename)\n",
    "    output_filename: str = (\n",
    "        f\"../trajectories_croma/{title}_frame_{frame_after_decrease}.csv\"\n",
    "    )\n",
    "\n",
    "    with open(output_filename, \"w\") as f:\n",
    "        writer: csv.writer = csv.writer(f)\n",
    "        writer.writerows(tuple_list)\n",
    "    print(f\"Data written to {output_filename}\")\n",
    "\n",
    "\n",
    "def process_file(filename: str, geometry: shapely.geometry.Polygon) -> None:\n",
    "    \"\"\"Process the file and handle data extraction, plotting, and file output.\"\"\"\n",
    "    df: pd.DataFrame\n",
    "    frame_after_decrease: Optional[int]\n",
    "    df, frame_after_decrease = get_first_frame_pedestrian_passes_line(filename)\n",
    "    print_agent_info(df, filename, frame_after_decrease)\n",
    "    df_moving = df[df[\"frame\"] >= frame_after_decrease]\n",
    "    traj_moving = pedpy.TrajectoryData(df_moving, frame_rate=50)\n",
    "    inifile = \"files/inifile.json\"\n",
    "    data = read_json_file(inifile)\n",
    "    measurement_line = pedpy.MeasurementLine(data[\"measurement_line\"][\"vertices\"])\n",
    "\n",
    "    if frame_after_decrease is not None:\n",
    "        write_frame_data_to_file(df, frame_after_decrease, filename)\n",
    "        title = extract_title(filename)\n",
    "        start_frame, end_frame = df[\"frame\"].min(), df[\"frame\"].max()\n",
    "        title = f\"{title}. Frame {start_frame} to {end_frame}. Starting at {frame_after_decrease}\"\n",
    "        plot_trajectories_around_frame(\n",
    "            df,\n",
    "            frame_after_decrease,\n",
    "            num_frames=0,\n",
    "            title=title,\n",
    "            geometry=geometry,\n",
    "            plot_all_pedestrians=True,\n",
    "        )\n",
    "        title = extract_title(filename) + f\" Frame {frame_after_decrease}\"\n",
    "        plot_time_distance(measurement_line, traj_moving, title)\n",
    "    else:\n",
    "        print(\"No valid frame found for visualization.\")\n",
    "\n",
    "\n",
    "def process_files(filenames: List[str], geometry: shapely.geometry.Polygon) -> None:\n",
    "    \"\"\"Process a list of filenames.\"\"\"\n",
    "    for filename in filenames:\n",
    "        process_file(filename, geometry)\n",
    "\n",
    "\n",
    "process_files(filenames, geometry)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot geometry for debugging coordinates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse the WKT polygon\n",
    "geometry2 = from_wkt(\n",
    "    \"POLYGON ((-8.88 -7.63, 8.3 -7.63, 8.3 27.95, -8.88 27.95, -8.88 -7.63), (-3.54 -1.13, -3.57 19.57, -1.52 19.57, -1.37 19.71,  -0.87 19.71, -0.72 19.57, -0.42 19.57, -0.27 19.71, -0.27 21.09, -0.42 21.23, -0.72 21.23, -0.87 21.09, -1.37 21.09, -1.52 21.23, -1.67 21.23, -1.67 21.18, -1.545 21.18, -1.4200000000000002 21.065, -1.4200000000000002 19.735, -1.545 19.62, -3.6199999999999997 19.62, -3.59 -1.13, -3.54 -1.13), (3.57 -0.89, 3.64 19.64, 1.47 19.57, 1.32 19.71, 0.82 19.71, 0.67 19.57, 0.38 19.57, 0.23 19.71, 0.23 21.09, 0.38 21.23, 0.67 21.23, 0.82 21.09, 1.32 21.09, 1.47 21.23, 1.62 21.23, 1.62 21.18, 1.4949999999999999 21.18, 1.37 21.065, 1.37 19.735, 1.4949999999999999 19.62, 3.69 19.69, 3.6199999999999997 -0.89, 3.57 -0.89))\"\n",
    ")\n",
    "\n",
    "\n",
    "# Extract exterior coordinates\n",
    "exterior_x, exterior_y = geometry2.exterior.xy\n",
    "\n",
    "# Extract interior coordinates (holes)\n",
    "interiors = [list(interior.coords.xy) for interior in geometry2.interiors]\n",
    "exterior_x = list(geometry2.exterior.xy[0])\n",
    "exterior_y = list(geometry2.exterior.xy[1])\n",
    "\n",
    "# Extract interior coordinates (holes) as lists\n",
    "interiors = [\n",
    "    (list(interior.xy[0]), list(interior.xy[1])) for interior in geometry2.interiors\n",
    "]\n",
    "\n",
    "# Create the figure\n",
    "fig = go.Figure()\n",
    "\n",
    "# Plot exterior\n",
    "fig.add_trace(go.Scatter(x=exterior_x, y=exterior_y, mode=\"lines\", name=\"Exterior\"))\n",
    "\n",
    "# Plot interiors (holes)\n",
    "for i, (x, y) in enumerate(interiors):\n",
    "    fig.add_trace(go.Scatter(x=x, y=y, mode=\"lines+markers\", name=f\"Interior {i+1}\"))\n",
    "    print(f\"Interior {i+1}. {x = }, {y = }\")\n",
    "\n",
    "\n",
    "# fig.add_trace(go.Scatter(x=combined_x, y=combined_y, mode='lines+markers', fill='toself', name='Combined Polygon'))\n",
    "\n",
    "# Update layout\n",
    "fig.update_layout(\n",
    "    title=\"Polygon with Interior Holes\",\n",
    "    xaxis_title=\"X Coordinate\",\n",
    "    yaxis_title=\"Y Coordinate\",\n",
    "    showlegend=True,\n",
    "    width=600,\n",
    "    height=600,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot motivation heatmaps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "motiv_files = ['files/trajectory_variation_001_motivation.csv',\n",
    "               #'files/trajectory_variation_002_motivation.csv',\n",
    "               #'files/trajectory_variation_003_motivation.csv',\n",
    "               #'files/trajectory_variation_004_motivation.csv',\n",
    "               #'files/trajectory_variation_005_motivation.csv',\n",
    "               #'files/trajectory_variation_006_motivation.csv',\n",
    "               #'files/trajectory_variation_007_motivation.csv',\n",
    "]\n",
    "colors = ['red', 'blue', 'green', 'orange', 'purple', 'black', 'yellow']\n",
    "\n",
    "for i, motiv_file in enumerate(motiv_files):\n",
    "    df = pd.read_csv(motiv_file,  names=[\"frame\", \"id\", \"time\", \"motivation\", \"x\", \"y\", \"value\"])\n",
    "    for id_to_plot in df[\"id\"].unique():\n",
    "        if id_to_plot!= 61: continue\n",
    "        ped_data = df[df[\"id\"] == id_to_plot]\n",
    "        plt.plot(ped_data[\"y\"], ped_data[\"motivation\"],'-o', ms=1, alpha=0.6, color=colors[i])\n",
    "        break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "motiv_files = [\n",
    "    \"files/trajectory_variation_001_motivation.csv\",\n",
    "    #'files/trajectory_variation_002_motivation.csv',\n",
    "    #'files/trajectory_variation_003_motivation.csv',\n",
    "    #'files/trajectory_variation_004_motivation.csv',\n",
    "    #'files/trajectory_variation_005_motivation.csv',\n",
    "    #'files/trajectory_variation_006_motivation.csv',\n",
    "    #'files/trajectory_variation_007_motivation.csv',\n",
    "]\n",
    "\n",
    "df = pd.read_csv(\n",
    "    motiv_files[0], names=[\"frame\", \"id\", \"time\", \"motivation\", \"x\", \"y\", \"value\"]\n",
    ")\n",
    "x_values = df[\"x\"].to_numpy()\n",
    "y_values = df[\"y\"].to_numpy()\n",
    "motivation_values = df[\"motivation\"].to_numpy()\n",
    "value_values = df[\"value\"].to_numpy()\n",
    "\n",
    "first_frame = df[\"frame\"].min()\n",
    "df_first_frame = df[df[\"frame\"] == first_frame]\n",
    "x_values0 = df_first_frame[\"x\"].to_numpy()\n",
    "y_values0 = df_first_frame[\"y\"].to_numpy()\n",
    "value_values0 = df_first_frame[\"value\"].to_numpy()\n",
    "\n",
    "id0 = 71\n",
    "df_m_frame = df[df[\"frame\"] == first_frame]\n",
    "x_values_m0 = df_m_frame[\"x\"].to_numpy()\n",
    "y_values_m0 = df_m_frame[\"y\"].to_numpy()\n",
    "motivation_values0 = df_m_frame[\"motivation\"].to_numpy()\n",
    "\n",
    "fig, (ax1,ax2) = plt.subplots(1, 2, figsize=(10, 10))\n",
    "heatmap, xedges, yedges = np.histogram2d(\n",
    "    x_values_m0, y_values_m0, bins=50, weights=motivation_values0\n",
    ")\n",
    "\n",
    "im = ax1.imshow(heatmap.T, origin='lower', cmap='jet', extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]],vmin=0, vmax=max(motivation_values))\n",
    "plot_walkable_area(geometry, axes=ax1)\n",
    "plt.colorbar(im, ax=ax1, label='Motivation')\n",
    "print(f\"Max motivation: {max(motivation_values)}\")\n",
    "ax1.set_xlabel('X')\n",
    "ax1.set_ylabel('Y')\n",
    "ax1.set_title('Heatmap of Motivation Values')\n",
    "\n",
    "\n",
    "heatmap2, xedges2, yedges2 = np.histogram2d(\n",
    "    x_values0, y_values0, bins=50, weights=value_values0\n",
    ")\n",
    "im2 = ax2.imshow(\n",
    "    heatmap2.T,\n",
    "    origin=\"lower\",\n",
    "    cmap=\"jet\",\n",
    "    extent=[xedges2[0], xedges2[-1], yedges2[0], yedges2[-1]],\n",
    "    vmin=0,\n",
    "    vmax=max(value_values0),\n",
    ")\n",
    "plot_walkable_area(geometry, axes=ax2)\n",
    "plt.colorbar(im2, ax=ax2, label=\"Value\")\n",
    "print(f\"Max value: {max(value_values)}\")\n",
    "ax2.set_xlabel(\"X\")\n",
    "ax2.set_ylabel(\"Y\")\n",
    "ax2.set_title(\"Heatmap of Value\")\n",
    "plt.savefig(\"files/figures/heatmap_value.pdf\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"id\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters\n",
    "width = 1\n",
    "\n",
    "# Generate distance values from 0 to 20 (you can adjust this range)\n",
    "distance_values = np.linspace(0, 10, 100)\n",
    "\n",
    "# Calculate probability for each distance value\n",
    "plt.figure(figsize=(8, 6))\n",
    "\n",
    "# for spatial_bias in [1, 5, 10]:\n",
    "#     probability_values = [math.exp(-spatial_bias * (d / distance_scale)) for d in distance_values]\n",
    "#     plt.plot(distance_values, probability_values, label=f\"{spatial_bias = }, {distance_scale = }\")\n",
    "\n",
    "for width in [1, 2, 3, 4, 5]:\n",
    "    distance_scale = -width / math.log(0.01)\n",
    "    probability_values = [math.exp(-(d / distance_scale)) for d in distance_values]\n",
    "    plt.plot(\n",
    "        distance_values,\n",
    "        probability_values,\n",
    "        \"--\",\n",
    "        label=f\"{distance_scale = :.1f}, {width = :.1f}\",\n",
    "    )\n",
    "\n",
    "\n",
    "# Labels and Title\n",
    "plt.xlabel(\"Distance\", fontsize=14)\n",
    "plt.ylabel(\"Probability\", fontsize=14)\n",
    "plt.title(\"Probability vs. Distance\", fontsize=16)\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "\n",
    "# Show plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Animation of trajectories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "walkable_area = pedpy.WalkableArea(geometry)\n",
    "for filename in filenames[0:1]:\n",
    "    df, frame_after_decrease = get_first_frame_pedestrian_passes_line(filename)\n",
    "    df[\"ox\"] = 0.0\n",
    "    df[\"oy\"] = 0.1\n",
    "    delta_frame = 20\n",
    "    start = frame_after_decrease - delta_frame\n",
    "    end = frame_after_decrease +  delta_frame\n",
    "    df = df[(df[\"frame\"] >= start) & (df[\"frame\"] <= end)]\n",
    "    trajectory_data = pedpy.TrajectoryData(df, frame_rate=50)\n",
    "    anim = animate(\n",
    "        trajectory_data,\n",
    "        walkable_area,\n",
    "        every_nth_frame=1,\n",
    "        title_note=f\"{extract_title(filename)}, start={frame_after_decrease}\",\n",
    "    )\n",
    "    anim.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Premovement frame\n",
    "\n",
    "calculate for each file the premovement frame for each pedestrian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = filenames[0]\n",
    "df = pd.read_csv(\n",
    "    filename, sep=\"\\t\", names=[\"id\", \"frame\", \"x\", \"y\", \"z\", \"m\"], comment=\"#\"\n",
    ")\n",
    "\n",
    "\n",
    "threshold = 0.1\n",
    "dy = 1\n",
    "ped = 70\n",
    "df_ped = df[(df[\"frame\"] >= frame_after_decrease) & (df[\"id\"] == ped)]\n",
    "\n",
    "\n",
    "def premovement_frame(df_ped, threshold, dy):\n",
    "    premovement_frame = pd.NA\n",
    "    while pd.isna(premovement_frame):\n",
    "        premovement_frame = df_ped[df_ped[\"y\"].diff(dy).abs() > threshold][\n",
    "            \"frame\"\n",
    "        ].min()\n",
    "        dy += 1\n",
    "    return premovement_frame, dy\n",
    "\n",
    "\n",
    "premovement_frame, dy = premovement_frame(df_ped, threshold, dy)\n",
    "\n",
    "print(f\"{premovement_frame = }, {dy = }\")\n",
    "plt.plot(df_ped[\"frame\"], df_ped[\"y\"], \"-k\", ms=1, alpha=0.6)\n",
    "plt.plot(\n",
    "    premovement_frame,\n",
    "    df_ped[df_ped[\"frame\"] == premovement_frame][\"y\"],\n",
    "    \"ro\",\n",
    "    label=\"Pre-movement frame\",\n",
    ")\n",
    "y_pos = df_ped[df_ped[\"frame\"] == premovement_frame][\"y\"].values[0]\n",
    "print(y_pos)\n",
    "plt.text(\n",
    "    premovement_frame,\n",
    "    y_pos,\n",
    "    f\"({premovement_frame}, {y_pos:.2f})\",\n",
    "    verticalalignment=\"bottom\",\n",
    "    horizontalalignment=\"right\",\n",
    ")\n",
    "plt.ylabel(\"Y Position\")\n",
    "plt.xlabel(\"Frame\")\n",
    "plt.title(f\"Pedestrian {ped}. {premovement_frame = }, {dy = }\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}