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

figrecipe/_editor/_bbox/_extract_axes.py

@@ -0,0 +1,370 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Axes element bbox extraction (lines, collections, patches, images)."""
+
+from matplotlib.collections import PathCollection, PolyCollection
+from matplotlib.patches import Rectangle
+
+from ._collections import get_collection_bbox, get_patch_bbox
+from ._elements import get_element_bbox
+from ._lines import get_line_bbox, get_quiver_bbox
+
+
+def 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 bboxes for line elements."""
+    for i, line in enumerate(ax.get_lines()):
+        if not line.get_visible():
+            continue
+        xdata = line.get_xdata()
+        ydata = line.get_ydata()
+        if len(xdata) == 0 or len(ydata) == 0:
+            continue
+        if line.axes != ax:
+            continue
+
+        bbox = get_line_bbox(
+            line,
+            ax,
+            fig,
+            renderer,
+            tight_bbox,
+            img_width,
+            img_height,
+            scale_x,
+            scale_y,
+            pad_inches,
+            saved_height_inches,
+            include_points,
+        )
+        if bbox:
+            bboxes[f"ax{ax_idx}_line{i}"] = {
+                **bbox,
+                "type": "line",
+                "label": line.get_label() or f"line_{i}",
+                "ax_index": ax_idx,
+            }
+
+
+def 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 bboxes for collection elements (scatter, fill, quiver, etc.)."""
+    from matplotlib.collections import LineCollection, QuadMesh
+    from matplotlib.contour import QuadContourSet
+    from matplotlib.quiver import Quiver
+
+    scatter_idx = 0
+    for i, coll in enumerate(ax.collections):
+        if isinstance(coll, Quiver):
+            if not coll.get_visible():
+                continue
+            bbox = get_quiver_bbox(
+                coll,
+                ax,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+            )
+            if bbox:
+                bboxes[f"ax{ax_idx}_quiver{i}"] = {
+                    **bbox,
+                    "type": "quiver",
+                    "label": coll.get_label() or f"quiver_{i}",
+                    "ax_index": ax_idx,
+                }
+
+        elif isinstance(coll, PathCollection):
+            if not coll.get_visible():
+                continue
+            bbox = get_collection_bbox(
+                coll,
+                ax,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+                include_points,
+            )
+            if bbox:
+                bboxes[f"ax{ax_idx}_scatter{scatter_idx}"] = {
+                    **bbox,
+                    "type": "scatter",
+                    "label": coll.get_label() or f"scatter_{scatter_idx}",
+                    "ax_index": ax_idx,
+                }
+            scatter_idx += 1
+
+        elif isinstance(coll, PolyCollection):
+            if not coll.get_visible():
+                continue
+            bbox = get_collection_bbox(
+                coll,
+                ax,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+                False,
+            )
+            if bbox:
+                bboxes[f"ax{ax_idx}_fill{i}"] = {
+                    **bbox,
+                    "type": "fill",
+                    "label": coll.get_label() or f"fill_{i}",
+                    "ax_index": ax_idx,
+                }
+
+        elif isinstance(coll, LineCollection):
+            if not coll.get_visible():
+                continue
+            bbox = get_collection_bbox(
+                coll,
+                ax,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+                False,
+            )
+            if bbox:
+                bboxes[f"ax{ax_idx}_linecoll{i}"] = {
+                    **bbox,
+                    "type": "linecollection",
+                    "label": coll.get_label() or f"linecoll_{i}",
+                    "ax_index": ax_idx,
+                }
+
+        elif isinstance(coll, QuadMesh):
+            if not coll.get_visible():
+                continue
+            bbox = get_collection_bbox(
+                coll,
+                ax,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+                False,
+            )
+            if bbox:
+                bboxes[f"ax{ax_idx}_quadmesh{i}"] = {
+                    **bbox,
+                    "type": "quadmesh",
+                    "label": f"quadmesh_{i}",
+                    "ax_index": ax_idx,
+                }
+
+        elif isinstance(coll, QuadContourSet):
+            bbox = get_element_bbox(
+                ax,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+            )
+            if bbox:
+                bboxes[f"ax{ax_idx}_contour{i}"] = {
+                    **bbox,
+                    "type": "contour",
+                    "label": f"contour_{i}",
+                    "ax_index": ax_idx,
+                }
+
+
+def extract_patches(
+    ax,
+    ax_idx,
+    fig,
+    renderer,
+    tight_bbox,
+    img_width,
+    img_height,
+    scale_x,
+    scale_y,
+    pad_inches,
+    saved_height_inches,
+    bboxes,
+):
+    """Extract bboxes for patch elements (bars, wedges, polygons)."""
+    from matplotlib.patches import Polygon, Wedge
+
+    bar_idx = 0
+    for i, patch in enumerate(ax.patches):
+        if isinstance(patch, Rectangle):
+            if not patch.get_visible():
+                continue
+            if patch.get_width() == 1.0 and patch.get_height() == 1.0:
+                continue
+            bbox = get_patch_bbox(
+                patch,
+                ax,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+            )
+            if bbox:
+                bboxes[f"ax{ax_idx}_bar{bar_idx}"] = {
+                    **bbox,
+                    "type": "bar",
+                    "label": patch.get_label() or f"bar_{bar_idx}",
+                    "ax_index": ax_idx,
+                }
+            bar_idx += 1
+
+        elif isinstance(patch, Wedge):
+            if not patch.get_visible():
+                continue
+            bbox = get_patch_bbox(
+                patch,
+                ax,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+            )
+            if bbox:
+                bboxes[f"ax{ax_idx}_wedge{i}"] = {
+                    **bbox,
+                    "type": "pie",
+                    "label": patch.get_label() or f"wedge_{i}",
+                    "ax_index": ax_idx,
+                }
+
+        elif isinstance(patch, Polygon):
+            if not patch.get_visible():
+                continue
+            bbox = get_patch_bbox(
+                patch,
+                ax,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+            )
+            if bbox:
+                bboxes[f"ax{ax_idx}_polygon{i}"] = {
+                    **bbox,
+                    "type": "fill",
+                    "label": patch.get_label() or f"fill_{i}",
+                    "ax_index": ax_idx,
+                }
+
+
+def extract_images(
+    ax,
+    ax_idx,
+    fig,
+    renderer,
+    tight_bbox,
+    img_width,
+    img_height,
+    scale_x,
+    scale_y,
+    pad_inches,
+    saved_height_inches,
+    bboxes,
+):
+    """Extract bboxes for image elements."""
+    from matplotlib.image import AxesImage
+
+    for i, img in enumerate(ax.images):
+        if isinstance(img, AxesImage):
+            if not img.get_visible():
+                continue
+            bbox = get_element_bbox(
+                img,
+                fig,
+                renderer,
+                tight_bbox,
+                img_width,
+                img_height,
+                scale_x,
+                scale_y,
+                pad_inches,
+                saved_height_inches,
+            )
+            if bbox:
+                bboxes[f"ax{ax_idx}_image{i}"] = {
+                    **bbox,
+                    "type": "image",
+                    "label": img.get_label() or f"image_{i}",
+                    "ax_index": ax_idx,
+                }
+
+
+__all__ = ["extract_lines", "extract_collections", "extract_patches", "extract_images"]
+
+# EOF

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