Upload 11 files

analysis/Curve.py

@@ -0,0 +1,844 @@
+import math
+from typing import List, Optional, Any, Tuple
+import numpy as np
+import matplotlib.pyplot as plt
+import warnings
+
+
+class Curve:
+         
+    def __init__(
+        self,
+        corner_id: int,
+        current_corner_dist: float,
+        lower_bound: float,
+        upper_bound: float,
+        compound: str,
+        life: int,
+        stint: int,
+        time: List[float],
+        rpm: List[float],
+        speed: List[float],
+        throttle: List[float],
+        brake: List[float],
+        distance: List[float],
+        acc_x: List[float],
+        acc_y: List[float],
+        acc_z: List[float],
+        x: List[float],
+        y: List[float],
+        z: List[float]
+    ):
+        self.corner_id = corner_id
+        self.current_corner_dist = current_corner_dist
+        self.lower_bound = lower_bound
+        self.upper_bound = upper_bound
+        self.time = np.asarray(time)
+        self.rpm = np.asarray(rpm)
+        self.speed = np.asarray(speed)
+        self.throttle = np.asarray(throttle)
+        self.brake = np.asarray(brake)
+        self.distance = np.asarray(distance)
+        self.acc_x = np.asarray(acc_x)
+        self.acc_y = np.asarray(acc_y)
+        self.acc_z = np.asarray(acc_z)
+        self.x = np.asarray(x)
+        self.y = np.asarray(y)
+        self.z = np.asarray(z)
+        self.compound = compound
+        self.life = life
+        self.stint = stint
+        self.latent_variable = None
+        self.num_cluster = None
+
+    @classmethod
+    def from_norm_data(
+        cls,
+        sample: np.ndarray,
+        mask: np.ndarray,
+        mean: np.ndarray,
+        std: np.ndarray,
+        latent_variable: Optional[List[float]] = None,
+        num_cluster: Optional[int] = None,
+    ):
+        """
+        sample: vettore 1D con layout:
+          0: life
+          1:51 speed
+          51:101 rpm
+          101:151 throttle
+          151:201 brake
+          201:251 acc_x
+          251:301 acc_y
+          301:351 acc_z
+          352,353: compound one-hot (hard/medium) altrimenti soft
+        mask: boolean mask compatibile (stesse slice)
+        """
+        compound = ""
+        # compound
+        if sample[352] != 0:
+            compound = "HARD"
+        elif sample[353] != 0:
+            compound = "INTERMEDIATE"
+        elif sample[354] != 0:
+            compound = "WET"
+        elif sample[355] != 0:
+            compound = "MEDIUM"
+        else:
+            compound = "SOFT"
+
+        bool_mask = mask.astype(bool)
+
+        life = int(sample[0])  # se life non è mascherato, meglio così
+        life = cls._denormalize_value(cls, life, mean[0], std[0]) 
+        
+        speed = cls._extract_and_denormalize(cls, 1, 51, sample, bool_mask, mean, std)
+        rpm = cls._extract_and_denormalize(cls, 51, 101, sample, bool_mask, mean, std)
+        throttle = cls._extract_and_denormalize(cls, 101, 151, sample, bool_mask, mean, std)
+        brake = cls._extract_and_denormalize(cls, 151, 201, sample, bool_mask, mean, std)
+        acc_x = cls._extract_and_denormalize(cls, 201, 251, sample, bool_mask, mean, std)
+        acc_y = cls._extract_and_denormalize(cls, 251, 301, sample, bool_mask, mean, std)
+        acc_z = cls._extract_and_denormalize(cls, 301, 351, sample, bool_mask, mean, std)
+
+        # Create the instance
+        instance = cls(
+            corner_id=-1,
+            current_corner_dist=-1,
+            lower_bound=-1,
+            upper_bound=-1,
+            compound=compound,
+            life=life,
+            stint=-1,
+            time=list(),
+            rpm=rpm,
+            speed=speed,
+            throttle=throttle,
+            brake=brake,
+            distance=list(),
+            acc_x=acc_x,
+            acc_y=acc_y,
+            acc_z=acc_z,
+            x=list(),
+            y=list(),
+            z=list()
+        )
+        
+        # Set optional attributes
+        instance.latent_variable = latent_variable
+        instance.num_cluster = num_cluster
+
+        
+        
+        return instance
+
+
+    #########################################################
+    #                   Metodi privati                      #
+    #########################################################
+
+    def _denormalize_array(self, arr: np.ndarray, mean: float, std: float) -> np.ndarray:
+        return (arr * std) + mean
+    
+    def _denormalize_value(self, value: float, mean: float, std: float) -> float:
+        return (value * std) + mean
+    
+    def _extract_and_denormalize(
+        self,
+        start: int,
+        end: int,
+        sample: np.ndarray,
+        bool_mask: np.ndarray,
+        mean: np.ndarray,
+        std: np.ndarray
+    ) -> list:
+        """
+        Estrae una porzione dell'array sample[start:end], applica la maschera e denormalizza.
+        
+        Args:
+            start: indice di inizio (incluso)
+            end: indice di fine (escluso)
+            sample: array completo dei dati normalizzati
+            bool_mask: maschera booleana per filtrare i valori validi
+            mean: array delle medie per la denormalizzazione
+            std: array delle deviazioni standard per la denormalizzazione
+        
+        Returns:
+            Lista dei valori estratti, filtrati e denormalizzati
+        """
+        extracted = sample[start:end][bool_mask[start:end]].tolist()
+        return self._denormalize_array(self, np.asarray(extracted), mean[start], std[start]).tolist()
+
+    def print(self):
+        print(f"[!] apex:{self.apex_dist}; start: {self.distance[0]} -> end: {self.distance[-1]}")
+
+    
+
+    #########################################################
+    #                   Metriche semplici                    #
+    #########################################################
+
+    def lateral_g(self) -> np.ndarray:
+        """G laterali (curva)"""
+        return self.acc_y / 9.81
+
+    def longitudinal_g(self) -> np.ndarray:
+        """G longitudinali (positivo=accelerazione, negativo=frenata)"""
+        return self.acc_x / 9.81
+
+    def vertical_g(self) -> np.ndarray:
+        """G verticali"""
+        return self.acc_z / 9.81
+
+    def total_g_xy(self) -> np.ndarray:
+        """G totali sul piano XY (grip utilizzato)"""
+        acc_total = np.sqrt(self.acc_x**2 + self.acc_y**2)
+        return acc_total / 9.81
+
+    def brake_intensity(self) -> np.ndarray:
+        """Intensità frenata (0 quando non frena, alto quando frena forte)"""
+        return self.brake * np.abs(np.minimum(self.acc_x, 0)) #confronta acc_x con zero e ritorna il più piccolo 
+
+    def throttle_rate(self) -> np.ndarray:
+        """Velocità di applicazione throttle (quanto velocemente apre/chiude)"""
+        return np.gradient(self.throttle)
+
+    def brake_time_percent(self) -> float:
+        """Percentuale tempo in frenata"""
+        return (np.sum(self.brake) / len(self.brake)) * 100
+
+    def full_throttle_percent(self) -> float:
+        """Percentuale tempo a gas spalancato (>95%)"""
+        return (np.sum(self.throttle > 95) / len(self.throttle)) * 100
+
+    def avg_speed(self) -> float:
+        """Velocità media"""
+        return np.mean(self.speed)
+
+    def max_speed(self) -> float:
+        """Velocità massima"""
+        return np.max(self.speed)
+
+    def tire_wear_total(self) -> float:
+        """Degrado totale gomme durante il periodo analizzato"""
+        if isinstance(self.life, (int, float, np.number)):
+            return 0.0
+        return self.life[0] - self.life[-1] if len(self.life) > 0 else 0
+
+    #########################################################
+    #                Metriche più complesse                 #
+    #########################################################
+
+    def grip_usage_percent(self, max_g: float = 6.5) -> np.ndarray:
+        """
+        Percentuale utilizzo cerchio di aderenza
+        max_g: massimo G teorico raggiungibile (default 6.5)
+        Ritorna: array con % utilizzo grip momento per momento
+        """
+        return (self.total_g_xy() / max_g) * 100
+
+    def aggressivity_index(self) -> np.ndarray:
+        """
+        Indice aggressività relativo al grip disponibile.
+        Stima quanto stai usando del grip residuo della gomma.
+        """
+        # Stima degradazione grip: perde circa 1.5-2% per giro
+        DEGRADATION_PER_LAP = 0.02  # 2% perdita grip per giro
+        
+        # Grip residuo stimato (da 1.0 a ~0.4 per gomme molto vecchie)
+        grip_remaining = max(1.0 - (self.life * DEGRADATION_PER_LAP), 0.4)
+        
+        # G massimi teorici (es. 6.5G) scalati per grip residuo
+        MAX_G = 6.5
+        available_g = MAX_G * grip_remaining
+        
+        # Quanto stai usando del grip disponibile
+        acc_total = np.sqrt(self.acc_x**2 + self.acc_y**2)
+        return (acc_total / available_g) * 100  # percentuale utilizzo
+
+    def smoothness_index(self, window: int = 20) -> float:
+        """
+        Indice di fluidità guida
+        Basso (< 0.3) = guida fluida, gestione
+        Alto (> 0.5) = guida nervosa, spinta al limite
+        """
+        acc_x = np.asarray(self.acc_x)
+        acc_y = np.asarray(self.acc_y)
+        acc_total = np.sqrt(acc_x**2 + acc_y**2)
+        
+        if len(acc_total) < window:
+            window = max(len(acc_total) // 2, 2)
+        
+        # Rolling standard deviation
+        rolling_std = np.array([np.std(acc_total[max(0, i-window):i+1]) for i in range(len(acc_total))])
+        mean_acc = np.mean(acc_total)
+        
+        return np.mean(rolling_std) / mean_acc if mean_acc > 0 else 0
+
+    def corner_speed_index(self, lateral_g_threshold: float = 0.3) -> float:
+        """
+        Velocità media nelle curve (dove G laterali > threshold)
+        Alto = entra veloce in curva (spingendo)
+        """
+        in_corner = np.abs(self.lateral_g()) > lateral_g_threshold
+        if not np.any(in_corner):
+            return 0.0
+        return np.mean(self.speed[in_corner])
+
+    def corner_aggression(self, lateral_g_threshold: float = 0.3) -> float:
+        """
+        Aggressività in curva = velocità × G laterali
+        Più alto = più aggressivo in curva
+        """
+        lateral_g = self.lateral_g()
+        in_corner = np.abs(lateral_g) > lateral_g_threshold
+        if not np.any(in_corner):
+            return 0.0
+        
+        avg_speed = np.mean(self.speed[in_corner])
+        avg_lat_g = np.mean(np.abs(lateral_g[in_corner]))
+        
+        return avg_speed * avg_lat_g
+
+    def tire_stress_score(self) -> float:
+        """
+        Score di stress sulle gomme
+        Combina accelerazione totale, velocità e usura
+        Gomme più vecchie = stress amplificato (più rischioso)
+        """
+        acc_total = np.sqrt(self.acc_x**2 + self.acc_y**2)
+        # Moltiplicatore usura: da 1.0 (gomma nuova) a ~2.0 (30 giri)
+        wear_multiplier = 1 + (self.life / 30)
+        stress = acc_total * self.speed * wear_multiplier
+        return np.mean(stress)
+
+    def braking_aggression(self) -> float:
+        """
+        Aggressività in frenata - Versione migliorata
+        Un pilota che spinge:
+        - Frena TARDI (alta velocità all'inizio frenata)
+        - Frena FORTE (alta decelerazione media)
+        - Frena BREVE (rilascio rapido)
+        """
+        brake = np.asarray(self.brake)
+        brake_mask = brake == 1
+        if not np.any(brake_mask):
+            return 0.0
+        
+        # 1. Decelerazione MEDIA durante frenata (non solo massima)
+        avg_decel_g = np.mean(np.abs(self.longitudinal_g()[brake_mask]))
+        
+        # 2. Velocità all'ingresso in frenata (più alta = più aggressivo)
+        speed_at_brake = np.mean(self.speed[brake_mask])
+        speed_factor = speed_at_brake / 300  # normalizza su 300 km/h
+        
+        # 3. "Brevità" frenata: meno tempo = più aggressivo (inversione)
+        brake_brevity = 1 - (self.brake_time_percent() / 100)
+        
+        # Score combinato (pesi da calibrare)
+        score = (avg_decel_g * 20) * speed_factor * (0.5 + brake_brevity)
+        
+        return np.clip(score, 0, 100)       
+            
+  
+    
+    def pushing_score(self) -> float:
+        """
+        SCORE PRINCIPALE: indica se sta spingendo (0-100)
+        
+        < 30: GESTIONE - Pilota conservativo, gestisce gomme/macchina
+        30-60: RITMO - Guida veloce ma controllata
+        > 60: SPINTA - Sta spingendo al limite
+        > 80: QUALIFICA - Massima spinta, un giro secco
+        """
+        # Grip usage assoluto (G totali vs max teorico)
+        grip_score = np.clip(np.mean(self.grip_usage_percent()), 0, 100)
+        
+        # Aggressivity: quanto stai usando del grip DISPONIBILE (considera usura gomme)
+        aggressivity_score = np.clip(np.mean(self.aggressivity_index()), 0, 100)
+        
+        # Smoothness: alto smoothness = guida nervosa = spinta alta
+        # (smoothness_index alto significa variazioni frequenti nelle accelerazioni)
+        smooth = self.smoothness_index()
+        smoothness_score = np.clip(smooth * 100, 0, 100)
+        
+        # Throttle usage
+        throttle_score = self.full_throttle_percent()
+        
+        # Corner aggression normalizzato
+        corner_agg = self.corner_aggression()
+        corner_score = np.clip(corner_agg * 0.5, 0, 100)
+        
+        # Braking aggression
+        brake_agg = self.braking_aggression()
+        brake_score = np.clip(brake_agg, 0, 100)
+        
+        # Fattore velocità: penalizza giri lenti (outlap, inlap, gestione estrema)
+        # Reference speed per curve F1: ~120 km/h media in curva durante spinta
+        avg_spd = self.avg_speed()
+        REFERENCE_SPEED = 120.0
+        speed_factor = np.clip(avg_spd / REFERENCE_SPEED, 0.0, 1.0)
+        
+        # Media ponderata - pesi ribilanciati:
+        # - grip e aggressivity pesano di più (sono la misura diretta dei G)
+        # - corner_score peso aumentato (riflette velocità in curva)
+        # - smoothness ridotto (meno affidabile come indicatore)
+        raw_score = (
+            grip_score * 0.25 +          # G assoluti - peso principale
+            aggressivity_score * 0.25 +  # G relativi al grip disponibile
+            throttle_score * 0.10 +      # Uso gas
+            corner_score * 0.20 +        # Aggressività in curva
+            brake_score * 0.10 +         # Aggressività frenata
+            smoothness_score * 0.10      # Variabilità guida
+        )
+        
+        # Applica penalità velocità: score finale scalato per speed_factor
+        total = raw_score * speed_factor
+        
+        return np.clip(total, 0, 100)
+    
+    def get_driving_mode(self) -> str:
+        """Restituisce il modo di guida attuale"""
+        score = self.pushing_score()
+        
+        if score < 30:
+            return "GESTIONE"
+        elif score < 50:
+            return "RITMO MEDIO"
+        elif score < 70:
+            return "SPINTA"
+        else:
+            return "MASSIMO ATTACCO"
+    
+    #########################################################
+    #                       Grafici                         #
+    #########################################################
+    
+    def plot_g_forces_map(self, figsize: Tuple[int, int] = (12, 10)):
+        """
+        Grafico 1: Mappa delle forze G (cerchio di aderenza)
+        Mostra come il pilota usa il grip disponibile
+        """
+        fig, axes = plt.subplots(2, 2, figsize=figsize)
+        fig.suptitle('ANALISI FORZE G E UTILIZZO GRIP', fontsize=16, fontweight='bold')
+        
+        # 1. Cerchio di aderenza (G plot)
+        ax = axes[0, 0]
+        scatter = ax.scatter(self.lateral_g(), self.longitudinal_g(), 
+                            c=self.speed, cmap='plasma', s=10, alpha=0.6)
+        
+        # Cerchio teorico massimo
+        theta = np.linspace(0, 2*np.pi, 100)
+        max_g = 5.0
+        ax.plot(max_g * np.cos(theta), max_g * np.sin(theta), 
+                'r--', linewidth=2, alpha=0.3, label=f'Limite teorico ({max_g}G)')
+        
+        ax.set_xlabel('G Laterali', fontweight='bold')
+        ax.set_ylabel('G Longitudinali', fontweight='bold')
+        ax.set_title('Cerchio di Aderenza')
+        ax.grid(True, alpha=0.3)
+        ax.axhline(0, color='k', linewidth=0.5)
+        ax.axvline(0, color='k', linewidth=0.5)
+        ax.legend()
+        plt.colorbar(scatter, ax=ax, label='Velocità (km/h)')
+        ax.set_aspect('equal')
+        
+        # 2. G totali nel tempo
+        ax = axes[0, 1]
+        time = np.arange(len(self.total_g_xy()))
+        ax.plot(time, self.total_g_xy(), color='#e74c3c', linewidth=1.5, label='G Totali')
+        ax.fill_between(time, 0, self.total_g_xy(), alpha=0.3, color='#e74c3c')
+        ax.set_xlabel('Campioni', fontweight='bold')
+        ax.set_ylabel('G Totali', fontweight='bold')
+        ax.set_title('G Totali nel Tempo')
+        ax.grid(True, alpha=0.3)
+        ax.legend()
+        
+        # 3. Utilizzo grip %
+        ax = axes[1, 0]
+        grip_usage = self.grip_usage_percent()
+        ax.plot(time, grip_usage, color='#3498db', linewidth=1.5)
+        ax.fill_between(time, 0, grip_usage, alpha=0.3, color='#3498db')
+        ax.axhline(80, color='orange', linestyle='--', linewidth=2, alpha=0.5, label='Soglia rischio')
+        ax.axhline(90, color='red', linestyle='--', linewidth=2, alpha=0.5, label='Limite')
+        ax.set_xlabel('Campioni', fontweight='bold')
+        ax.set_ylabel('Utilizzo Grip (%)', fontweight='bold')
+        ax.set_title('Percentuale Utilizzo Grip')
+        ax.set_ylim(0, 100)
+        ax.grid(True, alpha=0.3)
+        ax.legend()
+        
+        # 4. Distribuzione G laterali vs longitudinali
+        ax = axes[1, 1]
+        ax.hist2d(self.lateral_g(), self.longitudinal_g(), 
+                  bins=50, cmap='YlOrRd', alpha=0.8)
+        ax.set_xlabel('G Laterali', fontweight='bold')
+        ax.set_ylabel('G Longitudinali', fontweight='bold')
+        ax.set_title('Distribuzione Forze G (Heatmap)')
+        ax.grid(True, alpha=0.3)
+        
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", UserWarning)
+                fig.tight_layout()
+        except Exception:
+            pass
+        return fig
+    
+    def plot_driver_inputs(self, figsize: Tuple[int, int] = (14, 8)):
+        """
+        Grafico 2: Input del pilota (throttle, brake, steering proxy)
+        """
+        fig, axes = plt.subplots(3, 1, figsize=figsize, sharex=True)
+        fig.suptitle('INPUT DEL PILOTA', fontsize=16, fontweight='bold')
+        
+        time = np.arange(len(self.throttle))
+        
+        # 1. Throttle
+        ax = axes[0]
+        ax.fill_between(time, 0, self.throttle, color='#2ecc71', alpha=0.7, label='Throttle')
+        ax.set_ylabel('Throttle (%)', fontweight='bold')
+        ax.set_ylim(0, 100)
+        ax.grid(True, alpha=0.3)
+        ax.legend(loc='upper right')
+        ax.set_title(f'Gas Spalancato: {self.full_throttle_percent():.1f}% del tempo')
+        
+        # 2. Brake
+        ax = axes[1]
+        ax.fill_between(time, 0, self.brake * 100, color='#e74c3c', alpha=0.7, label='Brake')
+        ax.set_ylabel('Brake (On/Off)', fontweight='bold')
+        ax.set_ylim(0, 110)
+        ax.grid(True, alpha=0.3)
+        ax.legend(loc='upper right')
+        ax.set_title(f'Tempo in Frenata: {self.brake_time_percent():.1f}%')
+        
+        # 3. G Laterali (proxy per steering)
+        ax = axes[2]
+        ax.plot(time, self.lateral_g(), color='#9b59b6', linewidth=1, label='G Laterali')
+        ax.fill_between(time, 0, self.lateral_g(), where=self.lateral_g()>=0, 
+                        alpha=0.3, color='#9b59b6', interpolate=True)
+        ax.fill_between(time, 0, self.lateral_g(), where=self.lateral_g()<=0, 
+                        alpha=0.3, color='#e67e22', interpolate=True)
+        ax.set_xlabel('Campioni', fontweight='bold')
+        ax.set_ylabel('G Laterali', fontweight='bold')
+        ax.grid(True, alpha=0.3)
+        ax.legend(loc='upper right')
+        ax.axhline(0, color='k', linewidth=0.5)
+        
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", UserWarning)
+                fig.tight_layout()
+        except Exception:
+            pass
+        return fig
+    
+    def plot_tire_management(self, figsize: Tuple[int, int] = (14, 6)):
+        """
+        Grafico 3: Gestione gomme
+        """
+        fig, axes = plt.subplots(1, 3, figsize=figsize)
+        fig.suptitle('GESTIONE GOMME', fontsize=16, fontweight='bold')
+        
+        # Determina la lunghezza per l'asse temporale
+        telemetry_len = len(self.speed)
+        time = np.arange(telemetry_len)
+        
+        # Gestione life (può essere scalare o array)
+        life_data = np.asarray(self.life)
+        if life_data.ndim == 0:
+            life_plot = np.full(telemetry_len, self.life)
+        else:
+            life_plot = life_data
+            if len(life_plot) != telemetry_len:
+                # Se le lunghezze non coincidono, cerchiamo di interpolare o adattare
+                life_plot = np.interp(np.linspace(0, len(life_plot)-1, telemetry_len), 
+                                     np.arange(len(life_plot)), life_plot)
+
+        # 1. Vita gomme nel tempo
+        ax = axes[0]
+        ax.plot(time, life_plot, color='#e74c3c', linewidth=2, marker='o', 
+                markersize=2, label='Vita Gomme')
+        ax.fill_between(time, 0, life_plot, alpha=0.3, color='#e74c3c')
+        ax.axhline(20, color='orange', linestyle='--', alpha=0.5, label='Soglia critica')
+        ax.set_xlabel('Campioni', fontweight='bold')
+        ax.set_ylabel('Vita Gomme (%)', fontweight='bold')
+        ax.set_title(f'Degrado: {self.tire_wear_total():.1f}%')
+        ax.grid(True, alpha=0.3)
+        ax.legend()
+        ax.set_ylim(0, 100)
+        
+        # 2. Aggressivity Index
+        ax = axes[1]
+        agg_idx = self.aggressivity_index()
+        ax.plot(time, agg_idx, color='#f39c12', linewidth=1.5)
+        ax.fill_between(time, 0, agg_idx, alpha=0.3, color='#f39c12')
+        ax.set_xlabel('Campioni', fontweight='bold')
+        ax.set_ylabel('Aggressivity Index', fontweight='bold')
+        ax.set_title('Stress su Gomme vs Degrado')
+        ax.grid(True, alpha=0.3)
+        
+        # 3. Correlazione: Grip usage vs Tire life
+        ax = axes[2]
+        grip_usage = self.grip_usage_percent()
+        
+        # Assicuriamoci che grip_usage e life_plot abbiano la stessa dimensione
+        scatter = ax.scatter(life_plot, grip_usage, c=self.speed, 
+                            cmap='viridis', s=10, alpha=0.6)
+        ax.set_xlabel('Vita Gomme (%)', fontweight='bold')
+        ax.set_ylabel('Utilizzo Grip (%)', fontweight='bold')
+        ax.set_title('Grip Usage vs Tire Life')
+        ax.grid(True, alpha=0.3)
+        plt.colorbar(scatter, ax=ax, label='Velocità')
+        
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", UserWarning)
+                fig.tight_layout()
+        except Exception:
+            pass
+        return fig
+    
+    def plot_pushing_analysis(self, figsize: Tuple[int, int] = (14, 10)):
+        """
+        Grafico 4: ANALISI PRINCIPALE - Sta spingendo o gestendo?
+        """
+        fig = plt.figure(figsize=figsize)
+        gs = fig.add_gridspec(3, 3, hspace=0.3, wspace=0.3)
+        
+        pushing_score = self.pushing_score()
+        driving_mode = self.get_driving_mode()
+        
+        fig.suptitle(f'PUSHING ANALYSIS - Score: {pushing_score:.1f}/100 - {driving_mode}', 
+                     fontsize=18, fontweight='bold')
+        
+        # 1. Pushing Score Gauge (grande, in alto)
+        ax_gauge = fig.add_subplot(gs[0, :])
+        self._plot_gauge(ax_gauge, pushing_score)
+        
+        # 2. Metriche chiave
+        ax = fig.add_subplot(gs[1, 0])
+        metrics = {
+            'Grip Usage': np.mean(self.grip_usage_percent()),
+            'Throttle': self.full_throttle_percent(),
+            'Smoothness': (1 - self.smoothness_index()) * 100,
+            'Corner Agg': np.clip(self.corner_aggression() * 0.5, 0, 100),
+            'Brake Agg': np.clip(self.braking_aggression(), 0, 100)
+        }
+        
+        colors = ['#3498db', '#2ecc71', '#9b59b6', '#e67e22', '#e74c3c']
+        bars = ax.barh(list(metrics.keys()), list(metrics.values()), color=colors, alpha=0.7)
+        ax.set_xlabel('Score', fontweight='bold')
+        ax.set_title('Componenti Pushing Score')
+        ax.set_xlim(0, 100)
+        ax.grid(True, alpha=0.3, axis='x')
+        
+        # Aggiungi valori sulle barre
+        for i, (bar, val) in enumerate(zip(bars, metrics.values())):
+            ax.text(val + 2, i, f'{val:.1f}', va='center', fontweight='bold')
+        
+        # 3. Speed vs G totali
+        ax = fig.add_subplot(gs[1, 1])
+        scatter = ax.scatter(self.speed, self.total_g_xy(), 
+                            c=self.throttle, cmap='RdYlGn', s=15, alpha=0.6)
+        ax.set_xlabel('Velocità (km/h)', fontweight='bold')
+        ax.set_ylabel('G Totali', fontweight='bold')
+        ax.set_title('Velocità vs G Forces')
+        ax.grid(True, alpha=0.3)
+        plt.colorbar(scatter, ax=ax, label='Throttle %')
+        
+        # 4. Brake vs Throttle scatter
+        ax = fig.add_subplot(gs[1, 2])
+        brake_points = self.brake == 1
+        coast_points = (self.throttle < 10) & (self.brake == 0)
+        throttle_points = self.throttle > 10
+        
+        if np.any(brake_points):
+            ax.scatter(self.speed[brake_points], self.total_g_xy()[brake_points], 
+                      color='red', s=10, alpha=0.5, label='Brake')
+        if np.any(throttle_points):
+            ax.scatter(self.speed[throttle_points], self.total_g_xy()[throttle_points], 
+                      color='green', s=10, alpha=0.5, label='Throttle')
+        if np.any(coast_points):
+            ax.scatter(self.speed[coast_points], self.total_g_xy()[coast_points], 
+                      color='gray', s=10, alpha=0.3, label='Coast')
+        
+        ax.set_xlabel('Velocità (km/h)', fontweight='bold')
+        ax.set_ylabel('G Totali', fontweight='bold')
+        ax.set_title('Fasi di Guida')
+        handles, labels = ax.get_legend_handles_labels()
+        if labels:
+            ax.legend()
+        ax.grid(True, alpha=0.3)
+        
+        # 5. Timeline pushing intensity
+        ax = fig.add_subplot(gs[2, :])
+        time = np.arange(len(self.speed))
+        
+        # Calcola pushing intensity istantaneo
+        instant_push = self.grip_usage_percent()
+        
+        ax.fill_between(time, 0, instant_push, alpha=0.6, color='#e74c3c', label='Grip Usage %')
+        ax.plot(time, self.speed / self.speed.max() * 100, 
+                color='#3498db', linewidth=1.5, alpha=0.8, label='Velocità (norm)')
+        
+        # Evidenzia zone di massima spinta
+        high_push = instant_push > 70
+        if np.any(high_push):
+            ax.fill_between(time, 0, 100, where=high_push, 
+                           alpha=0.2, color='red', label='Zona Spinta Max')
+        
+        ax.set_xlabel('Campioni (Tempo)', fontweight='bold')
+        ax.set_ylabel('Intensità (%)', fontweight='bold')
+        ax.set_title('Timeline Intensità Spinta')
+        ax.set_ylim(0, 100)
+        handles, labels = ax.get_legend_handles_labels()
+        if labels:
+            ax.legend(loc='upper right')
+        ax.grid(True, alpha=0.3)
+        
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", UserWarning)
+                fig.tight_layout(rect=[0, 0.03, 1, 0.95])
+        except Exception:
+            pass
+        return fig
+    
+    def _plot_gauge(self, ax, value):
+        """Disegna un gauge per il pushing score"""
+        # Sfondo gauge
+        theta = np.linspace(0, np.pi, 100)
+        
+        # Arco di sfondo
+        ax.plot(np.cos(theta), np.sin(theta), 'lightgray', linewidth=20, solid_capstyle='round')
+        
+        # Arco colorato in base al valore
+        if value < 30:
+            color = '#2ecc71'  # Verde
+        elif value < 50:
+            color = '#f39c12'  # Giallo
+        elif value < 70:
+            color = '#e67e22'  # Arancione
+        else:
+            color = '#e74c3c'  # Rosso
+        
+        # Disegna l'arco fino al valore
+        theta_val = np.linspace(0, np.pi * (value/100), 50)
+        ax.plot(np.cos(theta_val), np.sin(theta_val), color, linewidth=20, solid_capstyle='round')
+        
+        # Testo centrale
+        ax.text(0, -0.3, f'{value:.1f}', ha='center', va='center', 
+                fontsize=48, fontweight='bold', color=color)
+        ax.text(0, -0.5, 'PUSHING SCORE', ha='center', va='center', 
+                fontsize=14, color='gray')
+        
+        # Etichette
+        ax.text(-1, 0, '0', ha='center', va='center', fontsize=12, fontweight='bold')
+        ax.text(1, 0, '100', ha='center', va='center', fontsize=12, fontweight='bold')
+        ax.text(-0.7, 0.7, 'GESTIONE', ha='center', va='center', fontsize=10, color='#2ecc71')
+        ax.text(0.7, 0.7, 'SPINTA', ha='center', va='center', fontsize=10, color='#e74c3c')
+        
+        ax.set_xlim(-1.5, 1.5)
+        ax.set_ylim(-0.7, 1.2)
+        ax.axis('off')
+        ax.set_aspect('equal')
+    
+    def plot_all(self, save_path: Optional[str] = None):
+        """
+        Genera tutti i grafici
+        save_path: se specificato, salva i grafici invece di mostrarli
+        """
+        if not save_path:
+            plt.close('all')
+            
+        print("Generazione grafici in corso...\n")
+        
+        # Grafico 1: G Forces
+        print("1/4 - Analisi Forze G...")
+        fig1 = self.plot_g_forces_map()
+        if save_path:
+            fig1.savefig(f'{save_path}_g_forces.png', dpi=150, bbox_inches='tight')
+            print(f"   ✓ Salvato: {save_path}_g_forces.png")
+        
+        # Grafico 2: Driver Inputs
+        print("2/4 - Input del Pilota...")
+        fig2 = self.plot_driver_inputs()
+        if save_path:
+            fig2.savefig(f'{save_path}_inputs.png', dpi=150, bbox_inches='tight')
+            print(f"   ✓ Salvato: {save_path}_inputs.png")
+        
+        # Grafico 3: Tire Management
+        print("3/4 - Gestione Gomme...")
+        fig3 = self.plot_tire_management()
+        if save_path:
+            fig3.savefig(f'{save_path}_tires.png', dpi=150, bbox_inches='tight')
+            print(f"   ✓ Salvato: {save_path}_tires.png")
+        
+        # Grafico 4: Pushing Analysis
+        print("4/4 - Analisi Spinta...")
+        fig4 = self.plot_pushing_analysis()
+        if save_path:
+            fig4.savefig(f'{save_path}_pushing.png', dpi=150, bbox_inches='tight')
+            print(f"   ✓ Salvato: {save_path}_pushing.png")
+        
+        print("\nTutti i grafici generati con successo!")
+        
+        if not save_path:
+            plt.show()
+            input("\n[INVIO per continuare...]")
+            plt.close('all')
+        else:
+            plt.close('all')
+    
+    def print_summary(self):
+        """Stampa un report testuale completo"""
+        pushing_score = self.pushing_score()
+        mode = self.get_driving_mode()
+        
+        print("=" * 60)
+        print("TELEMETRY ANALYSIS REPORT".center(60))
+        print("=" * 60)
+        print()
+        print(f"PUSHING SCORE: {pushing_score:.1f}/100")
+        print(f"DRIVING MODE:  {mode}")
+        print()
+        print("-" * 60)
+        print("METRICHE SEMPLICI:")
+        print("-" * 60)
+        print(f"  - Velocità Media:           {self.avg_speed():.1f} km/h")
+        print(f"  - Velocità Massima:         {self.max_speed():.1f} km/h")
+        print(f"  - Max G Laterali:           {np.max(np.abs(self.lateral_g())):.2f} G")
+        print(f"  - Max G Longitudinali:      {np.max(self.longitudinal_g()):.2f} G")
+        print(f"  - Max G Totali:             {np.max(self.total_g_xy()):.2f} G")
+        print(f"  - Tempo in Frenata:         {self.brake_time_percent():.1f}%")
+        print(f"  - Gas Spalancato:           {self.full_throttle_percent():.1f}%")
+        print(f"  - Degrado Gomme:            {self.tire_wear_total():.1f}%")
+        print()
+        print("-" * 60)
+        print("METRICHE COMPLESSE:")
+        print("-" * 60)
+        print(f"  • Utilizzo Grip Medio:      {np.mean(self.grip_usage_percent()):.1f}%")
+        print(f"  • Smoothness Index:         {self.smoothness_index():.3f}")
+        print(f"  • Aggressività Curve:       {self.corner_aggression():.1f}")
+        print(f"  • Aggressività Frenata:     {self.braking_aggression():.1f}")
+        print(f"  • Velocità in Curva:        {self.corner_speed_index():.1f} km/h")
+        print(f"  • Tire Stress Score:        {self.tire_stress_score():.1f}")
+        print()
+        print("=" * 60)
+        print()
+        
+        # Interpretazione
+        if pushing_score < 30:
+            print("INTERPRETAZIONE:")
+            print("   Il pilota sta GESTENDO. Guida conservativa,")
+            print("   probabilmente per preservare gomme o macchina.")
+        elif pushing_score < 50:
+            print("INTERPRETAZIONE:")
+            print("   Ritmo di GARA. Il pilota spinge ma in modo controllato.")
+        elif pushing_score < 70:
+            print("INTERPRETAZIONE:")
+            print("   Il pilota sta SPINGENDO. Vicino al limite della macchina.")
+        else:
+            print("INTERPRETAZIONE:")
+            print("   MASSIMO ATTACCO! Probabile giro di qualifica o sorpasso.")
+        print()

analysis/CurveDetector.py

@@ -0,0 +1,415 @@
+import json
+import os
+import matplotlib.pyplot as plt
+from src.analysis.Curve import Curve
+from src.analysis.utils_for_array import *
+import math
+import os
+
+
+
+
+class CurveDetector:
+    # ================== PARAMETRI DA TARARE (default) ==================
+    ACC_ENTER_THR_DEFAULT = 3.0    # entra in curva se |acc_y| > di questo
+    ACC_EXIT_THR_DEFAULT  = 2.5    # esci se |acc_y| < di questo (leggermente più basso = isteresi)
+    SMOOTH_WIN_DEFAULT    = 3      # smoothing su acc_y
+    MIN_SAMPLES_IN_CURVE_DEFAULT = 5   # minimo punti per dire che è davvero curva
+    MAX_SAMPLES_IN_CURVE_DEFAULT = 25 # grandezza massima curva
+    # ===================================================================
+
+    def __init__(
+        self,
+        telemetry_filename: str,
+        corners_filename: str,
+        acc_enter_thr: float = None,
+        acc_exit_thr: float = None,
+        smooth_win: int = None,
+        min_samples_in_curve: int = None,
+        max_samples_in_curve: int = None,
+    ):
+       
+        self.ACC_ENTER_THR = acc_enter_thr if acc_enter_thr is not None else self.ACC_ENTER_THR_DEFAULT
+        self.ACC_EXIT_THR  = acc_exit_thr  if acc_exit_thr  is not None else self.ACC_EXIT_THR_DEFAULT
+        self.SMOOTH_WIN    = smooth_win    if smooth_win    is not None else self.SMOOTH_WIN_DEFAULT
+        self.MIN_SAMPLES_IN_CURVE = (
+            min_samples_in_curve if min_samples_in_curve is not None else self.MIN_SAMPLES_IN_CURVE_DEFAULT
+        )
+        self.MAX_SAMPLES_IN_CURVE = (
+            max_samples_in_curve if max_samples_in_curve is not None else self.MAX_SAMPLES_IN_CURVE_DEFAULT
+        )
+
+        
+        self.telemetry_filename = telemetry_filename
+        self.corners_filename = corners_filename
+
+        # --- Tire Info Extraction ---
+        self.compound = "UNKNOWN"
+        self.tire_life = 0
+        self.stint = 0
+        
+        # --- 1) carico telemetria ---
+        with open(telemetry_filename, "r") as f:
+            tel_data = json.load(f)
+
+        tel = tel_data["tel"]
+        self.rpm = tel["rpm"]
+        self.speed = tel["speed"]
+        self.gear = tel["gear"]
+        self.acc_x = tel["acc_x"]
+        self.acc_z = tel["acc_z"]
+        self.x = tel["x"]
+        self.y = tel["y"]
+        self.z = tel["z"]
+        self.time = tel["time"]
+        self.acc_y = tel["acc_y"]
+        self.tel_dist = tel["distance"]
+        self.throttle = tel["throttle"]
+        self.brake = tel["brake"]
+        
+
+        # --- 2) carico corner map ---
+        with open(corners_filename, "r") as f:
+            corner_map = json.load(f)
+
+        self.corner_numbers = corner_map["CornerNumber"]
+        self.corner_distances = corner_map["Distance"]
+        self.corner_X = corner_map["X"]
+        self.corner_Y = corner_map["Y"]
+
+
+    # -------------------------------------------------------------
+
+
+    def distanza(self, p1, p2):
+        if len(p1) != len(p2):
+            raise ValueError("I due punti devono avere la stessa dimensione")
+        somma = 0
+
+        for a, b in zip(p1, p2):
+            somma += (b - a) ** 2
+        return math.sqrt(somma)
+
+    def nearest_point_index(self,xs, ys, cx, cy):
+        """Ritorna (idx, dist) del punto (xs[idx], ys[idx]) più vicino a (cx, cy)."""
+        best_idx = None
+        best_dist = float("inf")
+        for idx, (x, y) in enumerate(zip(xs, ys)):
+            d = self.distanza((x, y), (cx, cy))
+            if d < best_dist:
+                best_dist = d
+                best_idx = idx
+        return best_idx, best_dist
+
+    def compaund_and_life(self):
+
+        try:
+            dir_path = os.path.dirname(self.telemetry_filename)
+            base_name = os.path.basename(self.telemetry_filename)
+            # Extract lap number from filename (e.g., "12_tel.json" -> 12)
+            parts = base_name.split("_")
+            if parts[0].isdigit():
+                current_lap = int(parts[0]) - 1
+               
+                laptimes_path = os.path.join(dir_path, "laptimes.json")
+                if os.path.exists(laptimes_path):
+                    with open(laptimes_path, "r") as f:
+                        laptimes_data = json.load(f)
+                        
+                    if "lap" in laptimes_data:
+                        
+                        if current_lap != -1:
+                            if "compound" in laptimes_data:
+                                self.compound = laptimes_data["compound"][current_lap]
+                            if "life" in laptimes_data:
+                                self.tire_life = laptimes_data["life"][current_lap]
+                            if "stint" in laptimes_data:
+                                self.stint = laptimes_data["stint"][current_lap]
+
+        except Exception as e:
+            pass
+
+
+
+    def isApexInInterval(self, index_end, index_start):
+        if index_start > self.index_center_current_corner:
+            return False
+
+        if index_end < self.index_center_current_corner:
+            return False
+
+        return True
+
+    def getBounds(self, curve_number, corner_point, prev_corner, next_corner, n_corners):
+        DEFAULT_FIRST_DISTANCE_CURVE = 150
+        DEFAULT_LAST_DISTANCE_CURVE = 250
+
+        if curve_number == 0:
+            lower_bound = corner_point - DEFAULT_FIRST_DISTANCE_CURVE
+        else:
+            lower_bound = 0.5 * (prev_corner + corner_point)
+
+        if curve_number == n_corners - 1:
+            upper_bound = corner_point + DEFAULT_LAST_DISTANCE_CURVE
+        else:
+            upper_bound = 0.5 * (corner_point + next_corner)
+
+        return lower_bound, upper_bound
+
+    def getCurveWindow(self, start_win_idx, end_win_idx, curve_number):
+        in_curve = False
+        curve_start_idx = None
+        curve_end_idx = None
+
+        for idx in range(start_win_idx, end_win_idx + 1):
+            acc_smooth = avg_in_window(self.acc_y, idx, self.SMOOTH_WIN)
+            if not in_curve:
+                if acc_smooth >= self.ACC_ENTER_THR:
+                    in_curve = True
+                    curve_start_idx = idx
+            else:
+                if acc_smooth <= self.ACC_EXIT_THR:
+                    if not self.isApexInInterval( idx, curve_start_idx):
+                        in_curve = False
+                        curve_start_idx = None
+                    else:
+                        curve_end_idx = idx
+                        break
+         
+
+            # se sono arrivato alla fine finestra e sono ancora "in curva"
+            if in_curve and curve_end_idx is None:
+                curve_end_idx = end_win_idx
+
+        if curve_start_idx is not None:
+            if not self.isApexInInterval(curve_end_idx, curve_start_idx):
+                curve_end_idx = None
+                curve_start_idx = None 
+        
+        
+
+        return curve_start_idx, curve_end_idx
+
+    def calcolo_curve(self) -> list:
+
+        self.compaund_and_life()
+
+        detected_corners = []
+
+        n_corners = len(self.corner_distances)
+
+        for i in range(0,n_corners):
+
+            self.index_center_current_corner, _ = self.nearest_point_index(self.x,self.y ,self.corner_X[i],self.corner_Y[i])
+            current_corner_distance = self.tel_dist[self.index_center_current_corner]
+            
+            prev_center_curve = 0
+            next_center_curve = 0
+            
+            if (i > 0):
+                prev_index_center_current_corner, _ = self.nearest_point_index(self.x,self.y ,self.corner_X[i-1],self.corner_Y[i-1])
+                prev_center_curve = self.tel_dist[prev_index_center_current_corner]
+            if (i < n_corners - 1):
+                next_index_center_current_corner, _ = self.nearest_point_index(self.x,self.y ,self.corner_X[i+1],self.corner_Y[i+1])
+                next_center_curve = self.tel_dist[next_index_center_current_corner]
+
+            lower_bound, upper_bound = self.getBounds(i, current_corner_distance, prev_center_curve, next_center_curve, n_corners)
+
+
+            start_win_idx = find_frist_value(self.tel_dist, lower_bound)
+            end_win_idx = find_last_value(self.tel_dist, upper_bound)
+
+            curve_start_idx, curve_end_idx = self.getCurveWindow(start_win_idx, end_win_idx, i)
+
+
+            if curve_start_idx is not None and curve_end_idx is not None:
+                lenght_curve = curve_end_idx - curve_start_idx + 1
+                if lenght_curve >= self.MIN_SAMPLES_IN_CURVE:
+                  
+                    distance_from_start = self.index_center_current_corner - curve_start_idx
+                    distance_from_end   = curve_end_idx - self.index_center_current_corner
+
+                    MARGIN_BEFORE = 25   
+                    MARGIN_AFTER  = 25
+
+                    # se la curva inizia troppo lontano dall'apice → avvicino lo start
+                    if distance_from_start > MARGIN_BEFORE:
+                        curve_start_idx = self.index_center_current_corner - MARGIN_BEFORE
+
+                    # se la curva finisce troppo lontano dall'apice → avvicino l'end
+                    if distance_from_end > MARGIN_AFTER:
+                        curve_end_idx = self.index_center_current_corner + MARGIN_AFTER
+
+                            
+
+                    curve = Curve(
+                        corner_id=self.corner_numbers[i],
+                        current_corner_dist=current_corner_distance,
+                        lower_bound=lower_bound,
+                        upper_bound=upper_bound,
+                        compound=self.compound,
+                        life= self.tire_life,
+                        stint= self.stint,
+                        time=self.time[curve_start_idx:curve_end_idx],
+                        rpm=self.rpm[curve_start_idx:curve_end_idx],
+                        speed=self.speed[curve_start_idx:curve_end_idx],
+                        throttle=self.throttle[curve_start_idx:curve_end_idx],
+                        brake=self.brake[curve_start_idx:curve_end_idx],
+                        distance=self.tel_dist[curve_start_idx:curve_end_idx],
+                        acc_x=self.acc_x[curve_start_idx:curve_end_idx],
+                        acc_y=self.acc_y[curve_start_idx:curve_end_idx],
+                        acc_z=self.acc_z[curve_start_idx:curve_end_idx],
+                        x=self.x[curve_start_idx:curve_end_idx],
+                        y=self.y[curve_start_idx:curve_end_idx],
+                        z=self.z[curve_start_idx:curve_end_idx],
+                    )
+
+                    detected_corners.append(curve)
+
+        return detected_corners
+
+    def grafico(self, detected_corners, block=True):
+     
+        fig, ax1 = plt.subplots(figsize=(12, 5))
+
+        # acc_y
+        ax1.plot(self.time, self.acc_y, color='tab:blue', label='Acc Y (m/s²)')
+        ax1.set_xlabel('Tempo (s)')
+        ax1.set_ylabel('Acc Y (m/s²)', color='tab:blue')
+        ax1.tick_params(axis='y', labelcolor='tab:blue')
+
+        # secondo asse: throttle/brake
+        ax2 = ax1.twinx()
+        ax2.plot(self.time, self.throttle, color='tab:red', alpha=0.5, label='Throttle (%)')
+        ax2.plot(self.time, self.brake, color='tab:green', alpha=0.5, label='Brake (%)')
+        ax2.set_ylabel('Throttle / Brake (%)', color='tab:red')
+        ax2.tick_params(axis='y', labelcolor='tab:red')
+
+        i=0
+        for c in detected_corners:
+            # verticale del punto TEORICO (apice curva)
+           
+            theo_idx, _ = self.nearest_point_index(self.x, self.y, self.corner_X[i], self.corner_Y[i])
+            ax1.axvline(self.time[theo_idx], color='black', linestyle='--', linewidth=1, alpha=0.5)
+            i+=1
+            # finestra di ricerca [lower_bound, upper_bound]
+            left_idx = find_frist_value(self.tel_dist, c.lower_bound)
+            right_idx = find_last_value(self.tel_dist, c.upper_bound)
+            ax1.axvspan(self.time[left_idx], self.time[right_idx], color='gray', alpha=0.05)
+
+            # evidenzia la curva trovata (se presente)
+            if len(c.time) > 0:
+                ax1.axvspan(c.time[0], c.time[-1], color='orange', alpha=0.2)
+
+        # legenda
+        l1, lab1 = ax1.get_legend_handles_labels()
+        l2, lab2 = ax2.get_legend_handles_labels()
+        ax1.legend(l1 + l2, lab1 + lab2, loc='upper right')
+
+        ax1.set_title("Raffinamento curve con finestra per distanza")
+        fig.tight_layout()
+        plt.show(block=block)
+
+    def plot_curve_trajectories(self, detected_corners, show_apex=True, block=True):
+        """
+        Disegna la traiettoria XY del giro completo e, sopra,
+        evidenzia per ogni curva il tratto effettivo percorso dal pilota.
+
+        Parametri
+        ----------
+        detected_corners : list[Curve]
+            Lista di oggetti Curve restituiti da calcolo_curve().
+        show_apex : bool
+            Se True, marca anche il punto dell'apice per ogni curva.
+        """
+        fig, ax = plt.subplots(figsize=(8, 8))
+
+        # Disegno l'intero giro in grigio chiaro
+        ax.plot(self.x, self.y, linewidth=1, alpha=0.3, label="Giro completo")
+
+        # Per ogni curva, evidenzio la traiettoria dentro la curva
+        
+        for c in detected_corners:
+
+            # Traiettoria effettiva nella curva (già slice dell'intera telemetria)
+            ax.plot(c.x, c.y, linewidth=2, label=f"Curva {c.corner_id}")
+
+           
+            
+        i=0
+        for curve in self.corner_X:
+            try:
+                apex_idx_local = find_frist_value(c.distance, c.current_corner_dist)
+                apex_x = c.x[apex_idx_local]
+                apex_y = c.y[apex_idx_local]
+                apex_x = self.corner_X[i]
+                apex_y = self.corner_Y [i]
+                i+=1
+                ax.scatter(apex_x, apex_y, s=40, marker="x", color="red")
+                ax.text(
+                    apex_x,
+                    apex_y,
+                    f"{i}",
+                    fontsize=8,
+                    color="red",
+                    ha="left",
+                    va="bottom",
+                )
+            except Exception:
+                # Se qualcosa va storto, semplicemente non disegno il marker
+                pass
+        # i=0
+        # for curve in self.corner_distances:
+        #     try:
+        #         apex_idx_local = find_frist_value(self.tel_dist, curve)
+        #          print(f"{self.tel_dist[apex_idx_local]} distanza pilota")
+        #          print(f"{self.tel_dist[apex_idx_local]} distanza pilota")
+        #         apex_x = self.x[apex_idx_local]
+        #         apex_y = self.y[apex_idx_local]
+        #          print(f"n:{apex_x}, {apex_y}")
+        #         i+=1
+        #         ax.scatter(apex_x, apex_y, s=40, marker="x", color="blue")
+        #         ax.text(
+        #             apex_x,
+        #             apex_y,
+        #             f"{i}",
+        #             fontsize=8,
+        #             color="red",
+        #             ha="left",
+        #             va="bottom",
+        #         )
+        #     except Exception:
+        #         # Se qualcosa va storto, semplicemente non disegno il marker
+        #         pass
+        
+        
+        # --- nel tuo plotting ---
+        i = 0
+        for cx, cy in zip(self.corner_X, self.corner_Y):
+            try:
+                apex_idx_local, dmin = self.nearest_point_index(self.x, self.y, cx, cy)
+
+                # print(f"{apex_idx_local} indice (dist={dmin})")
+                apex_x = self.x[apex_idx_local]
+                apex_y = self.y[apex_idx_local]
+                # print(f"n:{apex_x}, {apex_y}")
+
+                i += 1
+                ax.scatter(apex_x, apex_y, s=40, marker="x", color="green")
+                ax.text(apex_x, apex_y, f"{i}", fontsize=8, color="red", ha="left", va="bottom")
+            except Exception:
+                pass
+        
+        ax.set_xlabel("X (m)")
+        ax.set_ylabel("Y (m)")
+        ax.set_title("Traiettoria in curva (XY)")
+
+        # Scala uguale sugli assi per non deformare la pista
+        ax.set_aspect("equal", adjustable="box")
+
+
+        plt.tight_layout()
+        plt.show(block=block)
+
+
+

analysis/__init__.py

@@ -0,0 +1,3 @@
+# Analysis subpackage - Data analysis and curve detection
+from src.analysis.Curve import Curve
+from src.analysis.CurveDetector import CurveDetector

analysis/dataset_builder.py

@@ -0,0 +1,470 @@
+import os
+import json
+import pandas as pd
+import numpy as np
+import logging
+import gc
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any
+
+from src.analysis.CurveDetector import CurveDetector
+
+# ============================================================================
+# CONSTANTS
+# ============================================================================
+BASE_DATA_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "data"))
+
+DEFAULT_OUTPUT_FILE = os.path.join(BASE_DATA_DIR, "dataset", "dataset_curves.csv")
+MAX_POINTS = 50
+PADDING_VALUE = -1000
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
+@dataclass
+class DatasetConfig:
+    """
+    Configuration for dataset building.
+    
+    Attributes:
+        years: List of years to include (e.g., [2024, 2025]). If None, includes all available.
+        drivers: List of driver codes to include (e.g., ["LEC", "HAM"]). If None, includes all.
+        sessions: List of sessions to process (e.g., ["Race", "Qualifying"]).
+        output_file: Path to the output CSV file.
+        max_points: Maximum number of data points per curve.
+        padding_value: Value used for padding shorter curves.
+    """
+    years: Optional[List[int]] = None
+    drivers: Optional[List[str]] = None
+    sessions: List[str] = field(default_factory=lambda: ["Race"])
+    output_file: str = DEFAULT_OUTPUT_FILE
+    max_points: int = MAX_POINTS
+    padding_value: float = PADDING_VALUE
+
+
+# ============================================================================
+# UTILITY FUNCTIONS
+# ============================================================================
+def get_padded_array(arr: Any, max_len: int = MAX_POINTS, padding: float = PADDING_VALUE) -> np.ndarray:
+    """
+    Pads or truncates an array to a fixed length.
+    
+    Args:
+        arr: Input array (list or numpy array).
+        max_len: Target length for the output array.
+        padding: Value used for padding.
+    
+    Returns:
+        Numpy array of length max_len.
+    """
+    if not isinstance(arr, (list, np.ndarray)):
+        arr = []
+    
+    arr = np.array(arr)
+    
+    if len(arr) == 0:
+        return np.full(max_len, padding)
+    
+    if len(arr) > max_len:
+        return arr[:max_len]
+    
+    return np.pad(arr, (0, max_len - len(arr)), 'constant', constant_values=padding)
+
+
+def get_data_directories(years: Optional[List[int]] = None) -> List[str]:
+    """
+    Gets data directories based on specified years.
+    
+    Args:
+        years: List of years to include. If None, scans for all available years.
+    
+    Returns:
+        List of absolute paths to data directories.
+    """
+    if years is None:
+        # Find all available year directories
+        directories = []
+        if os.path.exists(BASE_DATA_DIR):
+            for item in os.listdir(BASE_DATA_DIR):
+                item_path = os.path.join(BASE_DATA_DIR, item)
+                if os.path.isdir(item_path) and "-main" in item:
+                    directories.append(item_path)
+        return sorted(directories)
+    
+    # Build paths for specific years
+    return [
+        os.path.join(BASE_DATA_DIR, f"{year}-main")
+        for year in years
+    ]
+
+
+def find_corners_file(session_path: str) -> Optional[str]:
+    """
+    Finds the corners file in a session directory.
+    
+    Args:
+        session_path: Path to the session directory.
+    
+    Returns:
+        Path to corners file, or None if not found.
+    """
+    corners_file = os.path.join(session_path, "corners.json")
+    
+    if os.path.exists(corners_file):
+        return corners_file
+    
+    # Look for alternative corners files
+    candidates = [
+        f for f in os.listdir(session_path) 
+        if f.startswith("corners") and f.endswith(".json")
+    ]
+    
+    if candidates:
+        return os.path.join(session_path, candidates[0])
+    
+    return None
+
+
+# ============================================================================
+# CURVE PROCESSING
+# ============================================================================
+def extract_curve_data(
+    curve, 
+    detector: CurveDetector, 
+    gp_name: str, 
+    session: str, 
+    driver: str, 
+    lap_num: int,
+    config: DatasetConfig
+) -> Dict[str, Any]:
+    """
+    Extracts data from a single curve into a dictionary.
+    
+    Args:
+        curve: Curve object containing telemetry data.
+        detector: CurveDetector instance with compound/tire info.
+        gp_name: Name of the Grand Prix.
+        session: Session name (Race, Qualifying, etc.).
+        driver: Driver code.
+        lap_num: Lap number.
+        config: Dataset configuration.
+    
+    Returns:
+        Dictionary with curve data flattened for DataFrame.
+    """
+    # Basic metadata
+    curve_entry = {
+        "GrandPrix": gp_name,
+        "Session": session,
+        "Driver": driver,
+        "Lap": lap_num,
+        "CornerID": curve.corner_id,
+        "Compound": detector.compound,
+        "TireLife": detector.tire_life,
+        "Stint": detector.stint
+    }
+    
+    # Telemetry arrays to process
+    arrays_to_process = {
+        "speed": curve.speed,
+        "rpm": curve.rpm,
+        "throttle": curve.throttle,
+        "brake": curve.brake,
+        "acc_x": curve.acc_x,
+        "acc_y": curve.acc_y,
+        "acc_z": curve.acc_z,
+        "x": curve.x,
+        "y": curve.y,
+        "z": curve.z,
+        "distance": curve.distance,
+        "time": curve.time
+    }
+    
+    # Pad and flatten each array into columns
+    for name, arr in arrays_to_process.items():
+        padded = get_padded_array(arr, config.max_points, config.padding_value)
+        for i, value in enumerate(padded):
+            curve_entry[f"{name}_{i}"] = value
+    
+    return curve_entry
+
+
+def process_lap_telemetry(
+    telemetry_file: str,
+    corners_file: str,
+    gp_name: str,
+    session: str,
+    driver: str,
+    lap_num: int,
+    config: DatasetConfig
+) -> List[Dict[str, Any]]:
+    """
+    Processes a single lap's telemetry file.
+    
+    Args:
+        telemetry_file: Path to telemetry JSON file.
+        corners_file: Path to corners JSON file.
+        gp_name: Grand Prix name.
+        session: Session name.
+        driver: Driver code.
+        lap_num: Lap number.
+        config: Dataset configuration.
+    
+    Returns:
+        List of curve data dictionaries.
+    """
+    curves_data = []
+    
+    detector = CurveDetector(
+        telemetry_filename=telemetry_file,
+        corners_filename=corners_file
+    )
+    
+    curves = detector.calcolo_curve()
+    
+    for curve in curves:
+        curve_data = extract_curve_data(
+            curve, detector, gp_name, session, driver, lap_num, config
+        )
+        curves_data.append(curve_data)
+    
+    return curves_data
+
+
+def process_driver(
+    driver_path: str,
+    corners_file: str,
+    gp_name: str,
+    session: str,
+    driver: str,
+    config: DatasetConfig
+) -> List[Dict[str, Any]]:
+    """
+    Processes all laps for a single driver.
+    
+    Args:
+        driver_path: Path to driver's telemetry directory.
+        corners_file: Path to corners JSON file.
+        gp_name: Grand Prix name.
+        session: Session name.
+        driver: Driver code.
+        config: Dataset configuration.
+    
+    Returns:
+        List of curve data dictionaries.
+    """
+    driver_curves_data = []
+    
+    for filename in os.listdir(driver_path):
+        if not filename.endswith("_tel.json"):
+            continue
+        
+        parts = filename.split("_")
+        if not parts[0].isdigit():
+            continue
+        
+        try:
+            lap_num = int(parts[0])
+            telemetry_file = os.path.join(driver_path, filename)
+            
+            lap_data = process_lap_telemetry(
+                telemetry_file, corners_file, gp_name, session, driver, lap_num, config
+            )
+            driver_curves_data.extend(lap_data)
+            
+        except Exception as e:
+            logger.debug(f"Error processing {filename} for {driver}: {e}")
+            continue
+    
+    return driver_curves_data
+
+
+def process_session(
+    gp_path: str,
+    session: str,
+    config: DatasetConfig
+) -> List[Dict[str, Any]]:
+    """
+    Processes a single session (Race, Qualifying, etc.) for a Grand Prix.
+    
+    Args:
+        gp_path: Path to Grand Prix directory.
+        session: Session name to process.
+        config: Dataset configuration.
+    
+    Returns:
+        List of curve data dictionaries.
+    """
+    gp_name = os.path.basename(gp_path)
+    session_path = os.path.join(gp_path, session)
+    
+    if not os.path.exists(session_path):
+        return []
+    
+    corners_file = find_corners_file(session_path)
+    if not corners_file:
+        logger.warning(f"No corners file found for {gp_name}/{session}, skipping.")
+        return []
+    
+    logger.info(f"Processing {gp_name} - {session}...")
+    
+    session_curves_data = []
+    
+    # Determine which drivers to process
+    available_drivers = [
+        d for d in os.listdir(session_path) 
+        if os.path.isdir(os.path.join(session_path, d))
+    ]
+    
+    if config.drivers is not None:
+        drivers_to_process = [d for d in config.drivers if d in available_drivers]
+    else:
+        drivers_to_process = available_drivers
+    
+    for driver in drivers_to_process:
+        driver_path = os.path.join(session_path, driver)
+        
+        driver_data = process_driver(
+            driver_path, corners_file, gp_name, session, driver, config
+        )
+        session_curves_data.extend(driver_data)
+    
+    return session_curves_data
+
+
+def process_grand_prix(gp_path: str, config: DatasetConfig) -> List[Dict[str, Any]]:
+    """
+    Processes all configured sessions for a Grand Prix.
+    
+    Args:
+        gp_path: Path to Grand Prix directory.
+        config: Dataset configuration.
+    
+    Returns:
+        List of curve data dictionaries.
+    """
+    gp_curves_data = []
+    
+    for session in config.sessions:
+        session_data = process_session(gp_path, session, config)
+        gp_curves_data.extend(session_data)
+    
+    return gp_curves_data
+
+
+# ============================================================================
+# MAIN BUILDER
+# ============================================================================
+def build_dataset(config: Optional[DatasetConfig] = None) -> int:
+    """
+    Builds the complete dataset based on configuration.
+    
+    Args:
+        config: Dataset configuration. Uses defaults if None.
+    
+    Returns:
+        Total number of curves extracted.
+    """
+    if config is None:
+        config = DatasetConfig()
+    
+    # Ensure output directory exists
+    output_dir = os.path.dirname(config.output_file)
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Remove existing output file
+    if os.path.exists(config.output_file):
+        os.remove(config.output_file)
+        print(f"Removed existing output file: {config.output_file}")
+    
+    total_curves = 0
+    header_written = False
+    
+    # Get data directories
+    data_dirs = get_data_directories(config.years)
+    
+    for data_dir in data_dirs:
+        if not os.path.exists(data_dir):
+            print(f"Data directory not found, skipping: {data_dir}")
+            continue
+        
+        print(f"\n--- Processing data directory: {data_dir} ---")
+        
+        # Find Grand Prix directories
+        gp_dirs = sorted([
+            item for item in os.listdir(data_dir)
+            if os.path.isdir(os.path.join(data_dir, item)) and "Grand Prix" in item
+        ])
+        
+        for gp_name in gp_dirs:
+            gp_path = os.path.join(data_dir, gp_name)
+            
+            # Process Grand Prix
+            gp_data = process_grand_prix(gp_path, config)
+            
+            if not gp_data:
+                continue
+            
+            # Convert to DataFrame and save incrementally
+            print(f"Creating DataFrame...")
+            df = pd.DataFrame(gp_data)
+            
+            try:
+                print(f"Saving to CSV...")
+                df.to_csv(
+                    config.output_file, 
+                    mode='a', 
+                    index=False, 
+                    chunksize=10000,
+                    header=not header_written
+                )
+                header_written = True
+                
+                count = len(df)
+                total_curves += count
+                print(f"Saved {count} curves from {gp_name}. Total so far: {total_curves}")
+                
+                # Free memory
+                del df
+                del gp_data
+                gc.collect()
+                
+            except Exception as e:
+                print(f"Error saving CSV for {gp_name}: {e}")
+    
+    if total_curves == 0:
+        print("No curves extracted.")
+    else:
+        print(f"Finished processing. Total curves extracted: {total_curves}. Saved to {config.output_file}")
+    
+    return total_curves
+
+
+# ============================================================================
+# CLI ENTRY POINT
+# ============================================================================
+def main():
+    """
+    Main entry point with example configuration.
+    Modify the config below to customize data extraction.
+    """
+    # === CONFIGURATION ===
+    # Customize these settings as needed:
+    
+    config = DatasetConfig(
+        years=[2024, 2025],              # Years to include (None for all available)
+        drivers=None,                     # Driver codes to include (None for all)
+        sessions=["Qualifying", "Race"],  # Sessions to process
+        output_file=DEFAULT_OUTPUT_FILE,  # Output CSV path
+    )
+
+    # === RUN ===
+    build_dataset(config)
+
+
+if __name__ == "__main__":
+    main()

