scitex 2.14.0__py3-none-any.whl → 2.15.3__py3-none-any.whl

scitex/canvas/editor/_dearpygui/_selection.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/_dearpygui/_selection.py
+
+"""
+Element selection for DearPyGui editor.
+
+Handles click-to-select, hover detection, and element finding.
+"""
+
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+import numpy as np
+import pandas as pd
+
+if TYPE_CHECKING:
+    from ._state import EditorState
+
+
+def get_trace_labels(state: "EditorState") -> List[str]:
+    """Get list of trace labels for selection combo."""
+    traces = state.current_overrides.get("traces", [])
+    if not traces:
+        return ["(no traces)"]
+    return [t.get("label", t.get("id", f"Trace {i}")) for i, t in enumerate(traces)]
+
+
+def get_all_element_labels(state: "EditorState") -> List[str]:
+    """Get list of all selectable element labels."""
+    labels = []
+
+    # Fixed elements
+    labels.append("Title")
+    labels.append("X Label")
+    labels.append("Y Label")
+    labels.append("X Axis")
+    labels.append("Y Axis")
+    labels.append("Legend")
+
+    # Traces
+    traces = state.current_overrides.get("traces", [])
+    for i, t in enumerate(traces):
+        label = t.get("label", t.get("id", f"Trace {i}"))
+        labels.append(f"Trace: {label}")
+
+    return labels
+
+
+def find_clicked_element(
+    state: "EditorState", click_x: float, click_y: float
+) -> Optional[Dict]:
+    """Find which element was clicked based on stored bboxes."""
+    if not state.element_bboxes:
+        return None
+
+    # Check each element bbox
+    for element_type, bbox in state.element_bboxes.items():
+        if bbox is None:
+            continue
+        x0, y0, x1, y1 = bbox
+        if x0 <= click_x <= x1 and y0 <= click_y <= y1:
+            return {"type": element_type, "index": None}
+
+    return None
+
+
+def find_nearest_trace(
+    state: "EditorState",
+    click_x: float,
+    click_y: float,
+    preview_width: int,
+    preview_height: int,
+) -> Optional[int]:
+    """Find the nearest trace to the click position."""
+    if state.csv_data is None or not isinstance(state.csv_data, pd.DataFrame):
+        return None
+
+    traces = state.current_overrides.get("traces", [])
+    if not traces:
+        return None
+
+    # Get preview bounds from last render
+    if state.preview_bounds is None:
+        return None
+
+    x_offset, y_offset, fig_width, fig_height = state.preview_bounds
+
+    # Adjust click coordinates to figure space
+    fig_x = click_x - x_offset
+    fig_y = click_y - y_offset
+
+    # Check if click is within figure bounds
+    if not (0 <= fig_x <= fig_width and 0 <= fig_y <= fig_height):
+        return None
+
+    # Get axes transform info
+    if state.axes_transform is None:
+        return None
+
+    ax_x0, ax_y0, ax_width, ax_height, xlim, ylim = state.axes_transform
+
+    # Convert figure pixel to axes pixel
+    ax_pixel_x = fig_x - ax_x0
+    ax_pixel_y = fig_y - ax_y0
+
+    # Check if click is within axes bounds
+    if not (0 <= ax_pixel_x <= ax_width and 0 <= ax_pixel_y <= ax_height):
+        return None
+
+    # Convert axes pixel to data coordinates
+    # Note: y is flipped (0 at top in pixel space)
+    data_x = xlim[0] + (ax_pixel_x / ax_width) * (xlim[1] - xlim[0])
+    data_y = ylim[1] - (ax_pixel_y / ax_height) * (ylim[1] - ylim[0])
+
+    # Find nearest trace
+    df = state.csv_data
+    min_dist = float("inf")
+    nearest_idx = None
+
+    for i, trace in enumerate(traces):
+        csv_cols = trace.get("csv_columns", {})
+        x_col = csv_cols.get("x")
+        y_col = csv_cols.get("y")
+
+        if x_col not in df.columns or y_col not in df.columns:
+            continue
+
+        trace_x = df[x_col].dropna().values
+        trace_y = df[y_col].dropna().values
+
+        if len(trace_x) == 0:
+            continue
+
+        # Normalize coordinates for distance calculation
+        x_range = xlim[1] - xlim[0]
+        y_range = ylim[1] - ylim[0]
+
+        norm_click_x = (data_x - xlim[0]) / x_range if x_range > 0 else 0
+        norm_click_y = (data_y - ylim[0]) / y_range if y_range > 0 else 0
+
+        norm_trace_x = (trace_x - xlim[0]) / x_range if x_range > 0 else trace_x
+        norm_trace_y = (trace_y - ylim[0]) / y_range if y_range > 0 else trace_y
+
+        # Calculate distances to all points
+        distances = np.sqrt(
+            (norm_trace_x - norm_click_x) ** 2 + (norm_trace_y - norm_click_y) ** 2
+        )
+        min_trace_dist = np.min(distances)
+
+        if min_trace_dist < min_dist:
+            min_dist = min_trace_dist
+            nearest_idx = i
+
+    # Only select if close enough (threshold in normalized space)
+    if min_dist < 0.1:  # 10% of plot area
+        return nearest_idx
+
+    return None
+
+
+def select_element(state: "EditorState", element: Dict, dpg) -> None:
+    """Select an element and show appropriate controls."""
+    from ._rendering import update_preview
+
+    state.selected_element = element
+    elem_type = element.get("type")
+    elem_idx = element.get("index")
+
+    # Hide all control groups first
+    dpg.configure_item("trace_controls_group", show=False)
+    dpg.configure_item("text_controls_group", show=False)
+    dpg.configure_item("axis_controls_group", show=False)
+    dpg.configure_item("legend_controls_group", show=False)
+
+    # Update combo selection
+    if elem_type == "trace":
+        _select_trace(state, elem_idx, dpg)
+    elif elem_type in ("title", "xlabel", "ylabel"):
+        _select_text_element(state, elem_type, dpg)
+    elif elem_type in ("xaxis", "yaxis"):
+        _select_axis_element(state, elem_type, dpg)
+    elif elem_type == "legend":
+        _select_legend(state, dpg)
+
+    # Redraw with highlight
+    update_preview(state, dpg)
+
+
+def _select_trace(state: "EditorState", trace_idx: Optional[int], dpg) -> None:
+    """Handle trace selection."""
+    traces = state.current_overrides.get("traces", [])
+    if trace_idx is not None and trace_idx < len(traces):
+        trace = traces[trace_idx]
+        label = f"Trace: {trace.get('label', trace.get('id', f'Trace {trace_idx}'))}"
+        dpg.set_value("element_selector_combo", label)
+
+        # Show trace controls and populate
+        dpg.configure_item("trace_controls_group", show=True)
+        state.selected_trace_index = trace_idx
+        dpg.set_value("trace_label_input", trace.get("label", ""))
+
+        color_hex = trace.get("color", "#0080bf")
+        try:
+            r = int(color_hex[1:3], 16)
+            g = int(color_hex[3:5], 16)
+            b = int(color_hex[5:7], 16)
+            dpg.set_value("trace_color_picker", [r, g, b])
+        except (ValueError, IndexError):
+            dpg.set_value("trace_color_picker", [128, 128, 191])
+
+        dpg.set_value("trace_linewidth_slider", trace.get("linewidth", 1.0))
+        dpg.set_value("trace_linestyle_combo", trace.get("linestyle", "-"))
+        dpg.set_value("trace_marker_combo", trace.get("marker", "") or "")
+        dpg.set_value("trace_markersize_slider", trace.get("markersize", 6.0))
+
+        dpg.set_value(
+            "selection_text",
+            f"Selected: {trace.get('label', f'Trace {trace_idx}')}",
+        )
+
+
+def _select_text_element(state: "EditorState", elem_type: str, dpg) -> None:
+    """Handle text element selection (title, xlabel, ylabel)."""
+    dpg.set_value(
+        "element_selector_combo",
+        elem_type.replace("x", "X ").replace("y", "Y ").title(),
+    )
+    dpg.configure_item("text_controls_group", show=True)
+
+    o = state.current_overrides
+    if elem_type == "title":
+        dpg.set_value("element_text_input", o.get("title", ""))
+        dpg.set_value("element_fontsize_slider", o.get("title_fontsize", 8))
+    elif elem_type == "xlabel":
+        dpg.set_value("element_text_input", o.get("xlabel", ""))
+        dpg.set_value("element_fontsize_slider", o.get("axis_fontsize", 7))
+    elif elem_type == "ylabel":
+        dpg.set_value("element_text_input", o.get("ylabel", ""))
+        dpg.set_value("element_fontsize_slider", o.get("axis_fontsize", 7))
+
+    dpg.set_value("selection_text", f"Selected: {elem_type.title()}")
+
+
+def _select_axis_element(state: "EditorState", elem_type: str, dpg) -> None:
+    """Handle axis element selection (xaxis, yaxis)."""
+    label = "X Axis" if elem_type == "xaxis" else "Y Axis"
+    dpg.set_value("element_selector_combo", label)
+    dpg.configure_item("axis_controls_group", show=True)
+
+    o = state.current_overrides
+    dpg.set_value("axis_linewidth_slider", o.get("axis_width", 0.2))
+    dpg.set_value("axis_tick_length_slider", o.get("tick_length", 0.8))
+    dpg.set_value("axis_tick_fontsize_slider", o.get("tick_fontsize", 7))
+
+    if elem_type == "xaxis":
+        dpg.set_value("axis_show_spine_checkbox", not o.get("hide_bottom_spine", False))
+    else:
+        dpg.set_value("axis_show_spine_checkbox", not o.get("hide_left_spine", False))
+
+    dpg.set_value("selection_text", f"Selected: {label}")
+
+
+def _select_legend(state: "EditorState", dpg) -> None:
+    """Handle legend selection."""
+    dpg.set_value("element_selector_combo", "Legend")
+    dpg.configure_item("legend_controls_group", show=True)
+
+    o = state.current_overrides
+    dpg.set_value("legend_visible_edit", o.get("legend_visible", True))
+    dpg.set_value("legend_frameon_edit", o.get("legend_frameon", False))
+    dpg.set_value("legend_loc_edit", o.get("legend_loc", "best"))
+    dpg.set_value("legend_fontsize_edit", o.get("legend_fontsize", 6))
+
+    dpg.set_value("selection_text", "Selected: Legend")
+
+
+def deselect_element(state: "EditorState", dpg) -> None:
+    """Deselect the current element."""
+    from ._rendering import update_preview
+
+    state.selected_element = None
+    state.selected_trace_index = None
+
+    # Hide all control groups
+    dpg.configure_item("trace_controls_group", show=False)
+    dpg.configure_item("text_controls_group", show=False)
+    dpg.configure_item("axis_controls_group", show=False)
+    dpg.configure_item("legend_controls_group", show=False)
+
+    dpg.set_value("selection_text", "")
+    dpg.set_value("element_selector_combo", "")
+    update_preview(state, dpg)
+
+
+# EOF

