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

figrecipe/_editor/_hitmap/_artists/_images.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Image processing for hitmap generation."""
+
+from typing import Any, Dict
+
+from matplotlib.image import AxesImage
+
+from .._colors import id_to_rgb
+
+
+def process_images(
+    ax,
+    ax_idx: int,
+    element_id: int,
+    color_map: Dict[str, Any],
+    ax_info: Dict[str, Any],
+) -> int:
+    """Process images on an axes.
+
+    Returns updated element_id.
+    """
+    ax_call_ids = ax_info.get("call_ids", {})
+
+    imshow_ids = list(ax_call_ids.get("imshow", []))
+    specgram_ids = list(ax_call_ids.get("specgram", []))
+    contourf_ids = list(ax_call_ids.get("contourf", []))
+
+    image_idx = 0
+
+    for i, img in enumerate(ax.images):
+        if isinstance(img, AxesImage):
+            if not img.get_visible():
+                continue
+
+            key = f"ax{ax_idx}_image{i}"
+
+            call_id = None
+            label = f"image_{i}"
+
+            if image_idx < len(imshow_ids):
+                call_id = imshow_ids[image_idx]
+                label = call_id
+            elif image_idx < len(specgram_ids):
+                call_id = specgram_ids[image_idx]
+                label = call_id
+            elif image_idx < len(contourf_ids):
+                call_id = contourf_ids[image_idx]
+                label = call_id
+
+            image_idx += 1
+
+            color_map[key] = {
+                "id": element_id,
+                "type": "image",
+                "label": label,
+                "ax_index": ax_idx,
+                "rgb": list(id_to_rgb(element_id)),
+                "call_id": call_id,
+            }
+            element_id += 1
+
+    return element_id
+
+
+__all__ = ["process_images"]
+
+# EOF

figrecipe/_editor/_hitmap/_artists/_lines.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Line processing for hitmap generation."""
+
+from typing import Any, Dict
+
+from .._colors import id_to_rgb, mpl_color_to_hex, normalize_color
+from .._detect import is_boxplot_element
+
+
+def process_lines(
+    ax,
+    ax_idx: int,
+    element_id: int,
+    original_props: Dict[str, Any],
+    color_map: Dict[str, Any],
+    ax_info: Dict[str, Any],
+) -> int:
+    """Process lines (traces) on an axes.
+
+    Returns updated element_id.
+    """
+    ax_plot_types = ax_info.get("types", set())
+    ax_call_ids = ax_info.get("call_ids", {})
+    has_boxplot = "boxplot" in ax_plot_types
+    has_violin = "violinplot" in ax_plot_types
+    has_regular_plot = "plot" in ax_plot_types
+
+    boxplot_ids = list(ax_call_ids.get("boxplot", []))
+    violin_ids = list(ax_call_ids.get("violinplot", []))
+    plot_ids = list(ax_call_ids.get("plot", []))
+
+    boxplot_call_id = boxplot_ids[0] if boxplot_ids else None
+    violin_call_id = violin_ids[0] if violin_ids else None
+    regular_line_idx = 0
+    has_record = len(ax_plot_types) > 0
+
+    for i, line in enumerate(ax.get_lines()):
+        if not line.get_visible():
+            continue
+
+        orig_label = line.get_label() or ""
+
+        if has_record:
+            if (
+                orig_label.startswith("_child")
+                and not has_boxplot
+                and not has_violin
+                and not has_regular_plot
+            ):
+                continue
+
+        xdata = line.get_xdata()
+        if len(xdata) == 0:
+            continue
+
+        key = f"ax{ax_idx}_line{i}"
+        rgb = id_to_rgb(element_id)
+
+        original_props[key] = {
+            "color": line.get_color(),
+            "markerfacecolor": line.get_markerfacecolor(),
+            "markeredgecolor": line.get_markeredgecolor(),
+        }
+
+        line.set_color(normalize_color(rgb))
+        line.set_markerfacecolor(normalize_color(rgb))
+        line.set_markeredgecolor(normalize_color(rgb))
+
+        call_id = None
+        if has_boxplot and (is_boxplot_element(line, ax) or orig_label.startswith("_")):
+            elem_type = "boxplot"
+            label = boxplot_call_id or "boxplot"
+            call_id = boxplot_call_id
+        elif has_violin and orig_label.startswith("_"):
+            elem_type = "violin"
+            label = violin_call_id or "violin"
+            call_id = violin_call_id
+        else:
+            elem_type = "line"
+            label = orig_label if orig_label else f"line_{i}"
+            if regular_line_idx < len(plot_ids):
+                call_id = plot_ids[regular_line_idx]
+                label = call_id
+            else:
+                call_id = f"line_{ax_idx}_{regular_line_idx}"
+                if orig_label.startswith("_"):
+                    label = call_id
+            regular_line_idx += 1
+
+        color_map[key] = {
+            "id": element_id,
+            "type": elem_type,
+            "label": label,
+            "ax_index": ax_idx,
+            "rgb": list(rgb),
+            "original_color": mpl_color_to_hex(original_props[key]["color"]),
+            "call_id": call_id,
+        }
+        element_id += 1
+
+    return element_id
+
+
+__all__ = ["process_lines"]
+
+# EOF

