Update app.py

app.py

@@ -3,8 +3,8 @@ import librosa
 import numpy as np
 import pandas as pd
 from sklearn.cluster import KMeans, AgglomerativeClustering, DBSCAN
+from sklearn.preprocessing import StandardScaler
 from sklearn.metrics.pairwise import cosine_similarity
-from scipy.spatial.distance import jensenshannon
 from scipy import signal
 from scipy.signal import get_window as scipy_get_window
 import plotly.express as px
@@ -13,52 +13,35 @@ import os
 import tempfile
 
 # ----------------------------
-# 1. Signal Alignment & Preprocessing (NEW)
+# 1. Signal Alignment & Preprocessing
 # ----------------------------
 def align_signals(ref, target):
-    """
-    Aligns target signal (Far Field) to reference signal (Near Field) 
-    using Cross-Correlation to fix time-of-arrival delays.
-    """
-    # Normalize both to prevent amplitude from skewing correlation
+    """Aligns target signal to reference signal using Cross-Correlation."""
     ref_norm = librosa.util.normalize(ref)
     target_norm = librosa.util.normalize(target)
     
-    # correlated = signal.correlate(target_norm, ref_norm, mode='full')
-    # Use FFT-based correlation for speed on longer audio
     correlation = signal.fftconvolve(target_norm, ref_norm[::-1], mode='full')
     lags = signal.correlation_lags(len(target_norm), len(ref_norm), mode='full')
-    
     lag = lags[np.argmax(correlation)]
     
-    print(f"Calculated Lag: {lag} samples")
-
     if lag > 0:
-        # Target is "ahead" (starts later in the array structure relative to overlap)
-        # Shift target back
         aligned_target = target[lag:]
         aligned_ref = ref
     else:
-        # Target is "behind" (delayed), typical for Far Field
-        # Shift target forward (padding start) or slice Ref
-        # Easier strategy: slice Ref to match where Target starts
         aligned_target = target
         aligned_ref = ref[abs(lag):]
 
-    # Truncate to same length
     min_len = min(len(aligned_ref), len(aligned_target))
     return aligned_ref[:min_len], aligned_target[:min_len]
 
 # ----------------------------
-# 2. Segment Audio into Frames
+# 2. Segment Audio
 # ----------------------------
 def segment_audio(y, sr, frame_length_ms, hop_length_ms, window_type="hann"):
     frame_length = int(frame_length_ms * sr / 1000)
     hop_length = int(hop_length_ms * sr / 1000)
     window = scipy_get_window(window_type if window_type != "rectangular" else "boxcar", frame_length)
     frames = []
-    
-    # Pad to ensure we don't drop the last partial frame
     y_padded = np.pad(y, (0, frame_length), mode='constant')
     
     for i in range(0, len(y) - frame_length + 1, hop_length):
@@ -81,8 +64,6 @@ def extract_features_with_spectrum(frames, sr):
     
     for i in range(frames.shape[1]):
         frame = frames[:, i]
-        
-        # Skip empty/silent frames to prevent NaN
         if len(frame) < n_fft or np.max(np.abs(frame)) < 1e-10:
             feat = {k: 0.0 for k in ["rms", "spectral_centroid", "zcr", "spectral_flatness", 
                                      "low_freq_energy", "mid_freq_energy", "high_freq_energy"]}
@@ -92,38 +73,28 @@ def extract_features_with_spectrum(frames, sr):
             continue
 
         feat = {}
-        # Basic
         feat["rms"] = float(np.mean(librosa.feature.rms(y=frame)[0]))
         feat["zcr"] = float(np.mean(librosa.feature.zero_crossing_rate(frame)[0]))
         
-        # Spectral
-        try:
-            feat["spectral_centroid"] = float(np.mean(librosa.feature.spectral_centroid(y=frame, sr=sr)[0]))
+        try: feat["spectral_centroid"] = float(np.mean(librosa.feature.spectral_centroid(y=frame, sr=sr)[0]))
         except: feat["spectral_centroid"] = 0.0
             
-        # Reverb Metric (NEW)
-        try:
-            feat["spectral_flatness"] = float(np.mean(librosa.feature.spectral_flatness(y=frame)[0]))
+        try: feat["spectral_flatness"] = float(np.mean(librosa.feature.spectral_flatness(y=frame)[0]))
         except: feat["spectral_flatness"] = 0.0
 