scitex/canvas/editor/_dearpygui/_state.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/_dearpygui/_state.py
+
+"""
+Editor state management for DearPyGui editor.
+
+Provides EditorState dataclass to hold all editor state.
+"""
+
+import copy
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+
+@dataclass
+class EditorState:
+    """Holds all state for the DearPyGui editor."""
+
+    # Core data
+    json_path: Path
+    metadata: Dict[str, Any]
+    csv_data: Optional[Any] = None
+    png_path: Optional[Path] = None
+    manual_overrides: Dict[str, Any] = field(default_factory=dict)
+
+    # Defaults
+    scitex_defaults: Dict[str, Any] = field(default_factory=dict)
+    metadata_defaults: Dict[str, Any] = field(default_factory=dict)
+    current_overrides: Dict[str, Any] = field(default_factory=dict)
+
+    # Modification tracking
+    initial_overrides: Dict[str, Any] = field(default_factory=dict)
+    user_modified: bool = False
+    texture_id: Optional[int] = None
+
+    # Selection state
+    selected_element: Optional[Dict[str, Any]] = None
+    selected_trace_index: Optional[int] = None
+
+    # Preview bounds
+    preview_bounds: Optional[Tuple[int, int, int, int]] = None
+    axes_transform: Optional[Tuple] = None
+    element_bboxes: Dict[str, Tuple[int, int, int, int]] = field(default_factory=dict)
+    element_bboxes_raw: Dict[str, Tuple] = field(default_factory=dict)
+
+    # Hover state
+    hovered_element: Optional[Dict[str, Any]] = None
+    last_hover_check: float = 0
+    backend_name: str = "dearpygui"
+
+    # Cached rendering
+    cached_base_image: Optional[Any] = None
+    cached_base_data: Optional[List[float]] = None
+    cache_dirty: bool = True
+
+    @classmethod
+    def create(
+        cls,
+        json_path: Path,
+        metadata: Dict[str, Any],
+        csv_data: Optional[Any] = None,
+        png_path: Optional[Path] = None,
+        manual_overrides: Optional[Dict[str, Any]] = None,
+    ) -> "EditorState":
+        """Create an EditorState with properly initialized defaults."""
+        from .._defaults import extract_defaults_from_metadata, get_scitex_defaults
+
+        state = cls(
+            json_path=Path(json_path),
+            metadata=metadata,
+            csv_data=csv_data,
+            png_path=Path(png_path) if png_path else None,
+            manual_overrides=manual_overrides or {},
+        )
+
+        # Get SciTeX defaults and merge with metadata
+        state.scitex_defaults = get_scitex_defaults()
+        state.metadata_defaults = extract_defaults_from_metadata(metadata)
+
+        # Start with defaults, then overlay manual overrides
+        state.current_overrides = copy.deepcopy(state.scitex_defaults)
+        state.current_overrides.update(state.metadata_defaults)
+        state.current_overrides.update(state.manual_overrides)
+
+        # Track modifications
+        state.initial_overrides = copy.deepcopy(state.current_overrides)
+
+        return state
+
+
+# EOF