figrecipe/_editor/_hitmap/_artists/_patches.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Patch processing for hitmap generation."""
+
+from typing import Any, Dict
+
+from matplotlib.patches import Polygon, Rectangle, Wedge
+
+from .._colors import id_to_rgb, mpl_color_to_hex, normalize_color
+
+
+def process_patches(
+    ax,
+    ax_idx: int,
+    element_id: int,
+    original_props: Dict[str, Any],
+    color_map: Dict[str, Any],
+    ax_info: Dict[str, Any],
+) -> int:
+    """Process patches (bars, wedges, polygons) on an axes.
+
+    Returns updated element_id.
+    """
+    ax_plot_types = ax_info.get("types", set())
+    ax_call_ids = ax_info.get("call_ids", {})
+
+    has_hist = "hist" in ax_plot_types
+    has_bar = "bar" in ax_plot_types
+
+    hist_ids = list(ax_call_ids.get("hist", []))
+    bar_ids = list(ax_call_ids.get("bar", []))
+    pie_ids = list(ax_call_ids.get("pie", []))
+
+    if has_hist and hist_ids:
+        rect_call_id = hist_ids[0]
+        rect_type = "hist"
+    elif has_bar and bar_ids:
+        rect_call_id = bar_ids[0]
+        rect_type = "bar"
+    else:
+        rect_call_id = f"bar_{ax_idx}"
+        rect_type = "bar"
+
+    for i, patch in enumerate(ax.patches):
+        if isinstance(patch, Rectangle):
+            element_id = _process_rectangle(
+                patch,
+                i,
+                ax_idx,
+                element_id,
+                original_props,
+                color_map,
+                rect_call_id,
+                rect_type,
+            )
+        elif isinstance(patch, Wedge):
+            element_id = _process_wedge(
+                patch, i, ax_idx, element_id, original_props, color_map, pie_ids
+            )
+        elif isinstance(patch, Polygon):
+            element_id = _process_polygon(
+                patch, i, ax_idx, element_id, original_props, color_map
+            )
+
+    return element_id
+
+
+def _process_rectangle(
+    patch, i, ax_idx, element_id, original_props, color_map, rect_call_id, rect_type
+):
+    """Process Rectangle patch (bars, histogram bins)."""
+    if not patch.get_visible():
+        return element_id
+    if patch.get_width() == 1.0 and patch.get_height() == 1.0:
+        return element_id
+
+    key = f"ax{ax_idx}_bar{i}"
+    rgb = id_to_rgb(element_id)
+
+    original_props[key] = {
+        "facecolor": patch.get_facecolor(),
+        "edgecolor": patch.get_edgecolor(),
+    }
+
+    patch.set_facecolor(normalize_color(rgb))
+    patch.set_edgecolor(normalize_color(rgb))
+
+    label = rect_call_id or patch.get_label() or f"bar_{i}"
+
+    color_map[key] = {
+        "id": element_id,
+        "type": rect_type,
+        "label": label,
+        "ax_index": ax_idx,
+        "rgb": list(rgb),
+        "original_color": mpl_color_to_hex(original_props[key]["facecolor"]),
+        "call_id": rect_call_id,
+    }
+    return element_id + 1
+
+
+def _process_wedge(patch, i, ax_idx, element_id, original_props, color_map, pie_ids):
+    """Process Wedge patch (pie chart slices)."""
+    if not patch.get_visible():
+        return element_id
+
+    key = f"ax{ax_idx}_wedge{i}"
+    rgb = id_to_rgb(element_id)
+
+    original_props[key] = {
+        "facecolor": patch.get_facecolor(),
+        "edgecolor": patch.get_edgecolor(),
+    }
+
+    patch.set_facecolor(normalize_color(rgb))
+    patch.set_edgecolor(normalize_color(rgb))
+
+    call_id = pie_ids[0] if pie_ids else None
+    label = call_id or f"wedge_{i}"
+
+    color_map[key] = {
+        "id": element_id,
+        "type": "pie",
+        "label": label,
+        "ax_index": ax_idx,
+        "rgb": list(rgb),
+        "original_color": mpl_color_to_hex(original_props[key]["facecolor"]),
+        "call_id": call_id,
+    }
+    return element_id + 1
+
+
+def _process_polygon(patch, i, ax_idx, element_id, original_props, color_map):
+    """Process Polygon patch (fill areas)."""
+    if not patch.get_visible():
+        return element_id
+
+    key = f"ax{ax_idx}_polygon{i}"
+    rgb = id_to_rgb(element_id)
+
+    original_props[key] = {
+        "facecolor": patch.get_facecolor(),
+        "edgecolor": patch.get_edgecolor(),
+    }
+
+    patch.set_facecolor(normalize_color(rgb))
+    patch.set_edgecolor(normalize_color(rgb))
+
+    color_map[key] = {
+        "id": element_id,
+        "type": "fill",
+        "label": f"fill_{i}",
+        "ax_index": ax_idx,
+        "rgb": list(rgb),
+        "original_color": mpl_color_to_hex(original_props[key]["facecolor"]),
+        "call_id": None,
+    }
+    return element_id + 1
+
+
+__all__ = ["process_patches"]
+
+# EOF

figrecipe/_editor/_hitmap/_artists/_text.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Text and legend processing for hitmap generation."""
+
+from typing import Any, Dict
+
+from .._colors import id_to_rgb, normalize_color
+
+
+def process_text(
+    ax,
+    ax_idx: int,
+    element_id: int,
+    original_props: Dict[str, Any],
+    color_map: Dict[str, Any],
+) -> int:
+    """Process text elements (title, labels) on an axes.
+
+    Returns updated element_id.
+    """
+    # Title
+    title = ax.get_title()
+    if title:
+        key = f"ax{ax_idx}_title"
+        rgb = id_to_rgb(element_id)
+        title_obj = ax.title
+
+        original_props[key] = {"color": title_obj.get_color()}
+        title_obj.set_color(normalize_color(rgb))
+
+        color_map[key] = {
+            "id": element_id,
+            "type": "title",
+            "label": "title",
+            "ax_index": ax_idx,
+            "rgb": list(rgb),
+        }
+        element_id += 1
+
+    # X label
+    xlabel = ax.get_xlabel()
+    if xlabel:
+        key = f"ax{ax_idx}_xlabel"
+        rgb = id_to_rgb(element_id)
+        xlabel_obj = ax.xaxis.label
+
+        original_props[key] = {"color": xlabel_obj.get_color()}
+        xlabel_obj.set_color(normalize_color(rgb))
+
+        color_map[key] = {
+            "id": element_id,
+            "type": "xlabel",
+            "label": "xlabel",
+            "ax_index": ax_idx,
+            "rgb": list(rgb),
+        }
+        element_id += 1
+
+    # Y label
+    ylabel = ax.get_ylabel()
+    if ylabel:
+        key = f"ax{ax_idx}_ylabel"
+        rgb = id_to_rgb(element_id)
+        ylabel_obj = ax.yaxis.label
+
+        original_props[key] = {"color": ylabel_obj.get_color()}
+        ylabel_obj.set_color(normalize_color(rgb))
+
+        color_map[key] = {
+            "id": element_id,
+            "type": "ylabel",
+            "label": "ylabel",
+            "ax_index": ax_idx,
+            "rgb": list(rgb),
+        }
+        element_id += 1
+
+    return element_id
+
+
+def process_legend(
+    ax,
+    ax_idx: int,
+    element_id: int,
+    original_props: Dict[str, Any],
+    color_map: Dict[str, Any],
+) -> int:
+    """Process legend on an axes.
+
+    Returns updated element_id.
+    """
+    legend = ax.get_legend()
+    if legend is not None and legend.get_visible():
+        key = f"ax{ax_idx}_legend"
+        rgb = id_to_rgb(element_id)
+
+        frame = legend.get_frame()
+        original_props[key] = {
+            "facecolor": frame.get_facecolor(),
+            "edgecolor": frame.get_edgecolor(),
+        }
+
+        frame.set_facecolor(normalize_color(rgb))
+        frame.set_edgecolor(normalize_color(rgb))
+
+        color_map[key] = {
+            "id": element_id,
+            "type": "legend",
+            "label": "legend",
+            "ax_index": ax_idx,
+            "rgb": list(rgb),
+        }
+        element_id += 1
+
+    return element_id
+
+
+def process_figure_text(
+    mpl_fig,
+    element_id: int,
+    original_props: Dict[str, Any],
+    color_map: Dict[str, Any],
+) -> int:
+    """Process figure-level text elements (suptitle, supxlabel, supylabel).
+
+    Returns updated element_id.
+    """
+    # Suptitle
+    if hasattr(mpl_fig, "_suptitle") and mpl_fig._suptitle is not None:
+        suptitle_obj = mpl_fig._suptitle
+        if suptitle_obj.get_text():
+            key = "fig_suptitle"
+            rgb = id_to_rgb(element_id)
+
+            original_props[key] = {"color": suptitle_obj.get_color()}
+            suptitle_obj.set_color(normalize_color(rgb))
+
+            color_map[key] = {
+                "id": element_id,
+                "type": "suptitle",
+                "label": "suptitle",
+                "ax_index": -1,
+                "rgb": list(rgb),
+            }
+            element_id += 1
+
+    # Supxlabel
+    if hasattr(mpl_fig, "_supxlabel") and mpl_fig._supxlabel is not None:
+        supxlabel_obj = mpl_fig._supxlabel
+        if supxlabel_obj.get_text():
+            key = "fig_supxlabel"
+            rgb = id_to_rgb(element_id)
+
+            original_props[key] = {"color": supxlabel_obj.get_color()}
+            supxlabel_obj.set_color(normalize_color(rgb))
+
+            color_map[key] = {
+                "id": element_id,
+                "type": "supxlabel",
+                "label": "supxlabel",
+                "ax_index": -1,
+                "rgb": list(rgb),
+            }
+            element_id += 1
+
+    # Supylabel
+    if hasattr(mpl_fig, "_supylabel") and mpl_fig._supylabel is not None:
+        supylabel_obj = mpl_fig._supylabel
+        if supylabel_obj.get_text():
+            key = "fig_supylabel"
+            rgb = id_to_rgb(element_id)
+
+            original_props[key] = {"color": supylabel_obj.get_color()}
+            supylabel_obj.set_color(normalize_color(rgb))
+
+            color_map[key] = {
+                "id": element_id,
+                "type": "supylabel",
+                "label": "supylabel",
+                "ax_index": -1,
+                "rgb": list(rgb),
+            }
+            element_id += 1
+
+    return element_id
+
+
+__all__ = ["process_text", "process_legend", "process_figure_text"]
+
+# EOF

