Update app.py

app.py

@@ -90,6 +90,66 @@ _LEGACY_DIST_MAP = {
     "h1_h2_db":       "h1_h2_corrected",
 }
 
+# ── Resonance method definitions ──
+# Each method maps a Metrics field to a distribution and polarity.
+# "field":    attribute name on the Metrics dataclass
+# "dist":     distribution dict (mu/sigma/lo/hi) for percentile mapping
+# "invert":   if True, lower raw value → higher (brighter) slider position
+# "unit":     display unit for the report
+# "source":   brief literature reference
+RESONANCE_METHODS = {
+    "F2 − F1 (Hz)": {
+        "field": "f2_minus_f1_hz",
+        "dist":  {"mu": 900.0,  "sigma": 200.0, "lo": 300.0,  "hi": 1600.0},
+        "invert": False,  # higher = brighter
+        "unit": "Hz",
+        "source": "Hillenbrand 1995 — cis-M ≈ 780, cis-F ≈ 1020",
+    },
+    "Formant Dispersion Df": {
+        "field": "formant_dispersion_hz",
+        "dist":  {"mu": 1100.0, "sigma": 150.0, "lo": 700.0,  "hi": 1500.0},
+        "invert": False,  # higher spacing = shorter VTL = brighter
+        "unit": "Hz",
+        "source": "Fitch 1997 — cis-M ≈ 1050, cis-F ≈ 1150",
+    },
+    "Est. VTL (cm)": {
+        "field": "vtl_cm",
+        "dist":  {"mu": 16.0,   "sigma": 1.8,   "lo": 10.0,   "hi": 22.0},
+        "invert": True,   # shorter VTL = brighter → invert
+        "unit": "cm",
+        "source": "Fitch 1997; VTL = c / (4 × Df)",
+    },
+    "F2/F1 Ratio": {
+        "field": "f2_f1_ratio",
+        "dist":  {"mu": 2.0,    "sigma": 0.5,   "lo": 1.0,    "hi": 4.0},
+        "invert": False,  # higher ratio = brighter
+        "unit": "",
+        "source": "Derived; normalizes vowel-height confound",
+    },
+    "Composite Z (default)": {
+        "field": "resonance_combo",
+        "dist":  {"mu": 0.0,    "sigma": 1.0,   "lo": -3.0,   "hi": 3.0},
+        "invert": False,  # z-score: positive = brighter
+        "unit": "z",
+        "source": "Z-scored mean of F2−F1 + Df",
+    },
+    "Spectral Mean (Hz)": {
+        "field": "spectral_mean_hz",
+        "dist":  {"mu": 1400.0, "sigma": 350.0, "lo": 600.0,  "hi": 3000.0},
+        "invert": False,  # higher CoG = brighter
+        "unit": "Hz",
+        "source": "Power-spectrum center of gravity above F0; formant-free",
+    },
+    "F3 (Hz)": {
+        "field": "f3_hz",
+        "dist":  {"mu": 2800.0, "sigma": 250.0, "lo": 2000.0, "hi": 3800.0},
+        "invert": False,  # higher F3 = shorter pharynx = brighter
+        "unit": "Hz",
+        "source": "Direct pharyngeal-space cue; Vorperian & Kent 2007",
+    },
+}
+RESONANCE_METHOD_DEFAULT = "Composite Z (default)"
+
 DEFAULT_SR = 22050
 FRAME_LEN = 0.040
 HOP_LEN = 0.010
@@ -506,7 +566,9 @@ class Metrics:
     f2_minus_f1_hz: float
     formant_dispersion_hz: float   # (F3 - F1) / 2
     vtl_cm: float                  # estimated vocal tract length
+    f2_f1_ratio: float             # F2/F1, dimensionless resonance ratio
     resonance_combo: float         # z-scored composite of F2-F1 + Df
