Upload 26 files

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/demo_video.mp4 filter=lfs diff=lfs merge=lfs -text
+img/example.png filter=lfs diff=lfs merge=lfs -text
+img/verstappen_china_2025.jpg filter=lfs diff=lfs merge=lfs -text
+img/web1.jpg filter=lfs diff=lfs merge=lfs -text
+img/web2.jpg filter=lfs diff=lfs merge=lfs -text

.streamlit/config.toml

@@ -0,0 +1,37 @@
+[theme]
+base="dark"
+primaryColor="#ffffff"
+backgroundColor="#0e0e10"
+secondaryBackgroundColor="#1d1d21"
+textColor="#ffffff"
+font="sans serif"
+
+[server]
+maxUploadSize=200
+maxMessageSize=100
+enableCORS=false
+
+[browser]
+gatherUsageStats=false
+
+[runner]
+fastRerenderEnabled=false
+magicEnabled=true
+
+[logger]
+level="warning"
+
+[client]
+toolbarMode="minimal"
+showErrorDetails=false
+# Ocultar la barra de progreso (línea naranja)
+
+displayEnabled=false
+
+[global]
+dataFrameSerialization="arrow"
+
+# Desactivar elementos de la interfaz de usuario
+[ui]
+hideTopBar=true  # Oculta la barra superior completa
+

assets/demo_video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12f9865d3ac1b2f0a65e6bf175279b8b1c614aa8c4959acfd4565b1dd5c50317
+size 6081173

assets/style.css

@@ -0,0 +1,136 @@
+@import url('https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700&display=swap');
+
+/* Global styles 
+.stApp {
+    background: linear-gradient(135deg, #272730 0%, #000000 100%);
+}*/
+
+
+
+/* Button styles 
+.stButton button {
+    background: linear-gradient(90deg, #FF1E1E, #FF1E1E);
+    color: white;
+    border: none;
+    border-radius: 8px;
+    padding: 12px 24px;
+    font-family: 'Orbitron', sans-serif;
+    font-weight: 600;
+    letter-spacing: 1px;
+    text-transform: uppercase;
+    transition: all 0.3s ease;
+    align-items: center;
+}
+
+.stButton button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 5px 15px rgba(255, 30, 30, 0.4);
+}*/
+
+/* Tabs styling */
+.stTabs {
+    /*background: rgba(51, 49, 49, 0.4);*/
+    border-radius: 15px;
+    padding: 10px;
+    margin-bottom: 20px;
+}
+
+/* Center the tab container */
+.stTabs [data-testid="stTabsHeader"] {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+}
+
+/* Style for individual tabs */
+.stTab {
+    background: transparent !important;
+    color: #FFFFFF !important;
+    font-family: 'Orbitron', sans-serif;
+    margin: 0 5px;  /* Add some space between tabs */
+    min-width: 120px;  /* Set a minimum width for all tabs */
+    text-align: center;
+    padding: 8px 16px !important;  /* Add consistent padding */
+}
+
+.stTab[aria-selected="true"] {
+    background: linear-gradient(90deg, #FF1E1E, #FF8E53) !important;
+    color: white !important;
+    border-radius: 8px;
+}
+
+/* Make sure the tabs don't stretch too wide */
+.stTabs [role="tablist"] {
+    max-width: fit-content;
+    margin: 0 auto;
+}
+
+/* Ensure tab buttons have consistent width */
+.stTabs button[role="tab"] {
+    min-width: 200px;
+    display: inline-flex;
+    justify-content: center;
+}
+
+/* Input fields */
+.stNumberInput div {
+    background: rgba(36, 59, 85, 0.4);
+    border-radius: 8px;
+    padding: 5px;
+}
+
+.stTextInput div {
+    background: rgba(36, 59, 85, 0.4);
+    border-radius: 8px;
+    padding: 5px;
+}
+
+/* File uploader */
+.stUploader div {
+    background: rgba(36, 59, 85, 0.3);
+    border-radius: 8px;
+    padding: 10px;
+}
+
+/* DataFrame styling */
+.stDataFrame {
+    font-family: 'JetBrains Mono', monospace;
+    background: rgba(20, 30, 48, 0.4);
+    border-radius: 8px;
+    padding: 10px;
+}
+
+/* Estilo para imágenes redondeadas con sombras */
+img {
+    border-radius: 15px !important;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15) !important;
+    transition: transform 0.3s ease, box-shadow 0.3s ease !important;
+}
+
+img:hover {
+    transform: translateY(-3px) !important;
+    box-shadow: 0 8px 15px rgba(0, 0, 0, 0.2) !important;
+}
+
+/* Estilo para videos redondeados con sombras */
+.stVideo {
+    border-radius: 15px !important;
+    overflow: hidden !important;
+    box-shadow: 0 6px 18px rgba(0, 0, 0, 0.2) !important;
+}
+
+.stVideo > video {
+    border-radius: 15px !important;
+}
+
+
+
+
+@keyframes border-animation {
+    0% {
+        transform: rotate(0deg);
+    }
+    100% {
+        transform: rotate(360deg);
+    }
+}

models/best-224.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b098cf5d8646efd385df8186978289b1b5c617a181a42b490ea9933872a9945
+size 13123617

models/f1-steering-angle-model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afd3b47818d91146e09d1dfc495eaaa49122400c26b5e0c4b9cf4dd88259f88d
+size 17341463

models/f1-steering-angle-model_100.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d20f7509cd1a7dd1b74a77ce418a63f65531b6de2852ec8b58b07c315ca9bba
+size 17341463

navigation/soon.py

@@ -0,0 +1,87 @@
+import streamlit as st
+import streamlit as st
+import pandas as pd
+from pymongo import MongoClient
+from utils.ui_components import (
+    display_results,
+    create_line_chart
+)
+from utils.helper import client
+
+
+col1, col2,col3 = st.columns([1,3,1])
+
+with col2:
+    st.title("Data Base")
+
+    st.markdown("- All data is carefully matched to the start/finish lap")
+
+    if client is None:
+        st.warning("MongoDB client not connected. Please check your connection settings.")
+    else:
+        try:
+            collection = client["f1_data"]["steering_files"]
+
+            year = st.selectbox("Year", sorted(collection.distinct("year")),index=None,placeholder="Select year...",)
+
+            if year:
+
+                    
+                race = st.selectbox("Race", sorted(collection.distinct("race", {"year": year})),index=None,placeholder="Select race...")
+
+                if race:
+                
+                    session = st.selectbox("Session", sorted(collection.distinct("session", {"year": year, "race": race})),index=None,placeholder="Select session...")
+
+                    if session:
+                        driver = st.selectbox("Lap", sorted(collection.distinct("driver", {"year": year, "race": race, "session": session})),index=None,placeholder="Select lap")
+                        if driver:
+                                
+                            query = {
+                                "year": year,
+                                "race": race,
+                                "session": session,
+                                "driver": driver
+                            }
+                            doc = collection.find_one(query, {"_id": 0, "data": 1})
+
+                            if doc and doc["data"]:
+                                df = pd.DataFrame(doc["data"])
+                                #st.line_chart(df,x="time", y="steering_angle")
+                                #st.dataframe(df)
+
+                                
+                                st.markdown("# Results")
+
+                                with st.spinner("Processing frames..."):
+
+                                    display_results(df)
+
+                                    st.markdown("")
+                                    st.subheader("Steering Line Chart 📈")
+                                    # Create a Plotly figure
+
+                                    create_line_chart(df)
+
+                                    # Add steering angle statistics using Streamlit's built-in components
+                                    st.subheader("Steering Statistics 📊")
+                                    col1, col2, col3, col4 = st.columns(4)
+
+                                    with col1:
+                                        st.metric("Mean Angle", f"{df['steering_angle'].mean():.2f}°")
+
+                                    with col2:
+                                        st.metric("Max Right Turn", f"{df['steering_angle'].max():.2f}°")
+
+                                    with col3:
+                                        st.metric("Max Left Turn", f"{df['steering_angle'].min():.2f}°")
+
+                                    with col4:
+                                        # Calculate average rate of change of steering angle
+                                        angle_changes = abs(df['steering_angle'].diff().dropna())
+                                        st.metric("Avg. Change Rate", f"{angle_changes.mean():.2f}°/frame")
+                            else:
+                                st.warning("No se encontraron datos.")
+        except Exception as e:
+            st.error(f"Error at fetching data")
+            st.warning(f"If you are executing the app locally without the desktop app, you see this this message due to mongo keys")

navigation/steering-angle.py

