MIDRC-MELODY 0.3.3__py3-none-any.whl

MIDRC_MELODY/common/plotly_spider.py

@@ -0,0 +1,217 @@
+#  Copyright (c) 2025 Medical Imaging and Data Resource Center (MIDRC).
+#
+#      Licensed under the Apache License, Version 2.0 (the "License");
+#      you may not use this file except in compliance with the License.
+#      You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#      Unless required by applicable law or agreed to in writing, software
+#      distributed under the License is distributed on an "AS IS" BASIS,
+#      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#      See the License for the specific language governing permissions and
+#      limitations under the License.
+#
+
+from numpy import pi as np_pi
+import plotly.graph_objects as go
+import plotly.io as pio
+
+from MIDRC_MELODY.common.plot_tools import SpiderPlotData, get_full_theta, compute_angles, prepare_and_sort
+
+
+def spider_to_html(spider_data: SpiderPlotData) -> str:
+    """
+    Given a SpiderPlotData, return an HTML <div> string containing a Plotly radar chart where:
+      - Median 'values' are drawn as a line + circle markers at discrete category angles (in degrees).
+      - The region between 'lower_bounds' and 'upper_bounds' is shaded (no boundary lines),
+        computed using full_theta_deg for a smooth polygon.
+      - Baseline(s) and safe-band fills also use full_theta_deg (0→360°).
+      - Thresholds are drawn as short line segments at ±Δθ around each category angle,
+        where Δθ = delta * (ymax – radius)/(ymax – ymin) so that the visible length
+        of each tick is roughly constant in screen pixels.
+      - Line thickness is 1 px, and each tick is colored correctly.
+    """
+    raw_metric: str = spider_data.metric
+    metric_display: str = spider_data.metric.upper()
+    groups, values, lower_bounds, upper_bounds = prepare_and_sort(spider_data)
+
+    # 1) Number of categories (excluding the “closing” duplicate)
+    N = len(groups)
+
+    # 2) Build full_theta_deg: 100 points from 0° to 360° for smooth circular traces
+    full_theta = get_full_theta()
+
+    # 3) Compute discrete category angles in degrees: [0°, 360/N°, 2*360/N°, …]
+    cat_angles = compute_angles(len(groups), spider_data.plot_config)
+    cat_labels = [g.split(": ", 1)[-1] for g in groups]
+
+    # 5) Determine radial axis min/max from spider_data
+    radial_min = spider_data.ylim_min.get(raw_metric, None)
+    radial_max = spider_data.ylim_max.get(raw_metric, None)
+
+    # 6) Start building the Plotly figure
+    fig = go.Figure()
+
+    # 7) Shade between lower_bounds and upper_bounds (CI band)
+    theta_ub = cat_angles
+    theta_lb = cat_angles
+    theta_ci = theta_ub + theta_lb[::-1]
+    r_ci = upper_bounds + lower_bounds[::-1]
+    fig.add_trace(
+        go.Scatterpolar(
+            r=r_ci,
+            theta=theta_ci,
+            thetaunit="radians",       # treat ALL numeric theta as radians
+            mode="none",
+            fill="toself",
+            fillcolor="rgba(70,130,180,0.2)",  # semi-transparent steelblue
+            line=dict(color="rgba(0,0,0,0)"),
+            hoverinfo="skip",
+            showlegend=False,
+        )
+    )
+
+    # 8) Median “values” trace (lines + circle markers)
+    theta_vals = cat_angles
+    fig.add_trace(
+        go.Scatterpolar(
+            r=values,
+            theta=theta_vals,
+            thetaunit="radians",
+            mode="lines+markers",
+            line=dict(color="steelblue", width=2),
+            marker=dict(symbol="circle", size=6, color="steelblue"),
+            customdata=list(zip(groups, lower_bounds, upper_bounds)),
+            hovertemplate="%{customdata[0]}<br>Median: %{r:.3f} [%{customdata[1]:.3f}, %{customdata[2]:.3f}]<extra></extra>",
+            showlegend=False,
+        )
+    )
+
+    # 9) Metric-specific overlay rules (matching plot_tools._apply_metric_overlay)
+    overlay_config = {
+        "QWK": {
+            "baseline": {"type": "line", "y": 0, "color": "seagreen", "width": 3, "dash": "dash", "alpha": 0.8},
+            "thresholds": [
+                (lower_bounds[:N], lambda v: v > 0, "maroon"),
+                (upper_bounds[:N], lambda v: v < 0, "red"),
+            ],
+        },
+        "EOD": {
+            "fill": {"lo": -0.1, "hi": 0.1, "color": "lightgreen", "alpha": 0.5},
+            "thresholds": [
+                (values[:N], lambda v: v > 0.1, "maroon"),
+                (values[:N], lambda v: v < -0.1, "red"),
+            ],
+        },
+        "AAOD": {
+            "fill": {"lo": 0.0, "hi": 0.1, "color": "lightgreen", "alpha": 0.5},
+            "baseline": {"type": "ylim", "lo": 0.0},
+            "thresholds": [
+                (values[:N], lambda v: v > 0.1, "maroon"),
+            ],
+        },
+    }
+    cfg = overlay_config.get(metric_display, None)
+    if cfg:
+        # 9a) Draw baseline if specified
+        if "baseline" in cfg:
+            base = cfg["baseline"]
+            if base["type"] == "line":
+                baseline_r = [base["y"]] * len(full_theta)
+                fig.add_trace(
+                    go.Scatterpolar(
+                        r=baseline_r,
+                        theta=list(full_theta),
+                        thetaunit="radians",  # treat ALL numeric theta as radians
+                        mode="lines",
+                        line=dict(color=base["color"], dash=base["dash"], width=base["width"]),
+                        opacity=base["alpha"],
+                        hoverinfo="skip",
+                        showlegend=False,
+                    )
+                )
+            elif base["type"] == "ylim":
+                # Override radial_min below
+                radial_min = base["lo"]
+
+        # 9b) Draw “safe‐band” fill if specified
+        if "fill" in cfg:
+            f = cfg["fill"]
+            hi_vals = [f["hi"]] * len(full_theta)
+            lo_vals = [f["lo"]] * len(full_theta)
+            theta_fill = list(full_theta) + list(full_theta[::-1])
+            r_fill = hi_vals + lo_vals[::-1]
+            fig.add_trace(
+                go.Scatterpolar(
+                    r=r_fill,
+                    theta=theta_fill,
+                    thetaunit="radians",  # treat ALL numeric theta as radians
+                    mode="none",
+                    fill="toself",
+                    fillcolor=f"rgba({_hex_to_rgb(f['color'])}, {f['alpha']})",
+                    line=dict(color="rgba(0,0,0,0)"),
+                    hoverinfo="skip",
+                    showlegend=False,
+                )
+            )
+
+        # 9c) Draw threshold ticks as short line segments of constant pixel length
+        #     Compute Δθ per‐point: Δθ = delta * (radial_max – radius)/(radial_max – radial_min)
+        #     so that a fixed “delta” produces roughly uniform on‐screen length.
+        delta = 0.15 # Adjust this value to change the length of the threshold ticks (in radians)
+        for data_list, cond, color_name in cfg.get("thresholds", []):
+            for i, v in enumerate(data_list):
+                if cond(v):
+                    angle = cat_angles[i]
+                    radius = v
+                    # Avoid division by zero
+                    if radial_max == radial_min:
+                        d_theta = 0
+                    else:
+                        d_theta = delta * (radial_max - radius) / (radial_max - radial_min)
+
+                    theta_line = [angle - d_theta, angle + d_theta]
+                    r_line = [radius, radius]
+                    fig.add_trace(
+                        go.Scatterpolar(
+                            r=r_line,
+                            theta=theta_line,
+                            thetaunit="radians",  # treat ALL numeric theta as radians
+                            mode="lines",
+                            line=dict(color=color_name, width=1.5),
+                            hoverinfo="skip",
+                            showlegend=False,
+                        )
+                    )
+
+    # 10) Final polar layout adjustments - Tick angles must be degrees for Plotly
+    fig.update_layout(
+        title=f"{spider_data.model_name} – {metric_display}",
+        polar=dict(
+            radialaxis=dict(range=[radial_min, radial_max], visible=True),
+            angularaxis=dict(
+                tickmode="array",
+                tickvals=[ang * 180.0/np_pi for ang in cat_angles],
+                ticktext=cat_labels,
+            ),
+        ),
+        showlegend=False,
+        margin=dict(l=50, r=50, t=50, b=50),
+    )
+
+    # 11) Export only the <div> (omit full HTML <head>), using CDN for Plotly.js
+    html_str = pio.to_html(fig, full_html=False, include_plotlyjs="cdn")
+    return html_str
+
+
+def _hex_to_rgb(css_color: str) -> str:
+    """
+    Convert a CSS color name or hex string (e.g. "lightgreen") into an "R,G,B" integer string
+    so that Plotly’s fillcolor accepts "rgba(R,G,B,alpha)".
+    """
+    import matplotlib.colors as mcolors
+
+    rgba = mcolors.to_rgba(css_color)
+    r, g, b, _ = [int(255 * c) for c in rgba]
+    return f"{r},{g},{b}"

