scitex 2.7.0__py3-none-any.whl → 2.7.3__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()