Update app.py

app.py

@@ -13,51 +13,34 @@ import plotly.graph_objects as go
 import os
 import tempfile
 
-# ----------------------------
-# 1. Signal Alignment & Preprocessing
-# ----------------------------
+# ==========================================
+# 1. CORE SIGNAL PROCESSING & ALIGNMENT
+# ==========================================
 def align_signals(ref, target):
     """Aligns target signal to reference signal using Cross-Correlation."""
     ref_norm = librosa.util.normalize(ref)
     target_norm = librosa.util.normalize(target)
     
+    # FFT based correlation is faster for long 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)]
     
     if lag > 0:
-        aligned_target = target[lag:]
-        aligned_ref = ref
+        return ref, target[lag:][:len(ref)]
     else:
-        aligned_target = target
-        aligned_ref = ref[abs(lag):]
+        return ref[abs(lag):][:len(target)], target
 
-    min_len = min(len(aligned_ref), len(aligned_target))
-    return aligned_ref[:min_len], aligned_target[:min_len]
-
-# ----------------------------
-# 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 = []
-    y_padded = np.pad(y, (0, frame_length), mode='constant')
     
-    for i in range(0, len(y) - frame_length + 1, hop_length):
-        frame = y[i:i + frame_length] * window
-        frames.append(frame)
-        
-    if frames:
-        frames = np.array(frames).T
-    else:
-        frames = np.zeros((frame_length, 1))
-    return frames, frame_length
+    # Efficient framing
+    frames = librosa.util.frame(y, frame_length=frame_length, hop_length=hop_length).T
+    frames = frames * window
+    return frames.T, frame_length
 
-# ----------------------------
-# 3. Feature Extraction
-# ----------------------------
 def extract_features_with_spectrum(frames, sr):
     features = []
     n_mfcc = 13
@@ -65,6 +48,9 @@ def extract_features_with_spectrum(frames, sr):
     
     for i in range(frames.shape[1]):
         frame = frames[:, i]
+        feat = {}
+        
+        # Guard against silence/empty frames
         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"]}
@@ -73,32 +59,32 @@ def extract_features_with_spectrum(frames, sr):
             features.append(feat)
             continue
 
-        feat = {}
+        # Time Domain
         feat["rms"] = float(np.mean(librosa.feature.rms(y=frame)[0]))
         feat["zcr"] = float(np.mean(librosa.feature.zero_crossing_rate(frame)[0]))
         
+        # Spectral Domain
         try: feat["spectral_centroid"] = float(np.mean(librosa.feature.spectral_centroid(y=frame, sr=sr)[0]))
         except: feat["spectral_centroid"] = 0.0
-            
         try: feat["spectral_flatness"] = float(np.mean(librosa.feature.spectral_flatness(y=frame)[0]))
         except: feat["spectral_flatness"] = 0.0
 
+        # MFCCs
         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]))
         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
+            
+            feat["low_freq_energy"] = float(np.mean(S_db[freqs <= 2000])) if np.any(freqs <= 2000) else -80.0
+            feat["mid_freq_energy"] = float(np.mean(S_db[(freqs > 2000) & (freqs <= 4000)])) if np.any((freqs > 2000) & (freqs <= 4000)) else -80.0
+            feat["high_freq_energy"] = float(np.mean(S_db[freqs > 4000])) if np.any(freqs > 4000) else -80.0
             feat["spectrum"] = S_db
         except:
             feat["low_freq_energy"] = feat["mid_freq_energy"] = feat["high_freq_energy"] = -80.0
@@ -107,17 +93,18 @@ def extract_features_with_spectrum(frames, sr):
         features.append(feat)
     return features
 
-# ----------------------------
-# 4. Frame Comparison
-# ----------------------------
+# ==========================================
+# 2. COMPARISON & CLUSTERING LOGIC
+# ==========================================
 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()
 
     results = {"frame_index": list(range(min_len))}
     near_df = pd.DataFrame(near_feats[:min_len])
     far_df = pd.DataFrame(far_feats[:min_len])
     