-        # MFCC
         try:
             mfccs = librosa.feature.mfcc(y=frame, sr=sr, n_mfcc=n_mfcc, n_fft=n_fft)
-            for j in range(n_mfcc):
-                feat[f"mfcc_{j+1}"] = float(np.mean(mfccs[j]))
+            for j in range(n_mfcc): feat[f"mfcc_{j+1}"] = float(np.mean(mfccs[j]))
         except:
             for j in range(n_mfcc): feat[f"mfcc_{j+1}"] = 0.0
 
-        # Frequency Bands
         try:
             S = np.abs(librosa.stft(frame, n_fft=n_fft))
             S_db = librosa.amplitude_to_db(S, ref=np.max)
             freqs = librosa.fft_frequencies(sr=sr, n_fft=n_fft)
-            
             low_mask = freqs <= 2000
             mid_mask = (freqs > 2000) & (freqs <= 4000)
             high_mask = freqs > 4000
-            
             feat["low_freq_energy"] = float(np.mean(S_db[low_mask])) if np.any(low_mask) else -80.0
             feat["mid_freq_energy"] = float(np.mean(S_db[mid_mask])) if np.any(mid_mask) else -80.0
             feat["high_freq_energy"] = float(np.mean(S_db[high_mask])) if np.any(high_mask) else -80.0