@@ -0,0 +1,591 @@
+import streamlit as st
+import cv2
+import numpy as np
+from pathlib import Path
+import plotly.graph_objects as go
+from PIL import Image, ImageDraw
+from utils.video_processor import VideoProcessor
+from utils.model_handler import ModelHandler
+from utils.ui_components import (
+    create_header,
+    create_upload_section,
+    create_frame_selector,
+    display_results,
+    create_line_chart
+)
+from utils.video_processor import profiler
+
+
+if 'BASE_DIR' not in st.session_state:
+    from utils.helper import BASE_DIR,metrics_collection
+    st.session_state.BASE_DIR = BASE_DIR
+    print("BASE_DIR", BASE_DIR)
+
+if 'metrics_collection' not in st.session_state:
+    from utils.helper import BASE_DIR,metrics_collection
+    st.session_state.metrics_collection = metrics_collection
+    print("metrics_collection", metrics_collection)
+
+BASE_DIR = st.session_state.BASE_DIR
+metrics_collection = st.session_state.metrics_collection
+path_load_css = Path(BASE_DIR) / "assets" / "style.css"
+print(path_load_css)
+
+def load_css():
+    with open(Path(BASE_DIR) / "assets" / "style.css") as f:
+        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+
+
+def create_upload_section():
+    """Create the video upload section"""
+    st.markdown("<div class='glassmorphic-container'>", unsafe_allow_html=True)
+    uploaded_file = st.file_uploader(
+        "Upload Video",
+        type=['mp4', 'avi', 'mov'],
+        help="Upload onboard camera footage for analysis"
+    )
+    st.markdown("</div>", unsafe_allow_html=True)
+    return uploaded_file
+
+
+def clear_session_state():
+    """Clear unnecessary session state variables to free memory."""
+    keys_to_clear = ['video_processor', 'df', 'processed_frames', 'processed_frames1','end_dic', 'start_dic', 'start_preview', 'end_preview', 'start_preview1','end_frame_helper', 'start_frame_helper', 'start_frame', 'end_frame','driver_crop_type', 'driver_crop_type_2', 'start_frame_helper', 'end_frame_helper','postprocessing_mode']
+
+    for key in keys_to_clear:
+        if key in st.session_state:
+            del st.session_state[key]
+
+
+load_css()
+cont = 0
+
+
+
+col1, col2,col3 = st.columns([1,3,1])
+
+with col2:
+    st.title("F1 Steering Angle Model")
+
+    '''
+    [![Repo](https://badgen.net/badge/icon/GitHub?icon=github&label)](https://github.com/danielsaed/F1-steering-angle-predictor) 
+    [![Dataset on HF](https://huggingface.co/datasets/huggingface/badges/resolve/main/dataset-on-hf-md.svg)](https://huggingface.co/datasets/daniel-saed/f1-steering-angle)
+    '''
+    tabs = st.tabs(["Use Model", "About"])
+    # Initialize session state
+    if 'video_processor' not in st.session_state:
+        st.session_state.video_processor = VideoProcessor()
+    if 'model_handler' not in st.session_state:
+        st.session_state.model_handler = ModelHandler()
+    if 'fps_target' not in st.session_state:
+        st.session_state.fps_target = 10  # Default FPS target
+    if 'driver_crop_type' not in st.session_state:
+        st.session_state.driver_crop_type = None  # Default FPS target
+    if 'driver_crop_type_2' not in st.session_state:
+            st.session_state.driver_crop_type_2 = None  # Default FPS target
+    if 'start_frame' not in st.session_state:
+        st.session_state.start_frame = 0  # Default FPS target
+    if 'end_frame' not in st.session_state:
+        st.session_state.end_frame = -1  # Default FPS target
+    if 'start_preview' not in st.session_state:
+        st.session_state.start_preview = None
+    if 'end_preview' not in st.session_state:
+        st.session_state.end_preview = None
+    if 'start_preview1' not in st.session_state:
+        st.session_state.start_preview1 = None
+    if 'start_frame_helper' not in st.session_state:
+        st.session_state.start_frame_helper = 0
+    if 'end_frame_helper' not in st.session_state:
+        st.session_state.end_frame_helper = -1
+    if 'end_dic' not in st.session_state:
+        st.session_state.end_dic = None
+    if 'start_dic' not in st.session_state:
+        st.session_state.start_dic = None
+    if 'postprocessing_mode' not in st.session_state:
+        st.session_state.model_handler.postprocessing_mode = None
+
+
+
+    with tabs[0]:  # Steering Angle Detection tab
+        st.warning("Downloading or recording F1 onboards videos potentially violates F1/F1TV's terms of service.")
+        coll1, coll2,coll3 = st.columns([12,1,8])
+        with coll1:
+            st.markdown("#### Step 1: Upload F1 Onboard Video ⬆️")
+            st.markdown("")
+            st.markdown("Recomendations:")  
+            
+            st.markdown("- Check historical DB before, the lap may already be processed.")
+            st.markdown("- To record disable hardware aceleration on chrome.")
+            st.markdown("- Onboards with no steering wheel visibility, like Leclerc's 2025, may not work well.")
+
+
+            uploaded_file = create_upload_section()
+
+        with coll3:
+            st.markdown("<span style='margin-right: 18px;'><strong>Onboard example:</strong></span>", unsafe_allow_html=True)
+            st.markdown("- 1080p,720p,480p resolutions, 10 to 30 FPS.")
+            st.markdown("- Full onboard (mandatory).")
+            #st.markdown("( For testing, if needed )", unsafe_allow_html=True)
+
+            VIDEO_URL = Path(BASE_DIR) / "assets" / "demo_video.mp4"
+            st.video(VIDEO_URL)
+
+
+        if uploaded_file:
+            with st.spinner("Loading..."):
+                
+                st.markdown("")
+                st.markdown("")
+                st.markdown("")
+                st.markdown("")
+                st.markdown("")
+                st.markdown("")
+            # Load video
+                if st.session_state.video_processor.load_video(uploaded_file):
+                    
+
+                    if st.session_state.end_dic is None:
+                        st.session_state.end_dic = st.session_state.video_processor.frames_list_end
+                        print("End dic loaded:")
+
+                    if st.session_state.start_dic is None:
+                        st.session_state.start_dic = st.session_state.video_processor.frames_list_start
+                        print("Start dic loaded:")
+                    
+                    
+                    total_frames = st.session_state.video_processor.total_frames
+                    original_fps = st.session_state.video_processor.fps
+                    print("Original FPS:", original_fps)
+                    print("Total frames:", total_frames)
+
+
+                    
+                    # FPS selection dropdown - after video is loaded
+                    st.markdown("<div class='glassmorphic-container'>", unsafe_allow_html=True)
+
+
+                    st.markdown("#### Step 2: Select Start And End Frames ✂️")
+
+
+                    start_frame_min = 0
+                    start_frame_max = int(total_frames * 0.1)  # 10% del total
+                    end_frame_min = int(total_frames * 0.9)    # 90% del total
+                    end_frame_max = total_frames - 1
+                    if st.session_state.end_frame_helper == -1:
+                        st.session_state.end_frame_helper = end_frame_max
+                    
+                    # Actualizar los valores de session_state basándose en el slider
+                    st.markdown("- Match start & finish line")
+                    # CSS personalizado para los botones
+                    preview_cols1 = st.columns(2)
+
+                    with preview_cols1[0]:
+                        st.markdown("##### Start Frame")
+                        #slicer
+                        st.session_state.start_frame_helper = st.slider(
+                            "Select Start Frame",
+                            min_value=st.session_state.video_processor.start_frame_min,
+                            max_value=st.session_state.video_processor.start_frame_max,
+                            value=st.session_state.start_frame_helper,
+                            step=1,
+                            help="Select the start frame for processing",
+                            key="start_frame_slider"
+                        )
+                    with preview_cols1[1]:
+                        st.markdown("##### End Frame")
+                        st.session_state.end_frame_helper = st.slider(
+                            "Select Start Frame",
+                            min_value=st.session_state.video_processor.end_frame_min,
+                            max_value=st.session_state.video_processor.end_frame_max,
+                            value=st.session_state.end_frame_helper,
+                            step=1,
+                            help="Select the start frame for processing",
+                            key="end_frame_slider"
+                        )
+                        
+
+                    
+                    # Botones de control en la parte superior
+                    btn_cols = st.columns([1, 1, 5, 1, 1, 5])
+                    
+                    with btn_cols[0]:
+                        if st.button("-1",key="start_minus_1",use_container_width=True):
+                            st.session_state.start_frame_helper = max(start_frame_min, st.session_state.start_frame_helper - 1)
+                            st.rerun()  # Rerun to update the UI with the new value   
+                    with btn_cols[1]:
+                        if st.button("+1",key="start_plus_1",use_container_width=True):
+                            st.session_state.start_frame_helper = min(start_frame_max, st.session_state.start_frame_helper + 1)
+                            st.rerun()  # Rerun to update the UI with the new value       
+                    with btn_cols[3]:
+                        if st.button("-1", key="end_minus_1",
+                                help="Decrease end frame by 1",
+                                use_container_width=True):
+                            st.session_state.end_frame_helper = max(end_frame_min, st.session_state.end_frame_helper - 1)
+                            st.rerun()  # Rerun to update the UI with the new value  
+                    with btn_cols[4]:
+                        if st.button("+1", key="end_plus_1",
+                                help="Increase end frame by 1", 
+                                use_container_width=True):
+                            st.session_state.end_frame_helper = min(end_frame_max, st.session_state.end_frame_helper + 1)
+                            st.rerun()
+
+
+                    print("Start frame helper:", st.session_state.end_frame_helper)
+                    print("Start frame helper:", st.session_state.end_frame)
+
+                    
+                    
+                    # Añadir un poco de espacio entre botones y previsualizaciones
+                    st.markdown("<br>", unsafe_allow_html=True)
+                    
+                    # Preview columns originales (mantener tu código existente)
+                    preview_cols = st.columns(2)
+                    
+                    # Start frame preview
+                    with preview_cols[0]:
+                    
+                        # Siempre verificar si necesitamos actualizar la previsualización
+                        if (st.session_state.start_preview is None or 
+                            st.session_state.start_frame_helper != st.session_state.start_frame):
+                            try:
+                                print("Getting start frame preview for frame:", st.session_state.start_frame_helper)
+                                st.session_state.start_preview = st.session_state.start_dic[st.session_state.start_frame_helper]
+                                # Actualizar también el valor de referencia en session_state
+                                st.session_state.start_frame = st.session_state.start_frame_helper
+                            except Exception as e:
+                                print("Error getting start frame preview:", e)
+                                pass
+                        
+                        if st.session_state.start_preview is not None:
+                            print("Displaying start frame preview for frame:", st.session_state.start_frame_helper)
+                            st.image(st.session_state.start_preview, caption=f"Start Frame: {st.session_state.start_frame_helper}", use_container_width=True)
+                    
+                    # End frame preview
+                    with preview_cols[1]:
+                        
+                        # Aplicar la misma lógica para el end frame
+                        if (st.session_state.end_preview is None or 
+                            st.session_state.end_frame_helper != st.session_state.end_frame):
+                            try:
+                                print("Getting end frame preview for frame:", st.session_state.end_frame_helper)
+                                st.session_state.end_preview = st.session_state.end_dic[st.session_state.end_frame_helper]
+                                # Actualizar también el valor de referencia en session_state
+                                st.session_state.end_frame = st.session_state.end_frame_helper
+                            except Exception as e:
+                                print("Error getting end frame preview:", e)
+                                pass
+                        if st.session_state.end_preview is not None:
+                            st.image(st.session_state.end_preview, caption=f"End Frame: {st.session_state.end_frame_helper}", use_container_width=True)
+
+                    st.markdown("</div>", unsafe_allow_html=True)
+    # ...existing code...
+                    
+                    # Display the current range information
+                    selected_frames = st.session_state.end_frame_helper - st.session_state.start_frame_helper + 1
+                    selected_duration = selected_frames / original_fps
+                    estimated_selected_frames = int(selected_duration * st.session_state.fps_target)
+
+                    # Create a dropdown for FPS selection
+                    actual_fps = st.session_state.fps_target
+                    st.session_state.fps_target = original_fps
+
+                    st.info(f"Selected range: {st.session_state.start_frame_helper} to {st.session_state.end_frame_helper} ({int(selected_duration*st.session_state.fps_target)} frames, {selected_duration:.2f} seconds). " 
+                        f"At {st.session_state.fps_target} FPS")
+
+                    st.markdown("")
+                    st.markdown("")
+                    st.markdown("")
+                    st.markdown("")
+                    st.markdown("")
+                    st.markdown("")
+
+                    
+                    
+                    lst_team_option = ('RedBull', 'Ferrari', 'Mclaren','Mercedes','Williams','Aston Martin','RB','Hass','Sauber', 'Alpine')
+
+                    dic_masks = {
+                        'RedBull': ('Verstappen 2025','Tsunoda 2025'),
+                        'Ferrari': ('Hamilton 2025','Leclerc 2025'),
+                        'Mclaren': ('Piastri 2025','Norris 2025'),
+                        'Mercedes': ('Antonelli 2025','Russell 2025'),
+                        'Williams': ('Albon 2025','Sainz 2025'),
+                        'Alpine': ('Gasly 2025','Colapinto 2025'),
+                        'RB': ('Hadjar 2025','Lawson 2025'),
+                        'Hass': ('Bearman 2025','Ocon 2025'),
+                        'Sauber': ('Hulk 2025','Bortoleto 2025'),
+                        'Aston Martin': ('Alonso 2025','Stroll 2025')
+
+
+                    }
+                    
+                    #('Verstappen 2025', 'Piastri 2025','Norris 2025','Leclerc 2025','Hamilton 2025','Russell 2025', 'Antonelli 2025', 'Tsunoda 2025')
+
+
+                    driver_crop_type = st.session_state.driver_crop_type_2
+
+                    st.markdown("#### Step 3: Select Crop type 👈")
+                    st.markdown("- Steering wheel, helmet and hands shold be visible, aim for acrop type like the example image.")
+                    st.markdown("- Some onboards change the camera position along the season, a different team/driver crop type can match the camera position desired.")
+                    
+
+                    lst_columns = st.columns(2)
+
+                    with lst_columns[0]:
+                            
+                        st.session_state.driver_crop_type_2 = st.selectbox(
+                            "Select team",
+                            lst_team_option,
+                            index=None,
+                            format_func=lambda x: f"{x}",
+                            help="Choose recort for processing"
+                        )
+                    with lst_columns[1]:
+                        if st.session_state.driver_crop_type_2 != None:
+                            st.session_state.driver_crop_type = st.selectbox(
+                                "Select driver",
+                                dic_masks[st.session_state.driver_crop_type_2],
+                                index=0,
+                                format_func=lambda x: f"{x}",
+                                help="Choose recort for processing"
+                            )
+                    
+                    if st.session_state.driver_crop_type != None:
+                        # Update the video processor with the selected crop type
+                        
+                        print("Crop type updated to:", st.session_state.driver_crop_type)
+                    
+                        if st.session_state.driver_crop_type != driver_crop_type:
+                                
+                            st.session_state.btn = False
+
+                        
+                        preview_cols1 = st.columns(2)
+                        with preview_cols1[0]:
+                            st.markdown("##### Current Crop Type")
+                            if st.session_state.start_preview1 is None or st.session_state.driver_crop_type != driver_crop_type:
+                                st.session_state.start_preview1 = st.session_state.video_processor.get_frame_example(0)
+                                st.session_state.video_processor.load_crop_variables(st.session_state.driver_crop_type)
+                                
+                                st.session_state.start_preview1 = st.session_state.video_processor.crop_frame_example(st.session_state.start_preview1)
+                                
+                            if st.session_state.start_preview1 is not None:
+                                st.image(st.session_state.start_preview1, caption=f"Example",use_container_width=True)
+                        
+                        # End frame preview
+                        with preview_cols1[1]:
+                            st.markdown("##### Example frame")
+                            st.image(Path(BASE_DIR) / "img" / "example.png", caption=f"GOAL Frame:",use_container_width=True)
+
+                        
+                        
+
+                        # Process button
+                        st.markdown("")
+                        st.markdown("")
+                        st.markdown("")
+                        st.markdown("")
+                        st.markdown("")
+                        st.markdown("")
+
+                        st.markdown("#### Step 5: (Opcional) Postprocessing Settings")
+                        st.markdown("- First try default mode, is the best for 90% of the cases")
+
+                        #agregar opciones en radio para elegir el tipo de procesamiento
+
+                        postprocessing_mode = st.radio(
+                            "Select Postprocessing Mode",
+                            options=["Default","Low ilumination"],
+                            index=0,
+                            help="Choose the postprocessing mode for the model",
+                            horizontal=False
+                        )
+                        if postprocessing_mode != st.session_state.model_handler.postprocessing_mode:
+                            
+                            st.session_state.btn = False
+                            st.session_state.model_handler.postprocessing_mode = postprocessing_mode
+                           #st.rerun()  # Rerun to update the UI with the new value
+
+
+                        # Process button
+                        st.markdown("")
+                        st.markdown("")
+                        st.markdown("")
+                        st.markdown("")
+                        st.markdown("")
+                        st.markdown("")
+
+
+
+                        
+
+
+                        st.markdown("#### Step 4: Execute Model 🚀")
+                        if st.button("Process Video Segment") or st.session_state.get('btn', True):
+
+                            if not(st.session_state.get('btn', True)):
+                                # Reset profiler before processing
+                                profiler.reset()
+                                #st.rerun()  # Rerun to update the UI with the new value
+                                
+                                with st.spinner("Processing frames..."):
+                                    if int(selected_duration*st.session_state.fps_target) > 500:
+                                        st.warning("⚠️ Large video segment selected, it could take some minutes to process.")
+                    
+
+                                    # Extract and process frames
+                                    st.session_state.video_processor.mode = postprocessing_mode
+                                    frames,crude_frames = st.session_state.video_processor.extract_frames(
+                                        st.session_state.start_frame_helper, st.session_state.end_frame_helper, fps_target=st.session_state.fps_target
+                                    )
+                                    st.session_state.model_handler.fps = original_fps
+                                    results = st.session_state.model_handler.process_frames(
+                                        frames, "F1 Steering Angle Detection"
+                                    )
+                                    try:
+                                        metrics_collection.update_one(
+                                            {"action": "descargar_app"},
+                                            {"$inc": {"count": 1}}
+                                        )
+                                    except:
+                                        st.warning("MongoDB client not connected.")
+                                    #st.session_state.processed_frames = crude_frames
+                                    #st.session_state.processed_frames1 = frames
+                                    # Convert results to DataFrame and display
+                                    df = st.session_state.model_handler.export_results(results)
+                                    st.session_state.df = df
+                                    st.session_state.video_processor.clear_cache()  # Clear cache after processing
+                                    # Clear unnecessary session state variables to free memory
+                                    # Create steering angle chart using Plotly
+                            df = st.session_state.df
+                            #crude_frames = st.session_state.processed_frames
+                            #frames = st.session_state.processed_frames1
+                            
+                            st.markdown("")
+                            st.markdown("")
+                            st.markdown("")
+                            
+
+
+                            
+                            st.markdown("# Results")
+
+                            display_results(df)
+
+                            
+
+                            st.markdown("")
+                            st.subheader("Steering Line Chart 📈")
+                            # Create a Plotly figure
+
+                            create_line_chart(df)
+
+                            # Add steering angle statistics using Streamlit's built-in components
+                            st.subheader("Steering Statistics 📊")
+                            col1, col2, col3, col4 = st.columns(4)
+
+                            with col1:
+                                st.metric("Mean Angle", f"{df['steering_angle'].mean():.2f}°")
+
+                            with col2:
+                                st.metric("Max Right Turn", f"{df['steering_angle'].max():.2f}°")
+
+                            with col3:
+                                st.metric("Max Left Turn", f"{df['steering_angle'].min():.2f}°")
+
+                            with col4:
+                                # Calculate average rate of change of steering angle
+                                angle_changes = abs(df['steering_angle'].diff().dropna())
+                                st.metric("Avg. Change Rate", f"{angle_changes.mean():.2f}°/frame")
+
+                            st.session_state.btn = True
+
+
+        else:
+            st.session_state.btn = False
+            try:
+                st.session_state.video_processor.clean_up()  # Clear cache if no video is uploaded
+                clear_session_state()
+                print("Session state cleared")
+            except:
+                print("Error clearing session state")
+    
+        
+    with tabs[1]:  # Driver Behavior tab
+        
+        st.info("For research/educational purposes only, its not related to F1 or any organization.")
+
+
+        
+        
+        
+        st.markdown("""
+        #####
+        ## The Model 
+                         
+        - The **F1 Steering Angle Prediction Model** uses a CNN based on EfficientNet-B0 to predict steering angles from a F1 onboard camera footage, trained with over 25,000 images (7000 manual labaled augmented to 25000) and YOLOv8-seg nano for helmets segmentation, allowing the model to be more robust by erasing helmet designs.
+        
+        - Currentlly the model is able to predict steering angles from 180° to -180° with a 3°-5° of error on ideal contitions.
+                    
+        - EfficientNet-B0 and YOLOv8-seg nano are exported to ONNX format, and images are resized to 224x224 allowing it to run on low-end devices.
+                    
+        
+                    
+        #####
+        ## How It Works
+        
+        ##### Video Processing: 
+        - From the onboard camera video, the frames selected are extracted at the FPS rate.
+                    
+        ##### Image Preprocessing:
+        - The frames are cropeed based on selected crop type to focus on the steering wheel and driver area.
+        - YOLOv8-seg nano is applied to the cropped images to segment the helmet, removing designs and logos.
+        - Convert cropped images to grayscale and apply CLAHE to enhance visibility.
+        - Apply adaptive Canny edge detection to extract edges, helped with preprocessing techniques like bilateralFilter and morphological transformations.
+    
+        ##### Prediction: 
+        - The CNN model processes the edge image to predict the steering angle
+                    
+        ##### Postprocessing
+        - apply local a trend-based outlier correction algorithm to detect and correct outliers
+                    
+        ##### Results Visualization
+        - Angles are displayed as a line chart with statistical analysis also a csv file with the frame number, time and the steering angle.
+        #####""")
+
+
+        coll1, coll2, coll3,coll4,coll5 = st.columns([40,23,23,23,23])
+
+        with coll1:
+            st.image(Path(BASE_DIR) / "img" / "verstappen_china_2025.jpg", caption="1. Original Frame", use_container_width=True)
+        with coll2:
+            # Mostrar ejemplos de preprocesamiento - necesitas agregar estas imágenes a tu carpeta img/
+            
+            st.image(Path(BASE_DIR) / "img" / "verstappen_china_2025_cropped.jpg", caption="2. Crop image",use_container_width=True)
+
+            
+        with coll3:
+            st.image(Path(BASE_DIR) / "img" / "verstappen_china_2025_nohelmet.jpg", caption="3. Segment Helmet with YOLO",use_container_width=True)
+        
+        with coll4:
+            st.image(Path(BASE_DIR) / "img" / "verstappen_china_2025_clahe.jpg", caption="4. Apply clahe",use_container_width=True)
+        
+        with coll5:
+            st.image(Path(BASE_DIR) / "img" / "verstappen_china_2025_tresh.jpg", caption="5. Edge detection",use_container_width=True)
+
+                    
+        st.markdown("""
+        ####
+        ## Limitations 
+        - Low visibility conditions (rain, extreme shadows, extreme light).
+        - Not well recorded videos.
+        - Change of onboard camera position (different angle, height, shakiness).
+                    """)
+
+        
+
+        
+        
+        
+        
+        