+    # Vector preparation
     drop_cols = ["spectrum"]
     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
@@ -134,19 +121,18 @@ def compare_frames_enhanced(near_feats, far_feats, metrics):
         results["cosine_similarity"] = cos_vals
 
     if "High-Freq Loss Ratio" in metrics:
-        loss_ratios = []
-        for i in range(min_len):
-            loss_ratios.append(float(near_feats[i]["high_freq_energy"] - far_feats[i]["high_freq_energy"]))
-        results["high_freq_loss_db"] = loss_ratios
+        results["high_freq_loss_db"] = [float(near_feats[i]["high_freq_energy"] - far_feats[i]["high_freq_energy"]) for i in range(min_len)]
 
+    # 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_scores.append(float(cosine_similarity(near_spec.reshape(1, -1), far_spec.reshape(1, -1))[0][0]))
+        n_s = near_feats[i]["spectrum"].flatten()
+        f_s = far_feats[i]["spectrum"].flatten()
+        if np.all(n_s == 0) or np.all(f_s == 0): overlap_scores.append(0.0)
+        else: overlap_scores.append(float(cosine_similarity(n_s.reshape(1, -1), f_s.reshape(1, -1))[0][0]))
     results["spectral_overlap"] = overlap_scores
 
+    # Combined Match Score
     combined = []
     for i in range(min_len):
         score = (results["spectral_overlap"][i] * 0.5) 
@@ -156,12 +142,8 @@ def compare_frames_enhanced(near_feats, far_feats, metrics):
     
     return pd.DataFrame(results)
 
-# ----------------------------
-# 5. Dual Clustering & Feature Relation (NEW)
-# ----------------------------
 def perform_dual_clustering(near_df, far_df, cluster_features, algo, n_clusters, eps):
     if not cluster_features: return near_df, far_df
-
     valid_features = [f for f in cluster_features if f in near_df.columns]
     if not valid_features: return near_df, far_df
 
@@ -181,228 +163,258 @@ def perform_dual_clustering(near_df, far_df, cluster_features, algo, n_clusters,
         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":
+    else: # DBSCAN
         model = DBSCAN(eps=eps, min_samples=3)
         near_labels = model.fit_predict(X_near_scaled)
         far_labels = model.fit_predict(X_far_scaled)
-    else:
-        near_labels = np.zeros(len(X_near))
-        far_labels = np.zeros(len(X_far))
         
     near_df = near_df.copy(); near_df["cluster"] = near_labels.astype(str)
     far_df = far_df.copy(); far_df["cluster"] = far_labels.astype(str)
-
     return near_df, far_df
 
 def compute_feature_correlations(near_df, far_df, quality_scores):
-    """
-    Calculates the correlation between Near Features and Far Features
-    weighted by the Match Quality.
-    Returns a correlation matrix dataframe for plotting.
-    """
-    # Filter numeric columns only
+    """Calculates Pearson correlation between Near/Far features."""
+    if len(near_df) < 2: return pd.DataFrame()
+    
     near_num = near_df.select_dtypes(include=[np.number])
     far_num = far_df.select_dtypes(include=[np.number])
     
-    # We want to see: For a high quality frame, how does Near Feature X relate to Far Feature X?
-    # Simple approach: Calculate Pearson Correlation of (Near_Col, Far_Col) across all frames.
-    
     correlations = {}
-    
     common_cols = [c for c in near_num.columns if c in far_num.columns]
     
     for col in common_cols:
-        if col == "cluster": continue
         try:
-            # Basic Correlation: Do Near and Far move together?
             corr, _ = pearsonr(near_num[col], far_num[col])
             correlations[col] = corr
-        except:
-            correlations[col] = 0.0
+        except: correlations[col] = 0.0
             
-    # Also calculate correlation with Quality
     quality_corr = {}
     for col in common_cols:
-         if col == "cluster": continue
          try:
-             # Does this feature predict high quality?
-             # e.g., Does high 'rms' usually mean better match score?
              corr, _ = pearsonr(near_num[col], quality_scores)
              quality_corr[col] = corr
-         except:
-             quality_corr[col] = 0.0
+         except: quality_corr[col] = 0.0
 
     return pd.DataFrame({"Near-Far Correlation": correlations, "Correlation with Quality": quality_corr})
 
-# ----------------------------
-# 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 = 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
-    )
-    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")
-
-# ----------------------------
-# 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("Upload both files.")
-
-    # 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)
-    y_near, y_far = align_signals(y_near, y_far)
-    
-    # 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)
-    near_feats = extract_features_with_spectrum(frames_near, sr)
-    far_feats = extract_features_with_spectrum(frames_far, sr)
+# ==========================================
+# 3. FILTERING & VISUALIZATION ENGINE
+# ==========================================
+def update_visuals(near_df, far_df, comparison_df, 
+                   fil_col, fil_op, fil_val, 
+                   cluster_features, view_mode):
+    """
+    Master function that takes Full Data -> Applies Filter -> Generates ALL Plots
+    """
+    if near_df is None: return [None] * 6 # Return empty if no data
+
+    # 1. APPLY FILTER
+    # Merge for easier filtering
+    near_merged = near_df.copy()
+    far_merged = far_df.copy()
+    for c in comparison_df.columns: 
+        if c != "frame_index": 
+            near_merged[c] = comparison_df[c]
+            far_merged[c] = comparison_df[c]
+
+    mask = None
+    if fil_col != "None" and fil_op != "None":
+        if fil_col in near_merged.columns:
+            if fil_op == "<": mask = near_merged[fil_col] < fil_val
+            elif fil_op == ">": mask = near_merged[fil_col] > fil_val
+            elif fil_op == "=": mask = near_merged[fil_col] == fil_val
     
