Update main.py

main.py

@@ -1,6 +1,8 @@
 import datetime
 import os
 import streamlit as st
+import numpy as np
+import math
 import fastf1
 import pandas as pd
 from fastapi import FastAPI
@@ -20,6 +22,153 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+import math
+import numpy as np
+def smooth_derivative(t_in, v_in):
+
+    #
+    # Function to compute a smooth estimation of a derivative.
+    # [REF: http://holoborodko.com/pavel/numerical-methods/numerical-derivative/smooth-low-noise-differentiators/]
+    #
+
+    # Configuration
+    #
+    # Derivative method: two options: 'smooth' or 'centered'. Smooth is more conservative
+    # but helps to supress the very noisy signals. 'centered' is more agressive but more noisy
+    method = "smooth"
+
+    t = t_in.copy()
+    v = v_in.copy()
+
+    # (0) Prepare inputs
+
+    # (0.1) Time needs to be transformed to seconds
+    try:
+        for i in range(0, t.size):
+            t.iloc[i] = t.iloc[i].total_seconds()
+    except:
+        pass
+
+    t = np.array(t)
+    v = np.array(v)
+
+    # (0.1) Assert they have the same size
+    assert t.size == v.size
+
+    # (0.2) Initialize output
+    dvdt = np.zeros(t.size)
+
+    # (1) Manually compute points out of the stencil
+
+    # (1.1) First point
+    dvdt[0] = (v[1] - v[0]) / (t[1] - t[0])
+
+    # (1.2) Second point
+    dvdt[1] = (v[2] - v[0]) / (t[2] - t[0])
+
+    # (1.3) Third point
+    dvdt[2] = (v[3] - v[1]) / (t[3] - t[1])
+
+    # (1.4) Last points
+    n = t.size
+    dvdt[n - 1] = (v[n - 1] - v[n - 2]) / (t[n - 1] - t[n - 2])
+    dvdt[n - 2] = (v[n - 1] - v[n - 3]) / (t[n - 1] - t[n - 3])
+    dvdt[n - 3] = (v[n - 2] - v[n - 4]) / (t[n - 2] - t[n - 4])
+
+    # (2) Compute the rest of the points
+    if method == "smooth":
+        c = [5.0 / 32.0, 4.0 / 32.0, 1.0 / 32.0]
+        for i in range(3, t.size - 3):
+            for j in range(1, 4):
+                dvdt[i] += (
+                    2 * j * c[j - 1] * (v[i + j] - v[i - j]) /
+                    (t[i + j] - t[i - j])
+                )
+    elif method == "centered":
+        for i in range(3, t.size - 2):
+            for j in range(1, 4):
+                dvdt[i] = (v[i + 1] - v[i - 1]) / (t[i + 1] - t[i - 1])
+
+    return dvdt
+
+
+def truncated_remainder(dividend, divisor):
+    divided_number = dividend / divisor
+    divided_number = (
+        -int(-divided_number) if divided_number < 0 else int(divided_number)
+    )
+
+    remainder = dividend - divisor * divided_number
+
+    return remainder
+
+
+def transform_to_pipi(input_angle):
+    pi = math.pi
+    revolutions = int((input_angle + np.sign(input_angle) * pi) / (2 * pi))
+
+    p1 = truncated_remainder(input_angle + np.sign(input_angle) * pi, 2 * pi)
+    p2 = (
+        np.sign(
+            np.sign(input_angle)
+            + 2
+            * (
+                np.sign(
+                    math.fabs(
+                        (truncated_remainder(input_angle + pi, 2 * pi)) / (2 * pi)
+                    )
+                )
+                - 1
+            )
+        )
+    ) * pi
+
+    output_angle = p1 - p2
+
+    return output_angle, revolutions
+
+
+def remove_acceleration_outliers(acc):
+
+    acc_threshold_g = 7.5
+    if math.fabs(acc[0]) > acc_threshold_g:
+        acc[0] = 0.0
+
+    for i in range(1, acc.size - 1):
+        if math.fabs(acc[i]) > acc_threshold_g:
+            acc[i] = acc[i - 1]
+
+    if math.fabs(acc[-1]) > acc_threshold_g:
+        acc[-1] = acc[-2]
+
+    return acc
+
+
+def compute_accelerations(telemetry):
+
+    v = np.array(telemetry["Speed"]) / 3.6
+    lon_acc = smooth_derivative(telemetry["Time"], v) / 9.81
+
+    dx = smooth_derivative(telemetry["Distance"], telemetry["X"])
+    dy = smooth_derivative(telemetry["Distance"], telemetry["Y"])
+
+    theta = np.zeros(dx.size)
+    theta[0] = math.atan2(dy[0], dx[0])
+    for i in range(0, dx.size):
+        theta[i] = (
+            theta[i - 1] +
+            transform_to_pipi(math.atan2(dy[i], dx[i]) - theta[i - 1])[0]
+        )
+
+    kappa = smooth_derivative(telemetry["Distance"], theta)
+    lat_acc = v * v * kappa / 9.81
+
+    # Remove outliers
+    lon_acc = remove_acceleration_outliers(lon_acc)
+    lat_acc = remove_acceleration_outliers(lat_acc)
+
+    return lon_acc, lat_acc
+
 @st.cache_data
 @app.get("/", response_model=None)
 async def root():
@@ -150,6 +299,11 @@ def telemetry_data(year: int, event: str | int, session: str, driver: str, lap_n
     selected_lap = driver_laps[driver_laps.LapNumber == lap_number]
 
     telemetry = selected_lap.get_telemetry()
+    
+    lon_acc, lat_acc = compute_accelerations(telemetry)    
+    telemetry["lon_acc"] = lon_acc
+    telemetry["lat_acc"] = lat_acc
+    
     telemetry['Time'] =  telemetry['Time'].dt.total_seconds()
     
     laptime = selected_lap.LapTime.values[0]
@@ -165,6 +319,8 @@ def telemetry_data(year: int, event: str | int, session: str, driver: str, lap_n
     throttle_tel = []
     time_tel = []
     track_map = []
+    lon_acc_tel = []
+    lat_acc_tel = []
     
     for _, row in telemetry.iterrows():
         
@@ -202,11 +358,23 @@ def telemetry_data(year: int, event: str | int, session: str, driver: str, lap_n
                     "y": row['Time'],
                     } 
         time_tel.append(time)
+
+        lon_acc = {"x": row['Distance'],
+                    "y": row['lon_acc'],
+                    } 
+        lon_acc_tel.append(lon_acc)
+
+        lat_acc = {"x": row['Distance'],
+                    "y": row['lat_acc'],
+                    } 
+        lat_acc_tel.append(lat_acc)
         
         track = {"x": row['X'],
                     "y": row['Y'],
                     } 
         track_map.append(track)
+
+        
         
     telemetry_data = {
         "telemetryData":{
@@ -218,6 +386,8 @@ def telemetry_data(year: int, event: str | int, session: str, driver: str, lap_n
             "speed": speed_tel,
             "throttle": throttle_tel,
             "time": time_tel,
+            "lon_acc": lon_acc_tel,
+            "lat_acc": lat_acc_tel
             "trackMap": track_map,
         }
     }