streamlit_app.py

@@ -0,0 +1,146 @@
+#streamlit run your_script.py
+import streamlit as st
+import os
+import sys
+
+from pathlib import Path
+
+st.set_page_config(
+        page_title="F1 Video Analysis Platform",
+        page_icon="🏎️",
+        initial_sidebar_state="expanded",
+        layout="wide"
+    )
+from utils.helper import BASE_DIR,metrics_page
+if "visited" not in st.session_state:
+    st.session_state["visited"] = True
+    try:
+        metrics_page.update_one({"page": "inicio"}, {"$inc": {"visits": 1}})
+    except:
+        st.warning("MongoDB client not connected.")
+
+
+hide_decoration_bar_style = '''
+    <style>
+        header {visibility: hidden;}
+    </style>
+'''
+logo_style = '''
+    <style>
+        /* Estilo para iconos de contacto - versión compacta */
+        .contact-icons {
+            display: flex;
+            justify-content: center;
+            gap: 8px;
+            margin-top: 10px;
+            flex-wrap: wrap;
+        }
+        
+        .contact-icon {
+            display: flex;
+            align-items: center;
+            padding: 6px;
+            border-radius: 50%;
+            background-color: rgba(255, 255, 255, 0.1);
+            transition: all 0.3s ease;
+            text-decoration: none;
+            color: #ffffff;
+        }
+        
+        .contact-icon:hover {
+            background-color: rgba(255, 255, 255, 0.2);
+            transform: translateY(-2px);
+        }
+        
+        .contact-icon img {
+            width: 16px;
+            height: 16px;
+        }
+        
+        /* Email button style */
+        .email-button {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 8px 15px;
+            border-radius: 20px;
+            background-color: rgba(255, 255, 255, 0.1);
+            transition: all 0.3s ease;
+            text-decoration: none;
+            color: #ffffff;
+            font-size: 13px;
+            margin-top: 12px;
+            width: 100%;
+        }
+        
+        .email-button:hover {
+            background-color: rgba(255, 255, 255, 0.2);
+        }
+        
+        .email-button img {
+            width: 16px;
+            height: 16px;
+            margin-right: 8px;
+        }
+        
+        /* Estilo para el separador */
+        .sidebar-separator {
+            margin: 20px 0;
+            border-top: 1px solid rgba(255, 255, 255, 0.1);
+        }
+    </style>
+'''
+#sst.markdown(hide_decoration_bar_style, unsafe_allow_html=True)logo_style
+st.markdown(logo_style, unsafe_allow_html=True)
+
+#st.markdown("<br>",unsafe_allow_html=True)
+
+with st.sidebar:
+    st.markdown("<h3 style='text-align: center; color: #fff;'>Considerations</h3>", unsafe_allow_html=True)
+    st.caption("""**Ouput Data**:""")
+    st.markdown("<p style='text-align: left; color: gray; font-size: 12px;'>The model is trained with images from -180° to 180°, for the moment may not accurately predict angles beyond 180°. Poor or high-intensity lighting may affect data accuracy.</p>", unsafe_allow_html=True)
+    st.caption("""**Usage**:""") 
+    st.markdown("<p style='text-align: left; color: gray; font-size: 12px;'>Free-tier server resources are limited, so the page may be slow or crash with large files. To run it locally, feel free to fork/clone the project or download the desktop app.</p>", unsafe_allow_html=True)
+
+    st.markdown("<p style='text-align: left; color: gray; font-size: 12px;'>Any feedback is welcome.</p>", unsafe_allow_html=True)
+    st.markdown("", unsafe_allow_html=True)
+
+    st.markdown("<h3 style='text-align: center; color: #fff;'>Contact</h3>", unsafe_allow_html=True)
+    # Nueva versión más compacta de los iconos
+    contact_html = """
+    <div class="contact-icons">
+        <a href='https://x.com/justsaed' target="_blank" class="contact-icon" title="X">
+            <img src="https://static.vecteezy.com/system/resources/previews/053/986/348/non_2x/x-twitter-icon-logo-symbol-free-png.png" alt="X">
+        </a>
+        <a href="https://github.com/danielsaed/F1-steering-angle-model" target="_blank" class="contact-icon" title="GitHub">
+            <img src="https://cdn-icons-png.flaticon.com/512/25/25231.png" alt="GitHub">
+        </a>
+    </div>
+    
+    """
+    
+    st.markdown(contact_html, unsafe_allow_html=True)
+    st.write("")
+    st.write("")
+    st.markdown("<p style='text-align: center; color: gray; font-size: 10px;'>For research/educational purposes only</p>", unsafe_allow_html=True)
+    
+    st.write("")
+    st.write("")
+    st.write("")
+
+    st.markdown("<h3 style='text-align: center; color: #fff;'>Get Desktop App</h3>", unsafe_allow_html=True)
+    col1,col2, col3 = st.columns([1,6,1])
+    with col2:
+
+        st.markdown("<p style='text-align: center; color: gray; font-size: 10px;'>Click Assets then download .exe</p>", unsafe_allow_html=True)
+        st.link_button("Download", "https://github.com/danielsaed/F1-steering-angle-model/releases",type="secondary",use_container_width=True)
+
+
+pages = st.navigation({ 
+    "Steering Angle Model": [
+        st.Page(Path(BASE_DIR) / "navigation" / "steering-angle.py", title="Use Model"),
+        st.Page(Path(BASE_DIR) / "navigation" / "soon.py", title="Historical Steering Data Base"),
+        ],})
+
+pages.run()
+

utils/helper.py

