scitex 2.4.2__py3-none-any.whl → 2.5.0__py3-none-any.whl

scitex/vis/editor/flask_editor/__init__.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: ./src/scitex/vis/editor/flask_editor/__init__.py
+"""Flask-based web editor for SciTeX figures."""
+
+from .core import WebEditor
+from .utils import find_available_port, kill_process_on_port, check_port_available
+from .renderer import render_preview_with_bboxes
+from .plotter import plot_from_csv
+
+__all__ = [
+    'WebEditor',
+    'find_available_port',
+    'kill_process_on_port',
+    'check_port_available',
+    'render_preview_with_bboxes',
+    'plot_from_csv',
+]
+
+
+# EOF

scitex/vis/editor/flask_editor/bbox.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: ./src/scitex/vis/editor/flask_editor/bbox.py
+"""Bounding box extraction for figure elements."""
+
+from typing import Dict, Any
+
+
+def extract_bboxes(fig, ax, renderer, img_width: int, img_height: int) -> Dict[str, Any]:
+    """Extract bounding boxes for all figure elements."""
+    from matplotlib.transforms import Bbox
+
+    # Get figure tight bbox in inches
+    fig_bbox = fig.get_tightbbox(renderer)
+    tight_x0 = fig_bbox.x0
+    tight_y0 = fig_bbox.y0
+    tight_width = fig_bbox.width
+    tight_height = fig_bbox.height
+
+    # bbox_inches='tight' adds pad_inches (default 0.1) around the tight bbox
+    pad_inches = 0.1
+    saved_width_inches = tight_width + 2 * pad_inches
+    saved_height_inches = tight_height + 2 * pad_inches
+
+    # Scale factors for converting inches to pixels
+    scale_x = img_width / saved_width_inches
+    scale_y = img_height / saved_height_inches
+
+    bboxes = {}
+
+    def get_element_bbox(element, name):
+        """Get element bbox in image pixel coordinates."""
+        try:
+            bbox = element.get_window_extent(renderer)
+
+            elem_x0_inches = bbox.x0 / fig.dpi
+            elem_x1_inches = bbox.x1 / fig.dpi
+            elem_y0_inches = bbox.y0 / fig.dpi
+            elem_y1_inches = bbox.y1 / fig.dpi
+
+            x0_rel = elem_x0_inches - tight_x0 + pad_inches
+            x1_rel = elem_x1_inches - tight_x0 + pad_inches
+            y0_rel = saved_height_inches - (elem_y1_inches - tight_y0 + pad_inches)
+            y1_rel = saved_height_inches - (elem_y0_inches - tight_y0 + pad_inches)
+
+            bboxes[name] = {
+                'x0': max(0, int(x0_rel * scale_x)),
+                'y0': max(0, int(y0_rel * scale_y)),
+                'x1': min(img_width, int(x1_rel * scale_x)),
+                'y1': min(img_height, int(y1_rel * scale_y)),
+                'label': name.replace('_', ' ').title()
+            }
+        except Exception as e:
+            print(f"Error getting bbox for {name}: {e}")
+
+    def bbox_to_img_coords(bbox):
+        """Convert matplotlib bbox to image pixel coordinates."""
+        x0_inches = bbox.x0 / fig.dpi
+        y0_inches = bbox.y0 / fig.dpi
+        x1_inches = bbox.x1 / fig.dpi
+        y1_inches = bbox.y1 / fig.dpi
+        x0_rel = x0_inches - tight_x0 + pad_inches
+        y0_rel = y0_inches - tight_y0 + pad_inches
+        x1_rel = x1_inches - tight_x0 + pad_inches
+        y1_rel = y1_inches - tight_y0 + pad_inches
+        return {
+            'x0': int(x0_rel * scale_x),
+            'y0': int((saved_height_inches - y1_rel) * scale_y),
+            'x1': int(x1_rel * scale_x),
+            'y1': int((saved_height_inches - y0_rel) * scale_y),
+        }
+
+    # Get bboxes for title, labels
+    if ax.title.get_text():
+        get_element_bbox(ax.title, 'title')
+    if ax.xaxis.label.get_text():
+        get_element_bbox(ax.xaxis.label, 'xlabel')
+    if ax.yaxis.label.get_text():
+        get_element_bbox(ax.yaxis.label, 'ylabel')
+
+    # Get axis bboxes
+    _extract_axis_bboxes(ax, renderer, bboxes, bbox_to_img_coords, Bbox)
+
+    # Get legend bbox
+    legend = ax.get_legend()
+    if legend:
+        get_element_bbox(legend, 'legend')
+
+    # Get trace (line) bboxes
+    _extract_trace_bboxes(ax, fig, renderer, bboxes, get_element_bbox,
+                          tight_x0, tight_y0, saved_height_inches, scale_x, scale_y, pad_inches)
+
+    return bboxes
+
+
+def _extract_axis_bboxes(ax, renderer, bboxes, bbox_to_img_coords, Bbox):
+    """Extract bboxes for X and Y axis elements."""
+    try:
+        # X-axis: combine spine and tick labels into one bbox
+        x_axis_bboxes = []
+        for ticklabel in ax.xaxis.get_ticklabels():
+            if ticklabel.get_visible():
+                try:
+                    tb = ticklabel.get_window_extent(renderer)
+                    if tb.width > 0:
+                        x_axis_bboxes.append(tb)
+                except Exception:
+                    pass
+        for tick in ax.xaxis.get_major_ticks():
+            if tick.tick1line.get_visible():
+                try:
+                    tb = tick.tick1line.get_window_extent(renderer)
+                    if tb.width > 0 or tb.height > 0:
+                        x_axis_bboxes.append(tb)
+                except Exception:
+                    pass
+        spine_bbox = ax.spines['bottom'].get_window_extent(renderer)
+        if spine_bbox.width > 0:
+            if x_axis_bboxes:
+                tick_union = Bbox.union(x_axis_bboxes)
+                constrained_spine = Bbox.from_extents(
+                    tick_union.x0, spine_bbox.y0,
+                    tick_union.x1, spine_bbox.y1
+                )
+                x_axis_bboxes.append(constrained_spine)
+            else:
+                x_axis_bboxes.append(spine_bbox)
+        if x_axis_bboxes:
+            combined = Bbox.union(x_axis_bboxes)
+            bboxes['xaxis_ticks'] = bbox_to_img_coords(combined)
+            bboxes['xaxis_ticks']['label'] = 'X Spine & Ticks'
+
+        # Y-axis: combine spine and tick labels into one bbox
+        y_axis_bboxes = []
+        for ticklabel in ax.yaxis.get_ticklabels():
+            if ticklabel.get_visible():
+                try:
+                    tb = ticklabel.get_window_extent(renderer)
+                    if tb.width > 0:
+                        y_axis_bboxes.append(tb)
+                except Exception:
+                    pass
+        for tick in ax.yaxis.get_major_ticks():
+            if tick.tick1line.get_visible():
+                try:
+                    tb = tick.tick1line.get_window_extent(renderer)
+                    if tb.width > 0 or tb.height > 0:
+                        y_axis_bboxes.append(tb)
+                except Exception:
+                    pass
+        spine_bbox = ax.spines['left'].get_window_extent(renderer)
+        if spine_bbox.height > 0:
+            if y_axis_bboxes:
+                tick_union = Bbox.union(y_axis_bboxes)
+                constrained_spine = Bbox.from_extents(
+                    spine_bbox.x0, tick_union.y0,
+                    spine_bbox.x1, tick_union.y1
+                )
+                y_axis_bboxes.append(constrained_spine)
+            else:
+                y_axis_bboxes.append(spine_bbox)
+        if y_axis_bboxes:
+            combined = Bbox.union(y_axis_bboxes)
+            padded = Bbox.from_extents(
+                combined.x0 - 10,
+                combined.y0 - 5,
+                combined.x1 + 5,
+                combined.y1 + 5
+            )
+            bboxes['yaxis_ticks'] = bbox_to_img_coords(padded)
+            bboxes['yaxis_ticks']['label'] = 'Y Spine & Ticks'
+
+    except Exception as e:
+        print(f"Error getting axis bboxes: {e}")
+
+
+def _extract_trace_bboxes(ax, fig, renderer, bboxes, get_element_bbox,
+                          tight_x0, tight_y0, saved_height_inches, scale_x, scale_y, pad_inches):
+    """Extract bboxes for trace (line) elements with proximity detection points."""
+    for idx, line in enumerate(ax.get_lines()):
+        try:
+            label = line.get_label()
+            if label.startswith('_'):
+                continue
+            get_element_bbox(line, f'trace_{idx}')
+            if f'trace_{idx}' in bboxes:
+                bboxes[f'trace_{idx}']['label'] = label or f'Trace {idx}'
+                bboxes[f'trace_{idx}']['trace_idx'] = idx
+
+                # Get line data points in pixel coordinates for proximity detection
+                xdata, ydata = line.get_xdata(), line.get_ydata()
+                if len(xdata) > 0:
+                    transform = ax.transData
+                    points_display = transform.transform(list(zip(xdata, ydata)))
+
+                    points_img = []
+                    for px, py in points_display:
+                        px_inches = px / fig.dpi
+                        py_inches = py / fig.dpi
+                        x_rel = px_inches - tight_x0 + pad_inches
+                        y_rel = saved_height_inches - (py_inches - tight_y0 + pad_inches)
+                        x_img = int(x_rel * scale_x)
+                        y_img = int(y_rel * scale_y)
+                        points_img.append([x_img, y_img])
+
+                    # Downsample points if too many
+                    if len(points_img) > 100:
+                        step = len(points_img) // 100
+                        points_img = points_img[::step]
+
+                    bboxes[f'trace_{idx}']['points'] = points_img
+        except Exception as e:
+            print(f"Error getting trace bbox: {e}")
+
+
+# EOF