-    # Compare & Cluster
-    comparison_df = compare_frames_enhanced(near_feats, far_feats, comparison_metrics)
-    near_df_raw = pd.DataFrame(near_feats).drop(columns=["spectrum"], errors="ignore")
-    far_df_raw = pd.DataFrame(far_feats).drop(columns=["spectrum"], errors="ignore")
-    near_clustered, far_clustered = perform_dual_clustering(
-        near_df_raw, far_df_raw, cluster_features, clustering_algo, n_clusters, dbscan_eps
-    )
+    if mask is None:
+        f_near, f_far, f_comp = near_merged, far_merged, comparison_df
+        title_prefix = "Full Data"
+    else:
+        f_near, f_far, f_comp = near_merged[mask], far_merged[mask], comparison_df[mask]
+        title_prefix = f"Filtered ({fil_col} {fil_op} {fil_val})"
+        
+    if len(f_near) == 0:
+        return [px.scatter(title="No data matches filter")] * 5 + [pd.DataFrame()]
 
-    # 1. Comparison Plot
-    plot_comparison = go.Figure()
+    # 2. GENERATE COMPARISON PLOT
+    fig_comp = go.Figure()
+    # Plot Similarity Metrics
     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"))
-    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"))
-    plot_comparison.update_layout(
-        title="Comparison Metrics", yaxis=dict(title="Similarity"), yaxis2=dict(title="dB Loss", overlaying="y", side="right")
-    )
-
-    # 2. Cluster Plot
-    init_cluster_plot = update_cluster_view("Near Field", near_clustered, far_clustered, cluster_features)
+        if col in f_comp.columns:
+            mode = 'markers+lines' if len(f_comp) < 100 else 'lines'
+            fig_comp.add_trace(go.Scatter(x=f_comp["frame_index"], y=f_comp[col], name=col, mode=mode, yaxis="y1"))
+    # Plot dB Loss (Dual Axis)
+    if "high_freq_loss_db" in f_comp.columns:
+        mode = 'markers+lines' if len(f_comp) < 100 else 'lines'
+        fig_comp.add_trace(go.Scatter(x=f_comp["frame_index"], y=f_comp["high_freq_loss_db"], 
+                                      name="dB Loss", mode=mode, line=dict(color="red"), yaxis="y2"))
+    fig_comp.update_layout(title=f"{title_prefix}: Comparison", 
+                           yaxis=dict(title="Similarity (0-1)", range=[0, 1.1]),
+                           yaxis2=dict(title="dB Loss", overlaying="y", side="right"))
+
+    # 3. GENERATE CLUSTER PLOT
+    target_df = f_near if view_mode == "Near Field" else f_far
+    if len(cluster_features) >= 2:
+        fig_clust = px.scatter(target_df, x=cluster_features[0], y=cluster_features[1], color="cluster",
+                               title=f"{title_prefix}: Clustering ({view_mode})",
+                               color_discrete_sequence=px.colors.qualitative.Bold)
+    else:
+        fig_clust = px.scatter(title="Select 2+ 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
-    near_clustered["match_quality"] = comparison_df["combined_match_score"]
-    if len(cluster_features) > 0:
-        overlay_fig = px.scatter(near_clustered, x=cluster_features[0], y="match_quality", color="cluster", 
-                                 title="Cluster vs Quality (Near Field)")
+    # 4. GENERATE OVERLAY PLOT
+    if len(cluster_features) > 0 and "combined_match_score" in f_near.columns:
+        fig_over = px.scatter(f_near, x=cluster_features[0], y="combined_match_score", color="cluster",
+                              title=f"{title_prefix}: Quality Overlay")
     else:
-        overlay_fig = px.scatter(title="No features")
+        fig_over = px.scatter(title="No Match Score")
+
+    # 5. GENERATE CORRELATION HEATMAP
+    # Note: We calculate correlation on the FILTERED set. This allows seeing how relations change in failure modes.
+    corr_df = compute_feature_correlations(f_near, f_far, f_comp["combined_match_score"])
+    if not corr_df.empty:
+        fig_corr = px.imshow(corr_df.T, text_auto=True, aspect="auto", color_continuous_scale="RdBu", zmin=-1, zmax=1,
+                             title=f"{title_prefix}: Feature Correlations")
+    else:
+        fig_corr = px.scatter(title="Not enough data for correlation")
+
+    # 6. GENERATE SCATTER MATRIX
+    top_cols = cluster_features[:3] + ["combined_match_score"] if "combined_match_score" in f_near.columns else cluster_features[:3]
+    fig_matrix = px.scatter_matrix(f_near, dimensions=top_cols, color="cluster",
+                                   title=f"{title_prefix}: Scatter Matrix")
 
-    # 5. NEW: Feature Relation Heatmap
-    corr_df = compute_feature_correlations(near_clustered, far_clustered, comparison_df["combined_match_score"])
-    corr_fig = px.imshow(corr_df.T, text_auto=True, aspect="auto", color_continuous_scale="RdBu", zmin=-1, zmax=1,
-                         title="Feature Correlation Analysis")
+    return fig_comp, fig_clust, fig_over, fig_corr, fig_matrix, f_near
+
+# ==========================================
+# 4. MAIN ANALYZER WRAPPER
+# ==========================================
+def run_full_analysis(near, far, fl, hl, wt, cm, cf, ca, nc, eps):
+    if not near or not far: raise gr.Error("Upload files")
+    
+    # Process
+    y_n, sr = librosa.load(near.name, sr=None)
+    y_f, _ = librosa.load(far.name, sr=sr)
+    y_n, y_f = align_signals(y_n, y_f) # Align
+    y_n, y_f = librosa.util.normalize(y_n), librosa.util.normalize(y_f) # Normalize
+    
+    frames_n, _ = segment_audio(y_n, sr, fl, hl, wt)
+    frames_f, _ = segment_audio(y_f, sr, fl, hl, wt)
+    
+    feat_n = extract_features_with_spectrum(frames_n, sr)
+    feat_f = extract_features_with_spectrum(frames_f, sr)
+    
+    comp_df = compare_frames_enhanced(feat_n, feat_f, cm)
+    
+    df_n = pd.DataFrame(feat_n).drop(columns=["spectrum"], errors="ignore")
+    df_f = pd.DataFrame(feat_f).drop(columns=["spectrum"], errors="ignore")
+    
+    # Cluster
+    df_n, df_f = perform_dual_clustering(df_n, df_f, cf, ca, nc, eps)
+    
+    # Generate Plots (No Filter initially)
+    plots = update_visuals(df_n, df_f, comp_df, "None", "None", 0, cf, "Near Field")
+    
+    # Static Spectral Heatmap
+    idx = int(len(feat_n)/2)
+    diff = feat_n[idx]["spectrum"] - feat_f[idx]["spectrum"]
+    fig_spec = go.Figure(data=go.Heatmap(z=diff, colorscale='RdBu', zmid=0))
+    fig_spec.update_layout(title=f"Spectral Diff (Frame {idx})")
     
-    # 6. Scatter Matrix (Inter-feature)
-    # Pick top 3 features and Quality
-    top_cols = cluster_features[:3] + ["match_quality"]
-    scatter_matrix_fig = px.scatter_matrix(near_clustered, dimensions=top_cols, color="cluster",
-                                           title="Inter-Feature Scatter Matrix (Near Field)")
-
-    return (plot_comparison, comparison_df, 
-            init_cluster_plot, near_clustered, 
-            spec_heatmap, overlay_fig, 
-            corr_fig, scatter_matrix_fig,
-            near_clustered, far_clustered)
-
-def export_results(comparison_df, near_df, far_df):
-    temp_dir = tempfile.mkdtemp()
-    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]
-
-# ----------------------------
-# 8. Gradio UI
-# ----------------------------
+    # Return: Plots, Tables, Heatmap, StateVars
+    return (plots[0], comp_df, plots[1], df_n, plots[2], plots[3], plots[4], fig_spec, 
+            df_n, df_f, comp_df) # State
+
+# ==========================================
+# 5. GRADIO 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)]
+filter_opts = ["combined_match_score", "rms", "high_freq_loss_db", "spectral_flatness"] + feature_list
 
