Animation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "00822b63-0511-4ff7-b855-21b1c54411a6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import animation\n",
    "from matplotlib.patches import Rectangle, Arrow\n",
    "import pandas\n",
    "from pathlib import Path\n",
    "import numpy as np\n",
    "from moviepy.editor import concatenate_videoclips, VideoFileClip\n",
    "from moviepy.video.fx import speedx\n",
    "import os\n",
    "import multiprocess as mp\n",
    "\n",
    "import Utilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e79438db-1e71-42e4-9203-d23c94d11217",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CP1 - 314 \n",
      "CP8 - 282 \n",
      "CP7 - 301 \n",
      "CP3 - 309 \n",
      "CP2 - 302 \n",
      "CP5 - 305 \n",
      "CP6 - 281 \n",
      "CP4 - 3 \n"
     ]
    }
   ],
   "source": [
    "csv_categorized = Utilities.GetCSVDictionary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "58a081b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "StartPosition_A=np.array([80.87,-75.15])\n",
    "StartPosition_B=np.array([-85.28,78.04])\n",
    "initial_Yaw_A = -89.999\n",
    "initial_Yaw_B = 148.662\n",
    "scenarioNumber='1'\n",
    "IdealPathA = \"IdealPathData/CP1_a.npz\"\n",
    "IdealPathB = \"IdealPathData/CP1_b.npz\"\n",
    "CombinedRender = [   #CP1\n",
    "\"ISR02\",\n",
    "\"ISR03\",\n",
    "\"ISR05\",\n",
    "\"ISR08\",\n",
    "\"ISR09\",\n",
    "\"ISR10\",\n",
    "\"ISR12\",\n",
    "\"ISR14\",\n",
    "\"ISR16\",\n",
    "\"ISR18\",\n",
    "\"ISR19\",\n",
    "\"ISR21\",\n",
    "\"ISR22\",\n",
    "\"ISR23\",\n",
    "\"ISR24\",\n",
    "\"ISR25\",\n",
    "\"ISR26\",\n",
    "\"ISR28\",\n",
    "\"ISR29\",\n",
    "\"ISR30\",\n",
    "\"ISR31\",\n",
    "\"ISR32\",\n",
    "\"ISR33\",\n",
    "\"ISR34\",\n",
    "\"ISR35\",\n",
    "\"ISR36\",\n",
    "\"ISR37\",\n",
    "\"ISR38\",\n",
    "\"ISR39\",\n",
    "\"ISR41\",\n",
    "\"ISR42\",\n",
    "\"NYC10\",\n",
    "\"NYC11\",\n",
    "\"NYC13\",\n",
    "\"NYC16\",\n",
    "\"NYC17\",\n",
    "\"NYC18\",\n",
    "\"NYC19\",\n",
    "\"NYC20\",\n",
    "\"NYC21\",\n",
    "\"NYC22\",\n",
    "\"NYC23\",\n",
    "\"NYC24\",\n",
    "\"NYC25\",\n",
    "\"NYC26\",\n",
    "\"NYC27\",\n",
    "\"NYC28\",\n",
    "\"NYC29\",\n",
    "\"NYC32\",\n",
    "\"NYC35\",\n",
    "\"NYC36\",\n",
    "\"NYC37\",\n",
    "\"NYC38\",\n",
    "\"NYC39\",\n",
    "\"NYC40\",\n",
    "\"NYC41\",\n",
    "\"NYC42\",\n",
    "\"NYC41\",\n",
    "\"NYC42\",\n",
    "\"NYC41\",\n",
    "\"NYC42\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "0a51bdef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ -0.3228     -17.61529259   0.34242066 ...  23.06765556   0.36710951\n",
      "   -1.57985495]\n",
      " [ -0.31946241 -17.478365     0.33881768 ...  22.92081778   0.35446165\n",
      "   -1.58055585]\n",
      " [ -0.3161995  -17.34287721   0.34042766 ...  22.77903987   0.34935508\n",
      "   -1.58106999]\n",
      " ...\n",
      " [ -3.95340917   0.42006685   0.43665663 ...  10.78831798   0.13035834\n",
      "   -1.60510101]\n",
      " [ -4.08062646   0.53974476   0.42736155 ...  10.73620532   0.10749777\n",
      "   -1.60603364]\n",
      " [ -4.20464899   0.65739031   0.40244837 ...  10.6932329    0.05465307\n",
      "   -1.60702106]]\n"
     ]
    }
   ],
   "source": [
    "data = np.load(IdealPathA)\n",
    "\n",
    "# List all arrays in the file\n",
    "print(data['states'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "ab4e5ae6",
   "metadata": {},
   "outputs": [],
   "source": [
    "StartPosition_A=np.array([81.03,-75.33])\n",
    "StartPosition_B=np.array([-87.6,88])\n",
    "initial_Yaw_A = -88.328\n",
    "initial_Yaw_B = 160.91\n",
    "scenarioNumber='5'\n",
    "CombinedRender = [#CP5\n",
    "\"ISR02\",\n",
    "\"ISR05\",\n",
    "\"ISR08\",\n",
    "\"ISR09\",\n",
    "\"ISR10\",\n",
    "\"ISR11\",\n",
    "\"ISR12\",\n",
    "\"ISR13\",\n",
    "\"ISR14\",\n",
    "\"ISR16\",\n",
    "\"ISR17\",\n",
    "\"ISR18\",\n",
    "\"ISR19\",\n",
    "\"ISR21\",\n",
    "\"ISR22\",\n",
    "\"ISR23\",\n",
    "\"ISR24\",\n",
    "\"ISR25\",\n",
    "\"ISR26\",\n",
    "\"ISR28\",\n",
    "\"ISR29\",\n",
    "\"ISR30\",\n",
    "\"ISR31\",\n",
    "\"ISR32\",\n",
    "\"ISR33\",\n",
    "\"ISR34\",\n",
    "\"ISR35\",\n",
    "\"ISR36\",\n",
    "\"ISR37\",\n",
    "\"ISR41\",\n",
    "\"ISR42\",\n",
    "\"NYC10\",\n",
    "\"NYC11\",\n",
    "\"NYC12\",\n",
    "\"NYC13\",\n",
    "\"NYC14\",\n",
    "\"NYC15\",\n",
    "\"NYC16\",\n",
    "\"NYC17\",\n",
    "\"NYC19\",\n",
    "\"NYC20\",\n",
    "\"NYC21\",\n",
    "\"NYC22\",\n",
    "\"NYC24\",\n",
    "\"NYC25\",\n",
    "\"NYC26\",\n",
    "\"NYC27\",\n",
    "\"NYC28\",\n",
    "\"NYC29\",\n",
    "\"NYC32\",\n",
    "\"NYC35\",\n",
    "\"NYC36\",\n",
    "\"NYC37\",\n",
    "\"NYC38\",\n",
    "\"NYC39\",\n",
    "\"NYC40\",\n",
    "\"NYC42\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "99e8fcee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "we got all files\n"
     ]
    }
   ],
   "source": [
    "\n",
    "renderdict={}\n",
    "for scen in csv_categorized[scenarioNumber]:\n",
    "    Name = scen.name\n",
    "    ScenarioName = Name\n",
    "    pair =Name.split('_')[1].split('-')[1]\n",
    "    if(pair in CombinedRender):\n",
    "        renderdict[pair] = scen\n",
    "a= [x for x in renderdict.keys() if x not in CombinedRender]   \n",
    "if(len(a)>0):\n",
    "    print(\"we are missing a file\",a)\n",
    "else:\n",
    "    print(\"we got all files\")\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "b0a159df",
   "metadata": {},
   "outputs": [],
   "source": [
    "cwd = os.getcwd()\n",
    "video_out = Path(cwd) / 'VideoPath'\n",
    "data_out = Path(cwd) / 'ComputedData'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "04eb825b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def yaw_san(val):\n",
    "    # Normalize val to the range of [0, 360)\n",
    "    val = val % 360\n",
    "    if val > 180:\n",
    "        # Adjust to (-180, 0]\n",
    "        return val - 360\n",
    "    return val\n",
    "\n",
    "def r_or(vector, angle):\n",
    "    \"\"\"\n",
    "    Rotate a 2D vector (x, z) around the origin by an angle in radians using NumPy.\n",
    "    \n",
    "    Parameters:\n",
    "    - x: The x-coordinate of the vector or an array of x-coordinates.\n",
    "    - z: The z-coordinate of the vector or an array of z-coordinates.\n",
    "    - angle: The rotation angle in radians.\n",
    "    \n",
    "    Returns:\n",
    "    - new_x: The x-coordinate of the rotated vector(s).\n",
    "    - new_z: The z-coordinate of the rotated vector(s).\n",
    "    \"\"\"\n",
    "    angle =np.deg2rad(angle)\n",
    "    rotation_matrix = np.array([[np.cos(angle), -np.sin(angle)],\n",
    "                                [np.sin(angle), np.cos(angle)]])\n",
    "    vectors = np.array(vector)\n",
    "    rotated_vectors = np.dot(rotation_matrix, vectors)\n",
    "    return rotated_vectors\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "30723b5f-5557-4661-9f8e-17591372ab02",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\n",
    "def DrawAnimationVideo(path,name,outputPath,RenderBackground=True):\n",
    "    print(f\"Starting with {name}!\")  \n",
    "    wantedDistanceWithin = 35\n",
    "    df = pandas.read_csv(path, sep=';')\n",
    "    #print(df.columns)\n",
    "    #return\n",
    "    if('Car PositionXA' not in df.columns):\n",
    "        print(pair, \"Could not compute missing colum\")\n",
    "        return\n",
    "    \n",
    "    firstItemIndex = 0\n",
    "    \n",
    "    offset_Head_A = StartPosition_A - np.array([df['HeadPosXA'].iloc[firstItemIndex],df['HeadPosZA'].iloc[firstItemIndex]])\n",
    "    temp_yaw_A = yaw_san(df['HeadrotYA'].iloc[firstItemIndex])\n",
    "    offset_Yaw_A = -yaw_san(yaw_san(initial_Yaw_A) - temp_yaw_A)\n",
    "    offset_Head_A = r_or(offset_Head_A,temp_yaw_A+offset_Yaw_A)\n",
    "\n",
    "    #temp_yaw_A,offset_Yaw_A,offset_Head_A\n",
    "    \n",
    "    offset_Head_B = StartPosition_B - np.array([df['HeadPosXB'].iloc[firstItemIndex],df['HeadPosZB'].iloc[firstItemIndex]])\n",
    "    #print(offset_Head_B,StartPosition_CP1_B,np.array([df['HeadPosXB'].iloc[0],df['HeadPosZB'].iloc[0]]))\n",
    "    temp_yaw_B = yaw_san(df['HeadrotYB'].iloc[firstItemIndex])\n",
    "    offset_Yaw_B = -yaw_san(yaw_san(initial_Yaw_B) - temp_yaw_B)\n",
    "    offset_Head_B = r_or(offset_Head_B,temp_yaw_B+offset_Yaw_B)\n",
    "\n",
    "\n",
    "    print(f\"A=> is: {temp_yaw_A}\\t should: {initial_Yaw_A }\\t offset: {offset_Yaw_A}, \")\n",
    "    print(f\"B=> is: {temp_yaw_B}\\t should: {initial_Yaw_B }\\t offset: {offset_Yaw_B}, \")\n",
    "    dfLimit = df[\\\n",
    "         ((df['HeadPosXA'] > -wantedDistanceWithin) & (df['HeadPosXA'] < wantedDistanceWithin)) \\\n",
    "            & ((df['HeadPosZA'] > -wantedDistanceWithin) & (df['HeadPosZA'] < wantedDistanceWithin))\\\n",
    "            & ((df['HeadPosXB'] > -wantedDistanceWithin) & (df['HeadPosXB'] < wantedDistanceWithin)) \\\n",
    "            & ((df['HeadPosZB'] > -wantedDistanceWithin) & (df['HeadPosZB'] < wantedDistanceWithin))]\n",
    "    frameCount = len(dfLimit)\n",
    "    length= dfLimit[\"ScenarioTime\"].iloc[-1] - dfLimit[\"ScenarioTime\"].iloc[0]\n",
    "    frameTime = length/frameCount\n",
    "    #print(f\"FrameTime:{frameTime}, frameCount:{frameCount}, length:{length}\")\n",
    "    \n",
    "\n",
    "    fig, ax = plt.subplots()\n",
    "    fig.set_size_inches(8, 8, True)\n",
    "    ax.set_title=name\n",
    "    ax.axis('equal')\n",
    "    ax.set(xlim=[-wantedDistanceWithin, wantedDistanceWithin], ylim=[-wantedDistanceWithin, wantedDistanceWithin], xlabel='x', ylabel='y')\n",
    "   \n",
    "    #scatA = ax.scatter(dfLimit['Car PositionXA'].iloc[0], dfLimit['Car PositionZA'].iloc[0], c=\"g\", s=5, label=f'A')\n",
    "\n",
    "    lineA, = ax.plot(dfLimit['HeadPosXA'].iloc[0], dfLimit['HeadPosZA'].iloc[0], color='r',label=f'A')\n",
    "    lineB, = ax.plot(dfLimit['HeadPosXB'].iloc[0], dfLimit['HeadPosZB'].iloc[0], color='b',label=f'B')\n",
    "    #scatB = ax.scatter(dfLimit['HeadPosXB'].iloc[0], dfLimit['HeadPosZB'].iloc[0], c=\"b\", s=5, label=f'B')\n",
    "    StartValueTime = dfLimit[\"ScenarioTime\"].iloc[0]\n",
    "    txt = ax.text(0,37,f\"{name} : {-StartValueTime+dfLimit[\"ScenarioTime\"].iloc[0]:.1f}\",fontsize=14,horizontalalignment='center',verticalalignment='center')\n",
    "    \n",
    "    if RenderBackground:\n",
    "        im = plt.imread(\"Background_SL.png\")\n",
    "        im = ax.imshow(im, extent=[-35, 35, -35,35])\n",
    "    \n",
    "    \n",
    "    width = 1.85\n",
    "    length = 4.6375\n",
    "    \n",
    "    yawA= yaw_san(-dfLimit['HeadrotYA'].iloc[0]+offset_Yaw_A)\n",
    "    offset_Box_A = -r_or([width/2,length/2],yawA)\n",
    "    offset_Head_A_tmp = r_or(offset_Head_A,yawA)\n",
    "    Point_X_A = dfLimit['HeadPosXA'].iloc[0]+offset_Box_A[0]+offset_Head_A_tmp[0]\n",
    "    Point_Z_A = dfLimit['HeadPosZA'].iloc[0]+offset_Box_A[1]+offset_Head_A_tmp[1]\n",
    "    rectA = ax.add_patch(Rectangle((Point_X_A, Point_Z_A),width,length,angle=yawA,rotation_point='xy'))\n",
    "    rectA.set_color([1,0,0,0.5])\n",
    "    \n",
    "\n",
    "    rectA_OG_yaw = dfLimit['Car RotationYA'].iloc[0]\n",
    "    offset_Box_A_OG = -r_or([width/2,length/2],rectA_OG_yaw)\n",
    "    rectA_OG = ax.add_patch(Rectangle(offset_Box_A_OG+(dfLimit['Car PositionXA'].iloc[0], dfLimit['Car PositionZA'].iloc[0]),width,length,angle=rectA_OG_yaw,rotation_point='xy'))\n",
    "    rectA_OG.set_color([0.8,0.8,0,0.25])\n",
    "\n",
    "\n",
    "\n",
    "    fwd=np.array([0,2])\n",
    "    fwd_tmp = r_or(fwd,yawA)\n",
    "    #arrowA = ax.add_patch(Arrow(Point_X_A, Point_Z_A, fwd_tmp[0], fwd_tmp[1],  head_width=0.1, head_length=0.1, fc='r', ec='r'))\n",
    "    \n",
    "\n",
    "    yawB=yaw_san(-dfLimit['HeadrotYB'].iloc[0]+offset_Yaw_B)\n",
    "    offset_Box_B = -r_or([width/2,length/2],yawB)\n",
    "    offset_Head_B_tmp = r_or(offset_Head_B,yawB)\n",
    "    Point_X_B = dfLimit['HeadPosXB'].iloc[0]+offset_Box_B[0]+offset_Head_B_tmp[0]\n",
    "    Point_Z_B = dfLimit['HeadPosZB'].iloc[0]+offset_Box_B[1]+offset_Head_B_tmp[1]\n",
    "    #print(f\"X: {dfLimit['HeadPosXB'].iloc[0]}   {offset_Box_B[0]}  {offset_Head_B_tmp[0]}\")\n",
    "\n",
    "    #print(f\"Z: {dfLimit['HeadPosZB'].iloc[0]}   {offset_Box_B[1]}  {offset_Head_B_tmp[1]}\")\n",
    "    rectB = ax.add_patch(Rectangle((Point_X_B,Point_Z_B),width,length,angle=yawB,rotation_point='xy'))\n",
    "    rectB.set_color([0,0,1,0.5])\n",
    "    \n",
    "    ax.legend()\n",
    "    def update(frame):\n",
    "        # update the scatter plot:\n",
    "        \n",
    "        lineA.set_data(dfLimit['HeadPosXA'].iloc[:frame], dfLimit['HeadPosZA'].iloc[:frame])\n",
    "        lineB.set_data(dfLimit['HeadPosXB'].iloc[:frame], dfLimit['HeadPosZB'].iloc[:frame])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "        txt.set_text(f\"{name} : {-StartValueTime+dfLimit[\"ScenarioTime\"].iloc[frame]:.1f}\")\n",
    "\n",
    "        \n",
    "        dataA = np.stack([dfLimit['HeadPosXA'].iloc[frame], dfLimit['HeadPosZA'].iloc[frame]]).T\n",
    "        yawA=yaw_san(-dfLimit['HeadrotYA'].iloc[frame]+offset_Yaw_A)\n",
    "        offset_Box_A = -r_or([width/2,length/2],yawA)\n",
    "        offset_Head_A_tmp = r_or(offset_Head_A,yawA)\n",
    "\n",
    "\n",
    "        #datatest = np.stack([dfLimit['Car PositionXA'].iloc[frame], dfLimit['Car PositionZA'].iloc[frame]]).T\n",
    "        #scatA.set_offsets(datatest)\n",
    "\n",
    "        fwd_tmp = r_or(fwd,yawA)\n",
    "        #arrowA.set_xy(dataA) #= ax.arrow(dataA[0], dataA[1], offset_Head_A_tmp[0]*10, offset_Head_A_tmp[1]*10,  head_width=0.1, head_length=0.1, fc='r', ec='r')\n",
    "    \n",
    "        rectA.set_xy(dataA+offset_Box_A+offset_Head_A_tmp)\n",
    "        rectA.set_angle(yawA)\n",
    "\n",
    "\n",
    "        rectA_OG_yaw = -dfLimit['Car RotationYA'].iloc[frame]\n",
    "        offset_Box_A_OG = -r_or([width/2,length/2],rectA_OG_yaw)\n",
    "        dataA_OG = np.stack([dfLimit['Car PositionXA'].iloc[frame], dfLimit['Car PositionZA'].iloc[frame]]).T\n",
    "        rectA_OG.set_xy(dataA_OG+offset_Box_A_OG)\n",
    "        rectA_OG.set_angle(rectA_OG_yaw)\n",
    "\n",
    "        dataB = np.stack([dfLimit['HeadPosXB'].iloc[frame], dfLimit['HeadPosZB'].iloc[frame]]).T\n",
    "        yawB=yaw_san(-dfLimit['HeadrotYB'].iloc[frame]+offset_Yaw_B)\n",
    "        offset_Box_B = -r_or([width/2,length/2],yawB)\n",
    "        offset_Head_B_tmp = r_or(offset_Head_B,yawB)\n",
    "        rectB.set_xy(dataB+offset_Box_B+offset_Head_B_tmp)\n",
    "        rectB.set_angle(yawB)\n",
    "\n",
    "\n",
    "        return (lineA,lineB,txt,rectA,rectB )#,arrowA)#,scatA)\n",
    "\n",
    "    ani = animation.FuncAnimation(fig=fig, func=update, frames=frameCount, interval=1000*frameTime)\n",
    "    ani.save(filename=outputPath, writer=\"ffmpeg\",dpi=100)\n",
    "    print(f\"Finished {name}!\")  \n",
    "\n",
    "def DrawAnimationVideo_Unpack(data):\n",
    "    return DrawAnimationVideo(data[0],data[1],data[2],data[3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7da91199-f24b-4c2e-86f0-ce2e71db017c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting with testScene!\n"
     ]
    }
   ],
   "source": [
    "testScene = \"NYC39\"\n",
    "test = DrawAnimationVideo(renderdict[testScene],\"testScene\",video_out / f\"scenario{scenarioNumber}-{testScene}_testScene.mp4\",True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02afe0e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "ToDoList=[]\n",
    "for pair in renderdict:\n",
    "    tmp = f\"ScenarioCP{scenarioNumber}-{pair}.mp4\"\n",
    "    ToDoList.append([renderdict[pair],tmp,video_out / tmp,False])\n",
    "\n",
    "with mp.Pool(10) as p:\n",
    "    print(\"starting work\")\n",
    "    result = p.map(DrawAnimationVideo_Unpack, ToDoList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "89b9deab",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def ReCompute(path,name,outpath):\n",
    "    #print(f\"Starting with {name}!\")  \n",
    "    wantedDistanceWithin = 35\n",
    "    df = pandas.read_csv(path, sep=';')\n",
    "    #print(df.columns)\n",
    "    if('Car PositionXA' not in df.columns):\n",
    "        print(pair, \"Could not compute missing colum\")\n",
    "        return\n",
    "    \n",
    "    \n",
    "    offset_Head_A = StartPosition_A - np.array([df['HeadPosXA'].iloc[0],df['HeadPosZA'].iloc[0]])\n",
    "    temp_yaw_A = yaw_san(df['HeadrotYA'].iloc[0])\n",
    "    offset_Yaw_A = -yaw_san(yaw_san(initial_Yaw_A) - temp_yaw_A)\n",
    "    offset_Head_A = r_or(offset_Head_A,temp_yaw_A+offset_Yaw_A)\n",
    "\n",
    "    \n",
    "    offset_Head_B = StartPosition_B - np.array([df['HeadPosXB'].iloc[0],df['HeadPosZB'].iloc[0]])\n",
    "    temp_yaw_B = yaw_san(df['HeadrotYB'].iloc[0])\n",
    "    offset_Yaw_B = -yaw_san(yaw_san(initial_Yaw_B) - temp_yaw_B)\n",
    "    offset_Head_B = r_or(offset_Head_B,temp_yaw_B+offset_Yaw_B)\n",
    "    \n",
    "    def transform_row(row):\n",
    "        # Compute the yaw after normalization and adjustment\n",
    "        yawA = yaw_san(-row['HeadrotYA'] + offset_Yaw_A)\n",
    "        offset_Head_A_tmp = r_or(offset_Head_A, yawA)\n",
    "        Point_X_A = row['HeadPosXA'] + offset_Head_A_tmp[0]\n",
    "        Point_Z_A = row['HeadPosZA'] + offset_Head_A_tmp[1]\n",
    "\n",
    "        yawB = yaw_san(-row['HeadrotYB'] + offset_Yaw_B)\n",
    "        offset_Head_B_tmp = r_or(offset_Head_B, yawA)\n",
    "        Point_X_B = row['HeadPosXB'] + offset_Head_B_tmp[0]\n",
    "        Point_Z_B = row['HeadPosZB'] + offset_Head_B_tmp[1]\n",
    "\n",
    "\n",
    "\n",
    "        return pandas.Series([Point_X_A, Point_Z_A,yawA,Point_X_B,Point_Z_B,yawB])\n",
    "    dfOut= pandas.DataFrame()\n",
    "    dfOut[['X_A', 'Z_A','yaw_A','X_B', 'Z_B','yaw_B']]  = df.apply(transform_row, axis=1)\n",
    "    dfOut['AccelA']= df['AccelA']\n",
    "    dfOut['AccelB']= df['AccelB']\n",
    "    dfOut['SteerA']= df['SteerA']\n",
    "    dfOut['SteerB']= df['SteerB']\n",
    "    dfOut.to_pickle(outpath)\n",
    "    \n",
    "def ReCompute_Unpack(data):\n",
    "    data = ReCompute(data[0],data[1],data[2])\n",
    "    return data[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "dd891fc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "testScene = \"NYC35\"\n",
    "test = ReCompute(renderdict[testScene],\"testScene\",\"./test.pikle\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "6bec0e16",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'NoneType' object has no attribute 'columns'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[63], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'columns'"
     ]
    }
   ],
   "source": [
    "test.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "3ecbbe38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NYC22\n",
      "NYC25\n",
      "NYC13\n",
      "NYC14\n",
      "ISR25\n",
      "NYC40\n",
      "ISR22\n",
      "ISR14\n",
      "ISR13\n",
      "NYC15\n",
      "NYC12\n",
      "NYC24\n",
      "ISR41\n",
      "ISR12\n",
      "ISR23\n",
      "ISR24\n",
      "ISR08\n",
      "ISR37\n",
      "ISR30\n",
      "NYC39\n",
      "NYC37\n",
      "ISR31\n",
      "ISR09\n",
      "ISR36\n",
      "NYC36\n",
      "NYC38\n",
      "ISR21\n",
      "ISR26\n",
      "ISR19\n",
      "ISR10\n",
      "ISR17\n",
      "ISR28\n",
      "NYC26\n",
      "NYC19\n",
      "NYC21\n",
      "NYC17\n",
      "NYC28\n",
      "NYC10\n",
      "ISR16\n",
      "ISR29\n",
      "ISR11\n",
      "NYC42\n",
      "ISR18\n",
      "NYC11\n",
      "NYC16\n",
      "NYC29\n",
      "NYC20\n",
      "NYC27\n",
      "ISR42\n",
      "ISR02\n",
      "ISR05\n",
      "ISR33\n",
      "ISR34\n",
      "NYC32\n",
      "NYC35\n",
      "ISR35\n",
      "ISR32\n"
     ]
    }
   ],
   "source": [
    "for pair in renderdict:\n",
    "    print(pair)\n",
    "    tmp = f\"ScenarioCP{scenarioNumber}-{pair}.pkl\"\n",
    "    path = data_out / tmp\n",
    "    ReCompute(renderdict[pair],tmp,path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "1444f561",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n"
     ]
    }
   ],
   "source": [
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "dfed6acc",
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [(j[0],j[1]) for j in result if j != None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "8a4ae9b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x127c69eb0>,\n",
       " <matplotlib.lines.Line2D at 0x128311910>]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1f900334",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "t:  67%|██████▋   | 5651/8472 [15:14<00:39, 72.31it/s, now=None]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /Users/dg/GitRepos/CrossCulturalDataAnalysis/VideoPath/speedUpcompleteVideoh264.mp4.\n",
      "Moviepy - Writing video /Users/dg/GitRepos/CrossCulturalDataAnalysis/VideoPath/speedUpcompleteVideoh264.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "t:  67%|██████▋   | 5651/8472 [20:49<00:39, 72.31it/s, now=None]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /Users/dg/GitRepos/CrossCulturalDataAnalysis/VideoPath/speedUpcompleteVideoh264.mp4\n"
     ]
    }
   ],
   "source": [
    "# Specify the directory containing the video files\n",
    "output_path = 'completeVideoh264.mp4'\n",
    "\n",
    "# Retrieve all video file paths and sort them by creation date\n",
    "video_files = [os.path.join(video_out, f) for f in os.listdir(video_out) if f.endswith(('.mp4', '.avi'))]\n",
    "video_files.sort(key=os.path.getctime)  # Change to os.path.basename for sorting by name\n",
    "\n",
    "# Create a list of VideoFileClip objects\n",
    "clips = [VideoFileClip(f) for f in video_files]\n",
    "\n",
    "# Concatenate the video clips\n",
    "final_clip = concatenate_videoclips(clips)\n",
    "\n",
    "# Write the result to the file system\n",
    "#final_clip.write_videofile(os.path.join(video_out , output_path),codec='libx264', audio=False)\n",
    "\n",
    "speed_up_clip = final_clip.speedx( 10)\n",
    "speed_up_clip.write_videofile(os.path.join(video_out , (\"speedUp\"+output_path)), codec='libx264', audio=False)\n",
    "\n",
    "\n",
    "# Free up resources\n",
    "final_clip.close()\n",
    "for clip in clips:\n",
    "    clip.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ba4ea08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initial forward vector pointing \"up\"\n",
    "forward_vector = np.array([1, 1])\n",
    "\n",
    "# Number of arrows\n",
    "num_arrows = 12\n",
    "\n",
    "# Prepare the plot\n",
    "fig, ax = plt.subplots(figsize=(5, 5))\n",
    "ax.set_xlim(-2, 2)\n",
    "ax.set_ylim(-2, 2)\n",
    "\n",
    "# Angle between each arrow\n",
    "angle_increment = 360 / num_arrows\n",
    "\n",
    "for i in range(num_arrows):\n",
    "    angle = i * angle_increment\n",
    "    # Rotate the forward vector\n",
    "    x, z = r_or(forward_vector, angle)\n",
    "    # Draw the arrow\n",
    "    ax.arrow(0, 0, x, z, head_width=0.1, head_length=0.1, fc='k', ec='k')\n",
    "\n",
    "\n",
    "ax.arrow(1, 1, 0.1799, 0.4413,  head_width=0.1, head_length=0.1, fc='r', ec='r')\n",
    "ax.arrow(0, 0, 0.4412852, -0.1799362,  head_width=0.1, head_length=0.1, fc='b', ec='b')\n",
    "\n",
    "# Display the plot\n",
    "plt.grid(True)\n",
    "plt.axhline(0, color='black',linewidth=0.5)\n",
    "plt.axvline(0, color='black',linewidth=0.5)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba376927",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NYC42 Could not compute missing colum\n"
     ]
    }
   ],
   "source": [
    "outval = []\n",
    "for pair in renderdict:\n",
    "   \n",
    "    df = pandas.read_csv(renderdict[pair], sep=';')\n",
    "    if('Car PositionXA' not in df.columns):\n",
    "        print(pair, \"Could not compute missing colum\")\n",
    "        continue\n",
    "    x_A_Offset= df['Car PositionXA'].iloc[0]-df['HeadPosXA'].iloc[0]  \n",
    "    z_A_Offset= df['Car PositionZA'].iloc[0]-df['HeadPosZA'].iloc[0]  \n",
    "    outval.append([x_A_Offset,z_A_Offset])\n",
    "outval  = np.array(outval)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}