scitex 2.7.0__py3-none-any.whl → 2.8.1__py3-none-any.whl

scitex/{vis → fig}/editor/_qt_editor.py

@@ -56,6 +56,7 @@ class QtEditor:
     - Real-time preview updates
     - Save to .manual.json
     - SciTeX style defaults pre-filled
+    - Hitmap-based element selection (when available)
     """
 
     def __init__(
@@ -65,12 +66,32 @@ class QtEditor:
         csv_data: Optional[Any] = None,
         png_path: Optional[Path] = None,
         manual_overrides: Optional[Dict[str, Any]] = None,
+        hitmap_path: Optional[Path] = None,
+        bundle_spec: Optional[Dict[str, Any]] = None,
     ):
         self.json_path = Path(json_path)
         self.metadata = metadata
         self.csv_data = csv_data
         self.png_path = Path(png_path) if png_path else None
         self.manual_overrides = manual_overrides or {}
+        self.hitmap_path = Path(hitmap_path) if hitmap_path else None
+        self.bundle_spec = bundle_spec or {}
+
+        # Load hitmap image if available
+        self.hitmap_array = None
+        if self.hitmap_path and self.hitmap_path.exists():
+            try:
+                from PIL import Image
+                import numpy as np
+                hitmap_img = Image.open(self.hitmap_path).convert('RGB')
+                self.hitmap_array = np.array(hitmap_img)
+            except Exception:
+                pass
+
+        # Extract hit_regions and selectable_regions from spec
+        self.hit_regions = self.bundle_spec.get('hit_regions', {})
+        self.selectable_regions = self.bundle_spec.get('selectable_regions', {})
+        self.color_map = self.hit_regions.get('color_map', {})
 
         # Get SciTeX defaults and merge with metadata
         from ._defaults import get_scitex_defaults, extract_defaults_from_metadata
@@ -164,7 +185,7 @@ class QtEditorWindow:
         self.window.show()
 
     def _create_canvas_panel(self, parent):
-        """Create the matplotlib canvas panel."""
+        """Create the matplotlib canvas panel with hitmap-based selection."""
         from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg
         from matplotlib.backends.backend_qtagg import NavigationToolbar2QT
         from matplotlib.figure import Figure
@@ -184,8 +205,167 @@ class QtEditorWindow:
         toolbar = NavigationToolbar2QT(self.canvas, canvas_widget)
         canvas_layout.addWidget(toolbar)
 
+        # Connect click event for hitmap-based selection
+        self.canvas.mpl_connect('button_press_event', self._on_canvas_click)
+
+        # Selection info label
+        self.selection_label = self.QtWidgets.QLabel("Click on figure to select element")
+        self.selection_label.setStyleSheet("padding: 5px; background: #f0f0f0; border-radius: 3px;")
+        canvas_layout.addWidget(self.selection_label)
+
         parent.addWidget(canvas_widget)
 
+    def _on_canvas_click(self, event):
+        """Handle canvas click - use hitmap to identify clicked element."""
+        if event.inaxes is None:
+            return
+
+        # Get pixel coordinates
+        x_px = int(event.x)
+        y_px = int(self.canvas.get_width_height()[1] - event.y)  # Flip Y
+
+        # First check selectable_regions (bounding boxes for axis elements)
+        selection_info = self._check_selectable_regions(x_px, y_px)
+
+        # If no selectable_region hit, try hitmap for data elements
+        if selection_info is None and self.editor.hitmap_array is not None:
+            selection_info = self._check_hitmap(x_px, y_px)
+
+        # Update selection display
+        if selection_info:
+            self._show_selection(selection_info)
+        else:
+            self.selection_label.setText(f"No element at ({x_px}, {y_px})")
+            self.status_bar.showMessage(f"Click at ({x_px}, {y_px}) - no element found")
+
+    def _check_selectable_regions(self, x_px: int, y_px: int) -> Optional[Dict[str, Any]]:
+        """Check if click is within any selectable_region bounding box."""
+        regions = self.editor.selectable_regions
+        if not regions or 'axes' not in regions:
+            return None
+
+        for ax_info in regions['axes']:
+            ax_idx = ax_info.get('index', 0)
+
+            # Check title
+            if 'title' in ax_info:
+                bbox = ax_info['title'].get('bbox_px', [])
+                if len(bbox) == 4 and self._point_in_bbox(x_px, y_px, bbox):
+                    return {
+                        'type': 'title',
+                        'axes_index': ax_idx,
+                        'text': ax_info['title'].get('text', ''),
+                        'element': 'title',
+                    }
+
+            # Check xlabel
+            if 'xlabel' in ax_info:
+                bbox = ax_info['xlabel'].get('bbox_px', [])
+                if len(bbox) == 4 and self._point_in_bbox(x_px, y_px, bbox):
+                    return {
+                        'type': 'xlabel',
+                        'axes_index': ax_idx,
+                        'text': ax_info['xlabel'].get('text', ''),
+                        'element': 'xlabel',
+                    }
+
+            # Check ylabel
+            if 'ylabel' in ax_info:
+                bbox = ax_info['ylabel'].get('bbox_px', [])
+                if len(bbox) == 4 and self._point_in_bbox(x_px, y_px, bbox):
+                    return {
+                        'type': 'ylabel',
+                        'axes_index': ax_idx,
+                        'text': ax_info['ylabel'].get('text', ''),
+                        'element': 'ylabel',
+                    }
+
+            # Check legend
+            if 'legend' in ax_info:
+                bbox = ax_info['legend'].get('bbox_px', [])
+                if len(bbox) == 4 and self._point_in_bbox(x_px, y_px, bbox):
+                    return {
+                        'type': 'legend',
+                        'axes_index': ax_idx,
+                        'element': 'legend',
+                    }
+
+            # Check xaxis elements
+            if 'xaxis' in ax_info:
+                xaxis = ax_info['xaxis']
+                if 'spine' in xaxis and xaxis['spine']:
+                    bbox = xaxis['spine'].get('bbox_px', [])
+                    if len(bbox) == 4 and self._point_in_bbox(x_px, y_px, bbox):
+                        return {'type': 'xaxis_spine', 'axes_index': ax_idx, 'element': 'xaxis'}
+
+            # Check yaxis elements
+            if 'yaxis' in ax_info:
+                yaxis = ax_info['yaxis']
+                if 'spine' in yaxis and yaxis['spine']:
+                    bbox = yaxis['spine'].get('bbox_px', [])
+                    if len(bbox) == 4 and self._point_in_bbox(x_px, y_px, bbox):
+                        return {'type': 'yaxis_spine', 'axes_index': ax_idx, 'element': 'yaxis'}
+
+        return None
+
+    def _check_hitmap(self, x_px: int, y_px: int) -> Optional[Dict[str, Any]]:
+        """Check hitmap for data element at pixel position."""
+        hitmap = self.editor.hitmap_array
+        color_map = self.editor.color_map
+
+        if hitmap is None or not color_map:
+            return None
+
+        # Bounds check
+        h, w = hitmap.shape[:2]
+        if x_px < 0 or x_px >= w or y_px < 0 or y_px >= h:
+            return None
+
+        # Get RGB at position
+        r, g, b = hitmap[y_px, x_px]
+
+        # Skip background (black) and axes elements (dark gray)
+        if (r, g, b) == (0, 0, 0):  # Background
+            return None
+        if (r, g, b) == (64, 64, 64):  # Axes color (#404040)
+            return None
+
+        # Convert RGB to ID
+        element_id = r * 65536 + g * 256 + b
+
+        # Look up in color_map
+        if str(element_id) in color_map:
+            info = color_map[str(element_id)]
+            return {
+                'type': 'data_element',
+                'element_id': element_id,
+                'element_type': info.get('type', 'unknown'),
+                'label': info.get('label', ''),
+                'axes_index': info.get('axes_index', 0),
+                'rgb': [r, g, b],
+            }
+
+        return None
+
+    def _point_in_bbox(self, x: int, y: int, bbox: list) -> bool:
+        """Check if point (x, y) is within bounding box [x0, y0, x1, y1]."""
+        x0, y0, x1, y1 = bbox
+        return x0 <= x <= x1 and y0 <= y <= y1
+
+    def _show_selection(self, info: Dict[str, Any]):
+        """Display selection info in UI."""
+        if info['type'] == 'data_element':
+            text = f"Selected: {info['element_type']} - {info.get('label', 'unnamed')}"
+            detail = f"ID: {info['element_id']}, Axes: {info['axes_index']}"
+        else:
+            text = f"Selected: {info['type']}"
+            if 'text' in info:
+                text += f" - \"{info['text']}\""
+            detail = f"Axes: {info.get('axes_index', 0)}"
+
+        self.selection_label.setText(f"{text}\n{detail}")
+        self.status_bar.showMessage(text)
+
     def _create_control_panel(self, parent):
         """Create the control panel with property editors."""
         scroll_area = self.QtWidgets.QScrollArea()
@@ -837,7 +1017,7 @@ class QtEditorWindow:
 
     def _save_manual(self):
         """Save to .manual.json."""
-        from ._edit import save_manual_overrides
+        from .edit import save_manual_overrides
 
         try:
             self._collect_overrides()

scitex/{vis → fig}/editor/_tkinter_editor.py

@@ -490,7 +490,7 @@ class TkinterEditor:
 
     def _save_manual(self):
         """Save current overrides to .manual.json."""
-        from ._edit import save_manual_overrides
+        from .edit import save_manual_overrides
 
         try:
             manual_path = save_manual_overrides(self.json_path, self.current_overrides)

scitex/fig/editor/edit/__init__.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-14 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fig/editor/edit/__init__.py
+
+"""Edit module for launching visual figure editors.
+
+This module provides the main edit() function and supporting utilities for:
+- Backend detection and selection (flask, dearpygui, qt, tkinter, mpl)
+- Path resolution for figure files (.json, .csv, .png)
+- Bundle resolution for .pltz and .figz formats
+- Panel data loading for multi-panel figures
+- Manual override handling (.manual.json)
+"""
+
+from .editor_launcher import edit
+from .backend_detector import (
+    detect_best_backend,
+    print_available_backends,
+)
+from .path_resolver import resolve_figure_paths
+from .bundle_resolver import (
+    resolve_pltz_bundle,
+    resolve_figz_bundle,
+    resolve_layered_pltz_bundle,
+)
+from .panel_loader import load_panel_data
+from .manual_handler import compute_file_hash, save_manual_overrides
+
+__all__ = [
+    # Main entry point
+    "edit",
+    # Backend detection
+    "detect_best_backend",
+    "print_available_backends",
+    # Path resolution
+    "resolve_figure_paths",
+    # Bundle resolution
+    "resolve_pltz_bundle",
+    "resolve_figz_bundle",
+    "resolve_layered_pltz_bundle",
+    # Panel loading
+    "load_panel_data",
+    # Manual overrides
+    "compute_file_hash",
+    "save_manual_overrides",
+]
+
+
+# EOF

scitex/fig/editor/edit/backend_detector.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-14 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fig/editor/edit/backend_detector.py
+
+"""Backend detection and selection for figure editor."""
+
+import warnings
+
+__all__ = ["print_available_backends", "detect_best_backend"]
+
+# Backend packages mapping
+BACKENDS = {
+    "flask": ["flask"],
+    "dearpygui": ["dearpygui"],
+    "qt": ["PyQt6", "PyQt5", "PySide6", "PySide2"],
+    "tkinter": ["tkinter"],
+    "mpl": ["matplotlib"],
+}
+
+
+def print_available_backends() -> None:
+    """Print available backends status."""
+    print("\n" + "=" * 50)
+    print("SciTeX Visual Editor - Available Backends")
+    print("=" * 50)
+
+    for backend, packages in BACKENDS.items():
+        available = False
+        available_pkg = None
+        for pkg in packages:
+            try:
+                __import__(pkg)
+                available = True
+                available_pkg = pkg
+                break
+            except ImportError:
+                pass
+
+        status = f"[OK] {available_pkg}" if available else "[NOT INSTALLED]"
+        print(f"  {backend:12s}: {status}")
+
+    print("=" * 50)
+    print("Install: pip install scitex[gui]")
+    print("=" * 50 + "\n")
+
+
+def detect_best_backend() -> str:
+    """
+    Detect the best available GUI backend with graceful degradation.
+
+    Order: flask > dearpygui > qt > tkinter > mpl
+    Shows warnings when falling back to less capable backends.
+    """
+    # Try Flask - best for modern UI
+    try:
+        import flask
+        return "flask"
+    except ImportError:
+        pass
+
+    # Try DearPyGui - GPU-accelerated, modern
+    try:
+        import dearpygui
+        return "dearpygui"
+    except ImportError:
+        warnings.warn(
+            "Flask not available. Consider: pip install flask\nTrying DearPyGui..."
+        )
+
+    # Try DearPyGui again
+    try:
+        import dearpygui
+        return "dearpygui"
+    except ImportError:
+        pass
+
+    # Try Qt (richest desktop features)
+    for qt_pkg in ["PyQt6", "PyQt5", "PySide6", "PySide2"]:
+        try:
+            __import__(qt_pkg)
+            warnings.warn(
+                "DearPyGui not available. Consider: pip install dearpygui\n"
+                "Using Qt backend instead."
+            )
+            return "qt"
+        except ImportError:
+            pass
+
+    # Try Tkinter (built-in, good features)
+    try:
+        import tkinter
+        warnings.warn(
+            "Qt not available. Consider: pip install PyQt6\n"
+            "Using Tkinter backend (basic features)."
+        )
+        return "tkinter"
+    except ImportError:
+        pass
+
+    # Fall back to matplotlib interactive (always works)
+    warnings.warn(
+        "No GUI toolkit found. Using minimal matplotlib editor.\n"
+        "For better experience, install: pip install flask (web) or pip install PyQt6 (desktop)"
+    )
+    return "mpl"
+
+
+# EOF

scitex/fig/editor/edit/bundle_resolver.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-14 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/fig/editor/edit/bundle_resolver.py
+
+"""Bundle path resolution for .pltz and .figz formats."""
+
+import json as json_module
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Optional, Tuple, Dict, Any
+
+__all__ = ["resolve_pltz_bundle", "resolve_figz_bundle", "resolve_layered_pltz_bundle"]
+
+
+def resolve_figz_bundle(path: Path, panel_index: int = 0) -> Tuple:
+    """
+    Resolve paths from a .figz bundle (multi-panel figure).
+
+    Uses in-memory zip reading for .pltz panels - no disk extraction.
+
+    Parameters
+    ----------
+    path : Path
+        Path to .figz bundle (.figz or .figz.d)
+    panel_index : int, optional
+        Index of panel to open (default: 0 for first panel)
+
+    Returns
+    -------
+    tuple
+        (json_path, csv_path, png_path, hitmap_path, bundle_spec, panel_info)
+    """
+    spath = str(path)
+    figz_is_zip = False
+
+    # Handle ZIP vs directory for figz
+    if spath.endswith('.figz') and not spath.endswith('.figz.d'):
+        figz_is_zip = True
+        if not path.exists():
+            raise FileNotFoundError(f"Figz bundle not found: {path}")
+        # For figz zip, extract to access nested pltz
+        temp_dir = tempfile.mkdtemp(prefix='scitex_edit_figz_')
+        with zipfile.ZipFile(path, 'r') as zf:
+            zf.extractall(temp_dir)
+        bundle_dir = Path(temp_dir)
+        for item in bundle_dir.iterdir():
+            if item.is_dir() and str(item).endswith('.figz.d'):
+                bundle_dir = item
+                break
+    else:
+        bundle_dir = Path(path)
+        if not bundle_dir.exists():
+            raise FileNotFoundError(f"Figz bundle directory not found: {bundle_dir}")
+
+    # Find nested pltz bundles
+    panel_paths = []
+    panel_is_zip = []
+
+    for item in sorted(bundle_dir.iterdir(), key=lambda x: x.name):
+        if item.is_dir() and str(item).endswith('.pltz.d'):
+            panel_paths.append(str(item))
+            panel_is_zip.append(False)
+        elif item.is_file() and str(item).endswith('.pltz'):
+            panel_paths.append(str(item))
+            panel_is_zip.append(True)
+
+    if not panel_paths:
+        raise FileNotFoundError(f"No .pltz panels found in figz bundle: {bundle_dir}")
+
+    # Validate panel index
+    if panel_index < 0 or panel_index >= len(panel_paths):
+        panel_index = 0
+
+    selected_panel_path = panel_paths[panel_index]
+    panel_name = Path(selected_panel_path).name
+    print(f"Opening panel: {panel_name}")
+    if len(panel_paths) > 1:
+        print(f"  (Figz contains {len(panel_paths)} panels)")
+
+    # Build panel info
+    panel_names = [Path(p).name for p in panel_paths]
+    panel_info = {
+        "panels": panel_names,
+        "panel_paths": panel_paths,
+        "panel_is_zip": panel_is_zip,
+        "current_index": panel_index,
+        "figz_dir": str(bundle_dir),
+        "figz_is_zip": figz_is_zip,
+        "bundle_path": str(path) if figz_is_zip else None,  # Original figz zip path for export/download
+    }
+
+    # Resolve the selected panel
+    result = resolve_pltz_bundle(Path(selected_panel_path))
+    return result + (panel_info,)
+
+
+def resolve_pltz_bundle(path: Path) -> Tuple:
+    """
+    Resolve paths from a .pltz bundle (directory or ZIP).
+
+    Supports both:
+    - Legacy format (single {basename}.json)
+    - Layered format v2.0 (spec.json + style.json + cache/)
+
+    Parameters
+    ----------
+    path : Path
+        Path to .pltz bundle (.pltz or .pltz.d)
+
+    Returns
+    -------
+    tuple
+        (json_path, csv_path, png_path, hitmap_path, bundle_spec)
+    """
+    spath = str(path)
+
+    # Handle ZIP vs directory
+    if spath.endswith('.pltz') and not spath.endswith('.pltz.d'):
+        if not path.exists():
+            raise FileNotFoundError(f"Bundle not found: {path}")
+        temp_dir = tempfile.mkdtemp(prefix='scitex_edit_')
+        with zipfile.ZipFile(path, 'r') as zf:
+            zf.extractall(temp_dir)
+        bundle_dir = Path(temp_dir)
+        for item in bundle_dir.iterdir():
+            if item.is_dir() and str(item).endswith('.pltz.d'):
+                bundle_dir = item
+                break
+    else:
+        bundle_dir = Path(path)
+        if not bundle_dir.exists():
+            raise FileNotFoundError(f"Bundle directory not found: {bundle_dir}")
+
+    # Check if this is a layered bundle (v2.0)
+    spec_path = bundle_dir / "spec.json"
+    if spec_path.exists():
+        return resolve_layered_pltz_bundle(bundle_dir)
+
+    # === Legacy format ===
+    json_path = None
+    csv_path = None
+    png_path = None
+    svg_path = None
+    hitmap_path = None
+    bundle_spec = None
+
+    for f in bundle_dir.iterdir():
+        name = f.name
+        if name.endswith('.json') and not name.endswith('.manual.json'):
+            json_path = f
+        elif name.endswith('.csv'):
+            csv_path = f
+        elif name.endswith('_hitmap.png'):
+            hitmap_path = f
+        elif name.endswith('.svg') and '_hitmap' not in name:
+            svg_path = f
+        elif name.endswith('.png') and '_hitmap' not in name and '_overview' not in name:
+            png_path = f
+
+    # Prefer SVG for display
+    if svg_path:
+        png_path = svg_path
+
+    if json_path and json_path.exists():
+        with open(json_path, 'r') as f:
+            bundle_spec = json_module.load(f)
+
+    return (
+        json_path,
+        csv_path if csv_path and csv_path.exists() else None,
+        png_path if png_path and png_path.exists() else None,
+        hitmap_path if hitmap_path and hitmap_path.exists() else None,
+        bundle_spec,
+    )
+
+
+def resolve_layered_pltz_bundle(bundle_dir: Path) -> Tuple:
+    """
+    Resolve paths from a layered .pltz bundle (v2.0 format).
+
+    Layered format structure:
+        plot.pltz.d/
+            spec.json           # Semantic
+            style.json          # Appearance
+            {basename}.csv      # Data
+            exports/            # PNG, SVG, hitmap
+            cache/              # geometry_px.json
+
+    Parameters
+    ----------
+    bundle_dir : Path
+        Path to .pltz.d bundle directory.
+
+    Returns
+    -------
+    tuple
+        (json_path, csv_path, png_path, hitmap_path, bundle_spec)
+    """
+    from scitex.plt.io import load_layered_pltz_bundle
+
+    bundle_data = load_layered_pltz_bundle(bundle_dir)
+    spec_path = bundle_dir / "spec.json"
+    csv_path = None
+    png_path = None
+    hitmap_path = None
+
+    # Find CSV
+    for f in bundle_dir.glob("*.csv"):
+        csv_path = f
+        break
+
+    # Find exports
+    exports_dir = bundle_dir / "exports"
+    if exports_dir.exists():
+        for f in exports_dir.iterdir():
+            name = f.name
+            if name.endswith('_hitmap.png'):
+                hitmap_path = f
+            elif name.endswith('.svg') and '_hitmap' not in name:
+                png_path = f
+            elif name.endswith('.png') and '_hitmap' not in name and png_path is None:
+                png_path = f
+
+    bundle_spec = bundle_data.get("merged", {})
+
+    if hitmap_path and "hit_regions" in bundle_spec:
+        bundle_spec["hit_regions"]["hit_map"] = str(hitmap_path.name)
+
+    return (
+        spec_path,
+        csv_path if csv_path and csv_path.exists() else None,
+        png_path if png_path and png_path.exists() else None,
+        hitmap_path if hitmap_path and hitmap_path.exists() else None,
+        bundle_spec,
+    )
+
+
+# EOF