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

figrecipe/_editor/_bbox/_collections.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Collection bbox extraction for scatter, fill, and patch elements.
+
+This module handles bbox extraction for matplotlib collections
+(scatter plots, fills, bars, etc.).
+"""
+
+import math
+from typing import Any, Dict, Optional
+
+from matplotlib.axes import Axes
+from matplotlib.collections import PathCollection
+from matplotlib.figure import Figure
+from matplotlib.transforms import Bbox
+
+from ._elements import get_element_bbox
+from ._transforms import display_to_image, transform_bbox
+
+
+def get_collection_bbox(
+    coll,
+    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 collection (scatter, fill)."""
+    try:
+        bbox = None
+
+        # For scatter plots, get_window_extent() can fail or return empty
+        # So we calculate bbox from data points as fallback
+        if isinstance(coll, PathCollection):
+            offsets = coll.get_offsets()
+            if len(offsets) > 0:
+                transform = ax.transData
+                points = []
+
+                # Limit to reasonable number of points
+                max_points = 200
+                step = max(1, len(offsets) // max_points)
+
+                for i in range(0, len(offsets), step):
+                    try:
+                        offset = offsets[i]
+                        display_coords = transform.transform(offset)
+                        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
+
+                # Calculate bbox from points
+                if points:
+                    xs = [p[0] for p in points]
+                    ys = [p[1] for p in points]
+                    # Add padding around scatter points for easier clicking
+                    padding = 10  # pixels
+                    bbox = {
+                        "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),
+                        "points": points,
+                    }
+                    return bbox
+
+        # Fallback: try standard window extent
+        window_extent = coll.get_window_extent(renderer)
+        if window_extent is None:
+            # Use axes extent as fallback
+            return get_element_bbox(
+                ax,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+            )
+
+        # Check if window_extent is valid (not inf)
+        if (
+            math.isinf(window_extent.x0)
+            or math.isinf(window_extent.y0)
+            or math.isinf(window_extent.x1)
+            or math.isinf(window_extent.y1)
+        ):
+            # Invalid extent - use axes extent as fallback
+            return get_element_bbox(
+                ax,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+            )
+
+        bbox = transform_bbox(
+            window_extent,
+            fig,
+            tight_bbox,
+            img_width,
+            img_height,
+            scale_x,
+            scale_y,
+            pad_inches,
+            saved_height_inches,
+        )
+
+        return bbox
+
+    except Exception:
+        return None
+
+
+def get_patch_bbox(
+    patch,
+    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, float]]:
+    """Get bbox for a patch (bar, rectangle)."""
+    try:
+        window_extent = patch.get_window_extent(renderer)
+        if window_extent is None:
+            return None
+        return transform_bbox(
+            window_extent,
+            fig,
+            tight_bbox,
+            img_width,
+            img_height,
+            scale_x,
+            scale_y,
+            pad_inches,
+            saved_height_inches,
+        )
+    except Exception:
+        return None
+
+
+__all__ = ["get_collection_bbox", "get_patch_bbox"]