+    spectral_mean_hz: float        # center of gravity of power spectrum above F0
     # Voice quality / weight
     h1_h2_db: float                # uncorrected H1-H2
     h1_h2_corrected_db: float      # H1*-H2* with Iseli-Alwan formant correction
@@ -525,7 +587,7 @@ def empty_metrics(warnings=None):
         nan, nan, nan, nan,         # pitch
         nan, nan, nan,              # prosody
         nan, nan, nan,              # volume
-        nan, nan, nan, nan, nan, nan, nan,  # formants/resonance
+        nan, nan, nan, nan, nan, nan, nan, nan, nan,  # formants/resonance (9)
         nan, nan, nan, nan, nan, nan,       # voice quality
         0.0, warnings or [],        # meta
     )
@@ -822,6 +884,52 @@ def extract_distributions(y, sr, pitch_floor_hz, pitch_ceil_hz, max_formant_hz):
     if z_parts:
         resonance_combo = float(np.mean(z_parts))
 
+    # ── F2/F1 ratio (dimensionless resonance) ──
+    f2_f1_ratio = float("nan")
+    if f1_vals and f2_vals:
+        f1_arr_r = np.array(f1_vals, dtype=np.float32)
+        f2_arr_r = np.array(f2_vals, dtype=np.float32)
+        # Avoid division by zero; exclude extreme F1 values
+        valid = f1_arr_r > 200
+        if valid.sum() > 3:
+            ratios = f2_arr_r[valid] / f1_arr_r[valid]
+            ratios = robust_clip(ratios)
+            f2_f1_ratio = float(np.median(ratios))
+
+    # ── Spectral mean / center of gravity above F0 (formant-free resonance) ──
+    spectral_mean_hz = float("nan")
+    if np.isfinite(f0_med) and y.size >= frame:
+        # Compute average power spectrum across voiced frames, then find CoG
+        n_fft_cog = 4096
+        freqs_cog = np.fft.rfftfreq(n_fft_cog, d=1.0 / sr)
+        window_cog = np.hanning(frame).astype(np.float32)
+        sum_power = np.zeros(n_fft_cog // 2 + 1, dtype=np.float64)
+        n_frames_cog = 0
+        centers_cog = (times * sr).astype(int)
+        half_cog = frame // 2
+        for i, (c, v) in enumerate(zip(centers_cog, voiced)):
+            if not v:
+                continue
+            s0 = max(0, c - half_cog)
+            s1 = s0 + frame
+            if s1 > y.size:
+                continue
+            seg = y[s0:s1] * window_cog
+            power = np.abs(np.fft.rfft(seg, n=n_fft_cog)) ** 2
+            sum_power += power
+            n_frames_cog += 1
+        if n_frames_cog > 5:
+            avg_power = sum_power / n_frames_cog
+            # Mask below 1.5 × F0 to exclude fundamental and first harmonic
+            f_cutoff = 1.5 * f0_med
+            mask_above_f0 = freqs_cog >= f_cutoff
+            if mask_above_f0.sum() > 10:
+                p_above = avg_power[mask_above_f0]
+                f_above = freqs_cog[mask_above_f0]
+                total = p_above.sum()
+                if total > 0:
+                    spectral_mean_hz = float(np.sum(f_above * p_above) / total)
+
     # ── 9. H1*-H2* with Iseli-Alwan formant correction ──
     h1h2_raw_vals = []
     h1h2_corrected_vals = []
@@ -961,7 +1069,9 @@ def extract_distributions(y, sr, pitch_floor_hz, pitch_ceil_hz, max_formant_hz):
         f2_minus_f1_hz=f2_minus_f1_med,
         formant_dispersion_hz=formant_disp_med,
         vtl_cm=vtl_cm,
+        f2_f1_ratio=f2_f1_ratio,
         resonance_combo=resonance_combo,
+        spectral_mean_hz=spectral_mean_hz,
         h1_h2_db=h1_h2_med,
         h1_h2_corrected_db=h1_h2_corrected_med,
         cpp_db=cpp_db_val,
@@ -1025,13 +1135,26 @@ def select_dists(mapping_mode, baseline_state):
     return GLOBAL_DISTS
 
 
-def metrics_to_sliders(m, dists):
+def metrics_to_sliders(m, dists, resonance_method=None):
     pitch_p     = dist_to_percentile(m.f0_med_hz,          dists["f0_med_hz"])
     prosody_p   = dist_to_percentile(m.prosody_composite,   dists["f0_sd_st"])
     volume_p    = dist_to_percentile(m.rms_dbfs,            dists["rms_dbfs"])
-    resonance_p = dist_to_percentile(m.resonance_combo,     dists["resonance_combo"])
     weight_p    = dist_to_percentile(m.h1_h2_corrected_db,  dists["h1_h2_corrected"])
-    # Weight: higher H1*-H2* -> lighter voice -> higher slider.  No inversion.
+
+    # Resonance: use selected method's field and distribution
+    method_name = resonance_method or RESONANCE_METHOD_DEFAULT
+    method_cfg = RESONANCE_METHODS.get(method_name, RESONANCE_METHODS[RESONANCE_METHOD_DEFAULT])
+    res_field = method_cfg["field"]
+    res_val = getattr(m, res_field, float("nan"))
+    # Use baseline dist for resonance_combo key if available, else method-specific dist
+    res_dist = dists.get("resonance_combo", method_cfg["dist"])
+    # If mapping mode is Global/Anchored, always use the method-specific dist
+    if res_dist is dists.get("resonance_combo") and method_name != RESONANCE_METHOD_DEFAULT:
+        res_dist = method_cfg["dist"]
+    resonance_p = dist_to_percentile(res_val, res_dist)
+    if method_cfg.get("invert") and np.isfinite(resonance_p):
+        resonance_p = 1.0 - resonance_p
+
     # Volume: higher RMS -> louder -> 100 should be Soft -> invert.
     if np.isfinite(volume_p):
         volume_p = 1.0 - volume_p
@@ -1074,8 +1197,10 @@ def format_report(m):
         "  F2 (median):        {}".format(_fmt(m.f2_hz, '.0f', ' Hz')),
         "  F3 (median):        {}".format(_fmt(m.f3_hz, '.0f', ' Hz')),
         "  F2 − F1:            {}".format(_fmt(m.f2_minus_f1_hz, '.0f', ' Hz')),
+        "  F2/F1 ratio:        {}".format(_fmt(m.f2_f1_ratio, '.2f')),
         "  Formant dispersion: {}".format(_fmt(m.formant_dispersion_hz, '.0f', ' Hz')),
         "  Est. VTL:           {}".format(_fmt(m.vtl_cm, '.1f', ' cm')),
+        "  Spectral mean:      {}".format(_fmt(m.spectral_mean_hz, '.0f', ' Hz')),
         "  Resonance composite:{}".format(_fmt(m.resonance_combo, '.2f', ' z')),
         "",
         "── Voice Quality / Weight ──",
@@ -1176,8 +1301,10 @@ def history_row(label, m, sliders):
         "clipping_ratio": m.clipping_ratio,
         "f1_hz": m.f1_hz, "f2_hz": m.f2_hz, "f3_hz": m.f3_hz,
         "f2_minus_f1_hz": m.f2_minus_f1_hz,
+        "f2_f1_ratio": m.f2_f1_ratio,
         "formant_dispersion_hz": m.formant_dispersion_hz,
         "vtl_cm": m.vtl_cm,
+        "spectral_mean_hz": m.spectral_mean_hz,
         "resonance_combo": m.resonance_combo,
         "h1_h2_db": m.h1_h2_db,
         "h1_h2_corrected_db": m.h1_h2_corrected_db,
@@ -1210,13 +1337,14 @@ ANALYSIS_CACHE = {}
 _CACHE_LOCK = threading.Lock()
 
 
-def cached_analyze(y, sr, pf, pc, mf, cache_key, dists):
-    k = audio_hash(y, sr, extra="{}-{}-{}-{}".format(pf, pc, mf, cache_key))
+def cached_analyze(y, sr, pf, pc, mf, cache_key, dists, resonance_method=None):
+    rm = resonance_method or RESONANCE_METHOD_DEFAULT
+    k = audio_hash(y, sr, extra="{}-{}-{}-{}-rm:{}".format(pf, pc, mf, cache_key, rm))
     with _CACHE_LOCK:
         if k in ANALYSIS_CACHE:
             return ANALYSIS_CACHE[k]
     m = extract_metrics(y, sr, pf, pc, mf)
-    sliders = metrics_to_sliders(m, dists)
+    sliders = metrics_to_sliders(m, dists, resonance_method=rm)
     with _CACHE_LOCK:
         ANALYSIS_CACHE[k] = (m, sliders)
         if len(ANALYSIS_CACHE) > 128:
@@ -1306,6 +1434,99 @@ def _prep_audio(audio_like, window_choice, pitch_floor, pitch_ceil,
     return y, sr, pf, pc, mf
 
 
+# =============================================================================
+# Resonance method comparison
+# =============================================================================
+
+def resonance_comparison_table(m, dists, active_method=None):
+    """Generate an HTML comparison table showing all 7 resonance methods side-by-side.
+    
+    For each method, shows: raw value, unit, slider position (0-100), and
+    whether it's the currently active method.
+    """
+    active = active_method or RESONANCE_METHOD_DEFAULT
+    rows = []
+    for name, cfg in RESONANCE_METHODS.items():
+        field = cfg["field"]
+        raw_val = getattr(m, field, float("nan"))
+        unit = cfg["unit"]
+        is_active = (name == active)
+        
+        # Compute slider position using method-specific dist
+        d = cfg["dist"]
+        pct = dist_to_percentile(raw_val, d)
+        if cfg.get("invert") and np.isfinite(pct):
+            pct = 1.0 - pct
+        slider_val = pct_to_slider(pct) if np.isfinite(pct) else float("nan")
+        
+        # Format values
+        if np.isfinite(raw_val):
+            if unit == "cm":
+                raw_str = "{:.1f}".format(raw_val)
+            elif unit == "z":
+                raw_str = "{:+.2f}".format(raw_val)
+            elif unit == "":
+                raw_str = "{:.2f}".format(raw_val)
+            else:
+                raw_str = "{:.0f}".format(raw_val)
+        else:
+            raw_str = "—"
+        
+        slider_str = "{:.0f}".format(slider_val) if np.isfinite(slider_val) else "—"
+        
+        # Color-code slider value: gradient from dark (0) to bright (100)
+        if np.isfinite(slider_val):
+            hue = 25 + (slider_val / 100.0) * 10  # orange range 25-35
+            sat = 70
+            light = 30 + (slider_val / 100.0) * 35  # 30% to 65%
+            bar_pct = max(3, slider_val)
+            bar_color = "hsl({}, {}%, {}%)".format(hue, sat, light)
+        else:
+            bar_pct = 0
+            bar_color = "#555"
+        
+        active_marker = " ✦" if is_active else ""
+        row_class = "res-row-active" if is_active else "res-row"
+        
+        rows.append(
+            '<tr class="{cls}">'
+            '<td style="font-weight:{fw}; white-space:nowrap">{name}{mark}</td>'
+            '<td style="text-align:right; font-variant-numeric:tabular-nums">{raw} {u}</td>'
+            '<td style="width:45%">'
+            '  <div style="background:#333;border-radius:4px;height:18px;position:relative;overflow:hidden">'
+            '    <div style="background:{bc};height:100%;width:{bp}%;border-radius:4px;'
+            '         transition:width 0.4s ease"></div>'
+            '    <span style="position:absolute;right:6px;top:0;line-height:18px;'
+            '          font-size:11px;color:#eee">{sv}</span>'
+            '  </div>'
+            '</td>'
+            '<td style="text-align:center;font-size:11px;color:#999">{src}</td>'
+            '</tr>'.format(
+                cls=row_class,
+                fw="700" if is_active else "400",
+                name=name, mark=active_marker,
+                raw=raw_str, u=unit,
+                bc=bar_color, bp=bar_pct, sv=slider_str,
+                src=cfg["source"].split("—")[0].strip() if "—" in cfg["source"] else cfg["source"][:25],
+            )
+        )
+    
+    html = (
+        '<div style="margin:8px 0">'
+        '<table style="width:100%;border-collapse:collapse;font-size:13px;color:#ddd">'
+        '<thead><tr style="border-bottom:1px solid #555">'
+        '<th style="text-align:left;padding:4px 6px;color:#e8956e">Method</th>'
+        '<th style="text-align:right;padding:4px 6px;color:#e8956e">Value</th>'
+        '<th style="text-align:left;padding:4px 6px;color:#e8956e">Slider (0–100)</th>'
+        '<th style="text-align:center;padding:4px 6px;color:#e8956e">Source</th>'
+        '</tr></thead><tbody>'
+    )
+    for r in rows:
+        html += r
+    html += '</tbody></table></div>'
+    return html
+
+
 # =============================================================================
 # Coaching tips
 # =============================================================================
@@ -1848,21 +2069,25 @@ def clear_target(history_state):
     return None, history_state, "", "", z, z, z, z, z, render_slider_bars(None, None, context="target")
 
 def set_target(audio_like, window_choice, pitch_floor, pitch_ceil, max_formant,
-               use_preemph, use_loudnorm, mapping_mode, baseline_state, history_state):
+               use_preemph, use_loudnorm, mapping_mode, resonance_method,
+               baseline_state, history_state):
     z = gr.update(value=0)
     empty_bars = render_slider_bars(None, None, context="target")
     try:
         y, sr, pf, pc, mf = _prep_audio(audio_like, window_choice, pitch_floor,
                                          pitch_ceil, max_formant, use_preemph, use_loudnorm)
     except ValueError as e:
-        return None, history_state, str(e), "", z, z, z, z, z, empty_bars
+        return None, history_state, str(e), "", z, z, z, z, z, empty_bars, ""
 
     dists = select_dists(mapping_mode, baseline_state)
+    rm = resonance_method or RESONANCE_METHOD_DEFAULT
     cache_key = "target-{}-{}-{}-{}".format(window_choice, use_preemph, use_loudnorm, mapping_mode)
-    m, sliders = cached_analyze(y, sr, pf, pc, mf, cache_key=cache_key, dists=dists)
+    m, sliders = cached_analyze(y, sr, pf, pc, mf, cache_key=cache_key, dists=dists,
+                                 resonance_method=rm)
     target_state = {"metrics": asdict(m), "sliders": sliders}
     history_state = cap_history((history_state or []) + [history_row("Target", m, sliders)])
     bar_html = render_slider_bars(sliders, None, context="target")
+    res_compare = resonance_comparison_table(m, dists, active_method=rm)
     return (
         target_state, history_state,
         format_report(m), format_sliders(sliders),
@@ -1872,10 +2097,12 @@ def set_target(audio_like, window_choice, pitch_floor, pitch_ceil, max_formant,
         gr.update(value=safe(sliders["Prosody"])),
         gr.update(value=safe(sliders["Volume"])),
         bar_html,
+        res_compare,
     )
 
 def analyze_user(audio_like, label, window_choice, pitch_floor, pitch_ceil,
                  max_formant, use_preemph, use_loudnorm, mapping_mode,
+                 resonance_method,
                  baseline_state, target_state, history_state):
     z = gr.update(value=0)
     z0 = gr.update(value=0.0)
@@ -1888,7 +2115,7 @@ def analyze_user(audio_like, label, window_choice, pitch_floor, pitch_ceil,
         None, None, None,
         [],
         render_slider_bars((target_state or {}).get("sliders"), None, context="user"),
-        "", "", "",
+        "", "", "", "",
     )
     try:
         y, sr, pf, pc, mf = _prep_audio(audio_like, window_choice, pitch_floor,
@@ -1896,10 +2123,12 @@ def analyze_user(audio_like, label, window_choice, pitch_floor, pitch_ceil,
     except ValueError:
         return empty_out
 
+    rm = resonance_method or RESONANCE_METHOD_DEFAULT
     dists = select_dists(mapping_mode, baseline_state)
     cache_key = "user-{}-{}-{}-{}-{}".format(label, window_choice, use_preemph,
                                               use_loudnorm, mapping_mode)
-    m, sliders = cached_analyze(y, sr, pf, pc, mf, cache_key=cache_key, dists=dists)
+    m, sliders = cached_analyze(y, sr, pf, pc, mf, cache_key=cache_key, dists=dists,
+                                 resonance_method=rm)
 
     warnings = list(m.warnings)
     append_gain_warning(target_state, sliders, warnings)
@@ -1920,6 +2149,7 @@ def analyze_user(audio_like, label, window_choice, pitch_floor, pitch_ceil,
     radar_html = render_radar_chart(t_sliders, sliders)
     trend_html = render_trend_plot(history_state)
     coaching = generate_coaching(delta, m)
+    res_compare = resonance_comparison_table(m, dists, active_method=rm)
 
     return (
         history_state,
@@ -1943,10 +2173,12 @@ def analyze_user(audio_like, label, window_choice, pitch_floor, pitch_ceil,
         radar_html,
         trend_html,
         coaching,
+        res_compare,
     )
 
 def live_analyze(stream_like, buffer_state, pitch_floor, pitch_ceil, max_formant,
-                 use_preemph, use_loudnorm, mapping_mode, baseline_state, target_state):
+                 use_preemph, use_loudnorm, mapping_mode, resonance_method,
+                 baseline_state, target_state):
     no_change = (buffer_state, *(gr.update() for _ in range(16)))
 
     normalized = normalize_audio_tuple(stream_like)
@@ -1988,9 +2220,10 @@ def live_analyze(stream_like, buffer_state, pitch_floor, pitch_ceil, max_formant
         pf = min(pf, pc - 1)
     mf = int(np.clip(int(round(max_formant)), 4500, 6500))
 
+    rm = resonance_method or RESONANCE_METHOD_DEFAULT
     m = extract_metrics(seg, sr, pf, pc, mf)
     dists = select_dists(mapping_mode, baseline_state)
-    sliders = metrics_to_sliders(m, dists)
+    sliders = metrics_to_sliders(m, dists, resonance_method=rm)
 
     warnings = list(m.warnings)
     append_gain_warning(target_state, sliders, warnings)
@@ -2122,6 +2355,11 @@ with gr.Blocks(**_blocks_kw) as demo:
             mapping_mode = gr.Dropdown(
                 ["Global", "Anchored (literature)", "Baseline (personal)"],
                 value="Global", label="Mapping mode")
+            resonance_method = gr.Dropdown(
+                list(RESONANCE_METHODS.keys()),
+                value=RESONANCE_METHOD_DEFAULT,
+                label="Resonance method",
+                info="Which acoustic measure drives the Resonance slider")
         with gr.Row():
             pitch_floor = gr.Slider(40, 150, value=PITCH_FLOOR_DEFAULT, step=1, label="Pitch floor (Hz)")
             pitch_ceil = gr.Slider(250, 800, value=PITCH_CEIL_DEFAULT, step=1, label="Pitch ceiling (Hz)")
@@ -2174,6 +2412,11 @@ with gr.Blocks(**_blocks_kw) as demo:
                                            elem_classes=["report-box"])
                 target_slider_text = gr.Textbox(label="Slider values", lines=4,
                                                 elem_classes=["report-box"])
+            with gr.Accordion("Resonance Methods Comparison", open=False):
+                gr.Markdown("All 7 resonance measurement methods computed for this audio. "
+                            "The **active method** (✦) drives the Resonance slider above. "
+                            "Change the method in Analysis Settings to compare.")
+                target_res_compare = gr.HTML(value="")
 
         # ════════════════════════════════════════════════════════
         # TAB 2: YOUR VOICE
@@ -2210,6 +2453,12 @@ with gr.Blocks(**_blocks_kw) as demo:
                     radar_html = gr.HTML(value="", label="Radar comparison")
                     trend_html = gr.HTML(value="", label="Session trend")
 
+            with gr.Accordion("Resonance Methods Comparison", open=True):
+                gr.Markdown("All 7 resonance metrics computed simultaneously. "
+                            "The **active method** (✦) drives the slider. "
+                            "Compare to find which tracks your perceived resonance best.")
+                user_res_compare = gr.HTML(value="")
+
             with gr.Accordion("Live mode", open=False):
                 gr.Markdown("Live mode streams from your microphone with EMA smoothing.")
                 live_audio = gr.Audio(sources=["microphone"], type="numpy",
@@ -2275,9 +2524,11 @@ with gr.Blocks(**_blocks_kw) as demo:
     btn_clear_baseline.click(clear_baseline, [], baseline_outputs)
 
     target_inputs = [target_audio, analysis_window, pitch_floor, pitch_ceil, max_formant,
-                     use_preemph, use_loudnorm, mapping_mode, baseline_state, history_state]
+                     use_preemph, use_loudnorm, mapping_mode, resonance_method,
+                     baseline_state, history_state]
     target_outputs = [target_state, history_state, target_report, target_slider_text,
-                      t_pitch, t_weight, t_res, t_pros, t_vol, target_bars]
+                      t_pitch, t_weight, t_res, t_pros, t_vol, target_bars,
+                      target_res_compare]
     btn_set_target.click(set_target, target_inputs, target_outputs)
     btn_clear_target.click(clear_target, [history_state],
                            [target_state, history_state, target_report, target_slider_text,
@@ -2290,9 +2541,11 @@ with gr.Blocks(**_blocks_kw) as demo:
                     user_report, user_slider_text, delta_text,
                     export_json, export_csv, export_baseline,
                     history_table,
-                    user_bars, radar_html, trend_html, coaching_md]
+                    user_bars, radar_html, trend_html, coaching_md,
+                    user_res_compare]
     user_common_inputs = [analysis_window, pitch_floor, pitch_ceil, max_formant,
-                          use_preemph, use_loudnorm, mapping_mode, baseline_state,
+                          use_preemph, use_loudnorm, mapping_mode, resonance_method,
+                          baseline_state,
                           target_state, history_state]
     btn_analyze_mic.click(analyze_user, [user_audio_mic, label_recorded] + user_common_inputs, user_outputs)
     btn_analyze_upload.click(analyze_user, [user_audio_up, label_uploaded] + user_common_inputs, user_outputs)
@@ -2305,8 +2558,9 @@ with gr.Blocks(**_blocks_kw) as demo:
                     user_bars, coaching_md]
     live_audio.stream(live_analyze,
                       [live_audio, live_buffer_state, pitch_floor, pitch_ceil, max_formant,
-                       use_preemph, use_loudnorm, mapping_mode, baseline_state, target_state],
+                       use_preemph, use_loudnorm, mapping_mode, resonance_method,
+                       baseline_state, target_state],
                       live_outputs)
     btn_reset_live.click(reset_live, [], [live_buffer_state])
 
-demo.queue(max_size=32).launch(**_launch_kw)
+demo.queue(max_size=32).launch(**_launch_kw)