-with gr.Blocks(title="Audio Field Analyzer", theme=gr.themes.Soft()) as demo:
-    state_near_df = gr.State()
-    state_far_df = gr.State()
-
-    gr.Markdown("# 🎙️ Near vs Far Field Analyzer (Dual-Clustering)")
+with gr.Blocks(title="Ultimate Audio Analyzer", theme=gr.themes.Soft()) as demo:
+    # State Storage
+    s_near = gr.State()
+    s_far = gr.State()
+    s_comp = gr.State()
+    
+    gr.Markdown("# 🎙️ Ultimate Near/Far Field Analyzer")
+    gr.Markdown("Includes: Alignment, Dual Clustering, Feature Correlation, and Conditional Filtering.")
     
     with gr.Row():
-        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", "rms"], 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")
+        f1 = gr.File(label="Near Field (Ref)")
+        f2 = gr.File(label="Far Field (Target)")
+        run_btn = gr.Button("🚀 Run Analysis", variant="primary")
+        
+    with gr.Accordion("⚙️ Configuration", open=False):
+        fl = gr.Slider(10, 100, 30, label="Frame Length (ms)")
+        hl = gr.Slider(10, 50, 15, label="Hop Length (ms)")
+        wt = gr.Dropdown(["hann", "boxcar"], value="hann")
+        cm = gr.CheckboxGroup(["Cosine Similarity", "High-Freq Loss Ratio"], value=["Cosine Similarity"], label="Metrics")
+        cf = gr.CheckboxGroup(feature_list, value=["spectral_centroid", "rms", "mfcc_1"], label="Clustering Feats")
+        ca = gr.Dropdown(["KMeans", "DBSCAN"], value="KMeans")
+        nc = gr.Slider(2, 8, 4, label="Clusters")
+        eps = gr.Slider(0.1, 2.0, 0.5)
+
+    gr.Markdown("### 🔎 Frame Filtering (Updates ALL plots)")
+    with gr.Row(variant="panel"):
+        fil_col = gr.Dropdown(filter_opts, value="combined_match_score", label="Filter Column")
+        fil_op = gr.Dropdown(["<", ">"], value="<", label="Operator")
+        fil_val = gr.Number(value=0.8, label="Value")
+        apply_btn = gr.Button("Apply Filter")
+        reset_btn = gr.Button("Reset")
 
     with gr.Tabs():
