Refactor correlogram window and wizard; improve layout, resizing, and dataset name handling

Author: tmaier-kettering

assets/Banner_Narrow_transparent.png

@@ -15,27 +15,27 @@
 # ----------------------------- Tk Figure Window -----------------------------
 
 def show_correlogram_window(parent: tk.Misc, fig, title: str):
-    """
-    Embed a Matplotlib Figure in its own persistent Tk Toplevel, parented to the app root.
-    Centers the window on screen.
-    """
     root = parent.winfo_toplevel() if isinstance(parent, tk.Misc) else None
 
     win = tk.Toplevel(master=root)
     win.title(title)
 
-    container = tk.Frame(win)
-    container.pack(fill="both", expand=True)
+    outer = tk.Frame(win)
+    outer.pack(fill="both", expand=True)
 
-    canvas = FigureCanvasTkAgg(fig, master=container)
-    canvas.draw()
-    canvas.get_tk_widget().pack(fill="both", expand=True)
+    # Canvas (created first so we can hand it to the toolbar)
+    canvas = FigureCanvasTkAgg(fig, master=outer)
+    canvas_widget = canvas.get_tk_widget()
 
-    toolbar = NavigationToolbar2Tk(canvas, container)
+    # Toolbar ON TOP so controls don't get hidden
+    toolbar = NavigationToolbar2Tk(canvas, outer)
     toolbar.update()
-    toolbar.pack(fill="x")
+    toolbar.pack(side="top", fill="x")
+
+    # Canvas fills the rest
+    canvas_widget.pack(side="top", fill="both", expand=True)
 
-    # keep refs so they don’t get garbage collected
+    # Keep refs
     win._canvas = canvas
     win._toolbar = toolbar
     win._fig = fig
@@ -47,30 +47,43 @@ def _on_close():
         except Exception:
             pass
         win.destroy()
-
     win.protocol("WM_DELETE_WINDOW", _on_close)
 
-    # --- Center on screen ---
-    # Let widgets compute their natural size, then center to that size
+    # Cap initial window size to screen and center it
     win.update_idletasks()
-    width = max(900, win.winfo_reqwidth())    # ensure a reasonable minimum width
-    height = max(650, win.winfo_reqheight())  # ensure a reasonable minimum height
-    center_window(win, width, height)
+    sw, sh = win.winfo_screenwidth(), win.winfo_screenheight()
+    req_w, req_h = win.winfo_reqwidth(), win.winfo_reqheight()
+    width = min(max(900, req_w), int(sw * 0.9))
+    height = min(max(650, req_h), int(sh * 0.9))
+    x = (sw - width) // 2
+    y = (sh - height) // 2
+    win.geometry(f"{width}x{height}+{x}+{y}")
+
+    # Resize: match figure size to the canvas widget in pixels
+    def _resize_figure(event=None):
+        try:
+            w_px = canvas_widget.winfo_width()
+            h_px = canvas_widget.winfo_height()
+            # Ignore early calls when Tk hasn’t assigned size yet
+            if w_px < 200 or h_px < 200:
+                return
+            dpi = fig.get_dpi() or 100
+            fig.set_size_inches(w_px / dpi, h_px / dpi, forward=True)
+            canvas_widget.configure(width=w_px, height=h_px)
+            canvas.draw()  # no tight_layout() or engine changes here
+        except Exception:
+            pass
+
+    canvas_widget.bind("<Configure>", _resize_figure)
+    win.bind("<Configure>", _resize_figure)
+    win.after(60, _resize_figure)   # let Tk map the window first
 
     return win
 
 
 def ask_correlogram_options(parent: tk.Misc, *, ds1: str, ds2: str):
     """
     Modal dialog to pick plot options right after the wizard finishes.
-    Centers itself on screen before showing.
-    Returns a dict like:
-      { 'normalize': 'none'|'row'|'col'|'all',
-        'cmap': str,
-        'annotate': bool,
-        'zero_diag': bool,
-        'title': str }
-    or None if cancelled.
     """
     root = parent.winfo_toplevel() if isinstance(parent, tk.Misc) else None
 
@@ -98,30 +111,30 @@ def ask_correlogram_options(parent: tk.Misc, *, ds1: str, ds2: str):
     frm.pack(fill="both", expand=True)
 
     # Title
-    ttk.Label(frm, text="Title:").grid(row=0, column=0, sticky="w", padx=(0,8), pady=(0,8))
+    ttk.Label(frm, text="Title:").grid(row=0, column=0, sticky="w", padx=(0, 8), pady=(0, 8))
     title_entry = ttk.Entry(frm, textvariable=title_var, width=48)
-    title_entry.grid(row=0, column=1, sticky="ew", pady=(0,8))
+    title_entry.grid(row=0, column=1, sticky="ew", pady=(0, 8))
 
     # Normalize