figrecipe/_editor/_hitmap/_colors.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Color utilities for hitmap generation."""
+
+from typing import Tuple
+
+# Hand-picked distinct colors for first 12 elements (maximum visual distinction)
+DISTINCT_COLORS = [
+    (255, 0, 0),  # Red
+    (0, 200, 0),  # Green
+    (0, 100, 255),  # Blue
+    (255, 200, 0),  # Yellow
+    (255, 0, 255),  # Magenta
+    (0, 255, 255),  # Cyan
+    (255, 128, 0),  # Orange
+    (128, 0, 255),  # Purple
+    (0, 255, 128),  # Spring green
+    (255, 0, 128),  # Rose
+    (128, 255, 0),  # Lime
+    (0, 128, 255),  # Sky blue
+]
+
+# Reserved colors
+BACKGROUND_COLOR = (26, 26, 26)  # Dark gray for background
+AXES_COLOR = (64, 64, 64)  # Medium gray for non-selectable axes elements
+
+
+def hsv_to_rgb(h: float, s: float, v: float) -> Tuple[int, int, int]:
+    """Convert HSV to RGB (0-255 range).
+
+    Parameters
+    ----------
+    h : float
+        Hue (0-1).
+    s : float
+        Saturation (0-1).
+    v : float
+        Value (0-1).
+
+    Returns
+    -------
+    tuple
+        RGB tuple (0-255 range).
+    """
+    if s == 0:
+        r = g = b = int(v * 255)
+        return (r, g, b)
+
+    i = int(h * 6)
+    f = h * 6 - i
+    p = v * (1 - s)
+    q = v * (1 - s * f)
+    t = v * (1 - s * (1 - f))
+
+    i %= 6
+    if i == 0:
+        r, g, b = v, t, p
+    elif i == 1:
+        r, g, b = q, v, p
+    elif i == 2:
+        r, g, b = p, v, t
+    elif i == 3:
+        r, g, b = p, q, v
+    elif i == 4:
+        r, g, b = t, p, v
+    else:
+        r, g, b = v, p, q
+
+    return (int(r * 255), int(g * 255), int(b * 255))
+
+
+def id_to_rgb(element_id: int) -> Tuple[int, int, int]:
+    """Convert element ID to unique RGB color.
+
+    Parameters
+    ----------
+    element_id : int
+        Unique element identifier (1-based).
+
+    Returns
+    -------
+    tuple of int
+        RGB color tuple (0-255 range).
+
+    Notes
+    -----
+    - ID 0 is reserved for background
+    - IDs 1-12 use hand-picked distinct colors
+    - IDs 13+ use HSV-based generation
+    """
+    if element_id <= 0:
+        return BACKGROUND_COLOR
+
+    if element_id <= len(DISTINCT_COLORS):
+        return DISTINCT_COLORS[element_id - 1]
+
+    # HSV-based generation for IDs > 12
+    golden_ratio = 0.618033988749895
+    hue = ((element_id - len(DISTINCT_COLORS)) * golden_ratio) % 1.0
+    saturation = 0.7 + (element_id % 3) * 0.1
+    value = 0.75 + (element_id % 4) * 0.0625
+
+    return hsv_to_rgb(hue, saturation, value)
+
+
+def rgb_to_id(rgb: Tuple[int, int, int]) -> int:
+    """Convert RGB color back to element ID.
+
+    Parameters
+    ----------
+    rgb : tuple of int
+        RGB color tuple.
+
+    Returns
+    -------
+    int
+        Element ID, or 0 if background/unknown.
+    """
+    if rgb == BACKGROUND_COLOR:
+        return 0
+    if rgb == AXES_COLOR:
+        return 0
+
+    # Check hand-picked colors
+    if rgb in DISTINCT_COLORS:
+        return DISTINCT_COLORS.index(rgb) + 1
+
+    # For HSV-generated colors, search
+    for test_id in range(len(DISTINCT_COLORS) + 1, 1000):
+        if id_to_rgb(test_id) == rgb:
+            return test_id
+
+    return 0
+
+
+def normalize_color(rgb: Tuple[int, int, int]) -> Tuple[float, float, float]:
+    """Normalize RGB from 0-255 to 0-1 range."""
+    return (rgb[0] / 255, rgb[1] / 255, rgb[2] / 255)
+
+
+def mpl_color_to_hex(color) -> str:
+    """Convert matplotlib color to hex string.
+
+    Parameters
+    ----------
+    color : color
+        Matplotlib color (RGBA tuple, hex string, named color).
+
+    Returns
+    -------
+    str
+        Hex color string (e.g., '#FF0000').
+    """
+    import matplotlib.colors as mcolors
+
+    try:
+        if hasattr(color, "__iter__") and not isinstance(color, str):
+            color = tuple(color)
+            if len(color) >= 3:
+                if all(isinstance(c, (int, float)) for c in color[:3]):
+                    if all(c <= 1.0 for c in color[:3]):
+                        return mcolors.to_hex(color[:3])
+                    else:
+                        return mcolors.to_hex(tuple(c / 255 for c in color[:3]))
+        return mcolors.to_hex(color)
+    except Exception:
+        return "#888888"
+
+
+__all__ = [
+    "DISTINCT_COLORS",
+    "BACKGROUND_COLOR",
+    "AXES_COLOR",
+    "hsv_to_rgb",
+    "id_to_rgb",
+    "rgb_to_id",
+    "normalize_color",
+    "mpl_color_to_hex",
+]
+
+# EOF