-        with gr.Tab("📈 Comparison"):
-            comp_plot = gr.Plot()
-            comp_table = gr.Dataframe()
-        with gr.Tab("🧩 Phoneme Clustering"):
-            view_toggle = gr.Radio(["Near Field", "Far Field"], value="Near Field", label="View Mode")
-            cluster_plot = gr.Plot()
-            cluster_table = gr.Dataframe()
-        with gr.Tab("🔍 Spectral"):
-            spec_heatmap = gr.Plot()
-        with gr.Tab("🧭 Overlay"):
-            overlay_plot = gr.Plot()
-        with gr.Tab("🔗 Feature Relations"):
-            gr.Markdown("### Correlation Heatmap & Scatter Matrix")
-            corr_plot = gr.Plot(label="Correlation Heatmap")
-            scatter_matrix_plot = gr.Plot(label="Scatter Matrix")
-
-    with gr.Tab("📤 Export"):
-        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, 
-                 corr_plot, scatter_matrix_plot,
-                 state_near_df, state_far_df]
+        with gr.Tab("Comparison"):
+            p_comp = gr.Plot()
+            t_comp = gr.Dataframe(height=200)
+        with gr.Tab("Clustering"):
+            view_mode = gr.Radio(["Near Field", "Far Field"], value="Near Field", label="View Mode")
+            p_clust = gr.Plot()
+            t_clust = gr.Dataframe(height=200)
+        with gr.Tab("Overlay"):
+            p_over = gr.Plot()
+        with gr.Tab("Relations (Correlation)"):
+            p_corr = gr.Plot(label="Correlation Heatmap")
+            p_matrix = gr.Plot(label="Scatter Matrix")
+        with gr.Tab("Spectral"):
+            p_spec = gr.Plot()
+
+    with gr.Tab("Export"):
+        exp_btn = gr.Button("Download Results")
+        exp_file = gr.Files()
+
+    # Callbacks
+    run_btn.click(
+        run_full_analysis,
+        inputs=[f1, f2, fl, hl, wt, cm, cf, ca, nc, eps],
+        outputs=[p_comp, t_comp, p_clust, t_clust, p_over, p_corr, p_matrix, p_spec, s_near, s_far, s_comp]
     )
 