MIDRC_MELODY/common/qwk_metrics.py

@@ -0,0 +1,244 @@
+#  Copyright (c) 2025 Medical Imaging and Data Resource Center (MIDRC).
+#
+#      Licensed under the Apache License, Version 2.0 (the "License");
+#      you may not use this file except in compliance with the License.
+#      You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#      Unless required by applicable law or agreed to in writing, software
+#      distributed under the License is distributed on an "AS IS" BASIS,
+#      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#      See the License for the specific language governing permissions and
+#      limitations under the License.
+#
+
+""" Module for calculating quadratic weighted kappa and delta kappa values with confidence intervals. """
+
+from dataclasses import replace
+from typing import Any, Dict, List, Optional, Tuple
+
+from joblib import delayed, Parallel
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from sklearn.metrics import cohen_kappa_score
+from sklearn.utils import resample
+from tqdm import tqdm
+from tqdm_joblib import tqdm_joblib
+
+from MIDRC_MELODY.common.data_loading import TestAndDemographicData
+from MIDRC_MELODY.common.plot_tools import SpiderPlotData
+from MIDRC_MELODY.common.matplotlib_spider import plot_spider_chart, display_figures_grid
+
+
+def calculate_kappas_and_intervals(
+    test_data: TestAndDemographicData
+) -> Tuple[Dict[str, float], Dict[str, Tuple[float, float]]]:
+    """
+    Calculate Cohen's quadratic weighted kappa and bootstrap confidence intervals.
+
+    :arg test_data: TestAndDemographicData object containing the test and demographic data.
+
+    :returns: Tuple of dictionaries containing kappa scores and 95% confidence intervals.
+    """
+    ai_cols = test_data.test_cols
+    if not isinstance(ai_cols, list):
+        ai_cols = [ai_cols]
+    kappas: Dict[str, float] = {}
+    intervals: Dict[str, Tuple[float, float]] = {}
+    y_true = test_data.matched_df[test_data.truth_col].to_numpy(dtype=int)
+
+    rng = np.random.default_rng(test_data.base_seed)
+    print('-'*50)
+    print("Overall Quadratic Weighted Kappa (κ) Scores:")
+    for col in ai_cols:
+        y_pred = test_data.matched_df[col].to_numpy(dtype=int)
+        kappa = cohen_kappa_score(y_true, y_pred, weights='quadratic')
+        kappas[col] = kappa
+
+        kappa_scores = np.empty(test_data.n_iter)
+        for i in range(test_data.n_iter):
+            indices = rng.integers(0, len(y_true), size=len(y_true))
+            kappa_scores[i] = cohen_kappa_score(y_true[indices], y_pred[indices], weights='quadratic')
+        lower_bnd, upper_bnd = np.percentile(kappa_scores, [2.5, 97.5])
+        intervals[col] = (lower_bnd, upper_bnd)
+        print(f"Model: {col} | Kappa (κ): {kappa:.4f} | 95% CI: ({lower_bnd:.4f}, {upper_bnd:.4f}) N: {len(y_true)}")
+    print('-'*50)
+
+    return kappas, intervals
+
+
+def bootstrap_kappa(test_data: TestAndDemographicData, n_jobs: int = -1) -> Dict[str, List[float]]:
+    """
+    Perform bootstrap estimation of quadratic weighted kappa scores for each model in parallel.
+
+    :arg test_data: TestAndDemographicData object containing the test and demographic data.
+    :arg n_jobs: Number of parallel jobs.
+
+    :returns: Dictionary of model names and their corresponding kappa scores.
+    """
+    models = test_data.test_cols
+    if not isinstance(models, list):
+        models = [models]
+    rng = np.random.default_rng(test_data.base_seed)
+    seeds = rng.integers(0, 1_000_000, size=test_data.n_iter)
+
+    def resample_and_compute_kappa(df: pd.DataFrame, truth_col: str, _models: List[str], seed: int) -> List[float]:
+        sampled_df = resample(df, replace=True, random_state=seed)
+        return [
+            cohen_kappa_score(sampled_df[truth_col].to_numpy(dtype=int),
+                              sampled_df[model].to_numpy(dtype=int),
+                              weights='quadratic')
+            for model in _models
+        ]
+
+    with tqdm_joblib(total=test_data.n_iter, desc="Bootstrapping", leave=False):
+        kappas_2d = Parallel(n_jobs=n_jobs)(
+            delayed(resample_and_compute_kappa)(test_data.matched_df, test_data.truth_col, models, seed)
+            for seed in seeds
+        )
+    kappa_dict = dict(zip(models, zip(*kappas_2d)))
+    return kappa_dict
+
+
+def calculate_delta_kappa(
+    # df: pd.DataFrame, categories: List[str], reference_groups: Dict[str, Any], valid_groups: Dict[str, List[Any]],
+    # truth_col: str, ai_columns: List[str], n_iter: int = 1000, base_seed: Optional[int] = None
+    test_data: TestAndDemographicData
+) -> Dict[str, Dict[str, Dict[Any, Tuple[float, Tuple[float, float]]]]]:
+    """
+    Calculate delta kappa (difference between group and reference) with bootstrap confidence intervals.
+
+    :arg test_data: TestAndDemographicData object containing the test and demographic data.
+
+    :returns: Dictionary of delta quadratic weighted kappa values with 95% confidence intervals.
+    """
+    delta_kappas: Dict[str, Dict[str, Dict[Any, Tuple[float, Tuple[float, float]]]]] = {}
+    df = test_data.matched_df
+
+    for category in tqdm(test_data.categories, desc="Categories", position=0):
+        if category not in test_data.valid_groups:
+            continue
+
+        delta_kappas[category] = {model: {} for model in test_data.test_cols}
+        unique_values = df[category].unique().tolist()
+
+        kappa_dicts: Dict[str, Dict[str, List[float]]] = {}
+        for value in tqdm(unique_values, desc=f"Category \033[1m{category}\033[0m Groups", leave=False, position=1):
+            if value not in test_data.valid_groups[category]:
+                continue
+
+            filtered_df = df[df[category] == value]
+
+            # Create a shallow copy of test_data and update matched_df with filtered_df
+            filtered_test_data = replace(test_data, matched_df=filtered_df)
+
+            kappa_dicts[value] = bootstrap_kappa(filtered_test_data, n_jobs=-1)
+
+        # Remove and store reference bootstraps.
+        ref_bootstraps = kappa_dicts.pop(test_data.reference_groups[category])
+
+        # Now calculate the differences.
+        for value, kappa_dict in kappa_dicts.items():
+            for model in test_data.test_cols:
+                model_boot = np.array(kappa_dict[model])
+                ref_boot = np.array(ref_bootstraps[model])
+                deltas = model_boot - ref_boot
+                delta_median = float(np.median(deltas))
+                lower_value, upper_value = np.percentile(deltas, [2.5, 97.5])
+                delta_kappas[category][model][value] = (
+                    delta_median,
+                    (float(lower_value), float(upper_value))
+                    )
+    return delta_kappas
+
+
+def extract_plot_data(delta_kappas: Dict[str, Dict[str, Dict[Any, Tuple[float, Tuple[float, float]]]]],
+                      model_name: str) -> Tuple[List[str], List[float], List[float], List[float]]:
+    """
+    Extract group names, delta values and confidence intervals for plotting.
+
+    :arg delta_kappas: Dictionary of delta kappa values with 95% confidence intervals.
+    :arg model_name: Name of the AI model.
+
+    :returns: Tuple of group names, delta values, lower bounds and upper bounds.
+    """
+    groups: List[str] = []
+    values: List[float] = []
+    lower_bounds: List[float] = []
+    upper_bounds: List[float] = []
+
+    for category, model_data in delta_kappas.items():
+        if model_name in model_data:
+            for group, (value, (lower_ci, upper_ci)) in model_data[model_name].items():
+                groups.append(f"{category}: {group}")
+                values.append(value)
+                lower_bounds.append(lower_ci)
+                upper_bounds.append(upper_ci)
+    return groups, values, lower_bounds, upper_bounds
+
+
+def create_spider_plot_data_qwk(
+    delta_kappas: Dict[str, Dict[str, Dict[Any, Tuple[float, Tuple[float, float]]]]],
+    ai_models: List[str],
+    plot_config: Optional[Dict[str, Any]] = None
+) -> List[SpiderPlotData]:
+    """
+    Create a list of SpiderPlotData instances for each AI model based on delta kappas.
+
+    :arg delta_kappas: Dictionary of delta kappa values with 95% confidence intervals.
+    :arg ai_models: List of test columns (AI model names).
+    :arg plot_config: Optional configuration dictionary for plotting.
+
+    :returns: Dictionary of SpiderPlotData instances keyed by model names.
+    """
+    plot_data_list: List[SpiderPlotData] = []
+    all_values, all_lower, all_upper = [], [], []
+
+    for model in ai_models:
+        _, values, lower_bounds, upper_bounds = extract_plot_data(delta_kappas, model)
+        all_values.extend(values)
+        all_lower.extend(lower_bounds)
+        all_upper.extend(upper_bounds)
+
+    global_min = min(all_lower) - 0.05
+    global_max = max(all_upper) + 0.05
+    metric = "QWK"
+    base_plot_data = SpiderPlotData(
+        ylim_min={metric: global_min},
+        ylim_max={metric: global_max},
+        plot_config=plot_config,
+        metric=metric,
+    )
+    for model in ai_models:
+        # Create a new copy based on the base instance
+        plot_data = SpiderPlotData(**base_plot_data.__dict__)
+        plot_data.model_name = model
+        plot_data.groups, plot_data.values, plot_data.lower_bounds, plot_data.upper_bounds = \
+            extract_plot_data(delta_kappas, model)
+        plot_data_list.append(plot_data)
+
+    return plot_data_list
+
+def generate_plots_from_delta_kappas(
+    delta_kappas: Dict[str, Dict[str, Dict[Any, Tuple[float, Tuple[float, float]]]]],
+    ai_models: List[str],
+    plot_config: Optional[Dict[str, Any]] = None
+) -> None:
+    """
+    Generate spider plots for delta kappas using consistent scale across models.
+
+    :arg delta_kappas: Dictionary of delta kappa values with 95% confidence intervals.
+    :arg ai_models: List of test columns (AI model names).
+    :arg plot_config: Optional configuration dictionary for plotting
+    """
+
+    figures = []
+
+    plot_data_list = create_spider_plot_data_qwk(delta_kappas, ai_models, plot_config)
+    for plot_data in plot_data_list:
+        fig = plot_spider_chart(plot_data)
+        figures.append(fig)
+
+    display_figures_grid(figures)

