scitex 2.14.0__py3-none-any.whl → 2.15.1__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/templates/__init__.py

@@ -1,35 +1,20 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # File: ./src/scitex/vis/editor/flask_editor/templates/__init__.py
 """Template components for Flask editor.
 
-Supports two modes:
-- Static files mode (default): Uses external CSS/JS files from static/
-- Inline mode (fallback): Embeds CSS/JS directly in HTML
+Uses external CSS/JS files from static/ directory.
 """
 
 from ._html import HTML_BODY
 
-# Configuration flag - set to False to use inline mode for debugging
-USE_STATIC_FILES = True
 
-
-def build_html_template(use_static: bool = None) -> str:
-    """Build the complete HTML template from components.
-
-    Args:
-        use_static: Override static file usage. If None, uses USE_STATIC_FILES.
+def build_html_template() -> str:
+    """Build the complete HTML template.
 
     Returns:
         Complete HTML template string.
     """
-    if use_static is None:
-        use_static = USE_STATIC_FILES
-
-    if use_static:
-        return _build_static_template()
-    else:
-        return _build_inline_template()
+    return _build_static_template()
 
 
 def _build_static_template() -> str:
@@ -37,42 +22,44 @@ def _build_static_template() -> str:
     # Get list of JS files in correct load order
     js_files = [
         # Dev tools (load first to capture console logs)
-        'js/dev/element-inspector.js',
+        "js/dev/element-inspector.js",
         # Core modules first (dependencies)
-        'js/core/state.js',
-        'js/core/utils.js',
-        'js/core/api.js',
+        "js/core/state.js",
+        "js/core/utils.js",
+        "js/core/api.js",
         # Editor modules
-        'js/editor/bbox.js',
-        'js/editor/overlay.js',
-        'js/editor/preview.js',
-        'js/editor/element-drag.js',
+        "js/editor/bbox.js",
+        "js/editor/overlay.js",
+        "js/editor/preview.js",
+        "js/editor/element-drag.js",
         # Canvas modules
-        'js/canvas/selection.js',
-        'js/canvas/resize.js',
-        'js/canvas/dragging.js',
-        'js/canvas/canvas.js',
+        "js/canvas/selection.js",
+        "js/canvas/resize.js",
+        "js/canvas/dragging.js",
+        "js/canvas/canvas.js",
         # Alignment modules
-        'js/alignment/basic.js',
-        'js/alignment/axis.js',
-        'js/alignment/distribute.js',
+        "js/alignment/basic.js",
+        "js/alignment/axis.js",
+        "js/alignment/distribute.js",
         # UI modules
-        'js/ui/theme.js',
-        'js/ui/help.js',
-        'js/ui/download.js',
-        'js/ui/controls.js',
+        "js/ui/theme.js",
+        "js/ui/help.js",
+        "js/ui/download.js",
+        "js/ui/controls.js",
         # Shortcuts
-        'js/shortcuts/context-menu.js',
-        'js/shortcuts/keyboard.js',
+        "js/shortcuts/context-menu.js",
+        "js/shortcuts/keyboard.js",
         # Main entry (last)
-        'js/main.js',
+        "js/main.js",
     ]
 
     # Generate script tags
-    script_tags = '\n    '.join([
-        f'<script src="{{{{ url_for(\'static\', filename=\'{f}\') }}}}"></script>'
-        for f in js_files
-    ])
+    script_tags = "\n    ".join(
+        [
+            f"<script src=\"{{{{ url_for('static', filename='{f}') }}}}\"></script>"
+            for f in js_files
+        ]
+    )
 
     return f"""<!DOCTYPE html>
 <html lang="en" data-theme="dark">