@@ -133,299 +104,303 @@ def extract_features_with_spectrum(frames, sr):
             feat["spectrum"] = np.zeros((n_fft // 2 + 1, 1))
             
         features.append(feat)
-        
     return features
 
 # ----------------------------
-# 4. Frame Comparison Logic
+# 4. Frame Comparison
 # ----------------------------
 def compare_frames_enhanced(near_feats, far_feats, metrics):
     min_len = min(len(near_feats), len(far_feats))
-    if min_len == 0:
-        return pd.DataFrame({"frame_index": []})
+    if min_len == 0: return pd.DataFrame({"frame_index": []})
 
     results = {"frame_index": list(range(min_len))}
-    near_df = pd.DataFrame([f for f in near_feats[:min_len]])
-    far_df = pd.DataFrame([f for f in far_feats[:min_len]])
+    near_df = pd.DataFrame(near_feats[:min_len])
+    far_df = pd.DataFrame(far_feats[:min_len])
     
-    # Feature Vectors (exclude non-numeric or high-dim cols)
     drop_cols = ["spectrum"]
-    near_vec = near_df.drop(columns=drop_cols, errors="ignore").values
-    far_vec = far_df.drop(columns=drop_cols, errors="ignore").values
+    near_vec = near_df.drop(columns=drop_cols, errors="ignore").select_dtypes(include=[np.number]).values
+    far_vec = far_df.drop(columns=drop_cols, errors="ignore").select_dtypes(include=[np.number]).values
 
-    # Euclidean Distance
     if "Euclidean Distance" in metrics:
         results["euclidean_dist"] = np.linalg.norm(near_vec - far_vec, axis=1).tolist()
 
-    # Cosine Similarity
     if "Cosine Similarity" in metrics:
         cos_vals = []
         for i in range(min_len):
             a, b = near_vec[i].reshape(1, -1), far_vec[i].reshape(1, -1)
-            if np.all(a == 0) or np.all(b == 0):
-                cos_vals.append(0.0)
-            else:
-                cos_vals.append(float(cosine_similarity(a, b)[0][0]))
+            if np.all(a == 0) or np.all(b == 0): cos_vals.append(0.0)
+            else: cos_vals.append(float(cosine_similarity(a, b)[0][0]))
         results["cosine_similarity"] = cos_vals
 
-    # High-Freq Loss Ratio
     if "High-Freq Loss Ratio" in metrics:
         loss_ratios = []
         for i in range(min_len):
-            near_high = near_feats[i]["high_freq_energy"]
-            far_high = far_feats[i]["high_freq_energy"]
-            # Energy is in dB (negative), so we look at the difference
-            # Simple diff: Near (-20dB) - Far (-30dB) = 10dB loss
-            diff = near_high - far_high
-            loss_ratios.append(float(diff))
+            loss_ratios.append(float(near_feats[i]["high_freq_energy"] - far_feats[i]["high_freq_energy"]))
         results["high_freq_loss_db"] = loss_ratios
 
-    # Spectral Flatness Difference (Reverberation Check)
-    flatness_diff = []
-    for i in range(min_len):
-        n_flat = near_feats[i]["spectral_flatness"]
-        f_flat = far_feats[i]["spectral_flatness"]
-        flatness_diff.append(f_flat - n_flat) # Postive usually means more noise/reverb
-    results["flatness_increase"] = flatness_diff
-
-    # Spectral Overlap
     overlap_scores = []
     for i in range(min_len):
         near_spec = near_feats[i]["spectrum"].flatten()
         far_spec = far_feats[i]["spectrum"].flatten()
-        if np.all(near_spec == 0) or np.all(far_spec == 0):
-            overlap_scores.append(0.0)
-        else:
-            overlap = float(cosine_similarity(near_spec.reshape(1, -1), far_spec.reshape(1, -1))[0][0])
-            overlap_scores.append(overlap)
+        if np.all(near_spec == 0) or np.all(far_spec == 0): overlap_scores.append(0.0)
+        else: overlap_scores.append(float(cosine_similarity(near_spec.reshape(1, -1), far_spec.reshape(1, -1))[0][0]))
     results["spectral_overlap"] = overlap_scores
 
-    # Combined Quality Score (0 to 1 approximate)
-    # Higher overlap + Higher Cosine + Lower Loss = Better Quality
     combined = []
     for i in range(min_len):
         score = (results["spectral_overlap"][i] * 0.5) 
-        if "cosine_similarity" in results:
-             score += (results["cosine_similarity"][i] * 0.5)
+        if "cosine_similarity" in results: score += (results["cosine_similarity"][i] * 0.5)
         combined.append(score)
     results["combined_match_score"] = combined
     
     return pd.DataFrame(results)
 
 # ----------------------------
-# 5. Clustering & Visualization
+# 5. Dual Clustering Logic
 # ----------------------------
-def cluster_frames_custom(features_df, cluster_features, algo, n_clusters=5, eps=0.5):
+def perform_dual_clustering(near_df, far_df, cluster_features, algo, n_clusters, eps):
+    """
+    Fits clustering on Near Field (clean), then predicts on Far Field (noisy).
+    This ensures Cluster 0 in Near corresponds to the same physical sound in Far.
+    """
     if not cluster_features:
-        return features_df 
-        
-    # Ensure selected features exist in DF
-    valid_features = [f for f in cluster_features if f in features_df.columns]
+        return near_df, far_df
+
+    valid_features = [f for f in cluster_features if f in near_df.columns]
     if not valid_features:
-        return features_df
+        return near_df, far_df
 
-    X = features_df[valid_features].values
+    X_near = near_df[valid_features].values
+    X_near = np.nan_to_num(X_near)
     
-    # Handle NaN/Inf just in case
-    X = np.nan_to_num(X)
+    X_far = far_df[valid_features].values
+    X_far = np.nan_to_num(X_far)
 
-    if len(X) < 5:
-        features_df["cluster"] = -1
-        return features_df
+    # We use a Scaler to ensure features are comparable
+    scaler = StandardScaler()
+    X_near_scaled = scaler.fit_transform(X_near)
+    X_far_scaled = scaler.transform(X_far) # Use same scaler for Far
 
     if algo == "KMeans":
-        n_clusters = min(n_clusters, len(X))
-        model = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
-        labels = model.fit_predict(X)
+        model = KMeans(n_clusters=min(n_clusters, len(X_near)), random_state=42, n_init=10)
+        near_labels = model.fit_predict(X_near_scaled)
+        far_labels = model.predict(X_far_scaled) # Predict using Near model
     elif algo == "Agglomerative":
-        n_clusters = min(n_clusters, len(X))
-        model = AgglomerativeClustering(n_clusters=n_clusters)
-        labels = model.fit_predict(X)
+        # Agglomerative cannot "predict" on new data easily, so we cluster independently
+        # This is a limitation, but acceptable fallback
+        model = AgglomerativeClustering(n_clusters=min(n_clusters, len(X_near)))
+        near_labels = model.fit_predict(X_near_scaled)
+        far_model = AgglomerativeClustering(n_clusters=min(n_clusters, len(X_far)))
+        far_labels = far_model.fit_predict(X_far_scaled) 
     elif algo == "DBSCAN":
-        model = DBSCAN(eps=eps, min_samples=min(3, len(X)))
-        labels = model.fit_predict(X)
+        # DBSCAN also cannot "predict", must fit_predict.
+        model = DBSCAN(eps=eps, min_samples=3)
+        near_labels = model.fit_predict(X_near_scaled)
+        far_labels = model.fit_predict(X_far_scaled)
     else:
-        labels = np.zeros(len(X))
+        near_labels = np.zeros(len(X_near))
+        far_labels = np.zeros(len(X_far))
         
-    features_df = features_df.copy()
-    features_df["cluster"] = labels
-    return features_df
-
-def plot_spectral_difference(near_feats, far_feats, frame_idx=0):
-    if not near_feats or not far_feats:
-        fig = go.Figure(); fig.update_layout(title="No data"); return fig
-        
-    safe_idx = min(frame_idx, len(near_feats)-1, len(far_feats)-1)
-    
-    near_spec = near_feats[safe_idx]["spectrum"]
-    far_spec = far_feats[safe_idx]["spectrum"]
+    near_df = near_df.copy()
+    near_df["cluster"] = near_labels
+    near_df["cluster"] = near_df["cluster"].astype(str) # For categorical coloring
     
-    min_freq_bins = min(near_spec.shape[0], far_spec.shape[0])
-    diff = near_spec[:min_freq_bins] - far_spec[:min_freq_bins]
+    far_df = far_df.copy()
+    far_df["cluster"] = far_labels
+    far_df["cluster"] = far_df["cluster"].astype(str)
+
+    return near_df, far_df
+
+# ----------------------------
+# 6. Plotting Helpers
+# ----------------------------
+def generate_cluster_plot(df, x_attr, y_attr, title_suffix):
+    if len(df) == 0 or x_attr not in df.columns or y_attr not in df.columns:
+        return px.scatter(title="No Data")
     
-    fig = go.Figure(data=go.Heatmap(z=diff, colorscale='RdBu', zmid=0))
-    fig.update_layout(
-        title=f"Spectral Difference (Frame {safe_idx}) [Near - Far]", 
-        yaxis_title="Frequency Bin",
-        xaxis_title="Time (within frame)",
-        height=350
+    fig = px.scatter(
+        df, x=x_attr, y=y_attr, color="cluster",
+        title=f"Clustering Analysis ({title_suffix}): {x_attr} vs {y_attr}",
+        color_discrete_sequence=px.colors.qualitative.Bold # Consistent colors
     )
     return fig
 
+def update_cluster_view(view_mode, near_df, far_df, cluster_features):
+    if near_df is None or far_df is None:
+        return px.scatter(title="Run Analysis First")
+    
+    if len(cluster_features) < 2:
+         return px.scatter(title="Select at least 2 features")
+
+    x_attr, y_attr = cluster_features[0], cluster_features[1]
+    
+    if view_mode == "Near Field":
+        return generate_cluster_plot(near_df, x_attr, y_attr, "Near Field")
+    else:
+        return generate_cluster_plot(far_df, x_attr, y_attr, "Far Field")
+
 # ----------------------------
-# 6. Main Analysis Logic
+# 7. Main Analysis
 # ----------------------------
 def analyze_audio_pair(
     near_file, far_file,
     frame_length_ms, hop_length_ms, window_type,
     comparison_metrics, cluster_features, clustering_algo, n_clusters, dbscan_eps
 ):
-    if not near_file or not far_file:
-        raise gr.Error("Please upload both audio files.")
-
-    # 1. Load Audio
-    # Load Near
-    try:
-        y_near, sr_near = librosa.load(near_file.name, sr=None)
-    except:
-        raise gr.Error("Failed to load Near Field audio.")
-        
-    # Load Far (Force resample to match Near)
-    try:
-        y_far, sr_far = librosa.load(far_file.name, sr=sr_near)
-    except:
-        raise gr.Error("Failed to load Far Field audio.")
+    if not near_file or not far_file: raise gr.Error("Upload both files.")
 
-    # 2. Normalize and Align (CRITICAL STEP)
+    # Load & Align
+    y_near, sr = librosa.load(near_file.name, sr=None)
+    y_far, _ = librosa.load(far_file.name, sr=sr)
+    
     y_near = librosa.util.normalize(y_near)
     y_far = librosa.util.normalize(y_far)
-    
-    gr.Info("Aligning signals (calculating time delay)...")
     y_near, y_far = align_signals(y_near, y_far)
     
-    # 3. Segment
-    frames_near, _ = segment_audio(y_near, sr_near, frame_length_ms, hop_length_ms, window_type)
-    frames_far, _ = segment_audio(y_far, sr_near, frame_length_ms, hop_length_ms, window_type)
+    # Process
+    frames_near, _ = segment_audio(y_near, sr, frame_length_ms, hop_length_ms, window_type)
+    frames_far, _ = segment_audio(y_far, sr, frame_length_ms, hop_length_ms, window_type)
     
-    # 4. Extract
-    gr.Info("Extracting features...")
-    near_feats = extract_features_with_spectrum(frames_near, sr_near)
-    far_feats = extract_features_with_spectrum(frames_far, sr_near)
+    near_feats = extract_features_with_spectrum(frames_near, sr)
+    far_feats = extract_features_with_spectrum(frames_far, sr)
     
-    # 5. Compare
+    # Comparison Data
     comparison_df = compare_frames_enhanced(near_feats, far_feats, comparison_metrics)
     
-    # 6. Cluster (on Near field features usually, to classify phonemes)
-    near_df = pd.DataFrame(near_feats).drop(columns=["spectrum"], errors="ignore")
-    clustered_df = cluster_frames_custom(near_df, cluster_features, clustering_algo, n_clusters, dbscan_eps)
+    # Clustering Data
+    near_df_raw = pd.DataFrame(near_feats).drop(columns=["spectrum"], errors="ignore")
+    far_df_raw = pd.DataFrame(far_feats).drop(columns=["spectrum"], errors="ignore")
     
-    # 7. Visuals
-    metric_cols = [c for c in comparison_df.columns if c != "frame_index"]
-    if metric_cols:
-        plot_comparison = px.line(comparison_df, x="frame_index", y=metric_cols,
-                                  title="Frame-by-Frame Comparison Metrics")
-    else:
-        plot_comparison = px.line(title="No metrics selected")
-
-    if len(cluster_features) >= 2:
-        x_f, y_f = cluster_features[0], cluster_features[1]
-        plot_scatter = px.scatter(clustered_df, x=x_f, y=y_f, color="cluster",
-                                  title=f"Clustering Analysis (Near Field): {x_f} vs {y_f}")
-    else:
-        plot_scatter = px.scatter(title="Select at least 2 features to visualize clusters")
+    # Perform Dual Clustering
+    near_clustered, far_clustered = perform_dual_clustering(
+        near_df_raw, far_df_raw, cluster_features, clustering_algo, n_clusters, dbscan_eps
+    )
 
-    spec_heatmap = plot_spectral_difference(near_feats, far_feats, frame_idx=int(len(near_feats)/2))
+    # 1. Comparison Plot (Dual Axis)
+    plot_comparison = go.Figure()
+    # Axis 1: Similarity (0-1)
+    for col in ["cosine_similarity", "spectral_overlap", "combined_match_score"]:
+        if col in comparison_df.columns:
+            plot_comparison.add_trace(go.Scatter(x=comparison_df["frame_index"], y=comparison_df[col], name=col, yaxis="y1"))
+    # Axis 2: dB Loss
+    if "high_freq_loss_db" in comparison_df.columns:
+        plot_comparison.add_trace(go.Scatter(x=comparison_df["frame_index"], y=comparison_df["high_freq_loss_db"], 
+                                             name="High Freq Loss (dB)", line=dict(color="red", width=1), yaxis="y2"))
     
-    # Metric Overlay: Combine Clustering with Quality
-    # Add combined score to clustered df for visualization
-    clustered_df["match_quality"] = comparison_df["combined_match_score"]
+    plot_comparison.update_layout(
+        title="Comparison Metrics (Dual Axis)",
+        yaxis=dict(title="Similarity (0-1)", range=[0, 1.1]),
+        yaxis2=dict(title="Energy Diff (dB)", overlaying="y", side="right"),
+        legend=dict(x=1.1, y=1)
+    )
+
+    # 2. Initial Cluster Plot (Near Field)
+    init_cluster_plot = update_cluster_view("Near Field", near_clustered, far_clustered, cluster_features)
+
+    # 3. Spectral Heatmap
+    safe_idx = int(len(near_feats)/2)
+    diff = near_feats[safe_idx]["spectrum"] - far_feats[safe_idx]["spectrum"]
+    spec_heatmap = go.Figure(data=go.Heatmap(z=diff, colorscale='RdBu', zmid=0))
+    spec_heatmap.update_layout(title=f"Spectral Diff (Frame {safe_idx})", height=350)
     
+    # 4. Overlay Plot (Simple)
+    near_clustered["match_quality"] = comparison_df["combined_match_score"]
     if len(cluster_features) > 0:
-        overlay_fig = px.scatter(clustered_df, x=cluster_features[0], y="match_quality", 
-                                 color="cluster",
-                                 title=f"Cluster vs. Match Quality ({cluster_features[0]})")
+        overlay_fig = px.scatter(near_clustered, x=cluster_features[0], y="match_quality", color="cluster", 
+                                 title="Cluster vs Quality (Near Field)")
     else:
-        overlay_fig = px.scatter(title="Not enough data for overlay")
+        overlay_fig = px.scatter(title="No features")
 
-    return plot_comparison, comparison_df, plot_scatter, clustered_df, spec_heatmap, overlay_fig
+    # Return: Plots + Dataframes for State + Raw Tables
+    return (plot_comparison, comparison_df, 
+            init_cluster_plot, near_clustered, # Table 
+            spec_heatmap, overlay_fig, 
+            near_clustered, far_clustered) # States
 
-def export_results(comparison_df, clustered_df):
+def export_results(comparison_df, near_df, far_df):
     temp_dir = tempfile.mkdtemp()
-    comp_path = os.path.join(temp_dir, "frame_comparisons.csv")
-    cluster_path = os.path.join(temp_dir, "clustered_frames.csv")
-    comparison_df.to_csv(comp_path, index=False)
-    clustered_df.to_csv(cluster_path, index=False)
-    return [comp_path, cluster_path]
+    p1 = os.path.join(temp_dir, "comparison.csv")
+    p2 = os.path.join(temp_dir, "near_clusters.csv")
+    p3 = os.path.join(temp_dir, "far_clusters.csv")
+    comparison_df.to_csv(p1, index=False)
+    near_df.to_csv(p2, index=False)
+    far_df.to_csv(p3, index=False)
+    return [p1, p2, p3]
 
 # ----------------------------
-# 7. Gradio UI
+# 8. Gradio UI
 # ----------------------------
-# Expanded feature list for UI
 feature_list = ["rms", "spectral_centroid", "zcr", "spectral_flatness", 
-                "low_freq_energy", "mid_freq_energy", "high_freq_energy"] + \
-               [f"mfcc_{i}" for i in range(1, 14)]
-
-with gr.Blocks(title="Corrected Near vs Far Field Analyzer", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🎙️ Corrected Near vs Far Field Analyzer
-    **Now includes:** Automatic Time Alignment (Cross-Correlation), Normalization, and Reverb Detection.
-    """)
+                "low_freq_energy", "mid_freq_energy", "high_freq_energy"] + [f"mfcc_{i}" for i in range(1, 14)]
+
+with gr.Blocks(title="Audio Field Analyzer", theme=gr.themes.Soft()) as demo:
+    # State storage for interactivity
+    state_near_df = gr.State()
+    state_far_df = gr.State()
+
+    gr.Markdown("# 🎙️ Near vs Far Field Analyzer (Dual-Clustering)")
     
     with gr.Row():
-        with gr.Column():
-            near_file = gr.File(label="Near-Field Audio (Reference)", file_types=[".wav", ".mp3"])
-        with gr.Column():
-            far_file = gr.File(label="Far-Field Audio (Target)", file_types=[".wav", ".mp3"])
-
-    with gr.Accordion("⚙️ Analysis Settings", open=False):
-        with gr.Row():
-            frame_length_ms = gr.Slider(10, 200, value=30, step=5, label="Frame Length (ms)")
-            hop_length_ms = gr.Slider(5, 100, value=15, step=5, label="Hop Length (ms)")
-        window_type = gr.Dropdown(["hann", "hamming", "rectangular"], value="hann", label="Window Type")
-
-    with gr.Accordion("📊 Metrics & Clustering", open=False):
-        comparison_metrics = gr.CheckboxGroup(
-            choices=["Euclidean Distance", "Cosine Similarity", "High-Freq Loss Ratio"],
-            value=["Cosine Similarity", "High-Freq Loss Ratio"],
-            label="Comparison Metrics"
-        )
-        cluster_features = gr.CheckboxGroup(
-            choices=feature_list, 
-            value=["spectral_centroid", "spectral_flatness", "high_freq_energy"],
-            label="Features for Clustering (Select >= 2)"
-        )
-        with gr.Row():
-            clustering_algo = gr.Dropdown(["KMeans", "Agglomerative", "DBSCAN"], value="KMeans", label="Algorithm")
-            n_clusters = gr.Slider(2, 10, value=4, step=1, label="Num Clusters")
-            dbscan_eps = gr.Slider(0.1, 5.0, value=0.5, label="DBSCAN Epsilon")
-
-    btn = gr.Button("🚀 Align & Analyze", variant="primary")
+        near_file = gr.File(label="Near-Field (Ref)", file_types=[".wav"])
+        far_file = gr.File(label="Far-Field (Target)", file_types=[".wav"])
+
+    with gr.Accordion("⚙️ Settings", open=False):
+        frame_length_ms = gr.Slider(10, 200, value=30, label="Frame Length (ms)")
+        hop_length_ms = gr.Slider(5, 100, value=15, label="Hop Length (ms)")
+        window_type = gr.Dropdown(["hann", "hamming"], value="hann", label="Window")
+        
+        comparison_metrics = gr.CheckboxGroup(["Cosine Similarity", "High-Freq Loss Ratio"], 
+                                              value=["Cosine Similarity", "High-Freq Loss Ratio"], label="Metrics")
+        
+        cluster_features = gr.CheckboxGroup(feature_list, value=["spectral_centroid", "spectral_flatness"], 
+                                            label="Clustering Features")
+        
+        clustering_algo = gr.Dropdown(["KMeans", "Agglomerative"], value="KMeans", label="Algorithm")
+        n_clusters = gr.Slider(2, 10, value=4, step=1, label="Clusters")
+        dbscan_eps = gr.Slider(0.1, 5.0, value=0.5, visible=False)
+
+    btn = gr.Button("🚀 Analyze", variant="primary")
 
     with gr.Tabs():
-        with gr.Tab("📈 Time Series Comparison"):
+        with gr.Tab("📈 Comparison"):
             comp_plot = gr.Plot()
-            # CORRECTED: Replaced height=200 with row_count=10
-            comp_table = gr.Dataframe(row_count=10) 
+            comp_table = gr.Dataframe()
+        
         with gr.Tab("🧩 Phoneme Clustering"):
+            with gr.Row():
+                # TOGGLE SWITCH
+                view_toggle = gr.Radio(["Near Field", "Far Field"], value="Near Field", label="View Mode")
             cluster_plot = gr.Plot()
-            # CORRECTED: Replaced height=200 with row_count=10
-            cluster_table = gr.Dataframe(row_count=10) 
-        with gr.Tab("🔍 Spectral Check"):
-            gr.Markdown("Difference Heatmap (Near - Far). Blue = Near has more energy. Red = Far has more energy.")
+            cluster_table = gr.Dataframe()
+            
+        with gr.Tab("🔍 Spectral"):
             spec_heatmap = gr.Plot()
-        with gr.Tab("🧭 Quality Overlay"):
+        with gr.Tab("🧭 Overlay"):
             overlay_plot = gr.Plot()
 
     with gr.Tab("📤 Export"):
-        export_btn = gr.Button("💾 Download Results")
+        export_btn = gr.Button("Download CSVs")
         export_files = gr.Files()
 
-    btn.click(fn=analyze_audio_pair,
-              inputs=[near_file, far_file, frame_length_ms, hop_length_ms, window_type,
-                      comparison_metrics, cluster_features, clustering_algo, n_clusters, dbscan_eps],
-              outputs=[comp_plot, comp_table, cluster_plot, cluster_table, spec_heatmap, overlay_plot])
-              
-    export_btn.click(fn=export_results, inputs=[comp_table, cluster_table], outputs=export_files)
+    # Main Analysis Event
+    btn.click(
+        fn=analyze_audio_pair,
+        inputs=[near_file, far_file, frame_length_ms, hop_length_ms, window_type,
+                comparison_metrics, cluster_features, clustering_algo, n_clusters, dbscan_eps],
+        outputs=[comp_plot, comp_table, 
+                 cluster_plot, cluster_table, 
+                 spec_heatmap, overlay_plot, 
+                 state_near_df, state_far_df] # Save to State
+    )
+
+    # Toggle Event (Updates plot without re-running analysis)
+    view_toggle.change(
+        fn=update_cluster_view,
+        inputs=[view_toggle, state_near_df, state_far_df, cluster_features],
+        outputs=[cluster_plot]
+    )
+
+    export_btn.click(fn=export_results, inputs=[comp_table, state_near_df, state_far_df], outputs=export_files)
 
 if __name__ == "__main__":
     demo.launch()