@@ -0,0 +1,549 @@
+import cv2
+import numpy as np
+from typing import Tuple
+import tempfile
+import os
+from PIL import Image
+import sys
+from pymongo import MongoClient
+from dotenv import load_dotenv
+import os
+import streamlit as st
+
+try:
+    if getattr(sys, 'frozen', False):
+        # En el ejecutable, intentar sys._MEIPASS
+        BASE_DIR = getattr(sys, '_MEIPASS', os.path.dirname(sys.executable))
+        print(f"Executable mode - Initial BASE_DIR: {BASE_DIR} (_MEIPASS: {hasattr(sys, '_MEIPASS')})")
+        # Verificar si BASE_DIR contiene los archivos esperados
+        expected_dirs = ['navigation', 'models', 'assets', 'img', 'utils']
+        if not any(os.path.exists(os.path.join(BASE_DIR, d)) for d in expected_dirs):
+            print(f"Warning: Expected directories not found in {BASE_DIR}")
+            # Buscar _MEI<random> en el directorio padre
+            temp_dir = os.path.dirname(BASE_DIR) if BASE_DIR != os.path.dirname(sys.executable) else BASE_DIR
+            for d in os.listdir(temp_dir):
+                if d.startswith('_MEI'):
+                    candidate = os.path.join(temp_dir, d)
+                    if any(os.path.exists(os.path.join(candidate, ed)) for ed in expected_dirs):
+                        BASE_DIR = candidate
+                        print(f"Adjusted BASE_DIR to _MEI directory: {BASE_DIR}")
+                        break
+            else:
+                print(f"No _MEI directory found in {temp_dir}, using {BASE_DIR}")
+    else:
+        # En desarrollo, usar el directorio del proyecto
+        current_file = os.path.abspath(os.path.realpath(__file__))
+        print(f"Development mode - Current file: {current_file}")
+        BASE_DIR = os.path.dirname(os.path.dirname(current_file))  # Subir de utils/ a F1-machine-learning-webapp/
+        print(f"Development mode - BASE_DIR: {BASE_DIR}")
+except Exception as e:
+    print(f"Error setting BASE_DIR: {e}")
+    # Fallback
+    BASE_DIR = os.path.dirname(os.path.abspath(os.path.realpath(__file__)))
+    BASE_DIR = os.path.dirname(BASE_DIR)
+    print(f"Fallback BASE_DIR: {BASE_DIR}")
+
+BASE_DIR = os.path.normpath(BASE_DIR)
+print(f"Final BASE_DIR: {BASE_DIR}")
+
+
+
+
+#load_dotenv()  # Carga las variables desde .env
+#mongo_uri = os.getenv("MONGO_URI")
+@st.cache_resource
+def get_mongo_client():
+    return MongoClient(st.secrets["MONGO_URI"])
+client = get_mongo_client()
+
+
+def get_metrics_collections():
+
+    db = client["f1_data"]
+    metrics_collection = db["usage_metrics"]
+    metrics_page = db["visits"]
+    return metrics_collection, metrics_page, db
+
+metrics_collection, metrics_page, db = get_metrics_collections()
+'''if not metrics_page.find_one({"page": "inicio"}):
+    metrics_page.insert_one({"page": "inicio", "visits": 0})
+if not metrics_collection.find_one({"action": "descargar_app"}):
+    metrics_collection.insert_one({"action": "descargar_app", "count": 0})'''
+'''except:
+    print("Error loading MongoDB URI from .env file. Please check your configuration.")
+    client = None
+    metrics_collection = None
+    metrics_page = None
+    db = None'''
+
+
+#-------------YOLO ONNX HELPERS-------------------
+
+def preprocess_image_tensor(image_rgb: np.ndarray) -> np.ndarray:
+    """Preprocess image to match Ultralytics YOLOv8."""
+    
+    '''input = np.array(image_rgb)
+    input = input.transpose(2, 0, 1)
+    input = input.reshape(1,3,224,224).astype("float32")
+    input = input/255.0'''
+
+    input_data = image_rgb.transpose(2, 0, 1).reshape(1, 3, 224, 224)
+
+    # Convert to float32 and normalize to [0, 1]
+    input_data = input_data.astype(np.float32) / 255.0
+    
+    return input_data
+
+def postprocess_outputs(outputs: list, height: int, width: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Process ONNX model outputs for a single-class model."""
+    res_size = 56
+    output0 = outputs[0]
+    output1 = outputs[1]
+
+    output0 = output0[0].transpose()
+    output1 = output1[0]
+
+    boxes = output0[:,0:5]
+    masks = output0[:,5:]
+
+    output1 = output1.reshape(32,res_size*res_size)
+
+    masks = masks @ output1
+
+    boxes = np.hstack([boxes,masks])
+
+    yolo_classes = [
+        "helmet"
+    ]
+
+    # parse and filter all boxes
+    objects = []
+    for row in boxes:
+        xc,yc,w,h = row[:4]
+        x1 = (xc-w/2)/224*width
+        y1 = (yc-h/2)/224*height
+        x2 = (xc+w/2)/224*width
+        y2 = (yc+h/2)/224*height
+        prob = row[4:5].max()
+        if prob < 0.2:
+            continue
+        class_id = row[4:5].argmax()
+        label = yolo_classes[class_id]
+
+        mask = get_mask(row[5:25684], (x1,y1,x2,y2), width, height)
+        try:
+            polygon = get_polygon(mask)
+        except:
+            continue
+        objects.append([x1,y1,x2,y2,label,prob,mask,polygon])
+
+
+
+    # apply non-maximum suppression
+    objects.sort(key=lambda x: x[5], reverse=True)
+    result = []
+    while len(objects)>0:
+        result.append(objects[0])
+        objects = [object for object in objects if iou(object,objects[0])<0.7]
+
+
+
+    return True,result
+
+def intersection(box1,box2):
+    box1_x1,box1_y1,box1_x2,box1_y2 = box1[:4]
+    box2_x1,box2_y1,box2_x2,box2_y2 = box2[:4]
+    x1 = max(box1_x1,box2_x1)
+    y1 = max(box1_y1,box2_y1)
+    x2 = min(box1_x2,box2_x2)
+    y2 = min(box1_y2,box2_y2)
+    return (x2-x1)*(y2-y1) 
+
+def union(box1,box2):
+    box1_x1,box1_y1,box1_x2,box1_y2 = box1[:4]
+    box2_x1,box2_y1,box2_x2,box2_y2 = box2[:4]
+    box1_area = (box1_x2-box1_x1)*(box1_y2-box1_y1)
+    box2_area = (box2_x2-box2_x1)*(box2_y2-box2_y1)
+    return box1_area + box2_area - intersection(box1,box2)
+
+def iou(box1,box2):
+    return intersection(box1,box2)/union(box1,box2)
+
+def sigmoid(z):
+    return 1/(1 + np.exp(-z))
+
+# parse segmentation mask
+def get_mask(row, box, img_width, img_height):
+    # convert mask to image (matrix of pixels)
+    res_size = 56
+    mask = row.reshape(res_size,res_size)
+    mask = sigmoid(mask)
+    mask = (mask > 0.2).astype("uint8")*255
+    # crop the object defined by "box" from mask
+    x1,y1,x2,y2 = box
+    mask_x1 = round(x1/img_width*res_size)
+    mask_y1 = round(y1/img_height*res_size)
+    mask_x2 = round(x2/img_width*res_size)
+    mask_y2 = round(y2/img_height*res_size)
+    mask = mask[mask_y1:mask_y2,mask_x1:mask_x2]
+    # resize the cropped mask to the size of object
+    img_mask = Image.fromarray(mask,"L")
+    img_mask = img_mask.resize((round(x2-x1),round(y2-y1)))
+    mask = np.array(img_mask)
+    return mask
+
+
+
+# calculate bounding polygon from mask
+def get_polygon(mask):
+    contours = cv2.findContours(mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+    polygon = [[contour[0][0],contour[0][1]] for contour in contours[0][0]]
+    return polygon
+
+
+
+
+
+
+
+
+
+
+#------------------VIDEO CONVERSION------------------
+
+def convert_video_to_10fps(video_file):
+    """
+    Convert an uploaded video file to 10 FPS and return metadata
+    
+    Args:
+        video_file: Streamlit uploaded file object
+        
+    Returns:
+        Dictionary with video metadata and path to converted file
+    """
+    try:
+        # Create temporary file for the original upload
+        orig_tfile = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
+        orig_tfile.write(video_file.read())
+        orig_tfile.close()
+        
+        # Open the original video to get properties
+        orig_cap = cv2.VideoCapture(orig_tfile.name)
+        
+        if not orig_cap.isOpened():
+            return {"success": False, "error": "Could not open video file"}
+            
+        orig_fps = orig_cap.get(cv2.CAP_PROP_FPS)
+        width = int(orig_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(orig_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        orig_total_frames = int(orig_cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        # Calculate duration
+        duration_seconds = orig_total_frames / orig_fps
+        expected_frames = int(duration_seconds * 10)  # 10 fps
+        
+        # Create output temp file
+        converted_path = tempfile.mktemp(suffix='.mp4')
+        
+        # Create VideoWriter
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(converted_path, fourcc, 10, (width, height))
+        
+        # Calculate frame sampling
+        if orig_fps <= 10:
+            # If original is slower than target, duplicate frames
+            step = 1
+            duplication = int(10 / orig_fps)
+        else:
+            # If original is faster, skip frames
+            step = orig_fps / 10
+            duplication = 1
+            
+        # Convert the video
+        frame_count = 0
+        output_count = 0
+        
+        while orig_cap.isOpened():
+            ret, frame = orig_cap.read()
+            if not ret:
+                break
+                
+            # Determine if we should include this frame
+            if frame_count % step < 1:  # Using modulo < 1 for floating point step values
+                # Write frame (possibly multiple times)
+                for _ in range(duplication):
+                    out.write(frame)
+                    output_count += 1
+                    
+            frame_count += 1
+            
+        # Release resources
+        orig_cap.release()
+        out.release()
+        os.unlink(orig_tfile.name)  # Delete original temp file
+        
+        # Instead of returning a dictionary, read the file back into memory
+        with open(converted_path, "rb") as f:
+            video_data = f.read()
+        
+        # Clean up the temporary file
+        os.unlink(converted_path)
+        
+        # Return a file-like object
+        from io import BytesIO
+        video_io = BytesIO(video_data)
+        video_io.name = "converted_10fps.mp4"
+        return video_io
+        
+    except Exception as e:
+        print(f"Error converting video: {e}")
+        return None
+
+def recortar_imagen(image,starty_dic, axes_dic):
+    height, width, _ = image.shape
+    mask = np.zeros((height, width), dtype=np.uint8)
+    start_y = int((starty_dic-.02) * height)
+    cv2.rectangle(mask, (0, start_y), (width, height), 255, -1)
+    center = (width // 2, start_y)
+    axes = (width // 2, int(axes_dic * height))
+    cv2.ellipse(mask, center, axes, 0, 180, 360, 255, -1)
+    result = cv2.bitwise_and(image, image, mask=mask)
+    return result
+
+def recortar_imagen_again(image,starty_dic, axes_dic):
+    
+    try:
+        height, width,_ = image.shape
+    except :
+        height, width = image.shape
+
+    mask = np.zeros((height, width), dtype=np.uint8)
+
+    start_y = int(starty_dic * height)
+    cv2.rectangle(mask, (0, start_y), (width, height), 255, -1)
+    center = (width // 2, start_y)
+    axes = (width // 2, int(axes_dic * height))
+    cv2.ellipse(mask, center, axes, 0, 180, 360, 255, -1)
+    result = cv2.bitwise_and(image, image, mask=mask)
+    return result
+
+def calculate_black_pixels_percentage(image):
+    """
+    Calcula el porcentaje de píxeles totalmente negros en la imagen.
+    
+    Args:
+        image: Imagen cargada con cv2 (BGR o escala de grises).
+        is_grayscale: True si la imagen ya está en escala de gruises, False si es a color.
+    
+    Returns:
+        float: Porcentaje de píxeles negros.
+    """
+    # Obtener dimensiones
+    '''image = cv2.imread(image_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)'''
+    if image is None:
+        print(f"Error loading image")
+        return 0
+    
+    if len(image.shape) == 3:
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    else:
+        image = image.copy()
+    h, w = image.shape[:2]
+    total_pixels = h * w
+    
+    black_pixels = np.sum(image < 10)
+
+    # Calcular porcentaje
+    percentage = (black_pixels / total_pixels) * 100
+
+    
+    percentage = (100.00 - float(percentage)) * .06
+
+    
+    return percentage
+
+def create_rectangular_roi(height, width, x1=0, y1=0, x2=None, y2=None):
+    if x2 is None:
+        x2 = width
+    if y2 is None:
+        y2 = height
+    mask = np.zeros((height, width), dtype=np.uint8)
+    cv2.rectangle(mask, (x1, y1), (x2, y2), 255, -1)
+    return mask
+
+def preprocess_image(image, mask=None):
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    else:
+        gray = image.copy()
+    
+    denoised = cv2.bilateralFilter(gray, d=3, sigmaColor=20, sigmaSpace=10)
+    sharpened = cv2.addWeighted(denoised, 3.0, denoised, -2.0, 0)
+    normalized = cv2.normalize(sharpened, None, 0, 255, cv2.NORM_MINMAX)
+    
+    if mask is not None:
+        return cv2.bitwise_and(normalized, normalized, mask=mask)
+    return normalized
+
+def calculate_robust_rms_contrast(image, mask=None, bright_threshold=240):
+    if len(image.shape) == 3:
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    
+    if mask is not None:
+        masked_image = image[mask > 0]
+    else:
+        masked_image = image.ravel()
+    
+    if len(masked_image) == 0:
+        mean = np.mean(image)
+        std_dev = np.sqrt(np.mean((image - mean) ** 2))
+    else:
+        mask_bright = masked_image < bright_threshold
+        masked_image = masked_image[mask_bright]
+        if len(masked_image) == 0:
+            mean = np.mean(image)
+            std_dev = np.sqrt(np.mean((image - mean) ** 2))
+        else:
+            mean = np.mean(masked_image)
+            std_dev = np.sqrt(np.mean((masked_image - mean) ** 2))
+    return std_dev / 255.0
+
+def adaptive_clahe_iterative(image, roi_mask, initial_clip_limit=1.0, max_clip_limit=10.0, iterations=20, target_rms_min=0.199, target_rms_max=0.5, bright_threshold=230):
+    if len(image.shape) == 3:
+        original_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    else:
+        original_gray = image.copy()
+    
+    #preprocessed_image = preprocess_image(original_gray)
+    
+    best_image = original_gray.copy()
+    best_rms = calculate_robust_rms_contrast(original_gray, roi_mask, bright_threshold)
+    clip_limit = initial_clip_limit
+    
+    for i in range(iterations):
+        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=(8, 8))
+        current_image = clahe.apply(original_gray)
+        
+        rms_contrast = calculate_robust_rms_contrast(current_image, roi_mask, bright_threshold)
+        
+        if target_rms_min <= rms_contrast <= target_rms_max:
+            return current_image   
+        if rms_contrast > best_rms:
+            best_rms = rms_contrast
+            best_image = current_image.copy()
+        if rms_contrast > target_rms_max:
+            clip_limit = min(clip_limit, 1.0)
+        else:
+            clip_limit = min(initial_clip_limit + (i * 0.5), max_clip_limit)
+    
+    return best_image
+
+def adaptive_edge_detection(imagen, min_edge_percentage=5.5, max_edge_percentage=6.5, target_percentage=6.0, max_attempts=5,mode="Default"):
+    """
+    Detecta bordes con ajuste progresivo de parámetros hasta lograr un porcentaje óptimo
+    de píxeles de borde en la imagen - optimizado con operaciones vectorizadas.
+    """
+    # Read image
+    original = imagen
+    if original is None:
+        print(f"Error loading image")
+        return None, None, None, None
+    
+    # Convert to grayscale
+    gray = original
+    
+    # Calculate total pixels for percentage calculation
+    total_pixels = gray.shape[0] * gray.shape[1]
+    min_edge_pixels = int((min_edge_percentage / 100) * total_pixels)
+    max_edge_pixels = int((max_edge_percentage / 100) * total_pixels)
+    target_edge_pixels = int((target_percentage / 100) * total_pixels)
+    
+    # Initial parameters - ajustados para conseguir un rango alrededor del 6% de bordes
+    clip_limits = [1]
+    grid_sizes = [(2, 2)]
+    # Empezamos con umbrales más altos para restringir la cantidad de bordes
+    canny_thresholds = [(55, 170), (45, 160), (35, 150), (25, 140), (20, 130),(20, 130),(20, 130)]
+    
+    best_edges = None
+    best_enhanced = None
+    best_config = None
+    best_edge_score = float('inf')  # Inicializamos con un valor alto
+    edge_percentage = 0
+
+    
+    # Try progressively more aggressive parameters
+    for attempt in range(max_attempts):
+        # Get parameters for this attempt
+        clip_limit = clip_limits[attempt]
+        grid_size = grid_sizes[attempt]
+        low_threshold, high_threshold = canny_thresholds[attempt]
+        
+        if edge_percentage <= max_edge_percentage:
+            clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=grid_size)
+        elif edge_count > max_edge_percentage:
+            # Si hay demasiados bordes, aplicamos un CLAHE más fuerte
+            clahe = cv2.createCLAHE(clipLimit=1, tileGridSize=grid_size)
+        
+        enhanced = clahe.apply(gray)
+
+        
+        #print("denoised shape:", denoised.shape, "dtype:", denoised.dtype)
+        # Apply noise reduction for higher attempts
+        '''if attempt >= 2:
+            enhanced = cv2.bilateralFilter(enhanced, 5, 100, 100)'''
+        
+
+        
+        if mode == "Default":
+            denoised = cv2.bilateralFilter(enhanced, d=5, sigmaColor=200, sigmaSpace=200)
+            median_intensity = np.median(denoised)
+            low_threshold = max(20, (1.0 - .3) * median_intensity)
+            high_threshold = max(80, (1.0 + .8) * median_intensity)
+        elif mode == "Low ilumination":
+            denoised = cv2.bilateralFilter(enhanced, d=5, sigmaColor=200, sigmaSpace=200)
+            median_intensity = np.median(denoised)
+            low_threshold = max(20, (1.0 - .3) * median_intensity)
+            high_threshold = max(80, (1.0 + .8) * median_intensity)
+        # Edge detection
+        
+        edges = cv2.Canny(denoised, low_threshold, high_threshold)
+        std_intensity = np.std(edges)
+        
+        # Reducir ruido con operaciones morfológicas - vectorizado
+        kernel = np.ones((1, 1), np.uint8)
+        edges = cv2.morphologyEx(
+            edges, 
+            cv2.MORPH_OPEN, 
+            kernel, 
+            iterations=0 if std_intensity < 60 else 1  # Más iteraciones si hay más ruido
+        )
+        
+        
+        # Count edge pixels - vectorizado usando np.count_nonzero
+        edge_count = np.count_nonzero(edges)
+        edge_percentage = (edge_count / total_pixels) * 100
+        
+        # Calcular distancia al objetivo - vectorizado
+        edge_score = abs(edge_count - target_edge_pixels)
+        
+        # Record the best attempt (closest to target percentage)
+        if edge_score < best_edge_score:
+            best_edge_score = edge_score
+            best_edges = edges.copy()  # Hacer copia para evitar sobrescrituras
+            best_enhanced = enhanced.copy()
+            best_config = {
+                'attempt': attempt + 1,
+                'clip_limit': clip_limit,
+                'grid_size': grid_size,
+                'canny_thresholds': (low_threshold, high_threshold),
+                'edge_pixels': edge_count,
+                'edge_percentage': edge_percentage
+            }
+        
+        # Salida temprana si estamos cerca del objetivo
+        if abs(edge_percentage - target_percentage) < 0.1:  # Within 0.2% of target
+            break
+    
+    print(f"Mejor intento: {best_config['attempt']}, porcentaje de bordes: {edge_percentage:.2f}%")
+    return best_enhanced, best_edges, original, best_config

utils/model_handler.py

@@ -0,0 +1,258 @@
+import numpy as np
+import pandas as pd
+from typing import List, Dict
+from PIL import Image
+import cv2
+import onnxruntime as ort
+from utils.helper import BASE_DIR
+from pathlib import Path
+
+def denormalize_angles(normalized_angles):
+    """
+    Convierte ángulos normalizados [-1,1] a grados [-180,180]
+    """
+    return (normalized_angles + 1) / 2 * (180 - (-180)) + (-180)
+
+def preprocess_image_exactly_like_pytorch(image_input):
+    """
+    Preprocesa una imagen de OpenCV (como adjusted_edges) 
+    para usarla con modelos ONNX.
+    
+    Args:
+        image_input: Array NumPy de OpenCV (imagen de bordes, binaria, etc.)
+        
+    Returns:
+        Array NumPy listo para inferencia con ONNX
+    """
+    # Verificar que la entrada no sea None
+    if image_input is None:
+        raise ValueError("Received None as image input")
+        
+    # Asegurar que la imagen es un array NumPy
+    if not isinstance(image_input, np.ndarray):
+        raise TypeError(f"Expected NumPy array, got {type(image_input)}")
+        
+    # Verificar que la imagen tiene dimensiones válidas
+    if len(image_input.shape) < 2:
+        raise ValueError(f"Invalid image shape: {image_input.shape}")
+    
+    # Copia para no modificar la original    
+    img_copy = image_input.copy()
+    
+    # Si es una imagen de bordes o binaria, normalmente tiene valores 0 y 255
+    # o 0 y 1. Asegurarse de que está en el rango [0, 255]
+    if img_copy.dtype != np.uint8:
+        if np.max(img_copy) <= 1.0:
+            # Si está en rango [0, 1], convertir a [0, 255]
+            img_copy = (img_copy * 255).astype(np.uint8)
+        else:
+            # De otro modo, simplemente convertir a uint8
+            img_copy = img_copy.astype(np.uint8)
+    
+    # Para imágenes de bordes o binarias, asegurar que tenemos valores claros
+    # (si todos los valores son muy bajos, puede que no se vea nada)
+    if np.mean(img_copy) < 10 and np.max(img_copy) > 0:
+        # Estirar el contraste para mejor visualización
+        img_copy = cv2.normalize(img_copy, None, 0, 255, cv2.NORM_MINMAX)
+    
+    # Asegurar que la imagen es de un solo canal (escala de grises)
+    if len(img_copy.shape) == 3:
+        if img_copy.shape[2] == 3:
+            # Convertir imagen BGR a escala de grises
+            img_copy = cv2.cvtColor(img_copy, cv2.COLOR_BGR2GRAY)
+        else:
+            # Tomar solo el primer canal
+            img_copy = img_copy[:, :, 0]
+    
+    try:
+        # Convertir de NumPy array a PIL Image
+        img_pil = Image.fromarray(img_copy)
+        
+        # Redimensionar con PIL 
+        img_resized = img_pil.resize((224, 224), Image.BILINEAR)
+        
+        # Convertir a numpy array
+        img_np = np.array(img_resized, dtype=np.float32)
+        
+        # Normalizar de [0,255] a [0,1]
+        img_np = img_np / 255.0
+        
+        # Normalizar con mean=0.5, std=0.5 (como en PyTorch)
+        img_np = (img_np - 0.5) / 0.5
+        
+        # Reformatear para ONNX [batch_size, channels, height, width]
+        img_np = np.expand_dims(img_np, axis=0)  # Añadir dimensión de canal
+        img_np = np.expand_dims(img_np, axis=0)  # Añadir dimensión de batch
+        
+        return img_np
+    except Exception as e:
+        print(f"Error processing image: {e}")
+        print(f"Image shape: {image_input.shape}, dtype: {image_input.dtype}")
+        print(f"Min value: {np.min(image_input)}, Max value: {np.max(image_input)}")
+        raise
+
+def correct_outlier_angles(df, window_size=5, std_threshold=3.0, max_diff_threshold=80.0):
+    
+    angles = df['steering_angle'].values
+    corrected_angles = angles.copy()
+    
+    for i in range(len(angles)):
+        if i < window_size // 2 or i >= len(angles) - window_size // 2:  # Evitar bordes
+            continue
+        
+        # Definir ventana local
+        start_idx = max(0, i - window_size // 2)
+        end_idx = min(len(angles), i + window_size // 2 + 1)
+        window = angles[start_idx:end_idx]
+        
+        # Calcular estadísticas locales incluyendo el valor actual
+        curr_angle = angles[i]
+        local_mean = np.mean(window)
+        local_std = np.std(window) if len(window) > 1 else 0
+        
+        # Calcular distancia angular mínima considerando el rango cíclico (-180° a 180°)
+        def angular_distance(a, b):
+            diff = abs(a - b)
+            return min(diff, 360 - diff) if diff > 180 else diff
+        
+        diff_from_mean = angular_distance(curr_angle, local_mean)
+        
+        # Detectar outlier
+        is_outlier = (diff_from_mean > std_threshold * local_std) or (diff_from_mean > max_diff_threshold)
+        
+        if is_outlier:
+            print(i, curr_angle, local_mean, local_std, diff_from_mean)
+            # Excluir el valor actual del cálculo del promedio de corrección
+            corrected_window = np.delete(window, i - start_idx)
+            if len(corrected_window) > 0:
+                corrected_mean = np.mean(corrected_window)
+                # Ajustar el ángulo corregido al rango cíclico más cercano
+                diff_to_corrected = angular_distance(curr_angle, corrected_mean)
+                if diff_to_corrected > 180:
+                    corrected_angles[i] = corrected_mean - 360 if corrected_mean > 0 else corrected_mean + 360
+                else:
+                    corrected_angles[i] = corrected_mean
+    
+    # Crear nuevo DataFrame
+    corrected_df = df.copy()
+    corrected_df['steering_angle'] = corrected_angles
+    return corrected_df
+
+class ModelHandler:
+    def __init__(self):
+        # Placeholder for actual model loading
+        self.current_model = None
+        self.current_model_name = None
+        self.fps = None
+        self.available_models = {
+            "F1 Steering Angle Detection": Path(BASE_DIR) / "models" / "f1-steering-angle-model.onnx",
+            "Track Position Analysis": "position_model",
+            "Driver Behavior Analysis": "behavior_model"
+        }
+        
+    def _load_model_if_needed(self, model_name: str):
+        """Load the model only if it's not already loaded or if it's different"""
+        if self.current_model is None or self.current_model_name != model_name:
+            print(f"Loading model: {model_name}")  # Debugging info
+            self.current_model = ort.InferenceSession(self.available_models[model_name])
+            self.current_model_name = model_name
+        
+    def process_frames(self, frames: List[np.ndarray], model_name: str) -> Dict:
+        """Process frames through selected model with efficient batch processing"""
+        if not frames:
+            return []
+        
+        # Load model only once
+        self._load_model_if_needed(model_name)
+        
+        # Get input name once
+        input_name = self.current_model.get_inputs()[0].name
+        
+        results = []
+        
+        # Define optimal batch size - ajusta según tu hardware
+        BATCH_SIZE = 16
+        index = 0
+        # Process frames in batches
+        for batch_start in range(0, len(frames), BATCH_SIZE):
+            # Get current batch
+            batch_end = min(batch_start + BATCH_SIZE, len(frames))
+            current_batch = frames[batch_start:batch_end]
+            batch_inputs = []
+            
+            # Pre-process all frames in the current batch
+            for frame in current_batch:
+                try:
+                    # Procesar imagen pero mantener en formato que permita agrupación
+                    
+                    cv2.imwrite(r"img_test/"+str(index)+".jpg", frame)
+                    index= index+1
+                    processed_input = preprocess_image_exactly_like_pytorch(frame)
+                    batch_inputs.append(processed_input)
+                except Exception as e:
+                    print(f"Error preprocessing frame: {e}")
+                    # Usar un tensor vacío del mismo tamaño como reemplazo
+                    empty_tensor = np.zeros((1, 1, 224, 224), dtype=np.float32)
+                    batch_inputs.append(empty_tensor)
+            
+            try:
+                # Combinar todos los inputs pre-procesados en un solo lote grande
+                # Cada input tiene forma [1, 1, 224, 224], los concatenamos en la dimensión 0
+                batched_input = np.vstack(batch_inputs)
+                
+                # Ejecutar inferencia sobre todo el lote a la vez
+                ort_inputs = {input_name: batched_input}
+                ort_outputs = self.current_model.run(None, ort_inputs)
+                
+                # Procesar resultados por lotes
+                for i in range(len(current_batch)):
+                    frame_idx = batch_start + i +1
+                    predicted_angle_normalized = ort_outputs[0][i][0]
+                    angle = denormalize_angles(predicted_angle_normalized)
+                    confidence = np.random.uniform(0.7, 0.99)
+                    
+                    results.append({
+                        'frame_number': frame_idx,
+                        'steering_angle': angle,
+                    })
+                    
+            except Exception as e:
+                print(f"Error in batch processing: {e}")
+                # Si falla el procesamiento por lotes, volver a procesar individualmente
+                for i, frame in enumerate(current_batch):
+                    frame_idx = batch_start + i +1
+                    try:
+                        input_data = preprocess_image_exactly_like_pytorch(frame)
+                        ort_inputs = {input_name: input_data}
+                        ort_outputs = self.current_model.run(None, ort_inputs)
+                        
+                        predicted_angle_normalized = ort_outputs[0][0][0]
+                        angle = denormalize_angles(predicted_angle_normalized)
+                        confidence = np.random.uniform(0.7, 0.99)
+                        
+                        results.append({
+                            'frame_number': frame_idx,
+                            'steering_angle': angle
+                        })
+                    except Exception as sub_e:
+                        print(f"Error processing individual frame {frame_idx}: {sub_e}")
+                        # Añadir un resultado con valores predeterminados
+                        results.append({
+                            'frame_number': frame_idx,
+                            'steering_angle': 0.0
+                        })
+        
+        return results
+        
+    def export_results(self, results: Dict) -> pd.DataFrame:
+        """Convert results to pandas DataFrame for export"""
+        df = pd.DataFrame(results)
+        df['time'] = round(df['frame_number'] / self.fps,3)
+        
+        df = correct_outlier_angles(df, window_size=3, std_threshold=100, max_diff_threshold=15.0)
+        df = correct_outlier_angles(df, window_size=3, std_threshold=100, max_diff_threshold=15.0)
+        df = correct_outlier_angles(df, window_size=3, std_threshold=100, max_diff_threshold=15.0)
+        df = correct_outlier_angles(df, window_size=3, std_threshold=100, max_diff_threshold=15.0)
+            
+        
+        return df

utils/ui_components.py

@@ -0,0 +1,147 @@
+import streamlit as st
+import pandas as pd
+from typing import Tuple
+import plotly.graph_objects as go
+
+
+def create_header():
+    """Create the application header"""
+    st.markdown("""
+        <div class='custom-header'>
+            F1 Video Analysis Platform
+            <div style='font-size: 0.5em; font-weight: 400; margin-top: 10px;'>
+                Precision Telemetry & Analysis
+            </div>
+        </div>
+    """, unsafe_allow_html=True)
+
+def create_upload_section():
+    """Create the video upload section"""
+    st.markdown("<div class='glassmorphic-container'>", unsafe_allow_html=True)
+    uploaded_file = st.file_uploader(
+        "Upload video file",
+        type=['mp4', 'avi', 'mov'],
+        help="Upload onboard camera footage for analysis"
+    )
+    st.markdown("</div>", unsafe_allow_html=True)
+    return uploaded_file
+
+def create_frame_selector(total_frames: int) -> Tuple[int, int]:
+    """Create frame selection controls with slider and +/- buttons"""
+    st.markdown("<div class='glassmorphic-container'>", unsafe_allow_html=True)
+
+
+    # Create a slider for frame range selection
+    start_frame, end_frame = st.select_slider(
+        "Select Frame Range",
+        options=range(0, total_frames),
+        value=(0, total_frames-1),
+        format_func=lambda x: f"Frame {x}"
+    )
+    
+    
+
+
+    st.markdown("</div>", unsafe_allow_html=True)
+    return start_frame, end_frame
+
+def display_results(df: pd.DataFrame):
+
+
+    csv = df.to_csv(index=False)
+    st.markdown("")
+
+
+    st.markdown("#### Download Results 📥")
+
+    st.download_button(
+        label="Download Results (CSV)",
+        data=csv,
+        file_name="f1_analysis_results.csv",
+        mime="text/csv"
+    )
+    st.markdown("")
+
+def create_line_chart(df: pd.DataFrame):
+    """Create a line chart with the given DataFrame"""
+    fig = go.Figure()
+
+    # Add the main steering angle line
+    fig.add_trace(go.Scatter(
+        x=df['time'], 
+        y=df['steering_angle'],
+        mode='lines',
+        name='Steering Angle',
+        line=dict(color='white', width=1),
+        hovertemplate='<b>Time:</b> %{x}<br><b>Angle:</b> %{y:.2f}°<extra></extra>'
+    ))
+
+    # Add reference lines for straight, full right, and full left
+    fig.add_shape(type="line",
+        x0=df['time'].min(), y0=0, x1=df['time'].max(), y1=0,
+        line=dict(color="red", width=2, dash="solid"),
+        name="Straight (0°)"
+    )
+
+    fig.add_shape(type="line",
+        x0=df['time'].min(), y0=90, x1=df['time'].max(), y1=90,
+        line=dict(color="red", width=2, dash="dash"),
+        name="Full Right (90°)"
+    )
+
+    fig.add_shape(type="line",
+        x0=df['time'].min(), y0=-90, x1=df['time'].max(), y1=-90,
+        line=dict(color="red", width=2, dash="dash"),
+        name="Full Left (-90°)"
+    )
+
+    # Añadir etiquetas a las líneas de referencia
+    fig.add_annotation(x=df['time'].min(), y=0,
+        text="Straight (0°)",
+        showarrow=True,
+        arrowhead=1,
+        ax=-40,
+        ay=-20
+    )
+
+    fig.add_annotation(x=df['time'].min(), y=90,
+        text="Full Right (90°)",
+        showarrow=True,
+        arrowhead=1,
+        ax=-40,
+        ay=-20
+    )
+
+    fig.add_annotation(x=df['time'].min(), y=-90,
+        text="Full Left (-90°)",
+        showarrow=True,
+        arrowhead=1,
+        ax=-40,
+        ay=20
+    )
+
+    # Configure layout
+    fig.update_layout(
+        title="Steering Angle Over Time",
+        xaxis_title="Time (seconds)",
+        yaxis_title="Steering Angle (degrees)",
+        yaxis=dict(range=[-180, 180]),
+        hovermode="x unified",
+        legend_title="Legend",
+        template="plotly_white",
+        height=500,
+        margin=dict(l=20, r=20, t=40, b=20)
+    )
+
+    # Add a light gray range for "straight enough" (-10° to 10°)
+    fig.add_shape(type="rect",
+        x0=df['time'].min(), y0=-10,
+        x1=df['time'].max(), y1=10,
+        fillcolor="lightgray",
+        opacity=0.2,
+        layer="below",
+        line_width=0,
+    )
+
+    # Display the plot in Streamlit
+    st.plotly_chart(fig, use_container_width=True)

utils/video_processor.py

@@ -0,0 +1,1080 @@
+import cv2
+import numpy as np
+from typing import List, Tuple
+import tempfile
+import time
+import functools
+from collections import defaultdict
+import onnxruntime as ort
+from utils.model_handler import ModelHandler
+from utils.helper import (
+    preprocess_image_tensor,
+    postprocess_outputs,
+    recortar_imagen,
+    recortar_imagen_again,
+    calculate_black_pixels_percentage,
+    adaptive_edge_detection,
+
+    )
+from collections import OrderedDict
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from utils.helper import BASE_DIR
+
+class Profiler:
+    """Clase para trackear el tiempo de ejecución de las funciones"""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(Profiler, cls).__new__(cls)
+            cls._instance.function_times = defaultdict(list)
+            cls._instance.call_counts = defaultdict(int)
+        return cls._instance
+    
+    def track_time(self, func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            start_time = time.time()
+            result = func(*args, **kwargs)
+            end_time = time.time()
+            elapsed = end_time - start_time
+            
+            self.function_times[func.__name__].append(elapsed)
+            self.call_counts[func.__name__] += 1
+            
+            return result
+        return wrapper
+    
+    def print_stats(self):
+        print("\n===== FUNCIÓN TIMING STATS =====")
+        print(f"{'FUNCIÓN':<30} {'LLAMADAS':<10} {'TOTAL (s)':<15} {'PROMEDIO (s)':<15} {'% TIEMPO':<10}")
+        
+        total_time = sum(sum(times) for times in self.function_times.values())
+        
+        # Ordenar por tiempo total (descendente)
+        sorted_funcs = sorted(
+            self.function_times.items(),
+            key=lambda x: sum(x[1]),
+            reverse=True
+        )
+        
+        for func_name, times in sorted_funcs:
+            total = sum(times)
+            avg = total / len(times) if times else 0
+            calls = self.call_counts[func_name]
+            percent = (total / total_time * 100) if total_time > 0 else 0
+            
+            print(f"{func_name:<30} {calls:<10} {total:<15.4f} {avg:<15.4f} {percent:<10.2f}%")
+        
+        print(f"\nTiempo total de procesamiento: {total_time:.4f} segundos")
+        print("================================")
+    
+    def get_stats_dict(self):
+        """Devuelve las estadísticas como un diccionario para mostrar en Streamlit"""
+        stats = []
+        total_time = sum(sum(times) for times in self.function_times.values())
+        
+        for func_name, times in self.function_times.items():
+            total = sum(times)
+            avg = total / len(times) if times else 0
+            calls = self.call_counts[func_name]
+            percent = (total / total_time * 100) if total_time > 0 else 0
+            
+            stats.append({
+                'función': func_name,
+                'llamadas': calls,
+                'tiempo_total': total,
+                'tiempo_promedio': avg,
+                'porcentaje': percent
+            })
+        
+        # Ordenar por porcentaje de tiempo
+        stats.sort(key=lambda x: x['porcentaje'], reverse=True)
+        return stats, total_time
+    
+    def reset(self):
+        """Reiniciar las estadísticas"""
+        self.function_times.clear()
+        self.call_counts.clear()
+
+profiler = Profiler()
+
+
+class VideoProcessor:
+    def __init__(self):
+        self.cap = None
+        self.total_frames = 0
+        self.fps = 0
+        self.target_fps = 10
+        self.driver_crop_type = "Verstappen 2025"  # Default driver crop type
+        self.load_crop_variables(self.driver_crop_type)
+        #self.yolo_model = YOLO("models/best.pt")
+        self.model = ort.InferenceSession(Path(BASE_DIR) / "models" / "best-224.onnx")
+        self.input_shape = (224, 224)  # Match imgsz=224 from your original code
+        self.conf_thres = 0.5  # Confidence threshold
+        self.iou_thres = 0.5   # IoU threshold for NMS
+        self.frame_count = 0
+        self.mode = "Default"  # Default to False, can be set later
+
+
+        self.frame_cache = OrderedDict()
+        self.frame_cache_size = 50  # Reduced size to conserve memory
+        self.last_position = -1
+
+        self.frames_list_end = {}
+        self.frames_list_start = {}
+    
+    def clear_cache(self):
+        """Clear the frame cache to free memory."""
+        self.frame_cache.clear()
+
+    @profiler.track_time
+    def load_crop_variables(self,driver_crop_type):
+        """
+        Cargar variables de recorte según el tipo de conductor
+        """
+        driver_config = {
+    "Albon 2024": {
+        "starty": 0.55,
+        "axes": 0.39,
+        "y_start": 0.53,
+        "x_center": 0.59
+    },
+    "Albon 2025": {
+        "starty": 0.67,
+        "axes": 0.42,
+        "y_start": 0.53,
+        "x_center": 0.59
+    },
+    "Alonso 2024": {
+        "starty": 0.5,
+        "axes": 0.29,
+        "y_start": 0.53,
+        "x_center": 0.56
+    },
+    "Alonso 2025": {
+        "starty": 0.8,
+        "axes": 0.5,
+        "y_start": 0.53,
+        "x_center": 0.572
+    },
+    "Bortoleto 2025": {
+        "starty": 0.6,
+        "axes": 0.4,
+        "y_start": 0.53,
+        "x_center": 0.572
+    },
+    "bottas": {
+        "starty": 0.67,
+        "axes": 0.43,
+        "y_start": 0.53,
+        "x_center": 0.574
+    },
+    "colapinto": {
+        "starty": 0.52,
+        "axes": 0.33,
+        "y_start": 0.53,
+        "x_center": 0.594
+    },
+    "Colapinto 2025": {
+        "starty": 0.54,
+        "axes": 0.4,
+        "y_start": 0.53,
+        "x_center": 0.58
+    },
+    "Gasly 2025": {
+        "starty": 0.57,
+        "axes": 0.35,
+        "y_start": 0.53,
+        "x_center": 0.58
+    },
+    "Hulk 2025": {
+        "starty": 0.73,
+        "axes": 0.3,
+        "y_start": 0.53,
+        "x_center": 0.548
+    },
+    "Lawson 2025": {
+        "starty": 0.68,
+        "axes": 0.42,
+        "y_start": 0.53,
+        "x_center": 0.555
+    },
+    "Ocon 2025": {
+        "starty": 0.65,
+        "axes": 0.42,
+        "y_start": 0.53,
+        "x_center": 0.585
+    },
+    "Sainz 2025": {
+        "starty": 0.77,
+        "axes": 0.42,
+        "y_start": 0.53,
+        "x_center": 0.57
+    },
+    "Stroll 2025": {
+        "starty": 0.6,
+        "axes": 0.45,
+        "y_start": 0.53,
+        "x_center": 0.565
+    },
+    "Bearman 2025": {
+        "starty": 0.72,
+        "axes": 0.45,
+        "y_start": 0.53,
+        "x_center": 0.58
+    },
+    "Hadjar 2025": {
+        "starty": 0.7,
+        "axes": 0.42,
+        "y_start": 0.53,
+        "x_center": 0.57
+    },
+    "hamilton-arabia": {
+        "starty": 0.908,
+        "axes": 0.4,
+        "y_start": 0.53,
+        "x_center": 0.554
+    },
+     "Hamilton 2025": {
+        "starty": 0.59,
+        "axes": 0.4,
+        "y_start": 0.53,
+        "x_center": 0.573
+    },
+
+    "hamilton-texas": {
+        "starty": 0.7,
+        "axes": 0.38,
+        "y_start": 0.53,
+        "x_center": 0.6
+    },
+   "leclerc-china": {
+        "starty": 0.6,
+        "axes": 0.36,
+        "y_start": 0.53,
+        "x_center": 0.58
+    },
+    
+    "Leclerc 2025": {
+        "starty": 0.65,
+        "axes": 0.45,
+        "y_start": 0.53,
+        "x_center": 0.575
+    },
+    "magnussen": {
+        "starty": 0.6,
+        "axes": 0.34,
+        "y_start": 0.53,
+        "x_center": 0.58
+    },
+    "norris-arabia": {
+        "starty": 0.7,
+        "axes": 0.3,
+        "y_start": 0.53,
+        "x_center": 0.58
+    },
+    "norris-texas": {
+        "starty": 0.7,
+        "axes": 0.3,
+        "y_start": 0.53,
+        "x_center": 0.58
+    },
+    "Norris 2025": {
+        "starty": 0.79,
+        "axes": 0.6,
+        "y_start": 0.53,
+        "x_center": 0.571,
+        "helmet_height_ratio": 0.5
+    },
+    "ocon": {
+        "starty": 0.75,
+        "axes": 0.35,
+        "y_start": 0.53,
+        "x_center": 0.555
+    },
+    "piastri-azerbaiya": {
+        "starty": 0.65,
+        "axes": 0.34,
+        "y_start": 0.53,
+        "x_center": 0.549
+    },
+    "piastri-singapure": {
+        "starty": 0.65,
+        "axes": 0.34,
+        "y_start": 0.53,
+        "x_center": 0.549
+    },
+    'Piastri 2025': {
+        "starty": 0.93,
+        "axes": 0.59,
+        "y_start": 0.53,
+        "x_center": 0.573,
+        "helmet_height_ratio": 0.3
+    },
+    "russel-singapure": {
+        "starty": 0.63,
+        "axes": 0.44,
+        "y_start": 0.53,
+        "x_center": 0.56
+    },
+    "Russell 2025": {
+        "starty": 0.95,
+        "axes": 0.65,
+        "y_start": 0.53,
+        "x_center": 0.574,
+        "helmet_height_ratio": 0.35
+    },
+    "sainz": {
+        "starty": 0.57,
+        "axes": 0.32,
+        "y_start": 0.53,
+        "x_center": 0.59
+    },
+
+    
+    "Tsunoda 2025":{
+        "starty": 0.92,
+        "axes": 0.55,
+        "y_start": 0.53,
+        "x_center": 0.58,
+        "helmet_height_ratio": 0.25
+    },
+    "verstappen_china": {
+        "starty": 0.7,
+        "axes": 0.42,
+        "y_start": 0.53,
+        "x_center": 0.57
+    },
+    "Verstappen 2025": {
+        "starty": 0.7,
+        "axes": 0.42,
+        "y_start": 0.53,
+        "x_center": 0.57,
+        "helmet_height_ratio": 0.4
+    },
+    "vertappen": {
+        "starty": 0.7,
+        "axes": 0.42,
+        "y_start": 0.53,
+        "x_center": 0.57
+    },
+    "verstappen-arabia": {
+        "starty": 0.95,
+        "axes": 0.4,
+        "y_start": 0.53,
+        "x_center": 0.565
+    },
+    "yuki": {
+        "starty": 0.64,
+        "axes": 0.37,
+        "y_start": 0.53,
+        "x_center": 0.585
+    },
+    "Antonelli 2025":
+    {
+        "starty": 0.97,
+        "axes": 0.65,
+        "y_start": 0.53,
+        "x_center": 0.595,
+        "helmet_height_ratio": 0.5
+    }}
+        
+        print(f"Driver crop type: {self.driver_crop_type}")
+        self.driver_crop_type = driver_crop_type
+        self.starty = driver_config[self.driver_crop_type]["starty"]
+        self.axes = driver_config[self.driver_crop_type]["axes"]
+
+        self.y_start = driver_config[self.driver_crop_type]["y_start"]
+        self.x_center = driver_config[self.driver_crop_type]["x_center"]
+        self.helmet_height_ratio = driver_config[self.driver_crop_type]["helmet_height_ratio"] if "helmet_height_ratio" in driver_config[self.driver_crop_type] else 0.5
+
+    def clean_up(self):
+        """Release video capture and clear cache."""
+        
+        self.clear_cache()
+        self.frames_list_start = {}
+        self.frames_list_end = {}
+        self.video_path = None
+        self.frame_count = 0
+        print("VideoProcessor cleaned up.")
+
+    @profiler.track_time
+    def load_video(self, video_file) -> bool:
+        """Load video file and get basic information"""
+        tfile = tempfile.NamedTemporaryFile(delete=True)
+        tfile.write(video_file.read())
+        
+        # Guardar ruta para posibles reinicios
+        self.video_path = tfile.name
+        
+        self.cap = cv2.VideoCapture(tfile.name)
+        self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        self.fps = int(self.cap.get(cv2.CAP_PROP_FPS))
+        print(f"FPS: {self.fps}")
+        print(f"Total frames: {self.total_frames}")
+
+
+        #self.frames_list_start = [None] * self.total_frames  # prealocamos
+        #self.frames_list_end = [None] * self.total_frames  # prealocamos
+        self.start_frame_min = 0
+        self.start_frame_max = min(100,int(self.total_frames * 0.1))  # 10% del total
+
+        if self.total_frames > 500:
+            self.end_frame_min = int(self.total_frames-100)    # 90% del total
+        else:
+            self.end_frame_min = int(self.total_frames * 0.9)
+        self.end_frame_max = self.total_frames - 1
+        i = 0
+        print(len(self.frames_list_start), len(self.frames_list_end))
+
+        if self.frames_list_end == {}:
+
+
+        
+            current_frame_num = self.start_frame_min
+            cap_thread = cv2.VideoCapture(self.video_path)
+            cap_thread.set(cv2.CAP_PROP_POS_FRAMES, float(self.start_frame_min))
+
+            while current_frame_num <= self.start_frame_max:
+                ret, frame = cap_thread.read()
+                if not ret:
+                    # print(f"Advertencia: No se pudo leer el frame {current_frame_num} de {video_path}.")
+                    break
+                
+                processed_frame = cv2.cvtColor(cv2.resize(frame, (256, 144), interpolation=cv2.INTER_LINEAR), cv2.COLOR_BGR2GRAY)
+                self.frames_list_start[current_frame_num] = processed_frame
+                current_frame_num += 1
+
+            cap_thread.release()
+
+
+            current_frame_num = self.end_frame_min
+            cap_thread = cv2.VideoCapture(self.video_path)
+            cap_thread.set(cv2.CAP_PROP_POS_FRAMES, float(self.end_frame_min))
+
+            while current_frame_num <= self.end_frame_max:
+                ret, frame = cap_thread.read()
+                if not ret:
+                    # print(f"Advertencia: No se pudo leer el frame {current_frame_num} de {video_path}.")
+                    break
+                
+                processed_frame = cv2.cvtColor(cv2.resize(frame, (256, 144), interpolation=cv2.INTER_LINEAR), cv2.COLOR_BGR2GRAY)
+                self.frames_list_end[current_frame_num] = processed_frame
+                current_frame_num += 1
+
+            cap_thread.release()
+
+            '''while True:
+                ret, frame = self.cap.read()
+                
+                if i >= start_frame_min and i <= start_frame_max:
+
+                    self.frames_list_start[i] = cv2.cvtColor(cv2.resize(frame, (426,240), interpolation=cv2.INTER_LINEAR),cv2.COLOR_BGR2GRAY)
+
+                if i >= end_frame_min and i <= end_frame_max:
+                    self.frames_list_end[i] = cv2.cvtColor(cv2.resize(frame, (426,240), interpolation=cv2.INTER_LINEAR),cv2.COLOR_BGR2GRAY)
+                
+                if not ret or i >= self.total_frames:
+                    break
+
+                i += 1'''
+
+            self.cap = cv2.VideoCapture(tfile.name)
+        return True
+
+
+    def load_video2(self, video_file, output_resolution=(854, 480)) -> bool:
+        """
+        Load video file, resize to 480p, and get basic information.
+        
+        Args:
+            video_file: Input video file object
+            output_resolution: Tuple of (width, height) for resizing (default: 854x480 for 480p)
+        
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        try:
+            # Create temporary file to store the input video
+            tfile = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
+            tfile.write(video_file.read())
+            tfile.close()  # Close the file to allow VideoCapture to access it
+
+            # Store the temporary file path
+            self.video_path = tfile.name
+
+            # Load the video
+            self.cap = cv2.VideoCapture(tfile.name)
+            if not self.cap.isOpened():
+                print("Error: Could not open video file.")
+                return False
+
+            # Get original video properties
+            self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            self.fps = int(self.cap.get(cv2.CAP_PROP_FPS))
+            print(f"FPS: {self.fps}")
+            print(f"Total frames: {self.total_frames}")
+
+            # Prepare for resizing and saving to a new temporary file
+            output_path = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4').name
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # Codec for MP4
+            out = cv2.VideoWriter(output_path, fourcc, self.fps, output_resolution)
+
+            # Process each frame
+            while self.cap.isOpened():
+                ret, frame = self.cap.read()
+                if not ret:
+                    break
+                # Resize frame to 480p
+                resized_frame = cv2.resize(frame, output_resolution, interpolation=cv2.INTER_AREA)
+                out.write(resized_frame)
+
+            # Release resources
+            self.cap.release()
+            out.release()
+
+            # Update video path to the resized video
+            self.video_path = output_path
+            self.cap = cv2.VideoCapture(self.video_path)
+            if not self.cap.isOpened():
+                print("Error: Could not open resized video.")
+                return False
+
+            print(f"Video resized to {output_resolution} and saved to {output_path}")
+            return True
+
+        except Exception as e:
+            print(f"Error processing video: {str(e)}")
+            return False
+    
+    def load_video1(self, video_file) -> bool:
+        """Load video file and get basic information"""
+        with tempfile.TemporaryFile(suffix='.mp4') as tfile:
+            tfile.write(video_file.read())
+            tfile.seek(0)
+            self.video_path = tfile.name  # Store for reference
+            self.cap = cv2.VideoCapture(tfile.name)
+            if not self.cap.isOpened():
+                return False
+            self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            self.fps = int(self.cap.get(cv2.CAP_PROP_FPS))
+            return True
+            
+    @profiler.track_time
+    def get_frame1(self, frame_number: int) -> np.ndarray:
+        """
+        Obtiene un frame específico del video con optimizaciones de rendimiento
+        
+        Args:
+            frame_number: Número del frame a obtener
+            
+        Returns:
+            Frame como array NumPy (formato RGB) o None si no está disponible
+        """
+        if self.cap is None:
+            return None
+        
+        # 1. Inicializar atributos de seguimiento si no existen
+        if not hasattr(self, 'frame_cache'):
+            # Usamos un diccionario limitado para caché de frames frecuentes
+            self.frame_cache = {}
+            self.frame_cache_size = 100  # Ajustar según memoria disponible
+            self.last_position = -1  # Para seguimiento de posición
+        
+        # 2. Consultar caché primero (mejora extrema para frames accedidos repetidamente)
+        if frame_number in self.frame_cache:
+            return self.frame_cache[frame_number]
+        
+        # 3. Optimización para acceso secuencial (evita seeks innecesarios)
+        if hasattr(self, 'last_position') and frame_number == self.last_position + 1:
+            # El frame solicitado es el siguiente al último leído
+            ret, frame = self.cap.read()
+            if ret:
+                self.last_position = frame_number
+                rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                #rgb_frame = frame
+                
+                # Añadir al caché
+                self.frame_cache[frame_number] = rgb_frame
+                
+                # Mantener tamaño del caché
+                if len(self.frame_cache) > self.frame_cache_size:
+                    # Eliminar el frame más antiguo (menor número)
+                    oldest = min(self.frame_cache.keys())
+                    del self.frame_cache[oldest]
+                    
+                return rgb_frame
+            # Si falla la lectura, continuar con método directo
+        
+        # 4. Acceso directo con mecanismo de reintento
+        for attempt in range(3):  # Intentar hasta 3 veces si falla
+            self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+            ret, frame = self.cap.read()
+            
+            if ret:
+                # Actualizar last_position para futuras optimizaciones secuenciales
+                self.last_position = frame_number
+                rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                
+                # Añadir al caché
+                self.frame_cache[frame_number] = rgb_frame
+                
+                # Mantener tamaño del caché
+                if len(self.frame_cache) > self.frame_cache_size:
+                    # Eliminar el frame más antiguo (menor número)
+                    oldest = min(self.frame_cache.keys())
+                    del self.frame_cache[oldest]
+                    
+                return rgb_frame
+                
+            if attempt < 2:  # No reintentar en el último intento
+                # Restaurar el objeto cap en caso de error
+                # Esto ayuda con formatos de video problemáticos
+                if hasattr(self, 'video_path') and self.video_path:
+                    self.cap.release()
+                    self.cap = cv2.VideoCapture(self.video_path)
+        
+        # Si llegamos aquí, todos los intentos fallaron
+        return None
+    
+    def get_frame(self, frame_number: int) -> np.ndarray:
+        
+        if self.cap is None:
+            return None
+
+        '''if frame_number in self.frame_cache:
+            return self.frame_cache[frame_number]'''
+
+        if hasattr(self, 'last_position') and frame_number == self.last_position + 1:
+            ret, frame = self.cap.read()
+            if ret:
+                self.last_position = frame_number
+                rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                self.frame_cache[frame_number] = rgb_frame
+                if len(self.frame_cache) > self.frame_cache_size:
+                    self.frame_cache.popitem(last=False)  # Remove oldest item
+                return cv2.resize(rgb_frame, (849, 477))
+
+        for attempt in range(3):
+
+            self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+            ret, frame = self.cap.read()
+            if ret:
+                self.last_position = frame_number
+                rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                self.frame_cache[frame_number] = rgb_frame
+                if len(self.frame_cache) > self.frame_cache_size:
+                    self.frame_cache.popitem(last=False)
+                
+                return cv2.resize(rgb_frame, (854,480), interpolation=cv2.INTER_LINEAR)
+
+            if attempt < 2 and hasattr(self, 'video_path') and self.video_path:
+                self.cap.release()
+                self.cap = cv2.VideoCapture(self.video_path)
+            
+        print(f"Error reading frame {frame_number}, retrying...")
+        return None
+    
+    def get_frame_example(self, frame_number: int) -> np.ndarray:
+        """
+        Obtiene un frame específico del video con optimizaciones de rendimiento
+        
+        Args:
+            frame_number: Número del frame a obtener
+            
+        Returns:
+            Frame como array NumPy (formato RGB) o None si no está disponible
+        """
+        if self.cap is None:
+            return None
+        print(f"Frame number: {frame_number}")
+        
+        # 1. Inicializar atributos de seguimiento si no existen
+        if not hasattr(self, 'frame_cache'):
+            # Usamos un diccionario limitado para caché de frames frecuentes
+            self.frame_cache = {}
+            self.frame_cache_size = 30  # Ajustar según memoria disponible
+            self.last_position = -1  # Para seguimiento de posición
+        
+        # 2. Consultar caché primero (mejora extrema para frames accedidos repetidamente)
+        if frame_number in self.frame_cache:
+            return self.frame_cache[frame_number]
+        
+        # 4. Acceso directo con mecanismo de reintento
+        for attempt in range(3):  # Intentar hasta 3 veces si falla
+            try:
+                self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+                ret, frame = self.cap.read()
+                
+                if ret:
+                    # Actualizar last_position para futuras optimizaciones secuenciales
+                    self.last_position = frame_number
+                    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    
+                    # Añadir al caché
+                    self.frame_cache[frame_number] = rgb_frame
+                    
+                    # Mantener tamaño del caché
+                    if len(self.frame_cache) > self.frame_cache_size:
+                        # Eliminar el frame más antiguo (menor número)
+                        oldest = min(self.frame_cache.keys())
+                        del self.frame_cache[oldest]
+                        
+                    return rgb_frame
+            except:
+                pass
+                
+            if attempt < 2:  # No reintentar en el último intento
+                # Restaurar el objeto cap en caso de error
+                # Esto ayuda con formatos de video problemáticos
+                if hasattr(self, 'video_path') and self.video_path:
+                    self.cap.release()
+                    self.cap = cv2.VideoCapture(self.video_path)
+
+        
+        # Si llegamos aquí, todos los intentos fallaron
+        return None
+    
+    @profiler.track_time    
+    def mask_helmet_yolo(self, color_image: np.ndarray, helmet_height_ratio: float = 0.3, prev_mask: np.ndarray = None) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Usa YOLOv8 para segmentar el casco y lo pinta de verde.
+        Si se proporciona una máscara previa, la reutiliza.
+        Args:
+            color_image: Imagen en color (BGR).
+            helmet_height_ratio: Proporción de la imagen a considerar como región del casco (parte inferior).
+            prev_mask: Máscara previa para reutilizar (opcional).
+        Returns:
+            Tuple: (Imagen con la región del casco pintada de verde, Máscara generada o reutilizada).
+        """
+        # Copia de la imagen
+        result_1 = color_image.copy()
+        height, width = color_image.shape[:2]
+
+        # Si hay una máscara previa, reutilizarla
+        if prev_mask is not None:
+            mask_final = prev_mask
+        else:
+            # Convertir la imagen a RGB (YOLOv8 espera imágenes en RGB)
+            image_rgb = cv2.cvtColor(color_image, cv2.COLOR_BGR2RGB)
+
+            # Realizar la predicción con YOLOv8
+            results = self.yolo_model(image_rgb, conf=0.2, iou=0.5,imgsz=224)  # Ajusta conf e iou según necesidad
+
+            # Inicializar máscara vacía
+            mask_final = np.zeros((height, width), dtype=np.uint8)
+
+            # Procesar los resultados de segmentación
+            if results[0].masks is not None:
+                for result in results:
+                    masks = result.masks.data.cpu().numpy()  # Máscaras de segmentación
+                    boxes = result.boxes.xyxy.cpu().numpy()  # Cajas delimitadoras
+                    classes = result.boxes.cls.cpu().numpy()  # Clases predichas
+
+                    # Filtrar para la clase del casco (asumiendo que es la clase 0 o 'helmet')
+                    # Si usas un modelo pre-entrenado en COCO, la clase 'helmet' no existe, usa 'person' (clase 0) y ROI
+                    for i, cls in enumerate(classes):
+                        # Ajusta según la clase de tu modelo. Ejemplo: clase 0 para 'helmet' en modelo personalizado
+                        if int(cls) == 0:  # Cambia según el índice de clase de tu modelo
+                            # Obtener la máscara correspondiente
+                            '''mask = masks[i]
+                            # Redimensionar la máscara al tamaño de la imagen
+                            mask = cv2.resize(mask, (width, height), interpolation=cv2.INTER_NEAREST)
+                            mask = (mask > 0).astype(np.uint8) * 255  # Convertir a binario (0 o 255)
+
+                            # Opcional: Filtrar usando la ROI inferior para enfocarse en el casco
+                            roi_height = int(height * helmet_height_ratio)
+                            roi_mask = np.zeros((height, width), dtype=np.uint8)
+                            roi_mask[height - roi_height:, :] = 255  # Parte inferior
+                            mask = cv2.bitwise_and(mask, roi_mask)
+
+                            
+
+                            # Combinar máscaras si hay múltiples detecciones
+                            mask_final = cv2.bitwise_or(mask_final, mask)'''
+
+                            mask = masks[i]
+                            mask = cv2.resize(mask, (width, height), interpolation=cv2.INTER_NEAREST)
+                            mask = (mask > 0).astype(np.uint8) * 255
+                            mask_final = cv2.bitwise_or(mask_final, mask)
+
+                # Refinar la máscara con operaciones morfológicas
+                kernel = np.ones((5, 5), np.uint8)
+                mask_final = cv2.erode(mask_final, kernel, iterations=1)  # Eliminar ruido
+                mask_final = cv2.dilate(mask_final, kernel, iterations=3)  # Expandir para cubrir el casco
+
+            else:
+                # Si no se detecta casco, devolver la imagen sin cambios y máscara vacía
+                print("No helmet detected in this frame.")
+                return result_1, mask_final
+
+        # Crear una imagen verde del mismo tamaño que la imagen original
+        green_color = np.zeros_like(color_image)  # Crear una imagen vacía
+        green_color[:, :] = [125, 125, 125]  # Color verde en BGR (0, 255, 0)
+
+        # Aplicar la máscara para pintar solo la región del casco
+        masked_green = cv2.bitwise_and(green_color, green_color, mask=mask_final)
+
+        # Crear máscara invertida para conservar el resto de la imagen
+        mask_inv = cv2.bitwise_not(mask_final)
+
+        # Combinar la región verde con el resto de la imagen original    
+        
+        result_original = cv2.bitwise_and(result_1, result_1, mask=mask_inv)
+        result = cv2.add(masked_green, result_original)
+
+        return result, mask_final
+    
+    def mask_helmet(self, img):
+        """Mask the helmet region using SAM and paint it green."""
+        print("Processing frame...")
+        
+        img = cv2.resize(img, (224, 224), interpolation=cv2.INTER_LINEAR)
+        height, width = img.shape[:2]
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+        outputs = self.model.run(None, {"images":preprocess_image_tensor(img)})
+        print("test")
+        flag,result = postprocess_outputs(outputs, height, width)
+
+        
+        
+
+        # Procesar los resultados de segmentación
+
+        if flag is True:
+            result_image = img.copy()
+            overlay = np.zeros_like(img, dtype=np.uint8)
+            color = (125, 125, 125, 255)  # RGBA color for the helmet
+            # Extract RGB and alpha from color
+            fill_color = color[:3]  # (R, G, B) = (125, 125, 125)
+            alpha = color[3] / 255.0  # Normalize alpha to [0, 1]
+            
+            for obj in result:
+                x1, y1, x2, y2, _, _, _, polygon = obj
+                # Translate polygon coordinates relative to (x1, y1)
+                polygon = [(round(x1 + point[0]), round(y1 + point[1])) for point in polygon]
+                # Convert polygon to format required by cv2.fillPoly
+                pts = np.array(polygon, dtype=np.int32).reshape((-1, 1, 2))
+                # Draw filled polygon on overlay
+                cv2.fillPoly(overlay, [pts], fill_color)
+            
+            # Create alpha mask for blending
+            mask = np.any(overlay != 0, axis=2).astype(np.float32)
+            alpha_mask = mask * alpha
+
+            for c in range(3):  # For each color channel
+                result_image[:, :, c] = (1 - alpha_mask) * result_image[:, :, c] + alpha_mask * overlay[:, :, c]
+
+            return result_image
+        else:
+            # Si no se detecta casco, devolver la imagen sin cambios y máscara vacía
+            print("No helmet detected in this frame.")
+            return img
+
+    def extract_frames1(self, start_frame: int, end_frame: int, fps_target: int = 10) -> List[np.ndarray]:
+        """
+        Extract frames con procesamiento vectorizado para mayor rendimiento, actualizando la máscara cada 10 frames.
+        """
+        frames, crude_frames = [], []
+
+        # Calculate the total number of frames in the selection
+        total_frames_selection = end_frame - start_frame + 1
+
+        # Calculate the duration of the selection in seconds
+        selection_duration = total_frames_selection / self.fps
+
+        # Calculate total frames to extract based on target fps
+        frames_to_extract = int(selection_duration * fps_target)
+        frames_to_extract = max(1, frames_to_extract)
+
+        # Vectorizar cálculo de índices
+        if frames_to_extract < total_frames_selection:
+            frame_indices = np.linspace(start_frame, end_frame, frames_to_extract, dtype=int)
+        else:
+            frame_indices = np.arange(start_frame, end_frame + 1)
+        counter = 0
+        # Procesamiento por lotes para reducir sobrecarga de función
+        BATCH_SIZE =150
+        last_mask = None  # Almacenar la última máscara generada
+
+        for i in range(0, len(frame_indices), BATCH_SIZE):
+            batch_indices = frame_indices[i:i+BATCH_SIZE]
+            batch_frames = []
+            
+
+            # Extract the frames in the current batch
+            for frame_num in batch_indices:
+                frame = self.get_frame(frame_num)
+                if frame is not None:
+                    batch_frames.append((frame_num, frame))
+
+            # Process the batch of frames
+            if batch_frames:
+                for idx, (frame_num, frame) in enumerate(batch_frames):
+                    cropped = self.crop_frame(frame)
+
+                    result = self.mask_helmet(cropped)
+
+                    clahe_image = self.apply_clahe(result)
+
+                    threshold_image = self.apply_treshold(clahe_image)
+
+                    frames.append(threshold_image)
+
+        return frames, crude_frames
+
+    def extract_frames(self, start_frame: int, end_frame: int, fps_target: int = 10) -> List[np.ndarray]:
+        frames, crude_frames = [], []
+
+        total_frames_selection = end_frame - start_frame + 1
+        selection_duration = total_frames_selection / self.fps
+        frames_to_extract = max(1, int(selection_duration * fps_target))
+        frame_indices = np.linspace(start_frame, end_frame, frames_to_extract, dtype=int) if frames_to_extract < total_frames_selection else np.arange(start_frame, end_frame + 1)
+
+        BATCH_SIZE = 64
+
+        def process_frame(frame_data):
+            frame_num, frame = frame_data
+            if frame is None:
+                return None
+            cropped = self.crop_frame(frame)
+            result = self.mask_helmet(cropped)
+            clahe_image = self.apply_clahe(result)
+            threshold_image = self.apply_treshold(clahe_image)
+            return threshold_image
+
+        for i in range(0, len(frame_indices), BATCH_SIZE):
+            batch_indices = frame_indices[i:i+BATCH_SIZE]
+            batch_frames = [(idx, self.get_frame(idx)) for idx in batch_indices]
+            with ThreadPoolExecutor(max_workers=2) as executor:  # Adjust max_workers based on CPU cores
+                batch_results = list(executor.map(process_frame, [f for f in batch_frames if f[1] is not None]))
+            frames.extend([r for r in batch_results if r is not None])
+
+        return frames, crude_frames
+
+
+    @profiler.track_time
+    def crop_frame(self,image):
+
+         
+        if image is None:
+            print(f"Error loading")
+            return None
+        
+        height, width, _ = image.shape
+
+        # Use the bottom half of the image
+        #y_start = int(height * 0.53)
+                   # 55% of the height
+        y_start = int(height * self.y_start)  # 55% of the height
+        crop_height = height - y_start         # height of bottom half
+        square_size = crop_height              # base crop height
+
+        # Increase width by 30%: new_width equals 130% of square_size
+        new_width = square_size
+
+        # Shift the crop center 20% to the right.
+        # Calculate the desired center position.
+        #x_center = int(width * 0.57)
+        x_center = int(width * self.x_center)
+        x_start = max(0, x_center - new_width // 2)
+        x_end = x_start + new_width
+
+        # Adapt the crop if x_end exceeds the image width
+        if x_end > width:
+            x_end = width
+            x_start = max(0, width - new_width)
+
+        # Crop the image: bottom half in height and new_width in horizontal dimension
+        cropped_image = image[y_start:y_start+crop_height, x_start:x_end]
+
+        
+        print(cropped_image.shape)
+        return cropped_image
+    
+    def crop_frame_example(self,image):
+
+        if image is None:
+            print(f"Error loading")
+            return None
+        
+        height, width, _ = image.shape
+
+        # Use the bottom half of the image
+        #y_start = int(height * 0.53)
+                   # 55% of the height
+        y_start = int(height * self.y_start)  # 55% of the height
+        crop_height = height - y_start         # height of bottom half
+        square_size = crop_height              # base crop height
+
+        # Increase width by 30%: new_width equals 130% of square_size
+        new_width = square_size
+
+        # Shift the crop center 20% to the right.
+        # Calculate the desired center position.
+        #x_center = int(width * 0.57)
+        x_center = int(width * self.x_center)
+        x_start = max(0, x_center - new_width // 2)
+        x_end = x_start + new_width
+
+        # Adapt the crop if x_end exceeds the image width
+        if x_end > width:
+            x_end = width
+            x_start = max(0, width - new_width)
+
+        # Crop the image: bottom half in height and new_width in horizontal dimension
+        cropped_image = image[y_start:y_start+crop_height, x_start:x_end]
+        cropped_image = recortar_imagen(cropped_image,self.starty, self.axes)
+        cropped_image = recortar_imagen_again(cropped_image,self.starty, self.axes)
+        #print(self.starty, self.axes, self.y_start, self.x_center)
+        return cropped_image
+
+    @profiler.track_time
+    def apply_clahe(self, image):
+
+        image = recortar_imagen(image,self.starty, self.axes)
+        if self.mode == "Default":
+            clahe_image = cv2.createCLAHE(clipLimit=5.0, tileGridSize=(3, 3)).apply(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY))
+        
+        elif self.mode == "Low ilumination":
+            clahe_image = cv2.createCLAHE(clipLimit=7.0, tileGridSize=(3, 3)).apply(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY))
+        #clahe_image = cv2.equalizeHist(image)
+        return clahe_image
+    
+    @profiler.track_time
+    def apply_treshold(self, image):
+
+        #try:
+        # Process the image with adaptive edge detection (target 6% de bordes)
+        '''_, edges, _, config = adaptive_edge_detection(
+            image, 
+            min_edge_percentage=3,
+            max_edge_percentage=6,
+            target_percentage=5,
+            max_attempts=5
+        )'''
+        percentage = calculate_black_pixels_percentage(image)
+        _, edges, _, config = adaptive_edge_detection(
+            image, 
+            min_edge_percentage=percentage,
+            max_edge_percentage=percentage,
+            target_percentage=percentage,
+            max_attempts=1,
+            mode = self.mode
+        )
+        
+        # Save the edge image
+        if edges is not None:
+            edges = recortar_imagen_again(edges,self.starty, self.axes)
+            return edges
+            
+    
+    def __del__(self):
+        if self.cap is not None:
+            self.cap.release()
+        self.clear_cache()  # Ensure cache is cleared on object deletion
+