@@ -95,29 +82,4 @@ def _build_static_template() -> str:
 """
 
 
-def _build_inline_template() -> str:
-    """Build template with inline CSS/JS (fallback mode)."""
-    from ._styles import CSS_STYLES
-    from ._scripts import JS_SCRIPTS
-
-    return f"""<!DOCTYPE html>
-<html lang="en" data-theme="dark">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>SciTeX Figure Editor - {{{{ filename }}}}</title>
-    <style>
-{CSS_STYLES}
-    </style>
-</head>
-<body>
-{HTML_BODY}
-    <script>
-{JS_SCRIPTS}
-    </script>
-</body>
-</html>
-"""
-
-
 # EOF

scitex/cli/__init__.py

@@ -16,49 +16,44 @@ import click
 from .main import cli
 
 
-def add_help_recursive(group: click.Group, parent_name: str = "scitex") -> None:
-    """Add help-recursive command to a click group.
+def print_help_recursive(ctx, group: click.Group) -> None:
+    """Print help for a group and all its subcommands.
 
     Args:
-        group: The click group to add the command to
-        parent_name: The parent command name for display (e.g., "scitex writer")
+        ctx: The click context
+        group: The click group to print help for
     """
-
-    @group.command("help-recursive")
-    @click.pass_context
-    def help_recursive(ctx):
-        """Show help for all commands recursively."""
-        # Create a fake parent context to show correct command path in Usage
-        fake_parent = click.Context(click.Group(), info_name="scitex")
-        parent_ctx = click.Context(group, info_name=group.name, parent=fake_parent)
-
-        click.secho(f"━━━ scitex {group.name} ━━━", fg="cyan", bold=True)
-        click.echo(group.get_help(parent_ctx))
-
-        for name in sorted(group.list_commands(ctx) or []):
-            cmd = group.get_command(ctx, name)
-            if cmd is None or name == "help-recursive":
-                continue
-            click.echo()
-            click.secho(f"━━━ scitex {group.name} {name} ━━━", fg="cyan", bold=True)
-            with click.Context(cmd, info_name=name, parent=parent_ctx) as sub_ctx:
-                click.echo(cmd.get_help(sub_ctx))
-                # Handle nested subgroups
-                if isinstance(cmd, click.Group):
-                    for sub_name in sorted(cmd.list_commands(sub_ctx) or []):
-                        sub_cmd = cmd.get_command(sub_ctx, sub_name)
-                        if sub_cmd is None:
-                            continue
-                        click.echo()
-                        click.secho(
-                            f"━━━ scitex {group.name} {name} {sub_name} ━━━",
-                            fg="cyan",
-                            bold=True,
-                        )
-                        with click.Context(
-                            sub_cmd, info_name=sub_name, parent=sub_ctx
-                        ) as sub_sub_ctx:
-                            click.echo(sub_cmd.get_help(sub_sub_ctx))
-
-
-__all__ = ["cli", "add_help_recursive"]
+    # Create a fake parent context to show correct command path in Usage
+    fake_parent = click.Context(click.Group(), info_name="scitex")
+    parent_ctx = click.Context(group, info_name=group.name, parent=fake_parent)
+
+    click.secho(f"━━━ scitex {group.name} ━━━", fg="cyan", bold=True)
+    click.echo(group.get_help(parent_ctx))
+
+    for name in sorted(group.list_commands(ctx) or []):
+        cmd = group.get_command(ctx, name)
+        if cmd is None:
+            continue
+        click.echo()
+        click.secho(f"━━━ scitex {group.name} {name} ━━━", fg="cyan", bold=True)
+        with click.Context(cmd, info_name=name, parent=parent_ctx) as sub_ctx:
+            click.echo(cmd.get_help(sub_ctx))
+            # Handle nested subgroups
+            if isinstance(cmd, click.Group):
+                for sub_name in sorted(cmd.list_commands(sub_ctx) or []):
+                    sub_cmd = cmd.get_command(sub_ctx, sub_name)
+                    if sub_cmd is None:
+                        continue
+                    click.echo()
+                    click.secho(
+                        f"━━━ scitex {group.name} {name} {sub_name} ━━━",
+                        fg="cyan",
+                        bold=True,
+                    )
+                    with click.Context(
+                        sub_cmd, info_name=sub_name, parent=sub_ctx
+                    ) as sub_sub_ctx:
+                        click.echo(sub_cmd.get_help(sub_sub_ctx))
+
+
+__all__ = ["cli", "print_help_recursive"]