scitex/vis/editor/flask_editor/core.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: ./src/scitex/vis/editor/flask_editor/core.py
+"""Core WebEditor class for Flask-based figure editing."""
+
+from pathlib import Path
+from typing import Dict, Any, Optional
+import copy
+import json
+import threading
+import webbrowser
+
+from .utils import find_available_port, kill_process_on_port, check_port_available
+from .renderer import render_preview_with_bboxes
+from .templates import build_html_template
+
+
+class WebEditor:
+    """
+    Browser-based figure editor using Flask.
+
+    Features:
+    - Modern responsive UI
+    - Real-time preview via WebSocket or polling
+    - Property editors with sliders and color pickers
+    - Save to .manual.json
+    - SciTeX style defaults pre-filled
+    - Auto-finds available port if default is in use
+    """
+
+    def __init__(
+        self,
+        json_path: Path,
+        metadata: Dict[str, Any],
+        csv_data: Optional[Any] = None,
+        png_path: Optional[Path] = None,
+        manual_overrides: Optional[Dict[str, Any]] = None,
+        port: int = 5050,
+    ):
+        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._requested_port = port
+        self.port = port
+
+        # Get SciTeX defaults and merge with metadata
+        from .._defaults import get_scitex_defaults, extract_defaults_from_metadata
+        self.scitex_defaults = get_scitex_defaults()
+        self.metadata_defaults = extract_defaults_from_metadata(metadata)
+
+        # Start with defaults, then overlay manual overrides
+        self.current_overrides = copy.deepcopy(self.scitex_defaults)
+        self.current_overrides.update(self.metadata_defaults)
+        self.current_overrides.update(self.manual_overrides)
+
+        # Track initial state to detect modifications
+        self._initial_overrides = copy.deepcopy(self.current_overrides)
+        self._user_modified = False
+
+    def run(self):
+        """Launch the web editor."""
+        try:
+            from flask import Flask, render_template_string, request, jsonify
+        except ImportError:
+            raise ImportError("Flask is required for web editor. Install: pip install flask")
+
+        # Handle port conflicts
+        if not check_port_available(self._requested_port):
+            print(f"Port {self._requested_port} is in use. Attempting to free it...")
+            if kill_process_on_port(self._requested_port):
+                import time
+                time.sleep(0.5)
+                self.port = self._requested_port
+                print(f"Successfully freed port {self.port}")
+            else:
+                self.port = find_available_port(self._requested_port + 1)
+                print(f"Using alternative port: {self.port}")
+        else:
+            self.port = self._requested_port
+
+        app = Flask(__name__)
+        editor = self
+        html_template = build_html_template()
+
+        @app.route('/')
+        def index():
+            return render_template_string(
+                html_template,
+                filename=str(editor.json_path.resolve()),
+                overrides=json.dumps(editor.current_overrides)
+            )
+
+        @app.route('/preview')
+        def preview():
+            """Generate figure preview as base64 PNG with element bboxes."""
+            img_data, bboxes, img_size = render_preview_with_bboxes(
+                editor.csv_data, editor.current_overrides
+            )
+            return jsonify({'image': img_data, 'bboxes': bboxes, 'img_size': img_size})
+
+        @app.route('/update', methods=['POST'])
+        def update():
+            """Update overrides and return new preview."""
+            data = request.json
+            editor.current_overrides.update(data.get('overrides', {}))
+            editor._user_modified = True
+            img_data, bboxes, img_size = render_preview_with_bboxes(
+                editor.csv_data, editor.current_overrides
+            )
+            return jsonify({
+                'image': img_data,
+                'bboxes': bboxes,
+                'img_size': img_size,
+                'status': 'updated'
+            })
+
+        @app.route('/save', methods=['POST'])
+        def save():
+            """Save to .manual.json."""
+            from .._edit import save_manual_overrides
+            try:
+                manual_path = save_manual_overrides(editor.json_path, editor.current_overrides)
+                return jsonify({'status': 'saved', 'path': str(manual_path)})
+            except Exception as e:
+                return jsonify({'status': 'error', 'message': str(e)}), 500
+
+        @app.route('/shutdown', methods=['POST'])
+        def shutdown():
+            """Shutdown the server."""
+            func = request.environ.get('werkzeug.server.shutdown')
+            if func is None:
+                raise RuntimeError('Not running with Werkzeug Server')
+            func()
+            return jsonify({'status': 'shutdown'})
+
+        # Open browser after short delay
+        def open_browser():
+            import time
+            time.sleep(0.5)
+            webbrowser.open(f'http://127.0.0.1:{self.port}')
+
+        threading.Thread(target=open_browser, daemon=True).start()
+
+        print(f"Starting SciTeX Editor at http://127.0.0.1:{self.port}")
+        print("Press Ctrl+C to stop")
+
+        app.run(host='127.0.0.1', port=self.port, debug=False, use_reloader=False)
+
+
+# EOF