analysis/dataset_normalization.py

@@ -0,0 +1,520 @@
+import re
+import numpy as np
+import pandas as pd
+from dataclasses import dataclass
+from typing import Tuple, Optional, List, Dict
+
+
+# =============================================================================
+# CONFIGURATION
+# =============================================================================
+@dataclass
+class NormalizationConfig:
+    """Configuration for normalization operations."""
+    
+    # ----- Constants -----
+    padding_value: float = -1000.0
+    max_samples_per_curve: int = 50
+    compound_categories: tuple = ('HARD', 'INTERMEDIATE', 'WET', 'MEDIUM', 'SOFT')
+    
+    # ----- Dataset Paths (for script mode) -----
+    input_csv_path: str = "data/dataset/dataset_curves.csv"
+    output_dir: str = "data/dataset"
+    output_filename: str = "normalized_dataset.npz"
+
+
+# Default config instance
+DEFAULT_CONFIG = NormalizationConfig()
+
+# Export constants for backward compatibility
+PADDING_VALUE = DEFAULT_CONFIG.padding_value
+COMPOUND_CATEGORIES = list(DEFAULT_CONFIG.compound_categories)
+MAX_SAMPLES_PER_CURVE = DEFAULT_CONFIG.max_samples_per_curve
+
+
+# =============================================================================
+# SINGLE CURVE NORMALIZATION (for inference)
+# =============================================================================
+def pad_or_truncate(
+    arr, 
+    target_length: int, 
+    padding_value: float = PADDING_VALUE
+) -> list:
+    """
+    Pad or truncate an array to a target length.
+    
+    Args:
+        arr: Input array or list
+        target_length: Desired length
+        padding_value: Value to use for padding
+        
+    Returns:
+        List with exactly target_length elements
+    """
+    if hasattr(arr, 'tolist'):
+        arr = arr.tolist()
+    elif not isinstance(arr, list):
+        arr = list(arr)
+    
+    if len(arr) >= target_length:
+        return arr[:target_length]
+    return arr + [padding_value] * (target_length - len(arr))
+
+
+def curve_to_raw_features(
+    curve,
+    config: NormalizationConfig = None
+) -> np.ndarray:
+    """
+    Convert a Curve object to a raw (non-normalized) feature vector.
+    
+    Layout:
+      0: life
+      1:51 speed (50 columns)
+      51:101 rpm (50 columns)
+      101:151 throttle (50 columns)
+      151:201 brake (50 columns)
+      201:251 acc_x (50 columns)
+      251:301 acc_y (50 columns)
+      301:351 acc_z (50 columns)
+      351-355: Compound one-hot (HARD, INTERMEDIATE, WET, MEDIUM, SOFT)
+    
+    Args:
+        curve: Curve object from CurveDetector
+        config: Normalization configuration
+        
+    Returns:
+        Raw feature vector as numpy array
+    """
+    if config is None:
+        config = DEFAULT_CONFIG
+    
+    max_samples = config.max_samples_per_curve
+    padding = config.padding_value
+    categories = config.compound_categories
+    
+    # Prepare raw features with padding
+    life = curve.life if hasattr(curve, 'life') else 0
+    speed = pad_or_truncate(curve.speed, max_samples, padding)
+    rpm = pad_or_truncate(curve.rpm, max_samples, padding)
+    throttle = pad_or_truncate(curve.throttle, max_samples, padding)
+    brake = pad_or_truncate(curve.brake, max_samples, padding)
+    acc_x = pad_or_truncate(curve.acc_x, max_samples, padding)
+    acc_y = pad_or_truncate(curve.acc_y, max_samples, padding)
+    acc_z = pad_or_truncate(curve.acc_z, max_samples, padding)
+    
+    # Compound one-hot encoding
+    compound_one_hot = [
+        1.0 if curve.compound == cat else 0.0 
+        for cat in categories
+    ]
+    
+    # Build raw feature vector
+    raw_features = (
+        [life] + speed + rpm + throttle + brake + 
+        acc_x + acc_y + acc_z + compound_one_hot
+    )
+    
+    return np.array(raw_features, dtype=np.float64)
+
+
+def normalize_sample(
+    raw_features: np.ndarray,
+    mean: np.ndarray,
+    std: np.ndarray,
+    padding_value: float = PADDING_VALUE
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Normalize a single sample (feature vector) using pre-computed mean and std.
+    
+    Args:
+        raw_features: Raw feature vector as numpy array
+        mean: Mean values for normalization
+        std: Std values for normalization  
+        padding_value: Value used for padding
+        
+    Returns:
+        Tuple of (normalized_features, mask)
+    """
+    # Build mask (1 = valid, 0 = padding)
+    mask = np.array([
+        0.0 if val == padding_value else 1.0 
+        for val in raw_features
+    ], dtype=np.float64)
+    
+    # Z-score normalization
+    normalized = np.zeros_like(raw_features, dtype=np.float64)
+    for i in range(len(raw_features)):
+        if raw_features[i] != padding_value and std[i] != 0:
+            normalized[i] = (raw_features[i] - mean[i]) / std[i]
+        elif raw_features[i] == padding_value:
+            normalized[i] = 0.0  # Padding becomes 0
+    
+    return normalized, mask
+
+
+def normalize_curve(
+    curve,
+    mean: np.ndarray,
+    std: np.ndarray,
+    config: NormalizationConfig = None
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Convert a Curve object to a normalized feature vector.
+    
+    This is the main function to use for normalizing a single curve
+    during inference (e.g., in evaluate.py).
+    
+    Args:
+        curve: Curve object from CurveDetector
+        mean: Mean values for normalization (from dataset)
+        std: Std values for normalization (from dataset)
+        config: Normalization configuration
+        
+    Returns:
+        Tuple of (normalized_features, mask) as numpy arrays
+    """
+    if config is None:
+        config = DEFAULT_CONFIG
+    
+    # Get raw features
+    raw_features = curve_to_raw_features(curve, config)
+    
+    # Normalize using normalize_sample
+    normalized, mask = normalize_sample(
+        raw_features, mean, std, config.padding_value
+    )
+    
+    return normalized, mask
+
+
+def normalize_telemetry_json(
+    telemetry_path: str,
+    corners_path: str,
+    dataset_path: str,
+    config: NormalizationConfig = None
+) -> list:
+    """
+    Load telemetry JSON, detect curves, and normalize them.
+    
+    This is the HIGH-LEVEL function that does everything in one call:
+    1. Loads normalization stats from dataset
+    2. Detects curves from telemetry JSON
+    3. Normalizes each curve
+    
+    Args:
+        telemetry_path: Path to telemetry JSON file (e.g., "4_tel.json")
+        corners_path: Path to corners JSON file (e.g., "corners.json")
+        dataset_path: Path to normalized dataset .npz file (for mean/std)
+        config: Normalization configuration
+        
+    Returns:
+        List of dicts containing:
+        - 'curve': Original Curve object
+        - 'normalized': Normalized feature vector (np.ndarray)
+        - 'mask': Padding mask (np.ndarray)
+    
+    """
+    from src.analysis.CurveDetector import CurveDetector
+    
+    if config is None:
+        config = DEFAULT_CONFIG
+    
+    # Load normalization stats
+    data, mask, mean, std, columns = load_normalized_data(dataset_path)
+    
+    # Detect curves
+    detector = CurveDetector(telemetry_path, corners_path)
+    curves = detector.calcolo_curve()
+    
+    # Normalize each curve
+    results = []
+    for curve in curves:
+        normalized, curve_mask = normalize_curve(curve, mean, std, config)
+        results.append({
+            'curve': curve,
+            'normalized': normalized,
+            'mask': curve_mask
+        })
+    
+    return results
+
+
+# =============================================================================
+# DATASET NORMALIZATION (for training data preparation)
+# =============================================================================
+def one_hot_encode_compound(
+    df: pd.DataFrame, 
+    categories: List[str] = None
+) -> pd.DataFrame:
+    """
+    Perform one-hot encoding on the 'Compound' column.
+    
+    Args:
+        df: Input DataFrame
+        categories: List of compound categories to encode
+        
+    Returns:
+        DataFrame with 'Compound' column replaced by one-hot encoded columns
+    """
+    if categories is None:
+        categories = COMPOUND_CATEGORIES
+        
+    if 'Compound' not in df.columns:
+        return df
+    
+    df = df.copy()
+    compound_dummies = pd.get_dummies(df['Compound'], prefix='Compound', dtype=float)
+    
+    # Add missing columns and enforce order
+    for cat in categories:
+        col = f"Compound_{cat}"
+        if col not in compound_dummies.columns:
+            compound_dummies[col] = 0.0
+    
+    compound_dummies = compound_dummies[[f"Compound_{cat}" for cat in categories]]
+
+    df = pd.concat([df, compound_dummies], axis=1)
+    df = df.drop('Compound', axis=1)
+    
+    return df
+
+
+def create_padding_mask(
+    df: pd.DataFrame, 
+    padding_value: float = PADDING_VALUE
+) -> pd.DataFrame:
+    """
+    Create a mask where 1 = valid data, 0 = padding.
+    """
+    return (df != padding_value).astype(float)
+
+
+def compute_grouped_stats(
+    df: pd.DataFrame,
+    skip_prefixes: List[str] = None
+) -> Tuple[pd.Series, pd.Series]:
+    """
+    Compute mean and std for each column, grouping columns with same prefix.
+    
+    Columns ending with _<number> are grouped together and share the same
+    mean/std computed from all values in the group.
+    """
+    skip_prefixes = skip_prefixes or ["Compound"]
+    
+    mean_dict: Dict[str, float] = {}
+    std_dict: Dict[str, float] = {}
+    
+    grouped_cols: Dict[str, List[str]] = {}
+    single_cols: List[str] = []
+    
+    # Identify column groups (columns ending with _<number>)
+    for col in df.columns:
+        match = re.match(r"^(.*)_\d+$", col)
+        if match:
+            prefix = match.group(1)
+            if prefix not in grouped_cols:
+                grouped_cols[prefix] = []
+            grouped_cols[prefix].append(col)
+        else:
+            single_cols.append(col)
+    
+    # Process groups - compute global mean/std across all columns in group
+    for prefix, cols in grouped_cols.items():
+        group_data = df[cols].values.flatten()
+        g_mean = np.nanmean(group_data)
+        g_std = np.nanstd(group_data)
+        
+        if g_std == 0 or np.isnan(g_std):
+            g_std = 1.0
+            
+        for col in cols:
+            mean_dict[col] = g_mean
+            std_dict[col] = g_std
+    
+    # Process single columns
+    for col in single_cols:
+        # Skip normalization for specified prefixes
+        if any(skip in col for skip in skip_prefixes):
+            mean_dict[col] = 0.0
+            std_dict[col] = 1.0
+            continue
+        
+        val_mean = df[col].mean()
+        val_std = df[col].std()
+        
+        if pd.isna(val_std) or val_std == 0:
+            val_std = 1.0
+        if pd.isna(val_mean):
+            val_mean = 0.0
+            
+        mean_dict[col] = val_mean
+        std_dict[col] = val_std
+    
+    mean = pd.Series(mean_dict)[df.columns]
+    std = pd.Series(std_dict)[df.columns]
+    
+    return mean, std
+
+
+def normalize_dataframe(
+    df: pd.DataFrame,
+    config: NormalizationConfig = None,
+    apply_one_hot: bool = True,
+    skip_prefixes: List[str] = None,
+    return_stats: bool = True
+) -> Tuple[pd.DataFrame, pd.DataFrame, Optional[pd.Series], Optional[pd.Series]]:
+    """
+    Normalize a DataFrame using z-score normalization.
+    
+    This is the main function to use for normalizing an entire dataset
+    (e.g., for training data preparation).
+    
+    Performs:
+    1. One-hot encoding of 'Compound' column (if present and apply_one_hot=True)
+    2. Creation of padding mask
+    3. Grouped z-score normalization
+    
+    Args:
+        df: Input DataFrame to normalize
+        config: Normalization configuration
+        apply_one_hot: Whether to apply one-hot encoding to 'Compound' column
+        skip_prefixes: Column prefixes to skip during normalization
+        return_stats: Whether to return mean and std
+        
+    Returns:
+        Tuple of:
+        - Normalized DataFrame (padding replaced with 0.0)
+        - Mask DataFrame (1=valid, 0=padding)
+        - Mean Series (if return_stats=True, else None)
+        - Std Series (if return_stats=True, else None)
+    """
+    if config is None:
+        config = DEFAULT_CONFIG
+    
+    df = df.copy()
+    categories = list(config.compound_categories)
+    padding_value = config.padding_value
+    
+    # Apply one-hot encoding if needed
+    if apply_one_hot:
+        df = one_hot_encode_compound(df, categories)
+    
+    # Create mask before replacing padding
+    mask = create_padding_mask(df, padding_value)
+    
+    # Replace padding with NaN for stats calculation
+    df_for_stats = df.replace(padding_value, np.nan)
+    
+    # Compute grouped statistics
+    mean, std = compute_grouped_stats(df_for_stats, skip_prefixes)
+    
+    # Apply z-score normalization
+    df_normalized = (df_for_stats - mean) / std
+    df_normalized = df_normalized.fillna(0.0)
+    
+    if return_stats:
+        return df_normalized, mask, mean, std
+    else:
+        return df_normalized, mask, None, None
+
+
+def denormalize_dataframe(
+    df: pd.DataFrame,
+    mean: pd.Series,
+    std: pd.Series,
+    mask: Optional[pd.DataFrame] = None,
+    padding_value: float = PADDING_VALUE
+) -> pd.DataFrame:
+    """
+    Denormalize a DataFrame using stored mean and std.
+    """
+    df_denorm = (df * std) + mean
+    
+    if mask is not None:
+        df_denorm = df_denorm.where(mask == 1, padding_value)
+    
+    return df_denorm
+
+
+# =============================================================================
+# I/O FUNCTIONS
+# =============================================================================
+def save_normalized_data(
+    df_normalized: pd.DataFrame,
+    mask: pd.DataFrame,
+    mean: pd.Series,
+    std: pd.Series,
+    output_path: str
+) -> None:
+    """Save normalized data to .npz file."""
+    np.savez(
+        output_path,
+        data=df_normalized.values,
+        mask=mask.values,
+        mean=mean.values,
+        std=std.values,
+        columns=df_normalized.columns.values
+    )
+    print(f"Saved normalized data to {output_path}")
+
+
+def load_normalized_data(
+    input_path: str
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Load normalized data from .npz file.
+    
+    Returns:
+        Tuple of (data, mask, mean, std, columns)
+    """
+    loaded = np.load(input_path, allow_pickle=True)
+    return (
+        loaded['data'],
+        loaded['mask'],
+        loaded['mean'],
+        loaded['std'],
+        loaded['columns']
+    )
+
+
+# =============================================================================
+# SCRIPT MODE: Run as standalone script
+# =============================================================================
+if __name__ == "__main__":
+    # Configuration
+    config = NormalizationConfig(
+        input_csv_path="data/dataset/dataset_curves.csv",
+        output_dir="data/dataset",
+        output_filename="normalized_dataset.npz"
+    )
+    
+    # Load dataset
+    print(f"Loading CSV from {config.input_csv_path}...")
+    df = pd.read_csv(
+        config.input_csv_path,
+        sep=",",
+        encoding="utf-8",
+        decimal="."
+    )
+    
+    # Remove unnecessary columns
+    df = df.drop(df.columns[:5], axis=1)
+    df = df.drop(df.columns[2], axis=1)
+    
+    # Remove X, Y, Z columns
+    df = df.drop(df.columns[352:502], axis=1)
+    
+    # Remove time and distance columns
+    df = df.drop(df.columns[352:], axis=1)
+    
+    # Normalize
+    print("Normalizing dataset...")
+    df_normalized, mask, mean, std = normalize_dataframe(df, config)
+    
+    print(f"Normalized Data Shape: {df_normalized.shape}")
+    print(f"Mask Shape: {mask.shape}")
+    
+    # Save
+    output_path = f"{config.output_dir}/{config.output_filename}"
+    save_normalized_data(df_normalized, mask, mean, std, output_path)

analysis/utils_for_array.py

@@ -0,0 +1,30 @@
+import numpy as np
+
+
+def avg_in_window(arr, i, win):
+    start = max(0, i - win)
+    end = min(len(arr), i + win + 1)
+    vals = [abs(a) for a in arr[start:end]]
+    return sum(vals) / len(vals)
+
+def find_frist_value(array, value):
+    #primo indice dove array[i] >= value
+    for i, d in enumerate(array):
+        if d >= value:
+            return i
+    return len(array) - 1
+
+#Ritorna una indice
+def find_closest_value(array, value):
+    array = np.asarray(array)
+    return np.abs(array - value).argmin()
+
+def find_last_value(array, value):
+    #ultimo indice dove array[i] <= value
+    last = 0
+    for i, d in enumerate(array):
+        if d <= value:
+            last = i
+        else:
+            break
+    return last