scitex/canvas/editor/_dearpygui/_utils.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/_dearpygui/_utils.py
+
+"""
+Utility functions for DearPyGui editor.
+
+Provides helper functions like checkerboard pattern creation for transparency preview.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from PIL import Image
+
+
+def create_checkerboard(width: int, height: int, square_size: int = 10) -> "Image":
+    """Create a checkerboard pattern image for transparency preview.
+
+    Parameters
+    ----------
+    width : int
+        Image width in pixels
+    height : int
+        Image height in pixels
+    square_size : int
+        Size of each checkerboard square (default: 10)
+
+    Returns
+    -------
+    PIL.Image
+        RGBA image with checkerboard pattern (light/dark gray)
+    """
+    import numpy as np
+    from PIL import Image
+
+    # Create checkerboard pattern
+    light_gray = (220, 220, 220, 255)
+    dark_gray = (180, 180, 180, 255)
+
+    # Create array
+    img_array = np.zeros((height, width, 4), dtype=np.uint8)
+
+    for y in range(height):
+        for x in range(width):
+            # Determine which square we're in
+            square_x = x // square_size
+            square_y = y // square_size
+            if (square_x + square_y) % 2 == 0:
+                img_array[y, x] = light_gray
+            else:
+                img_array[y, x] = dark_gray
+
+    return Image.fromarray(img_array, "RGBA")
+
+
+# mm to pt conversion factor
+MM_TO_PT = 2.83465
+
+
+# EOF

scitex/canvas/editor/flask_editor/_core/__init__.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/flask_editor/_core/__init__.py
+
+"""Core WebEditor package for Flask-based figure editing.
+
+This package provides the WebEditor class and supporting modules for
+browser-based figure editing functionality.
+"""
+
+from ._bbox_extraction import extract_bboxes_from_metadata
+from ._editor import WebEditor
+from ._export_helpers import compose_panels_to_figure, export_composed_figure
+
+# Backward compatibility alias
+_extract_bboxes_from_metadata = extract_bboxes_from_metadata
+
+__all__ = [
+    "WebEditor",
+    "extract_bboxes_from_metadata",
+    "export_composed_figure",
+    "compose_panels_to_figure",
+    "_extract_bboxes_from_metadata",
+]
+
+
+# EOF

scitex/canvas/editor/flask_editor/_core/_bbox_extraction.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/flask_editor/_core/_bbox_extraction.py
+
+"""Bounding box extraction from pltz metadata."""
+
+from typing import Any, Dict, Optional
+
+__all__ = ["extract_bboxes_from_metadata"]
+
+
+def extract_bboxes_from_metadata(
+    metadata: Dict[str, Any],
+    display_width: Optional[float] = None,
+    display_height: Optional[float] = None,
+) -> Dict[str, Any]:
+    """Extract element bounding boxes from pltz metadata.
+
+    Builds bboxes from selectable_regions in the metadata for click detection.
+    This allows the editor to highlight elements when clicked.
+
+    Coordinate system (new layered format):
+    - selectable_regions bbox_px: Already in final image space (figure_px)
+    - Display size: Actual displayed image size (PNG pixels or SVG viewBox)
+    - Scale = display_size / figure_px (usually 1:1, but may differ for scaled display)
+
+    Parameters
+    ----------
+    metadata : dict
+        The pltz JSON metadata containing selectable_regions
+    display_width : float, optional
+        Actual display image width (from PNG size or SVG viewBox)
+    display_height : float, optional
+        Actual display image height (from PNG size or SVG viewBox)
+
+    Returns
+    -------
+    dict
+        Mapping of element IDs to their bounding box coordinates (in display pixels)
+    """
+    bboxes = {}
+    selectable = metadata.get("selectable_regions", {})
+
+    # Figure dimensions from new layered format (bbox_px are in this space)
+    figure_px = metadata.get("figure_px", [])
+    if isinstance(figure_px, list) and len(figure_px) >= 2:
+        fig_width = figure_px[0]
+        fig_height = figure_px[1]
+    else:
+        # Fallback for old format: try hit_regions.path_data.figure
+        hit_regions = metadata.get("hit_regions", {})
+        path_data = hit_regions.get("path_data", {})
+        orig_fig = path_data.get("figure", {})
+        fig_width = orig_fig.get("width_px", 944)
+        fig_height = orig_fig.get("height_px", 803)
+
+    # Use actual display dimensions if provided, else use figure_px
+    if display_width is None:
+        display_width = fig_width
+    if display_height is None:
+        display_height = fig_height
+
+    # Scale factor: display / figure_px
+    scale_x = display_width / fig_width if fig_width > 0 else 1
+    scale_y = display_height / fig_height if fig_height > 0 else 1
+
+    def to_display_bbox(bbox, is_list=True):
+        """Convert bbox to display pixels."""
+        if is_list:
+            x0, y0, x1, y1 = bbox[0], bbox[1], bbox[2], bbox[3]
+        else:
+            x0 = bbox.get("x0", 0)
+            y0 = bbox.get("y0", 0)
+            x1 = bbox.get("x1", bbox.get("x0", 0) + bbox.get("width", 0))
+            y1 = bbox.get("y1", bbox.get("y0", 0) + bbox.get("height", 0))
+
+        disp_x0 = x0 * scale_x
+        disp_x1 = x1 * scale_x
+        disp_y0 = y0 * scale_y
+        disp_y1 = y1 * scale_y
+
+        return {
+            "x0": disp_x0,
+            "y0": disp_y0,
+            "x1": disp_x1,
+            "y1": disp_y1,
+            "x": disp_x0,
+            "y": disp_y0,
+            "width": disp_x1 - disp_x0,
+            "height": disp_y1 - disp_y0,
+        }
+
+    # Extract from selectable_regions.axes
+    axes_regions = selectable.get("axes", [])
+    for ax_idx, ax in enumerate(axes_regions):
+        ax_key = f"ax_{ax_idx:02d}"
+
+        # Title
+        title = ax.get("title", {})
+        if title and "bbox_px" in title:
+            bbox_disp = to_display_bbox(title["bbox_px"])
+            bboxes[f"{ax_key}_title"] = {
+                **bbox_disp,
+                "type": "title",
+                "text": title.get("text", ""),
+            }
+
+        # X label
+        xlabel = ax.get("xlabel", {})
+        if xlabel and "bbox_px" in xlabel:
+            bbox_disp = to_display_bbox(xlabel["bbox_px"])
+            bboxes[f"{ax_key}_xlabel"] = {
+                **bbox_disp,
+                "type": "xlabel",
+                "text": xlabel.get("text", ""),
+            }
+
+        # Y label
+        ylabel = ax.get("ylabel", {})
+        if ylabel and "bbox_px" in ylabel:
+            bbox_disp = to_display_bbox(ylabel["bbox_px"])
+            bboxes[f"{ax_key}_ylabel"] = {
+                **bbox_disp,
+                "type": "ylabel",
+                "text": ylabel.get("text", ""),
+            }
+
+        # Legend
+        legend = ax.get("legend", {})
+        if legend and "bbox_px" in legend:
+            bbox_disp = to_display_bbox(legend["bbox_px"])
+            bboxes[f"{ax_key}_legend"] = {
+                **bbox_disp,
+                "type": "legend",
+            }
+
+        # X-axis spine
+        xaxis = ax.get("xaxis", {})
+        if xaxis:
+            spine = xaxis.get("spine", {})
+            if spine and "bbox_px" in spine:
+                bbox_disp = to_display_bbox(spine["bbox_px"])
+                bboxes[f"{ax_key}_xaxis_spine"] = {
+                    **bbox_disp,
+                    "type": "xaxis",
+                }
+
+        # Y-axis spine
+        yaxis = ax.get("yaxis", {})
+        if yaxis:
+            spine = yaxis.get("spine", {})
+            if spine and "bbox_px" in spine:
+                bbox_disp = to_display_bbox(spine["bbox_px"])
+                bboxes[f"{ax_key}_yaxis_spine"] = {
+                    **bbox_disp,
+                    "type": "yaxis",
+                }
+
+    # Extract traces from artists
+    artists = metadata.get("artists", [])
+    if not artists:
+        hit_regions = metadata.get("hit_regions", {})
+        path_data = hit_regions.get("path_data", {})
+        artists = path_data.get("artists", [])
+
+    for artist in artists:
+        artist_id = artist.get("id", 0)
+        artist_type = artist.get("type", "line")
+        bbox_px = artist.get("bbox_px", {})
+        if bbox_px:
+            bbox_disp = to_display_bbox(bbox_px, is_list=False)
+            trace_entry = {
+                **bbox_disp,
+                "type": artist_type,
+                "label": artist.get("label", f"Trace {artist_id}"),
+                "element_type": artist_type,
+            }
+
+            path_px = artist.get("path_px", [])
+            if path_px:
+                scaled_points = [
+                    [pt[0] * scale_x, pt[1] * scale_y] for pt in path_px if len(pt) >= 2
+                ]
+                trace_entry["points"] = scaled_points
+
+            bboxes[f"trace_{artist_id}"] = trace_entry
+
+    bboxes["_meta"] = {
+        "display_width": display_width,
+        "display_height": display_height,
+        "figure_px_width": fig_width,
+        "figure_px_height": fig_height,
+        "scale_x": scale_x,
+        "scale_y": scale_y,
+    }
+
+    return bboxes
+
+
+# EOF