scitex/vis/editor/flask_editor/plotter.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: ./src/scitex/vis/editor/flask_editor/plotter.py
+"""CSV plotting functionality for Flask editor."""
+
+from typing import Dict, Any, Optional
+import pandas as pd
+
+
+def plot_from_csv(ax, csv_data: Optional[pd.DataFrame], overrides: Dict[str, Any], linewidth: float = 1.0):
+    """Reconstruct plot from CSV data using trace info from overrides.
+
+    Args:
+        ax: Matplotlib axes object
+        csv_data: DataFrame containing CSV data
+        overrides: Dictionary with override settings including traces
+        linewidth: Default line width in points
+    """
+    if csv_data is None or not isinstance(csv_data, pd.DataFrame):
+        return
+
+    df = csv_data
+    o = overrides
+
+    # Get legend settings from overrides
+    legend_fontsize = o.get('legend_fontsize', 6)
+    legend_visible = o.get('legend_visible', True)
+    legend_frameon = o.get('legend_frameon', False)
+    legend_loc = o.get('legend_loc', 'best')
+    legend_x = o.get('legend_x', 0.5)
+    legend_y = o.get('legend_y', 0.5)
+
+    # Get traces from overrides (which may have been edited by user)
+    traces = o.get('traces', [])
+
+    if traces:
+        _plot_with_traces(ax, df, traces, linewidth, legend_fontsize, legend_visible,
+                         legend_frameon, legend_loc, legend_x, legend_y)
+    else:
+        _plot_fallback(ax, df, linewidth, legend_fontsize, legend_visible,
+                      legend_frameon, legend_loc, legend_x, legend_y)
+
+
+def _plot_with_traces(ax, df, traces, linewidth, legend_fontsize, legend_visible,
+                     legend_frameon, legend_loc, legend_x, legend_y):
+    """Plot using trace information from overrides."""
+    for trace in traces:
+        csv_cols = trace.get('csv_columns', {})
+        x_col = csv_cols.get('x')
+        y_col = csv_cols.get('y')
+
+        if x_col in df.columns and y_col in df.columns:
+            ax.plot(
+                df[x_col],
+                df[y_col],
+                label=trace.get('label', trace.get('id', '')),
+                color=trace.get('color'),
+                linestyle=trace.get('linestyle', '-'),
+                linewidth=trace.get('linewidth', linewidth),
+                marker=trace.get('marker', None),
+                markersize=trace.get('markersize', 6),
+            )
+
+    # Add legend if there are labeled traces
+    if legend_visible and any(t.get('label') for t in traces):
+        _add_legend(ax, legend_fontsize, legend_frameon, legend_loc, legend_x, legend_y)
+
+
+def _plot_fallback(ax, df, linewidth, legend_fontsize, legend_visible,
+                  legend_frameon, legend_loc, legend_x, legend_y):
+    """Fallback plotting when no trace info available - smart parsing of column names."""
+    cols = df.columns.tolist()
+
+    # Group columns by trace ID
+    trace_groups = {}
+    for col in cols:
+        if col.endswith('_x'):
+            trace_id = col[:-2]  # Remove '_x'
+            y_col = trace_id + '_y'
+            if y_col in cols:
+                # Extract label from column name (e.g., ax_00_sine_plot -> sine)
+                parts = trace_id.split('_')
+                label = parts[2] if len(parts) > 2 else trace_id
+                trace_groups[trace_id] = {
+                    'x_col': col,
+                    'y_col': y_col,
+                    'label': label,
+                }
+
+    if trace_groups:
+        for trace_id, info in trace_groups.items():
+            ax.plot(
+                df[info['x_col']],
+                df[info['y_col']],
+                label=info['label'],
+                linewidth=linewidth,
+            )
+        if legend_visible:
+            _add_legend(ax, legend_fontsize, legend_frameon, legend_loc, legend_x, legend_y)
+
+    elif len(cols) >= 2:
+        # Last resort: assume first column is x, rest are y
+        x_col = cols[0]
+        for y_col in cols[1:]:
+            try:
+                ax.plot(df[x_col], df[y_col], label=str(y_col), linewidth=linewidth)
+            except Exception:
+                pass
+        if len(cols) > 2 and legend_visible:
+            _add_legend(ax, legend_fontsize, legend_frameon, legend_loc, legend_x, legend_y)
+
+
+def _add_legend(ax, fontsize, frameon, loc, x, y):
+    """Add legend to axes with specified settings."""
+    if loc == 'custom':
+        ax.legend(
+            fontsize=fontsize,
+            frameon=frameon,
+            loc='upper left',
+            bbox_to_anchor=(x, y),
+        )
+    else:
+        ax.legend(
+            fontsize=fontsize,
+            frameon=frameon,
+            loc=loc,
+        )
+
+
+# EOF