-    ttk.Label(frm, text="Normalize:").grid(row=1, column=0, sticky="w", padx=(0,8), pady=4)
-    normalize_combo = ttk.Combobox(frm, textvariable=normalize_var, values=["none", "row", "col", "all"], state="readonly", width=12)
+    ttk.Label(frm, text="Normalize:").grid(row=1, column=0, sticky="w", padx=(0, 8), pady=4)
+    normalize_combo = ttk.Combobox(frm, textvariable=normalize_var, values=["none", "row", "col", "all"],
+                                   state="readonly", width=12)
     normalize_combo.grid(row=1, column=1, sticky="w", pady=4)
 
     # Colormap
-    ttk.Label(frm, text="Colormap:").grid(row=2, column=0, sticky="w", padx=(0,8), pady=4)
+    ttk.Label(frm, text="Colormap:").grid(row=2, column=0, sticky="w", padx=(0, 8), pady=4)
     cmap_combo = ttk.Combobox(frm, textvariable=cmap_var, values=cmaps, state="readonly", width=20)
     cmap_combo.grid(row=2, column=1, sticky="w", pady=4)
 
     # Checkboxes
     annotate_chk = ttk.Checkbutton(frm, text="Annotate cells", variable=annotate_var)
     annotate_chk.grid(row=3, column=1, sticky="w", pady=4)
-
     zero_diag_chk = ttk.Checkbutton(frm, text="Zero-out diagonal", variable=zero_diag_var)
     zero_diag_chk.grid(row=4, column=1, sticky="w", pady=4)
 
     # Buttons
     btns = ttk.Frame(frm)
-    btns.grid(row=5, column=0, columnspan=2, sticky="e", pady=(12,0))
+    btns.grid(row=5, column=0, columnspan=2, sticky="e", pady=(12, 0))
     result = {"_ok": False}
 
     def on_ok():
@@ -139,21 +152,19 @@ def on_cancel():
         result["_ok"] = False
         win.destroy()
 
-    ttk.Button(btns, text="Cancel", command=on_cancel).pack(side="right", padx=(0,8))
+    ttk.Button(btns, text="Cancel", command=on_cancel).pack(side="right", padx=(0, 8))
     ttk.Button(btns, text="OK", command=on_ok).pack(side="right")
 
     # Sizing and focus
     frm.columnconfigure(1, weight=1)
     title_entry.focus_set()
 
-    # --- Center on screen ---
+    # Center
     win.update_idletasks()
-    # Use the natural requested size, but ensure a sensible minimum
     width = max(520, win.winfo_reqwidth())
     height = max(240, win.winfo_reqheight())
     center_window(win, width, height)
 
-    # Modal behavior
     win.protocol("WM_DELETE_WINDOW", on_cancel)
     win.wait_visibility()
     win.wait_window()
@@ -169,73 +180,51 @@ def plot_label_correlogram(
     col_y: str,                     # dataset 1 name (y-axis)
     col_x: str,                     # dataset 2 name (x-axis)
     weight: str = "count",          # "count" (kept for parity)
-    normalize: str = "row",        # "none" | "row" | "col" | "all"
+    normalize: str = "row",         # "none" | "row" | "col" | "all"
     cmap: str = "Blues",
     annotate: bool = True,
     zero_diag: bool = False,        # set True to zero-out perfect matches on the diagonal
     title: str | None = None,
 ):
     """
     Plot a correlogram (co-occurrence heatmap) between two categorical columns.
-
-    Parameters
-    ----------
-    df : pd.DataFrame
-        Must contain columns: 'text', col_y, col_x.
-    col_y : str
-        Column name for Y axis (Dataset 1 label column).
-    col_x : str
-        Column name for X axis (Dataset 2 label column).
-    weight : {"count"}, default "count"
-        - "count": cell value = number of rows with (col_y, col_x)
-    normalize : {"none", "row", "col", "all"}, default "none"
-        - "row": each row sums to 1
-        - "col": each column sums to 1
-        - "all": divide by grand total
-        - "none": raw counts
-    cmap : str, default "Blues"
-        Matplotlib colormap name.
-    annotate : bool, default True
-        Draw numeric labels on each cell.
-    zero_diag : bool, default False
-        If True, sets the diagonal to zero before normalization/plotting.
-    title : str or None
-        Optional plot title.
-
-    Returns
-    -------
-    fig, ax : matplotlib Figure and Axes
+    Returns fig, ax.
     """
-
     required_cols = {"text", col_y, col_x}
     missing = required_cols.difference(df.columns)
     if missing:
         raise ValueError(f"DataFrame is missing required columns: {sorted(missing)}")
 
-    # Work on a copy to avoid modifying the caller's df
     data = df.copy()
-
-    # Ensure labels are strings (prevents issues with None/NaN vs. ints)
     data[col_y] = data[col_y].astype(str)
     data[col_x] = data[col_x].astype(str)
 
-    # Axis order: alphabetical by default (stable and predictable)
+    # Axis order
     y_order = sorted(pd.unique(data[col_y]))
     x_order = sorted(pd.unique(data[col_x]))
 
-    # Build the matrix (counts)
+    # Choose a smaller label font when many categories
+    n_labels = max(len(x_order), len(y_order))
+    if n_labels <= 15:
+        lab_fs = 10
+    elif n_labels <= 30:
+        lab_fs = 8
+    else:
+        lab_fs = 6
+
+    # Counts matrix
     mat = pd.crosstab(
         index=pd.Categorical(data[col_y], categories=y_order, ordered=True),
         columns=pd.Categorical(data[col_x], categories=x_order, ordered=True),
     ).reindex(index=y_order, columns=x_order, fill_value=0)
 