-    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)
+    # Filter Logic
+    apply_btn.click(
+        update_visuals,
+        inputs=[s_near, s_far, s_comp, fil_col, fil_op, fil_val, cf, view_mode],
+        outputs=[p_comp, p_clust, p_over, p_corr, p_matrix, t_clust]
+    )
+    
+    reset_btn.click(
+        lambda n, f, c, feat, v: update_visuals(n, f, c, "None", "None", 0, feat, v),
+        inputs=[s_near, s_far, s_comp, cf, view_mode],
+        outputs=[p_comp, p_clust, p_over, p_corr, p_matrix, t_clust]
+    )
+    
+    # View Mode Logic
+    view_mode.change(
+        update_visuals,
+        inputs=[s_near, s_far, s_comp, fil_col, fil_op, fil_val, cf, view_mode],
+        outputs=[p_comp, p_clust, p_over, p_corr, p_matrix, t_clust]
+    )
+    
+    # Export Logic
+    def export(c, n, f):
+        d = tempfile.mkdtemp()
+        p1, p2, p3 = os.path.join(d, "comp.csv"), os.path.join(d, "near.csv"), os.path.join(d, "far.csv")
+        c.to_csv(p1, index=False); n.to_csv(p2, index=False); f.to_csv(p3, index=False)
+        return [p1, p2, p3]
+        
+    exp_btn.click(export, inputs=[s_comp, s_near, s_far], outputs=[exp_file])
 
 if __name__ == "__main__":
     demo.launch()