figrecipe/_editor/_bbox/_elements.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Element bbox extraction for general elements, text, and ticks.
+
+This module handles bbox extraction for axes, text labels, and tick marks.
+"""
+
+from typing import Dict, Optional
+
+from matplotlib.figure import Figure
+from matplotlib.transforms import Bbox
+
+from ._transforms import transform_bbox
+
+
+def get_element_bbox(
+    element,
+    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, float]]:
+    """Get bbox for a general element."""
+    try:
+        window_extent = element.get_window_extent(renderer)
+        if window_extent is None:
+            return None
+        return transform_bbox(
+            window_extent,
+            fig,
+            tight_bbox,
+            img_width,
+            img_height,
+            scale_x,
+            scale_y,
+            pad_inches,
+            saved_height_inches,
+        )
+    except Exception:
+        return None
+
+
+def get_text_bbox(
+    text,
+    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, float]]:
+    """Get bbox for a text element."""
+    try:
+        window_extent = text.get_window_extent(renderer)
+        if window_extent is None:
+            return None
+        return transform_bbox(
+            window_extent,
+            fig,
+            tight_bbox,
+            img_width,
+            img_height,
+            scale_x,
+            scale_y,
+            pad_inches,
+            saved_height_inches,
+        )
+    except Exception:
+        return None
+
+
+def get_tick_labels_bbox(
+    axis,
+    axis_type: str,  # 'x' or 'y'
+    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, float]]:
+    """
+    Get bbox for tick labels, extended to span the full axis dimension.
+
+    For x-axis: tick labels bbox spans the full width of the plot area.
+    For y-axis: tick labels bbox spans the full height of the plot area.
+    """
+    try:
+        all_bboxes = []
+
+        # Get all tick label bboxes
+        for tick in axis.get_major_ticks():
+            tick_label = tick.label1 if hasattr(tick, "label1") else tick.label
+            if tick_label and tick_label.get_visible():
+                try:
+                    tick_extent = tick_label.get_window_extent(renderer)
+                    if tick_extent is not None and tick_extent.width > 0:
+                        all_bboxes.append(tick_extent)
+                except Exception:
+                    pass
+
+        if not all_bboxes:
+            return None
+
+        # Merge all tick label bboxes
+        merged = all_bboxes[0]
+        for bbox in all_bboxes[1:]:
+            merged = Bbox.union([merged, bbox])
+
+        # Get the axes extent to extend the tick labels region
+        ax = axis.axes
+        ax_bbox = ax.get_window_extent(renderer)
+
+        if axis_type == "x":
+            # For x-axis: extend width to match axes width, keep tick labels height
+            merged = Bbox.from_extents(
+                ax_bbox.x0,  # Align left with axes
+                merged.y0,  # Keep tick labels y position
+                ax_bbox.x1,  # Align right with axes
+                merged.y1,  # Keep tick labels height
+            )
+        else:  # y-axis
+            # For y-axis: extend height to match axes height, keep tick labels width
+            merged = Bbox.from_extents(
+                merged.x0,  # Keep tick labels x position
+                ax_bbox.y0,  # Align bottom with axes
+                merged.x1,  # Keep tick labels width
+                ax_bbox.y1,  # Align top with axes
+            )
+
+        return transform_bbox(
+            merged,
+            fig,
+            tight_bbox,
+            img_width,
+            img_height,
+            scale_x,
+            scale_y,
+            pad_inches,
+            saved_height_inches,
+        )
+
+    except Exception:
+        return None
+
+
+__all__ = ["get_element_bbox", "get_text_bbox", "get_tick_labels_bbox"]

figrecipe/_editor/_bbox/_extract.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Main bounding box extraction function.
+
+This module contains the main extract_bboxes function that coordinates
+all element-specific bbox extractors.
+"""
+
+from typing import Any, Dict
+
+from matplotlib.figure import Figure
+from matplotlib.transforms import Bbox
+
+from ._elements import get_element_bbox
+from ._extract_axes import (
+    extract_collections,
+    extract_images,
+    extract_lines,
+    extract_patches,
+)
+from ._extract_text import (
+    extract_figure_text,
+    extract_legend,
+    extract_spines,
+    extract_text_elements,
+)
+
+
+def extract_bboxes(
+    fig: Figure,
+    img_width: int,
+    img_height: int,
+    include_points: bool = True,
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Extract bounding boxes for all figure elements.
+
+    Parameters
+    ----------
+    fig : matplotlib.figure.Figure
+        Figure to extract bboxes from.
+    img_width : int
+        Width of the output image in pixels.
+    img_height : int
+        Height of the output image in pixels.
+    include_points : bool, optional
+        Whether to include point arrays for lines/scatter (default: True).
+
+    Returns
+    -------
+    dict
+        Mapping from element key to bbox info.
+    """
+    bboxes = {}
+
+    # Get renderer for bbox calculations
+    fig.canvas.draw()
+    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())
+
+    # 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
+
+    # Calculate scale factors from saved image size to pixel size
+    scale_x = img_width / saved_width_inches if saved_width_inches > 0 else 1
+    scale_y = img_height / saved_height_inches if saved_height_inches > 0 else 1
+
+    # Process each axes
+    for ax_idx, ax in enumerate(fig.get_axes()):
+        _extract_axes_bboxes(
+            ax,
+            ax_idx,
+            fig,
+            renderer,
+            tight_bbox,
+            img_width,
+            img_height,
+            scale_x,
+            scale_y,
+            pad_inches,
+            saved_height_inches,
+            include_points,
+            bboxes,
+        )
+
+    # Process figure-level text elements
+    extract_figure_text(
+        fig,
+        renderer,
+        tight_bbox,
+        img_width,
+        img_height,
+        scale_x,
+        scale_y,
+        pad_inches,
+        saved_height_inches,
+        bboxes,
+    )
+
+    # Add metadata
+    bboxes["_meta"] = {
+        "img_width": img_width,
+        "img_height": img_height,
+        "fig_width_inches": fig.get_figwidth(),
+        "fig_height_inches": fig.get_figheight(),
+        "dpi": fig.dpi,
+    }
+
+    return bboxes
+
+
+def _extract_axes_bboxes(
+    ax,
+    ax_idx,
+    fig,
+    renderer,
+    tight_bbox,
+    img_width,
+    img_height,
+    scale_x,
+    scale_y,
+    pad_inches,
+    saved_height_inches,
+    include_points,
+    bboxes,
+):
+    """Extract bboxes for all elements within an axes."""
+    # Axes bounding box
+    ax_bbox = get_element_bbox(
+        ax,
+        fig,
+        renderer,
+        tight_bbox,
+        img_width,
+        img_height,
+        scale_x,
+        scale_y,
+        pad_inches,
+        saved_height_inches,
+    )
+    if ax_bbox:
+        bboxes[f"ax{ax_idx}_axes"] = {**ax_bbox, "type": "axes", "ax_index": ax_idx}
+
+    # Extract all element types
+    extract_lines(
+        ax,
+        ax_idx,
+        fig,
+        renderer,
+        tight_bbox,
+        img_width,
+        img_height,
+        scale_x,
+        scale_y,
+        pad_inches,
+        saved_height_inches,
+        include_points,
+        bboxes,
+    )
+    extract_collections(
+        ax,
+        ax_idx,
+        fig,
+        renderer,
+        tight_bbox,
+        img_width,
+        img_height,
+        scale_x,
+        scale_y,
+        pad_inches,
+        saved_height_inches,
+        include_points,
+        bboxes,
+    )
+    extract_patches(
+        ax,
+        ax_idx,
+        fig,
+        renderer,
+        tight_bbox,
+        img_width,
+        img_height,
+        scale_x,
+        scale_y,
+        pad_inches,
+        saved_height_inches,
+        bboxes,
+    )
+    extract_images(
+        ax,
+        ax_idx,
+        fig,
+        renderer,
+        tight_bbox,
+        img_width,
+        img_height,
+        scale_x,
+        scale_y,
+        pad_inches,
+        saved_height_inches,
+        bboxes,
+    )
+    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_legend(
+        ax,
+        ax_idx,
+        fig,
+        renderer,
+        tight_bbox,
+        img_width,
+        img_height,
+        scale_x,
+        scale_y,
+        pad_inches,
+        saved_height_inches,
+        bboxes,
+    )
+    extract_spines(
+        ax,
+        ax_idx,
+        fig,
+        renderer,
+        tight_bbox,
+        img_width,
+        img_height,
+        scale_x,
+        scale_y,
+        pad_inches,
+        saved_height_inches,
+        bboxes,
+    )
+
+
+__all__ = ["extract_bboxes"]
+
+# EOF