-    # Optionally zero the diagonal (useful if you only care about cross-label associations)
+    # Optionally zero the diagonal
     if zero_diag:
         common = set(mat.index).intersection(mat.columns)
         for k in common:
             mat.loc[k, k] = 0
 
-    # Normalize as requested
+    # Normalize
     mat_values = mat.to_numpy(dtype=float)
     if normalize == "row":
         row_sums = mat_values.sum(axis=1, keepdims=True)
@@ -248,8 +237,7 @@ def plot_label_correlogram(
         mat_plot = mat_values / col_sums
         fmt = ".2f"
     elif normalize == "all":
-        total = mat_values.sum()
-        total = total if total != 0 else 1.0
+        total = mat_values.sum() or 1.0
         mat_plot = mat_values / total
         fmt = ".3f"
     elif normalize == "none":
@@ -258,10 +246,12 @@ def plot_label_correlogram(
     else:
         raise ValueError("normalize must be one of {'none','row','col','all'}")
 
-    # Plot (size scales with label cardinality)
-    fig_w = max(6, len(x_order) * 0.5 + 2)
-    fig_h = max(5, len(y_order) * 0.5 + 2)
+    # Start with a modest base and cap growth
+    fig_w = min(max(8, len(x_order) * 0.30 + 3), 14)
+    fig_h = min(max(6, len(y_order) * 0.30 + 2), 12)
     fig, ax = plt.subplots(figsize=(fig_w, fig_h))
+    fig.set_layout_engine('constrained')  # choose ONE engine before adding colorbar
+
     im = ax.imshow(mat_plot, aspect="auto", cmap=cmap)
 
     # Colorbar
@@ -275,16 +265,16 @@ def plot_label_correlogram(
     # Ticks & labels
     ax.set_xticks(np.arange(len(x_order)))
     ax.set_yticks(np.arange(len(y_order)))
-    ax.set_xticklabels(x_order, rotation=45, ha="right")
-    ax.set_yticklabels(y_order)
+    ax.set_xticklabels(x_order, rotation=45, ha="right", fontsize=lab_fs)
+    ax.set_yticklabels(y_order, fontsize=lab_fs)
+    ax.set_title(title, pad=10)
 
-    # Grid lines
+    # Grid
     ax.set_xticks(np.arange(-.5, len(x_order), 1), minor=True)
     ax.set_yticks(np.arange(-.5, len(y_order), 1), minor=True)
     ax.grid(which="minor", color="w", linestyle="-", linewidth=0.8)
     ax.tick_params(which="minor", bottom=False, left=False)
 
-    # Annotations
     if annotate:
         vmax = np.nanmax(mat_plot) if mat_plot.size else 0
         threshold = vmax * 0.6 if vmax > 0 else 0
@@ -301,9 +291,8 @@ def plot_label_correlogram(
         norm = "" if normalize == "none" else f" ({normalize}-normalized)"
         title = f"Correlogram of {col_y} × {col_x} — {base}{norm}"
     ax.set_title(title)
-    fig.tight_layout()
 
-    # Give the native window a nice title (helps when multiple figures are open)
+    # Nice window title (if backend supports it)
     try:
         fig.canvas.manager.set_window_title(title)
     except Exception:
@@ -316,19 +305,15 @@ def plot_label_correlogram(
 
 def open_correlogram_wizard(parent: tk.Misc):
     """
-    Opens the reusable two-page wizard and, on finish, prompts for plot options
-    and then renders the correlogram in a persistent Tk window.
-    Mirrors the usage pattern in reliability_calculator.
+    Opens the two-page wizard and, on finish, prompts for plot options,
+    then renders the correlogram in a persistent Tk window.
     """
-
     def _finish_handler(*args):
-        # Accept either signature: (res) or (res, win)
         if not args:
             return False
         res: WizardResult = args[0]
         host_parent = parent
 
-        # Validate expected fields from the wizard
         try:
             merged = res.merged.copy()
             ds1 = res.ds1_name
@@ -347,10 +332,9 @@ def _finish_handler(*args):
             )
             return False
 
-        # === NEW: Ask user for plotting options ===
+        # Ask user for plotting options
         opts = ask_correlogram_options(host_parent, ds1=ds1, ds2=ds2)
         if opts is None:
-            # User cancelled the options dialog; do not open the correlogram window.
             return False
 
         # Build figure with chosen options
@@ -366,11 +350,8 @@ def _finish_handler(*args):
             title=opts["title"],
         )
 
-        # Show in persistent Tk window (no plt.show())
+        # Show in persistent Tk window
         show_correlogram_window(parent=host_parent, fig=fig, title=opts["title"])
-
-        # Return True so wizards that expect a truthy value will close.
         return True
 
-    # Launch the wizard; our finish handler handles options + plotting.
     return open_two_page_wizard(parent, on_finish=_finish_handler)