figrecipe 0.7.4__py3-none-any.whl → 0.9.0__py3-none-any.whl

figrecipe/_editor/_bbox/_extract.py

@@ -20,6 +20,7 @@ from ._extract_axes import (
     extract_patches,
 )
 from ._extract_text import (
+    extract_annotations,
     extract_figure_text,
     extract_legend,
     extract_spines,
@@ -55,18 +56,35 @@ def extract_bboxes(
     bboxes = {}
 
     # Get renderer for bbox calculations
-    fig.canvas.draw()
+    # Handle matplotlib's Done exception from _get_renderer (can occur with corrupted canvas state)
+    try:
+        fig.canvas.draw()
+    except Exception as e:
+        # Matplotlib's Done exception or other draw issues - reset canvas and retry
+        if "Done" in str(type(e).__name__) or "Done" in str(e):
+            from matplotlib.backends.backend_agg import FigureCanvasAgg
+
+            fig.set_canvas(FigureCanvasAgg(fig))
+            try:
+                fig.canvas.draw()
+            except Exception:
+                pass  # Continue with potentially stale renderer
+        else:
+            raise
     renderer = fig.canvas.get_renderer()
 
-    # Get tight bbox for coordinate transformation
-    tight_bbox = fig.get_tightbbox(renderer)
-    if tight_bbox is None:
-        tight_bbox = Bbox.from_bounds(0, 0, fig.get_figwidth(), fig.get_figheight())
+    # Get figure bounds for coordinate transformation
+    # NOTE: We do NOT use bbox_inches='tight' in savefig, so use fixed figsize
+    fig_width_inches = fig.get_figwidth()
+    fig_height_inches = fig.get_figheight()
+
+    # Create a bbox representing the full figure (for compatibility with element extraction)
+    tight_bbox = Bbox.from_bounds(0, 0, fig_width_inches, fig_height_inches)
 
-    # bbox_inches='tight' adds pad_inches (default 0.1) around the tight bbox
-    pad_inches = 0.1
-    saved_width_inches = tight_bbox.width + 2 * pad_inches
-    saved_height_inches = tight_bbox.height + 2 * pad_inches
+    # No padding since we don't use bbox_inches='tight'
+    pad_inches = 0.0
+    saved_width_inches = fig_width_inches
+    saved_height_inches = fig_height_inches
 
     # Calculate scale factors from saved image size to pixel size
     scale_x = img_width / saved_width_inches if saved_width_inches > 0 else 1
@@ -104,6 +122,16 @@ def extract_bboxes(
         bboxes,
     )
 
+    # Compute panel bboxes using tight bbox from matplotlib
+    panel_bboxes = _compute_panel_bboxes(
+        bboxes,
+        len(fig.get_axes()),
+        fig=fig,
+        renderer=renderer,
+        img_width=img_width,
+        img_height=img_height,
+    )
+
     # Add metadata
     bboxes["_meta"] = {
         "img_width": img_width,
@@ -111,6 +139,7 @@ def extract_bboxes(
         "fig_width_inches": fig.get_figwidth(),
         "fig_height_inches": fig.get_figheight(),
         "dpi": fig.dpi,
+        "panel_bboxes": panel_bboxes,
     }
 
     return bboxes
@@ -249,6 +278,123 @@ def _extract_axes_bboxes(
         saved_height_inches,
         bboxes,
     )
+    extract_annotations(
+        ax,
+        ax_idx,
+        fig,
+        renderer,
+        tight_bbox,
+        img_width,
+        img_height,
+        scale_x,
+        scale_y,
+        pad_inches,
+        saved_height_inches,
+        bboxes,
+    )
+
+
+def _compute_panel_bboxes(
+    bboxes: Dict[str, Any],
+    num_axes: int,
+    fig: Figure = None,
+    renderer=None,
+    img_width: int = None,
+    img_height: int = None,
+) -> Dict[int, Dict[str, float]]:
+    """
+    Compute tight bounding box for each panel (axis).
+
+    Uses matplotlib's ax.get_tightbbox() for reliable panel bounds that include
+    all decorators (title, labels, tick labels) without outliers.
+
+    Falls back to union of elements if tight bbox is unavailable.
+
+    Parameters
+    ----------
+    bboxes : dict
+        All extracted element bboxes.
+    num_axes : int
+        Number of axes in the figure.
+    fig : Figure, optional
+        Matplotlib figure (needed for tight bbox computation).
+    renderer : optional
+        Matplotlib renderer (needed for tight bbox computation).
+    img_width : int, optional
+        Image width in pixels.
+    img_height : int, optional
+        Image height in pixels.
+
+    Returns
+    -------
+    dict
+        Mapping from ax_index to panel bbox: {ax_index: {x, y, width, height}}
+    """
+    panel_bboxes = {}
+
+    # Try to use tight bbox if figure is available
+    if fig is not None and renderer is not None and img_width and img_height:
+        fig_width_inches = fig.get_figwidth()
+        fig_height_inches = fig.get_figheight()
+        dpi = fig.dpi
+
+        for ax_idx, ax in enumerate(fig.get_axes()):
+            try:
+                tight = ax.get_tightbbox(renderer)
+                if tight is not None:
+                    # Convert from display coords to image coords
+                    # Display y=0 is at bottom, image y=0 is at top
+                    x = tight.x0 * img_width / (fig_width_inches * dpi)
+                    y = img_height - tight.y1 * img_height / (fig_height_inches * dpi)
+                    width = tight.width * img_width / (fig_width_inches * dpi)
+                    height = tight.height * img_height / (fig_height_inches * dpi)
+                    panel_bboxes[ax_idx] = {
+                        "x": x,
+                        "y": y,
+                        "width": width,
+                        "height": height,
+                    }
+            except Exception:
+                pass  # Fall back to union method below
+
+    # Fall back to union method for any missing panels
+    for ax_idx in range(num_axes):
+        if ax_idx in panel_bboxes:
+            continue
+
+        min_x, min_y = float("inf"), float("inf")
+        max_x, max_y = float("-inf"), float("-inf")
+
+        for key, bbox in bboxes.items():
+            if key == "_meta" or not isinstance(bbox, dict):
+                continue
+            elem_ax_index = bbox.get("ax_index")
+            if elem_ax_index is None:
+                if key.startswith("ax") and "_" in key:
+                    try:
+                        elem_ax_index = int(key.split("_")[0][2:])
+                    except (ValueError, IndexError):
+                        continue
+                else:
+                    continue
+            if elem_ax_index != ax_idx:
+                continue
+            x, y = bbox.get("x"), bbox.get("y")
+            w, h = bbox.get("width"), bbox.get("height")
+            if x is None or y is None or w is None or h is None:
+                continue
+            min_x, min_y = min(min_x, x), min(min_y, y)
+            max_x, max_y = max(max_x, x + w), max(max_y, y + h)
+
+        if min_x != float("inf"):
+            panel_bboxes[ax_idx] = {
+                "x": min_x,
+                "y": min_y,
+                "width": max_x - min_x,
+                "height": max_y - min_y,
+            }
+
+    return panel_bboxes
 
 
 __all__ = ["extract_bboxes"]

figrecipe/_editor/_bbox/_extract_text.py

@@ -332,11 +332,135 @@ def extract_figure_text(
                 pass
 
 
+def extract_annotations(
+    ax,
+    ax_idx,
+    fig,
+    renderer,
+    tight_bbox,
+    img_width,
+    img_height,
+    scale_x,
+    scale_y,
+    pad_inches,
+    saved_height_inches,
+    bboxes,
+):
+    """Extract bboxes for decorative elements (ax.text, ax.annotate, panel labels).
+
+    These are cosmetic elements that can be repositioned without affecting data.
+    """
+    import string
+
+    panel_label_chars = set(string.ascii_uppercase)
+
+    # Extract ax.texts (includes panel labels and other text annotations)
+    for i, text_obj in enumerate(ax.texts):
+        text_content = text_obj.get_text().strip()
+        if not text_content:
+            continue
+
+        try:
+            bbox = get_text_bbox(
+                text_obj,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+            )
+            if bbox:
+                # Determine if this is a panel label
+                is_panel_label = (
+                    text_content in panel_label_chars
+                    and text_obj.get_transform() == ax.transAxes
+                )
+
+                # Get position
+                pos = text_obj.get_position()
+
+                # Calculate axes-relative position (0-1)
+                if text_obj.get_transform() == ax.transAxes:
+                    # Already in axes coordinates
+                    rel_x, rel_y = pos[0], pos[1]
+                else:
+                    # Convert from data coordinates to axes
+                    xlim = ax.get_xlim()
+                    ylim = ax.get_ylim()
+                    rel_x = (
+                        (pos[0] - xlim[0]) / (xlim[1] - xlim[0])
+                        if xlim[1] != xlim[0]
+                        else 0.5
+                    )
+                    rel_y = (
+                        (pos[1] - ylim[0]) / (ylim[1] - ylim[0])
+                        if ylim[1] != ylim[0]
+                        else 0.5
+                    )
+
+                if is_panel_label:
+                    key = f"ax{ax_idx}_panel_label"
+                    elem_type = "panel_label"
+                else:
+                    key = f"ax{ax_idx}_text_{i}"
+                    elem_type = "text"
+
+                bboxes[key] = {
+                    **bbox,
+                    "type": elem_type,
+                    "label": elem_type,
+                    "ax_index": ax_idx,
+                    "text": text_content,
+                    "text_index": i,
+                    "pos_x": pos[0],
+                    "pos_y": pos[1],
+                    "rel_x": rel_x,
+                    "rel_y": rel_y,
+                }
+        except Exception:
+            pass
+
+    # Extract ax.patches that are arrows (FancyArrowPatch)
+    from matplotlib.patches import FancyArrowPatch
+
+    for i, patch in enumerate(ax.patches):
+        if isinstance(patch, FancyArrowPatch):
+            try:
+                patch_bbox = patch.get_window_extent(renderer)
+                if patch_bbox is not None:
+                    bbox = transform_bbox(
+                        patch_bbox,
+                        fig,
+                        tight_bbox,
+                        img_width,
+                        img_height,
+                        scale_x,
+                        scale_y,
+                        pad_inches,
+                        saved_height_inches,
+                    )
+                    if bbox:
+                        bboxes[f"ax{ax_idx}_arrow_{i}"] = {
+                            **bbox,
+                            "type": "arrow",
+                            "label": "arrow",
+                            "ax_index": ax_idx,
+                            "arrow_index": i,
+                        }
+            except Exception:
+                pass
+
+
 __all__ = [
     "extract_text_elements",
     "extract_legend",
     "extract_spines",
     "extract_figure_text",
+    "extract_annotations",
 ]
 
 # EOF

figrecipe/_editor/_call_overrides.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Call-specific override application for element properties.
+
+This is the SINGLE SOURCE OF TRUTH for applying element-level changes.
+Both initial render and re-render use this same function through apply_overrides().
+"""
+
+from typing import Any, Dict
+
+from matplotlib.figure import Figure
+
+
+def apply_call_overrides(
+    fig: Figure, call_overrides: Dict[str, Dict[str, Any]], record: Any
+) -> None:
+    """Apply call-specific overrides to figure elements.
+
+    Parameters
+    ----------
+    fig : Figure
+        Matplotlib figure.
+    call_overrides : dict
+        Mapping from call_id to {param: value} overrides.
+    record : FigureRecord
+        Recording record to find call metadata.
+    """
+    from matplotlib.patches import Wedge
+
+    axes_list = fig.get_axes()
+
+    # Build mapping from ax_key to axes index
+    # ax_keys are in format "ax_{row}_{col}", need to map to actual axes indices
+    ax_keys_sorted = sorted(record.axes.keys())
+    ax_key_to_index = {key: idx for idx, key in enumerate(ax_keys_sorted)}
+
+    for call_id, params in call_overrides.items():
+        # Find the call in record to get function type, ax_index, and call position
+        call_function = None
+        ax_index = None
+        ax_record_found = None
+        for ax_key, ax_record in record.axes.items():
+            for call in ax_record.calls:
+                if call.id == call_id:
+                    call_function = call.function
+                    ax_record_found = ax_record
+                    # Use sorted key order to get correct axes index
+                    ax_index = ax_key_to_index.get(ax_key, 0)
+                    break
+            if call_function:
+                break
+
+        if call_function is None or ax_index is None or ax_index >= len(axes_list):
+            continue
+
+        ax = axes_list[ax_index]
+
+        # Apply overrides based on plot type
+        for param, value in params.items():
+            if call_function in ("bar", "barh", "hist"):
+                # Bar/hist creates multiple patches per call - apply to ALL
+                _apply_bar_override(ax, ax_record_found, call_id, param, value)
+            elif call_function == "plot":
+                _apply_line_override(ax, ax_record_found, call_id, param, value)
+            elif call_function == "scatter":
+                _apply_scatter_override(ax, ax_record_found, call_id, param, value)
+            elif call_function == "pie":
+                # Pie wedges - apply to all wedges for this call
+                wedges = [p for p in ax.patches if isinstance(p, Wedge)]
+                for wedge in wedges:
+                    _apply_patch_param(wedge, param, value)
+            elif call_function in ("fill_between", "fill_betweenx"):
+                _apply_fill_override(ax, ax_record_found, call_id, param, value)
+
+
+def _apply_bar_override(ax, ax_record, call_id, param, value):
+    """Apply override to bar/hist patches for a specific call."""
+    from matplotlib.patches import Rectangle
+
+    rectangles = [p for p in ax.patches if isinstance(p, Rectangle)]
+    if not rectangles:
+        return
+
+    # Find all bar/hist calls to determine grouping
+    bar_calls = [c for c in ax_record.calls if c.function in ("bar", "barh", "hist")]
+    if not bar_calls:
+        return
+
+    # Find which call index this is
+    call_idx = next((i for i, c in enumerate(bar_calls) if c.id == call_id), None)
+    if call_idx is None:
+        return
+
+    # Distribute patches among calls
+    patches_per_call = len(rectangles) // len(bar_calls) if bar_calls else 1
+    start_idx = call_idx * patches_per_call
+    end_idx = start_idx + patches_per_call
+
+    # Apply to all patches for this call
+    for patch in rectangles[start_idx:end_idx]:
+        _apply_patch_param(patch, param, value)
+
+
+def _apply_line_override(ax, ax_record, call_id, param, value):
+    """Apply override to line for a specific call."""
+    lines = [line for line in ax.get_lines() if not line.get_label().startswith("_")]
+    line_calls = [c for c in ax_record.calls if c.function == "plot"]
+
+    call_idx = next((i for i, c in enumerate(line_calls) if c.id == call_id), None)
+    if call_idx is not None and call_idx < len(lines):
+        _apply_line_param(lines[call_idx], param, value)
+
+
+def _apply_scatter_override(ax, ax_record, call_id, param, value):
+    """Apply override to scatter collection for a specific call."""
+    from matplotlib.collections import PathCollection
+
+    collections = [c for c in ax.collections if isinstance(c, PathCollection)]
+    scatter_calls = [c for c in ax_record.calls if c.function == "scatter"]
+
+    call_idx = next((i for i, c in enumerate(scatter_calls) if c.id == call_id), None)
+    if call_idx is not None and call_idx < len(collections):
+        _apply_collection_param(collections[call_idx], param, value)
+
+
+def _apply_fill_override(ax, ax_record, call_id, param, value):
+    """Apply override to fill_between for a specific call."""
+    from matplotlib.collections import PolyCollection
+
+    fills = [c for c in ax.collections if isinstance(c, PolyCollection)]
+    fill_calls = [
+        c for c in ax_record.calls if c.function in ("fill_between", "fill_betweenx")
+    ]
+
+    call_idx = next((i for i, c in enumerate(fill_calls) if c.id == call_id), None)
+    if call_idx is not None and call_idx < len(fills):
+        _apply_collection_param(fills[call_idx], param, value)
+
+
+def _apply_patch_param(patch: Any, param: str, value: Any) -> None:
+    """Apply parameter to a patch (bar, wedge, etc.)."""
+    if param == "color":
+        patch.set_facecolor(value)
+    elif param == "edgecolor":
+        patch.set_edgecolor(value)
+    elif param == "linewidth":
+        patch.set_linewidth(value)
+    elif param == "alpha":
+        patch.set_alpha(value)
+
+
+def _apply_line_param(line: Any, param: str, value: Any) -> None:
+    """Apply parameter to a line."""
+    if param == "color":
+        line.set_color(value)
+    elif param == "linewidth":
+        line.set_linewidth(value)
+    elif param == "linestyle":
+        line.set_linestyle(value)
+    elif param == "alpha":
+        line.set_alpha(value)
+    elif param == "marker":
+        line.set_marker(value)
+    elif param == "markersize":
+        line.set_markersize(value)
+
+
+def _apply_collection_param(coll: Any, param: str, value: Any) -> None:
+    """Apply parameter to a collection (scatter, fill)."""
+    if param in ("color", "c"):
+        coll.set_facecolors(value)
+    elif param == "edgecolor":
+        coll.set_edgecolors(value)
+    elif param == "s":
+        coll.set_sizes([value] if not hasattr(value, "__len__") else value)
+    elif param == "alpha":
+        coll.set_alpha(value)
+
+
+__all__ = ["apply_call_overrides"]
+
+# EOF