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

figrecipe/_editor/_bbox/_extract_text.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Text, legend, spine, and figure text bbox extraction."""
+
+from ._elements import get_text_bbox, get_tick_labels_bbox
+from ._transforms import transform_bbox
+
+
+def extract_text_elements(
+    ax,
+    ax_idx,
+    fig,
+    renderer,
+    tight_bbox,
+    img_width,
+    img_height,
+    scale_x,
+    scale_y,
+    pad_inches,
+    saved_height_inches,
+    bboxes,
+):
+    """Extract bboxes for text elements (title, labels, ticks)."""
+    # Title
+    title = ax.get_title()
+    if title:
+        bbox = get_text_bbox(
+            ax.title,
+            fig,
+            renderer,
+            tight_bbox,
+            img_width,
+            img_height,
+            scale_x,
+            scale_y,
+            pad_inches,
+            saved_height_inches,
+        )
+        if bbox:
+            bboxes[f"ax{ax_idx}_title"] = {
+                **bbox,
+                "type": "title",
+                "label": "title",
+                "ax_index": ax_idx,
+                "text": title,
+            }
+
+    # X label
+    xlabel = ax.get_xlabel()
+    if xlabel:
+        bbox = get_text_bbox(
+            ax.xaxis.label,
+            fig,
+            renderer,
+            tight_bbox,
+            img_width,
+            img_height,
+            scale_x,
+            scale_y,
+            pad_inches,
+            saved_height_inches,
+        )
+        if bbox:
+            bboxes[f"ax{ax_idx}_xlabel"] = {
+                **bbox,
+                "type": "xlabel",
+                "label": "xlabel",
+                "ax_index": ax_idx,
+                "text": xlabel,
+            }
+
+    # X tick labels
+    xtick_bbox = get_tick_labels_bbox(
+        ax.xaxis,
+        "x",
+        fig,
+        renderer,
+        tight_bbox,
+        img_width,
+        img_height,
+        scale_x,
+        scale_y,
+        pad_inches,
+        saved_height_inches,
+    )
+    if xtick_bbox:
+        bboxes[f"ax{ax_idx}_xticks"] = {
+            **xtick_bbox,
+            "type": "xticks",
+            "label": "x tick labels",
+            "ax_index": ax_idx,
+        }
+
+    # Y label
+    ylabel = ax.get_ylabel()
+    if ylabel:
+        bbox = get_text_bbox(
+            ax.yaxis.label,
+            fig,
+            renderer,
+            tight_bbox,
+            img_width,
+            img_height,
+            scale_x,
+            scale_y,
+            pad_inches,
+            saved_height_inches,
+        )
+        if bbox:
+            bboxes[f"ax{ax_idx}_ylabel"] = {
+                **bbox,
+                "type": "ylabel",
+                "label": "ylabel",
+                "ax_index": ax_idx,
+                "text": ylabel,
+            }
+
+    # Y tick labels
+    ytick_bbox = get_tick_labels_bbox(
+        ax.yaxis,
+        "y",
+        fig,
+        renderer,
+        tight_bbox,
+        img_width,
+        img_height,
+        scale_x,
+        scale_y,
+        pad_inches,
+        saved_height_inches,
+    )
+    if ytick_bbox:
+        bboxes[f"ax{ax_idx}_yticks"] = {
+            **ytick_bbox,
+            "type": "yticks",
+            "label": "y tick labels",
+            "ax_index": ax_idx,
+        }
+
+
+def extract_legend(
+    ax,
+    ax_idx,
+    fig,
+    renderer,
+    tight_bbox,
+    img_width,
+    img_height,
+    scale_x,
+    scale_y,
+    pad_inches,
+    saved_height_inches,
+    bboxes,
+):
+    """Extract bbox for legend."""
+    legend = ax.get_legend()
+    if legend is not None and legend.get_visible():
+        try:
+            legend_bbox = legend.get_window_extent(renderer)
+            if legend_bbox is not None:
+                bbox = transform_bbox(
+                    legend_bbox,
+                    fig,
+                    tight_bbox,
+                    img_width,
+                    img_height,
+                    scale_x,
+                    scale_y,
+                    pad_inches,
+                    saved_height_inches,
+                )
+                if bbox:
+                    bboxes[f"ax{ax_idx}_legend"] = {
+                        **bbox,
+                        "type": "legend",
+                        "label": "legend",
+                        "ax_index": ax_idx,
+                    }
+        except Exception:
+            pass
+
+
+def extract_spines(
+    ax,
+    ax_idx,
+    fig,
+    renderer,
+    tight_bbox,
+    img_width,
+    img_height,
+    scale_x,
+    scale_y,
+    pad_inches,
+    saved_height_inches,
+    bboxes,
+):
+    """Extract bboxes for spines with padding for easier clicking."""
+    spine_min_size = 8
+    for spine_name, spine in ax.spines.items():
+        if spine.get_visible():
+            try:
+                spine_bbox = spine.get_window_extent(renderer)
+                if spine_bbox is not None:
+                    bbox = transform_bbox(
+                        spine_bbox,
+                        fig,
+                        tight_bbox,
+                        img_width,
+                        img_height,
+                        scale_x,
+                        scale_y,
+                        pad_inches,
+                        saved_height_inches,
+                    )
+                    if bbox:
+                        if bbox["width"] < spine_min_size:
+                            expand = (spine_min_size - bbox["width"]) / 2
+                            bbox["x"] -= expand
+                            bbox["width"] = spine_min_size
+                        if bbox["height"] < spine_min_size:
+                            expand = (spine_min_size - bbox["height"]) / 2
+                            bbox["y"] -= expand
+                            bbox["height"] = spine_min_size
+                        bboxes[f"ax{ax_idx}_spine_{spine_name}"] = {
+                            **bbox,
+                            "type": "spine",
+                            "label": spine_name,
+                            "ax_index": ax_idx,
+                        }
+            except Exception:
+                pass
+
+
+def extract_figure_text(
+    fig,
+    renderer,
+    tight_bbox,
+    img_width,
+    img_height,
+    scale_x,
+    scale_y,
+    pad_inches,
+    saved_height_inches,
+    bboxes,
+):
+    """Extract bboxes for figure-level text (suptitle, supxlabel, supylabel)."""
+    # Suptitle
+    if hasattr(fig, "_suptitle") and fig._suptitle is not None:
+        suptitle_obj = fig._suptitle
+        if suptitle_obj.get_text():
+            try:
+                suptitle_extent = suptitle_obj.get_window_extent(renderer)
+                if suptitle_extent is not None:
+                    bbox = transform_bbox(
+                        suptitle_extent,
+                        fig,
+                        tight_bbox,
+                        img_width,
+                        img_height,
+                        scale_x,
+                        scale_y,
+                        pad_inches,
+                        saved_height_inches,
+                    )
+                    if bbox:
+                        bboxes["fig_suptitle"] = {
+                            **bbox,
+                            "type": "suptitle",
+                            "label": "suptitle",
+                            "ax_index": -1,
+                            "text": suptitle_obj.get_text(),
+                        }
+            except Exception:
+                pass
+
+    # Supxlabel
+    if hasattr(fig, "_supxlabel") and fig._supxlabel is not None:
+        supxlabel_obj = fig._supxlabel
+        if supxlabel_obj.get_text():
+            try:
+                supxlabel_extent = supxlabel_obj.get_window_extent(renderer)
+                if supxlabel_extent is not None:
+                    bbox = transform_bbox(
+                        supxlabel_extent,
+                        fig,
+                        tight_bbox,
+                        img_width,
+                        img_height,
+                        scale_x,
+                        scale_y,
+                        pad_inches,
+                        saved_height_inches,
+                    )
+                    if bbox:
+                        bboxes["fig_supxlabel"] = {
+                            **bbox,
+                            "type": "supxlabel",
+                            "label": "supxlabel",
+                            "ax_index": -1,
+                            "text": supxlabel_obj.get_text(),
+                        }
+            except Exception:
+                pass
+
+    # Supylabel
+    if hasattr(fig, "_supylabel") and fig._supylabel is not None:
+        supylabel_obj = fig._supylabel
+        if supylabel_obj.get_text():
+            try:
+                supylabel_extent = supylabel_obj.get_window_extent(renderer)
+                if supylabel_extent is not None:
+                    bbox = transform_bbox(
+                        supylabel_extent,
+                        fig,
+                        tight_bbox,
+                        img_width,
+                        img_height,
+                        scale_x,
+                        scale_y,
+                        pad_inches,
+                        saved_height_inches,
+                    )
+                    if bbox:
+                        bboxes["fig_supylabel"] = {
+                            **bbox,
+                            "type": "supylabel",
+                            "label": "supylabel",
+                            "ax_index": -1,
+                            "text": supylabel_obj.get_text(),
+                        }
+            except Exception:
+                pass
+
+
+__all__ = [
+    "extract_text_elements",
+    "extract_legend",
+    "extract_spines",
+    "extract_figure_text",
+]
+
+# EOF

figrecipe/_editor/_bbox/_lines.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Line bbox extraction for line plots.
+
+This module handles bbox extraction for line elements,
+including data point sampling for hit detection.
+"""
+
+from typing import Any, Dict, Optional
+
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+from matplotlib.transforms import Bbox
+
+from ._transforms import display_to_image, transform_bbox
+
+
+def get_line_bbox(
+    line,
+    ax: Axes,
+    fig: Figure,
+    renderer,
+    tight_bbox: Bbox,
+    img_width: int,
+    img_height: int,
+    scale_x: float,
+    scale_y: float,
+    pad_inches: float,
+    saved_height_inches: float,
+    include_points: bool = True,
+) -> Optional[Dict[str, Any]]:
+    """Get bbox and points for a line."""
+    try:
+        # Get window extent
+        window_extent = line.get_window_extent(renderer)
+        if window_extent is None:
+            return None
+
+        bbox = transform_bbox(
+            window_extent,
+            fig,
+            tight_bbox,
+            img_width,
+            img_height,
+            scale_x,
+            scale_y,
+            pad_inches,
+            saved_height_inches,
+        )
+        if bbox is None:
+            return None
+
+        # Add path points for proximity detection
+        if include_points:
+            xdata = line.get_xdata()
+            ydata = line.get_ydata()
+
+            if len(xdata) > 0 and len(ydata) > 0:
+                # Transform data coords to image pixels
+                transform = ax.transData
+                points = []
+
+                # Downsample if too many points
+                max_points = 100
+                step = max(1, len(xdata) // max_points)
+
+                for i in range(0, len(xdata), step):
+                    try:
+                        display_coords = transform.transform((xdata[i], ydata[i]))
+                        img_coords = display_to_image(
+                            display_coords[0],
+                            display_coords[1],
+                            fig,
+                            tight_bbox,
+                            img_width,
+                            img_height,
+                            scale_x,
+                            scale_y,
+                            pad_inches,
+                            saved_height_inches,
+                        )
+                        if img_coords:
+                            points.append(img_coords)
+                    except Exception:
+                        continue
+
+                if points:
+                    bbox["points"] = points
+
+        return bbox
+
+    except Exception:
+        return None
+
+
+def get_quiver_bbox(
+    quiver,
+    ax: Axes,
+    fig: Figure,
+    renderer,
+    tight_bbox: Bbox,
+    img_width: int,
+    img_height: int,
+    scale_x: float,
+    scale_y: float,
+    pad_inches: float,
+    saved_height_inches: float,
+) -> Optional[Dict[str, Any]]:
+    """Get bbox for a quiver plot from its data points."""
+    try:
+        # Get X, Y positions from quiver
+        # Quiver stores positions in X, Y arrays
+        X = quiver.X
+        Y = quiver.Y
+
+        if X is None or Y is None or len(X) == 0:
+            return None
+
+        # Flatten if needed
+        import numpy as np
+
+        X_flat = np.asarray(X).flatten()
+        Y_flat = np.asarray(Y).flatten()
+
+        if len(X_flat) == 0 or len(Y_flat) == 0:
+            return None
+
+        transform = ax.transData
+        points = []
+
+        # Limit to reasonable number of points
+        max_points = 100
+        step = max(1, len(X_flat) // max_points)
+
+        for i in range(0, len(X_flat), step):
+            try:
+                display_coords = transform.transform((X_flat[i], Y_flat[i]))
+                img_coords = display_to_image(
+                    display_coords[0],
+                    display_coords[1],
+                    fig,
+                    tight_bbox,
+                    img_width,
+                    img_height,
+                    scale_x,
+                    scale_y,
+                    pad_inches,
+                    saved_height_inches,
+                )
+                if img_coords:
+                    points.append(img_coords)
+            except Exception:
+                continue
+
+        if not points:
+            return None
+
+        # Calculate bbox from points
+        xs = [p[0] for p in points]
+        ys = [p[1] for p in points]
+        padding = 15  # pixels - slightly larger for quiver arrows
+        return {
+            "x": float(min(xs) - padding),
+            "y": float(min(ys) - padding),
+            "width": float(max(xs) - min(xs) + 2 * padding),
+            "height": float(max(ys) - min(ys) + 2 * padding),
+        }
+    except Exception:
+        return None
+
+
+__all__ = ["get_line_bbox", "get_quiver_bbox"]

figrecipe/_editor/_bbox/_transforms.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Coordinate transformation utilities for bbox extraction.
+
+This module handles the transformation from matplotlib display coordinates
+to image pixel coordinates for hit detection.
+"""
+
+from typing import Dict, List, Optional
+
+from matplotlib.figure import Figure
+from matplotlib.transforms import Bbox
+
+
+def transform_bbox(
+    window_extent: Bbox,
+    fig: Figure,
+    tight_bbox: Bbox,
+    img_width: int,
+    img_height: int,
+    scale_x: float,
+    scale_y: float,
+    pad_inches: float,
+    saved_height_inches: float,
+) -> Optional[Dict[str, float]]:
+    """
+    Transform matplotlib window extent to image pixel coordinates.
+
+    Parameters
+    ----------
+    window_extent : Bbox
+        Bbox in display coordinates (points).
+    fig : Figure
+        Matplotlib figure.
+    tight_bbox : Bbox
+        Tight bbox of figure in inches.
+    img_width, img_height : int
+        Output image dimensions.
+    scale_x, scale_y : float
+        Scale factors from inches to pixels.
+    pad_inches : float
+        Padding added by bbox_inches='tight' (default 0.1).
+    saved_height_inches : float
+        Total saved image height including padding.
+
+    Returns
+    -------
+    dict or None
+        {x, y, width, height} in image pixels.
+    """
+    try:
+        dpi = fig.dpi
+
+        # Convert display coords to inches
+        x0_inches = window_extent.x0 / dpi
+        y0_inches = window_extent.y0 / dpi
+        x1_inches = window_extent.x1 / dpi
+        y1_inches = window_extent.y1 / dpi
+
+        # Transform to saved image coordinates
+        # Account for tight bbox origin and padding
+        x0_rel = x0_inches - tight_bbox.x0 + pad_inches
+        x1_rel = x1_inches - tight_bbox.x0 + pad_inches
+
+        # Y coordinate flip: matplotlib Y=0 at bottom, image Y=0 at top
+        y0_rel = saved_height_inches - (y1_inches - tight_bbox.y0 + pad_inches)
+        y1_rel = saved_height_inches - (y0_inches - tight_bbox.y0 + pad_inches)
+
+        # Scale to image pixels
+        x0_px = x0_rel * scale_x
+        y0_px = y0_rel * scale_y
+        x1_px = x1_rel * scale_x
+        y1_px = y1_rel * scale_y
+
+        # Clamp to bounds
+        x0_px = max(0, min(x0_px, img_width))
+        x1_px = max(0, min(x1_px, img_width))
+        y0_px = max(0, min(y0_px, img_height))
+        y1_px = max(0, min(y1_px, img_height))
+
+        width = x1_px - x0_px
+        height = y1_px - y0_px
+
+        if width <= 0 or height <= 0:
+            return None
+
+        return {
+            "x": float(x0_px),
+            "y": float(y0_px),
+            "width": float(width),
+            "height": float(height),
+        }
+
+    except Exception:
+        return None
+
+
+def display_to_image(
+    display_x: float,
+    display_y: float,
+    fig: Figure,
+    tight_bbox: Bbox,
+    img_width: int,
+    img_height: int,
+    scale_x: float,
+    scale_y: float,
+    pad_inches: float,
+    saved_height_inches: float,
+) -> Optional[List[float]]:
+    """
+    Transform display coordinates to image pixel coordinates.
+
+    Returns
+    -------
+    list or None
+        [x, y] in image pixels.
+    """
+    try:
+        dpi = fig.dpi
+
+        # Convert to inches
+        x_inches = display_x / dpi
+        y_inches = display_y / dpi
+
+        # Transform to saved image coordinates with padding
+        x_rel = x_inches - tight_bbox.x0 + pad_inches
+
+        # Y coordinate flip: matplotlib Y=0 at bottom, image Y=0 at top
+        y_rel = saved_height_inches - (y_inches - tight_bbox.y0 + pad_inches)
+
+        # Scale to image pixels
+        x_px = x_rel * scale_x
+        y_px = y_rel * scale_y
+
+        # Clamp
+        x_px = max(0, min(x_px, img_width))
+        y_px = max(0, min(y_px, img_height))
+
+        return [float(x_px), float(y_px)]
+
+    except Exception:
+        return None
+
+
+__all__ = ["transform_bbox", "display_to_image"]