Update src/streamlit_app.py

src/streamlit_app.py

@@ -4,115 +4,115 @@ import numpy as np
 from sklearn.preprocessing import StandardScaler
 from sklearn.neighbors import KNeighborsRegressor
 
-# ---------------------------------------------------------
-# 1. macOS STYLING (CSS Injection)
-# ---------------------------------------------------------
-st.set_page_config(page_title="Mac-Mod Tuner", page_icon="🖥️", layout="wide")
+# ---------------------------
+# 1. Configuration & Custom CSS (MacOS Theme)
+# ---------------------------
+st.set_page_config(
+    page_title="DynoPro for Mac",
+    page_icon="🖥️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
 
+# Custom CSS for the Apple/MacOS Aesthetic
 st.markdown("""
-<style>
-    /* Main Background - Apple Light Grey */
+    <style>
+    /* Main Background - Apple Light Gray */
     .stApp {
-        background-color: #f5f5f7;
+        background-color: #F5F5F7;
         font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
     }
     
-    /* Sidebar Styling */
+    /* Sidebar - White with border */
     section[data-testid="stSidebar"] {
-        background-color: #e8e8ed; /* Slightly darker grey */
-        border-right: 1px solid #d1d1d6;
+        background-color: #FFFFFF;
+        border-right: 1px solid #E5E5E5;
     }
     
-    /* Card/Container Styling (The "Window" look) */
-    div[data-testid="stVerticalBlock"] > div[style*="background-color"] {
-        background-color: white;
-        border-radius: 18px;
-        padding: 20px;
-        box-shadow: 0 4px 20px rgba(0,0,0,0.05);
-        border: 1px solid #e5e5ea;
-    }
-
-    /* Input Widgets - Rounded pills */
-    .stSelectbox > div > div {
-        border-radius: 12px;
-        border: 1px solid #d1d1d6;
-    }
-    .stNumberInput > div > div > input {
-        border-radius: 12px;
-    }
-    
-    /* Metrics Styling */
-    div[data-testid="stMetricValue"] {
+    /* Headings */
+    h1, h2, h3 {
+        color: #1D1D1F;
         font-weight: 600;
-        color: #1d1d1f;
     }
     
-    /* Headers */
-    h1, h2, h3 {
-        color: #1d1d1f;
-        font-weight: 700;
-        letter-spacing: -0.5px;
+    /* Metrics - Card Style */
+    div[data-testid="stMetric"] {
+        background-color: #FFFFFF;
+        padding: 15px;
+        border-radius: 12px;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.04);
+        border: 1px solid #EAEAEA;
     }
     
-    /* Custom "Traffic Lights" for visual flair */
-    .traffic-lights {
-        display: flex;
-        gap: 8px;
+    /* Custom Container Card */
+    .mac-card {
+        background-color: #FFFFFF;
+        padding: 20px;
+        border-radius: 16px;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.05);
         margin-bottom: 20px;
     }
-    .dot { width: 12px; height: 12px; border-radius: 50%; }
-    .red { background-color: #ff5f57; border: 1px solid #e0443e; }
-    .yellow { background-color: #febc2e; border: 1px solid #d89e24; }
-    .green { background-color: #28c840; border: 1px solid #1aab29; }
-</style>
-""", unsafe_allow_html=True)
-
-# ---------------------------------------------------------
-# 2. DATA & MODEL (Expanded for V10/V12 & Nitrous)
-# ---------------------------------------------------------
+    
+    /* Button Styling */
+    .stButton>button {
+        border-radius: 8px;
+        background-color: #0071E3;
+        color: white;
+        border: none;
+    }
+    </style>
+    """, unsafe_allow_html=True)
 
+# ---------------------------
+# 2. Advanced Dataset Generation
+# ---------------------------
 @st.cache_resource
-def train_model():
+def build_engine_model(n=800):
     np.random.seed(42)
-    n = 1000 # More data for better accuracy with V12s
     data = []
 
     for _ in range(n):
         # Expanded Engine Options
-        engine = np.random.choice([1.6, 2.0, 2.4, 3.0, 3.8, 4.0, 5.0, 5.2, 6.0, 6.5])
-        cyl = np.random.choice([4, 6, 8, 10, 12])
+        cyl = np.random.choice([3, 4, 5, 6, 8, 10, 12])
         
-        # Base HP logic (roughly 80-120 hp per liter depending on tech)
-        base_hp = int(engine * np.random.uniform(60, 110)) 
+        # Displacement logic based on cyl
+        if cyl <= 4: engine = np.random.uniform(1.0, 2.5)
+        elif cyl <= 6: engine = np.random.uniform(2.5, 4.0)
+        elif cyl <= 8: engine = np.random.uniform(4.0, 6.2)
+        else: engine = np.random.uniform(5.0, 8.4) # V10/V12
         
-        # Mods
-        intake = np.random.choice([0, 1, 2])       # Stock/Sport/Race
-        exhaust = np.random.choice([0, 1, 2, 3])   # Stock/Catback/Headers/Straight
+        # Base HP Calculation (more realistic variance)
+        specific_output = np.random.uniform(60, 110) # HP per Liter
+        base_hp = int(engine * specific_output)
+
+        # Mods (0=Stock)
+        intake = np.random.choice([0, 1, 2])       # Stock/CAI/Race
+        headers = np.random.choice([0, 1])         # Stock/Aftermarket
+        exhaust = np.random.choice([0, 1, 2])      # Stock/Sport/Straight
         induction = np.random.choice([0, 1, 2, 3]) # None/Turbo/Twin-Turbo/Super
-        cams = np.random.choice([0, 1, 2])         # Stock/Street/Track
-        nitrous = np.random.choice([0, 1])         # No/Yes (50 shot equivalent)
+        intercooler = np.random.choice([0, 1])     # Stock/Upgraded
         fuel = np.random.choice([0, 1, 2, 3])      # 87/91/93/E85
-        tune = np.random.choice([0, 1, 2])         # None/Stage 1/Stage 2
+        tune = np.random.choice([0, 1, 2, 3])      # None/Stage1/Stage2/Custom
         
-        # Gain Logic
-        gain = (
-            (intake * 3) + 
-            (exhaust * 5) + 
-            (induction * (base_hp * 0.35)) +  # Forced induction is % based
-            (cams * (base_hp * 0.10)) + 
-            (nitrous * 50) + 
-            (tune * (base_hp * 0.08)) + 
-            (fuel * 4) +
+        # Logic: V12s gain more from exhaust/headers, Turbos gain huge from intercoolers
+        hp_gain = (
+            (intake * 4) +
+            (headers * (cyl * 1.5)) + 
+            (exhaust * 8) +
+            (induction * (base_hp * 0.30)) +  # % gain based on base HP
+            (intercooler * (15 if induction > 0 else 0)) +
+            (tune * 15) +
+            (fuel * 5) +
             np.random.uniform(-5, 5)
         )
         
-        # Diminishing returns for small engines with big mods
-        if cyl < 6 and gain > 200: 
-            gain *= 0.8
+        # Diminishing returns for N/A engines
+        if induction == 0:
+            hp_gain = hp_gain * 0.7
 
-        data.append([engine, cyl, base_hp, intake, exhaust, induction, cams, nitrous, fuel, tune, gain])
+        data.append([engine, cyl, base_hp, intake, headers, exhaust, induction, intercooler, fuel, tune, hp_gain])
 
-    columns = ["engine", "cyl", "base_hp", "intake", "exhaust", "induction", "cams", "nitrous", "fuel", "tune", "hp_gain"]
+    columns = ["engine", "cyl", "base_hp", "intake", "headers", "exhaust", "induction", "intercooler", "fuel", "tune", "hp_gain"]
     df = pd.DataFrame(data, columns=columns)
 
     X = df.drop("hp_gain", axis=1)
@@ -126,128 +126,140 @@ def train_model():
     
     return scaler, model
 
-scaler, model = train_model()
-
-# ---------------------------------------------------------
-# 3. SIDEBAR CONTROLS (The "Settings Pane")
-# ---------------------------------------------------------
+scaler, model = build_engine_model()
 
+# ---------------------------
+# 3. Sidebar (The "Control Center")
+# ---------------------------
 with st.sidebar:
-    st.header("⚙️ Configuration")
+    st.title("🎛️ Tuner Studio")
+    st.caption("Vehicle Configuration")
+    
+    st.subheader("Base Vehicle")
+    cyl = st.select_slider("Cylinders", options=[3, 4, 5, 6, 8, 10, 12], value=6)
+    engine = st.number_input("Displacement (L)", 1.0, 8.4, 3.0, step=0.1)
+    base_hp = st.number_input("Factory Horsepower", 80, 1200, 300, step=10)
+    
+    st.markdown("---")
+    st.subheader("Modifications")
     
-    with st.expander("🚙 Base Vehicle Stats", expanded=True):
-        col_eng_1, col_eng_2 = st.columns(2)
-        with col_eng_1:
-            cyl = st.selectbox("Cylinders", [4, 5, 6, 8, 10, 12])
-        with col_eng_2:
-            engine = st.selectbox("Size (L)", [1.6, 2.0, 2.5, 3.0, 3.5, 4.0, 5.0, 5.2, 6.0, 6.5, 8.4])
-            
-        base_hp = st.number_input("Factory HP", 100, 1000, 300)
-
-    with st.expander("🔧 Bolt-on Modifications", expanded=True):
-        intake = st.selectbox("Intake", ["Stock", "High Flow Filter", "Cold Air Intake"])
-        exhaust = st.selectbox("Exhaust", ["Stock", "Cat-back", "Long Tube Headers", "Full Straight Pipe"])
-
-    with st.expander("🔥 Internals & Boost", expanded=True):
+    # Air & Exhaust
+    with st.expander("💨 Air & Exhaust", expanded=True):
+        intake = st.selectbox("Intake", ["Stock", "Cold Air", "Race Intake"])
+        headers = st.toggle("Aftermarket Headers")
+        exhaust = st.select_slider("Exhaust System", options=["Stock", "Sport Cat-back", "Straight Pipe"])
+
+    # Engine & Power Adders
+    with st.expander("⚡ Induction & Tune", expanded=True):
         induction = st.selectbox("Forced Induction", ["Naturally Aspirated", "Single Turbo", "Twin Turbo", "Supercharger"])
-        cams = st.selectbox("Camshafts", ["Stock", "Street Profile", "Track/Race Profile"])
-        nitrous = st.checkbox("Nitrous Oxide System (NOS)", value=False)
-
-    with st.expander("💻 Tuning & Fuel", expanded=True):
-        fuel = st.selectbox("Fuel Type", ["87 Octane", "91 Octane", "93 Octane", "E85 (Ethanol)"])
-        tune = st.selectbox("ECU Map", ["Stock Map", "Stage 1", "Stage 2"])
-
-# ---------------------------------------------------------
-# 4. MAIN DASHBOARD (The "App View")
-# ---------------------------------------------------------
-
-# Prediction Mappings
-intake_map = {"Stock":0, "High Flow Filter":1, "Cold Air Intake":2}
-exhaust_map = {"Stock":0, "Cat-back":1, "Long Tube Headers":2, "Full Straight Pipe":3}
-induction_map = {"Naturally Aspirated":0, "Single Turbo":1, "Twin Turbo":2, "Supercharger":3}
-cams_map = {"Stock":0, "Street Profile":1, "Track/Race Profile":2}
-nitrous_map = {False:0, True:1}
-fuel_map = {"87 Octane":0, "91 Octane":1, "93 Octane":2, "E85 (Ethanol)":3}
-tune_map = {"Stock Map":0, "Stage 1":1, "Stage 2":2}
-
-# Calculation
-input_data = np.array([[
-    engine, cyl, base_hp,
-    intake_map[intake], exhaust_map[exhaust], induction_map[induction],
-    cams_map[cams], nitrous_map[nitrous], fuel_map[fuel], tune_map[tune]
-]])
+        intercooler = st.toggle("Upgraded Intercooler")
+        tune = st.select_slider("ECU Tune", options=["Stock Map", "Stage 1", "Stage 2", "Custom Dyno"])
+        fuel = st.selectbox("Fuel Type", ["87 Octane", "91 Octane", "93 Octane", "E85 / Race Gas"])
 
-pred = model.predict(scaler.transform(input_data))[0]
-new_hp = base_hp + pred
-pct_gain = (pred / base_hp) * 100
+# ---------------------------
+# 4. Processing
+# ---------------------------
+# Mappings
+map_intake = {"Stock":0, "Cold Air":1, "Race Intake":2}
+map_exhaust = {"Stock":0, "Sport Cat-back":1, "Straight Pipe":2}
+map_induct = {"Naturally Aspirated":0, "Single Turbo":1, "Twin Turbo":2, "Supercharger":3}
+map_tune = {"Stock Map":0, "Stage 1":1, "Stage 2":2, "Custom Dyno":3}
+map_fuel = {"87 Octane":0, "91 Octane":1, "93 Octane":2, "E85 / Race Gas":3}
 
-# --- UI LAYOUT ---
+input_vector = np.array([[
+    engine, cyl, base_hp,
+    map_intake[intake],
+    1 if headers else 0,
+    map_exhaust[exhaust],
+    map_induct[induction],
+    1 if intercooler else 0,
+    map_fuel[fuel],
+    map_tune[tune]
+]])
 
-# 1. Header with Fake Window Controls
-st.markdown("""
-    <div class="traffic-lights">
-        <div class="dot red"></div>
-        <div class="dot yellow"></div>
-        <div class="dot green"></div>
-    </div>
-""", unsafe_allow_html=True)
+input_scaled = scaler.transform(input_vector)
+pred_gain = model.predict(input_scaled)[0]
+final_hp = base_hp + pred_gain
 
-st.title("Performance Estimator Pro")
-st.markdown(f"Analysis for **{cyl}-Cylinder {engine}L Engine**")
+# ---------------------------
+# 5. Main Dashboard (MacOS Style)
+# ---------------------------
 
-st.divider()
+# Header
+st.markdown("### 🏎️ Dyno Simulation Results")
+st.markdown("This dashboard estimates power output based on component synergy.")
+st.write("") # Spacer
 
-# 2. Main Hero Section (Glass Cards)
-col1, col2 = st.columns([1.5, 1])
+# Top Row: The "Hero" Cards
+col1, col2 = st.columns([1, 2])
 
 with col1:
-    st.markdown("### 📈 Dyno Projection")
-    # Area chart looks cleaner/more modern than bar
-    chart_data = pd.DataFrame({
-        "Horsepower": [base_hp, new_hp],
-        "Stage": ["Factory", "Modified"]
-    })
-    
-    # Custom color for the chart to match Apple blue
-    st.vega_lite_chart(chart_data, {
-        "mark": {"type": "bar", "cornerRadiusEnd": 4, "color": "#007AFF"},
-        "encoding": {
-            "x": {"field": "Stage", "type": "nominal", "axis": {"labelAngle": 0}},
-            "y": {"field": "Horsepower", "type": "quantitative"},
-            "tooltip": ["Stage", "Horsepower"]
-        }
-    }, use_container_width=True)
+    # Summary Card
+    with st.container(border=True):
+        st.markdown("**Vehicle Profile**")
+        st.markdown(f"<h1 style='margin:0; font-size: 40px;'>{str(cyl)}<span style='font-size:20px; color:gray'>cyl</span></h1>", unsafe_allow_html=True)
+        st.caption(f"{engine}L Displacement")
+        st.divider()
+        st.write(f"**Induction:** {induction}")
+        st.write(f"**Tune:** {tune}")
 
 with col2:
-    st.markdown("### ⚡ Results")
-    
-    # Container for the metrics
-    with st.container():
-        st.markdown(f"""
-        <div style="padding: 10px;">
-            <span style="font-size: 14px; color: #86868b; text-transform: uppercase; letter-spacing: 1px; font-weight: 600;">Total Power</span>
-            <div style="font-size: 48px; font-weight: 700; color: #1d1d1f; line-height: 1.2;">{int(new_hp)} HP</div>
-        </div>
-        """, unsafe_allow_html=True)
+    # Results Card
+    with st.container(border=True):
+        st.markdown("**Projected Output**")
         
-        st.divider()
+        m1, m2, m3 = st.columns(3)
+        with m1:
+            st.metric("Base Power", f"{base_hp} HP")
+        with m2:
+            st.metric("Gain", f"+{pred_gain:.0f} HP", delta=f"{((pred_gain/base_hp)*100):.1f}%")
+        with m3:
+            st.metric("Total Power", f"{final_hp:.0f} HP", delta="Peak Output")
         
-        c1, c2 = st.columns(2)
-        with c1:
-            st.metric("Gain", f"+{int(pred)} HP")
-        with c2:
-            st.metric("Improvement", f"{pct_gain:.1f}%")
-
-# 3. Spec Summary Row
-st.markdown("### 📋 Build Summary")
-with st.container():
-    c1, c2, c3, c4 = st.columns(4)
-    c1.info(f"**Induction:** {induction}")
-    c2.info(f"**Fuel:** {fuel}")
-    c3.info(f"**Camshafts:** {cams}")
-    c4.info(f"**Nitrous:** {'Enabled' if nitrous else 'Disabled'}")
-
-if pct_gain > 50:
-    st.toast("🚀 Massive gains detected! Check transmission limits.", icon="⚠️")
+        # Progress Bar visual
+        st.write("")
+        st.write("Power Utilization")
+        pct_gain = min((final_hp / (base_hp * 2)), 1.0) # Cap bar at 200% base
+        st.progress(pct_gain)
+
+# Bottom Row: Visualization
+st.write("")
+st.markdown("### 📈 Power Curve Analysis")
+
+with st.container(border=True):
+    # Creating a synthetic RPM curve for visualization
+    rpms = np.linspace(2000, 8000, 50)
+    
+    # Physics approximation for torque curve shape
+    def torque_curve(rpm, peak_hp):
+        peak_rpm = 6500
+        # simplified curve logic
+        return -((rpm - peak_rpm)**2) + (peak_hp * 5000) 
+    
+    # Normalized curves scaled to HP
+    base_curve = [base_hp * (1 - ((x - 6500)/5000)**2) * (x/8000) for x in rpms]
+    mod_curve = [final_hp * (1 - ((x - 6500)/5000)**2) * (x/8000) for x in rpms]
+    
+    chart_data = pd.DataFrame({
+        "RPM": np.tile(rpms, 2),
+        "Horsepower": np.concatenate([base_curve, mod_curve]),
+        "Setup": ["Factory Stock"] * 50 + ["Modified"] * 50
+    })
 
+    # Use Streamlit's native area chart but configure it to look clean
+    st.area_chart(
+        chart_data, 
+        x="RPM", 
+        y="Horsepower", 
+        color="Setup",
+        stack=False # Overlay them
+    )
+
+# Footer / "Dock" feel
+st.divider()
+cols = st.columns(4)
+cols[0].info(f"Fuel: {fuel}")
+cols[1].info(f"Exhaust: {exhaust}")
+cols[2].info(f"Headers: {'Yes' if headers else 'No'}")
+cols[3].info(f"Intercooler: {'Yes' if intercooler else 'No'}")