MIDRC_MELODY/common/table_tools.py

@@ -0,0 +1,230 @@
+#  Copyright (c) 2025 Medical Imaging and Data Resource Center (MIDRC).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Dict, Final, List, Tuple
+
+from tabulate import tabulate
+
+# ANSI color codes
+GLOBAL_COLORS: Final = {
+    'eod_negative': (128, 0, 0),  # Maroon
+    'eod_positive': (0, 128, 0),  # Green
+    'aaod': (255, 165, 0),  # Orange
+    'kappa_negative': (128, 0, 0),  # Maroon
+    'kappa_positive': (0, 128, 0),  # Green
+}
+
+_CONSOLE_RESET: Final = "\033[0m"
+
+
+def _console_color(color: str | Tuple[int, int, int]) -> str:
+    """
+    Convert RGB color tuple or color name to ANSI escape code string.
+    """
+    if isinstance(color, tuple):
+        return f"\033[38;2;{color[0]};{color[1]};{color[2]}m"
+    if isinstance(color, str):
+        if color in GLOBAL_COLORS:
+            rgb = GLOBAL_COLORS[color]
+            return _console_color(rgb)
+    return ""
+
+
+def _format_console_string(value: str, color: str) -> str:
+    """
+    Format a string value with ANSI color if it qualifies.
+    """
+    if color is not None:
+        return f"{color}{value}{_CONSOLE_RESET}"
+    return value
+
+
+def _format_console_value(value: float, color: str) -> str:
+    """
+    Format a numeric value with ANSI color if it qualifies.
+    """
+    formatted = f"{value:.4f}"
+    return _format_console_string(formatted, color)
+
+
+def _sort_rows(rows: List[List[str]]) -> List[List[str]]:
+    """Sort rows by Model, Category, Group, then Metric if present."""
+    return sorted(rows, key=lambda r: tuple(r[:4]))
+
+
+def _build_eod_aaod_tables_generic(
+    eod_aaod: Dict[str, Dict[str, Dict[Any, Dict[str, Tuple[float, Tuple[float, float]]]]]], *,
+    console: bool
+) -> List[Tuple[List[str], str]]:
+    """
+    Generate tables for EOD/AAOD metrics.
+    If console is True, returns tables of list[str] rows with ANSI coloring.
+    If console is False, returns tables as tuples of (row: list[str], color: QColor | None).
+    """
+    # Set up color formatting based on mode.
+    if console:
+        color_fn = _console_color
+    else:
+        # For GUI, use plain formatting
+        try:
+            from PySide6.QtGui import QColor
+        except ImportError:
+            raise ImportError("PySide6 is required for GUI table generation.")
+        color_fn = lambda x: QColor(*GLOBAL_COLORS[x]) if x in GLOBAL_COLORS else None
+
+    # Initialize lists; console returns lists of rows, GUI returns tuples (row, color).
+    all_eod = []
+    all_aaod = []
+    filtered = []
+    
+    for category, model_data in eod_aaod.items():
+        for model, groups in model_data.items():
+            for group, metrics in groups.items():
+                for metric in ('eod', 'aaod'):
+                    if metric not in metrics:
+                        continue
+                    median, (ci_lo, ci_hi) = metrics[metric]
+                    if metric == 'eod':
+                        qualifies = abs(median) > 0.1
+                        color = None if not qualifies else\
+                            color_fn('eod_negative') if median < 0 else color_fn('eod_positive')
+                        target_list = all_eod
+                    else:
+                        qualifies = median > 0.1
+                        color = color_fn('aaod') if qualifies else None
+                        target_list = all_aaod
+                    
+                    # Format each cell
+                    format_fn = lambda v: f"{v:.4f}"
+                    val_str = format_fn(median)
+                    lo_str = format_fn(ci_lo)
+                    hi_str = format_fn(ci_hi)
+                    
+                    row = [model, category, group, val_str, lo_str, hi_str]
+                    target_list.append((row, color))
+                    
+                    if qualifies:
+                        # For filtered rows, insert the metric name.
+                        row_f = row.copy()
+                        row_f.insert(3, metric.upper())
+                        filtered.append((row_f, color))
+
+    # Define a common sort key based on the first 4 cells of each row.
+    sort_key = lambda x: tuple(x[0][:4])
+
+    # Sort all lists using map for conciseness.
+    sorted_all_eod, sorted_all_aaod, sorted_filtered = map(
+        lambda rows: sorted(rows, key=sort_key),
+        [all_eod, all_aaod, filtered]
+    )
+
+    return sorted_all_eod, sorted_all_aaod, sorted_filtered
+
+
+def _print_section(title: str, rows: List[List[str]], headers: List[str], tablefmt: str) -> None:
+    print(title)
+    print(tabulate(rows, headers=headers, tablefmt=tablefmt))
+    print()
+
+
+def _build_eod_aaod_tables_console(
+    eod_aaod: Dict[str, Dict[str, Dict[Any, Dict[str, Tuple[float, Tuple[float, float]]]]]]
+) -> Tuple[List[List[str]], List[List[str]], List[List[str]]]:
+    # Delegate table-building to the generic function with console=True.
+    sorted_all_eod, sorted_all_aaod, sorted_filtered = _build_eod_aaod_tables_generic(eod_aaod, console=True)
+
+    def convert_fn(rows: List[Tuple[List[str], str]]) -> List[List[str]]:
+        return [
+            row if color is None else row[:-3] + [f"{color}{cell}{_CONSOLE_RESET}" for cell in row[-3:]]
+            for row, color in rows
+        ]
+
+    sorted_all_eod, sorted_all_aaod, sorted_filtered = map(convert_fn,
+                                                           [sorted_all_eod, sorted_all_aaod, sorted_filtered])
+    return sorted_all_eod, sorted_all_aaod, sorted_filtered
+
+
+def print_table_of_nonzero_eod_aaod(
+    eod_aaod: Dict[str, Dict[str, Dict[Any, Dict[str, Tuple[float, Tuple[float, float]]]]]],
+    tablefmt: str = 'grid'
+) -> None:
+    """
+    Print tables for EOD and AAOD medians, highlighting values meeting criteria.
+    """
+    all_eod, all_aaod, filtered = _build_eod_aaod_tables_console(eod_aaod)
+
+    headers_all = ['Model', 'Category', 'Group', 'Median', 'Lower CI', 'Upper CI']
+    headers_filtered = ['Model', 'Category', 'Group', 'Metric', 'Median', 'Lower CI', 'Upper CI']
+
+    _print_section('All EOD median values:', all_eod, headers_all, tablefmt)
+    _print_section('All AAOD median values:', all_aaod, headers_all, tablefmt)
+
+    if filtered:
+        _print_section('EOD/AAOD median values meeting criteria:', filtered, headers_filtered, tablefmt)
+    else:
+        print('No model/group combinations meeting the specified criteria for EOD/AAOD.')
+
+
+def _build_delta_tables(
+    delta_kappas: Dict[str, Dict[str, Dict[Any, Tuple[float, Tuple[float, float]]]]]
+) -> Tuple[List[List[str]], List[List[str]]]:
+    all_deltas, filtered = [], []
+
+    for category, model_data in delta_kappas.items():
+        for model, groups in model_data.items():
+            for group, (delta, (ci_lo, ci_hi)) in groups.items():
+                qualifies = ci_lo > 0 or ci_hi < 0
+                color = None if not qualifies else\
+                    _console_color('kappa_negative' if delta < 0 else 'kappa_positive')
+
+                delta_str = _format_console_value(delta, color)
+                lo_str = _format_console_value(ci_lo, color)
+                hi_str = _format_console_value(ci_hi, color)
+                row = [model, category, group, delta_str, lo_str, hi_str]
+                all_deltas.append(row)
+
+                if qualifies:
+                    filtered.append(row)
+
+    return _sort_rows(all_deltas), _sort_rows(filtered)
+
+
+def print_table_of_nonzero_deltas(
+    delta_kappas: Dict[str, Dict[str, Dict[Any, Tuple[float, Tuple[float, float]]]]],
+    tablefmt: str = 'grid'
+) -> None:
+    """
+    Print tables for Delta Kappa values, highlighting those with 95% CI excluding zero.
+    """
+    all_deltas, filtered = _build_delta_tables(delta_kappas)
+    headers = ['Model', 'Category', 'Group', 'Δκ', 'Lower CI', 'Upper CI']
+
+    _print_section('All Δκ Values:', all_deltas, headers, tablefmt)
+
+    if filtered:
+        _print_section('Δκ values with 95% CI excluding zero:', filtered, headers, tablefmt)
+    else:
+        print('No model/group combinations meeting the specified criteria for Δκ.')
+
+
+try:
+    from PySide6.QtGui import QColor
+except ImportError:
+    build_eod_aaod_tables_gui = None
+else:
+    def build_eod_aaod_tables_gui(
+            eod_aaod: Dict[str, Dict[str, Dict[Any, Dict[str, Tuple[float, Tuple[float, float]]]]]]
+    ) -> tuple[list[tuple[list[str], "QColor | None"]], list[tuple[list[str], "QColor | None"]], list[tuple[list[str], "QColor | None"]]]:
+        # Delegate table-building to the generic function with console=False.
+        return _build_eod_aaod_tables_generic(eod_aaod, console=False)