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

scitex/vis/editor/flask_editor/bbox.py

@@ -1,216 +0,0 @@
-#!/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/plotter.py

@@ -1,130 +0,0 @@
-#!/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

scitex/vis/editor/flask_editor/renderer.py

@@ -1,184 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# File: ./src/scitex/vis/editor/flask_editor/renderer.py
-"""Figure rendering for Flask editor."""
-
-from typing import Dict, Any, Tuple
-import base64
-import io
-
-import matplotlib
-matplotlib.use('Agg')
-import matplotlib.pyplot as plt
-from matplotlib.ticker import MaxNLocator
-from PIL import Image
-
-from .plotter import plot_from_csv
-from .bbox import extract_bboxes
-
-# mm to pt conversion factor
-MM_TO_PT = 2.83465
-
-
-def render_preview_with_bboxes(csv_data, overrides: Dict[str, Any], axis_fontsize: int = 7
-                               ) -> Tuple[str, Dict[str, Any], Dict[str, int]]:
-    """Render figure and return base64 PNG along with element bounding boxes.
-
-    Args:
-        csv_data: DataFrame containing CSV data
-        overrides: Dictionary with override settings
-        axis_fontsize: Default font size for axis labels
-
-    Returns:
-        tuple: (base64_image_data, bboxes_dict, image_size)
-    """
-    o = overrides
-
-    # Dimensions
-    dpi = o.get('dpi', 300)
-    fig_size = o.get('fig_size', [3.15, 2.68])
-
-    # Font sizes
-    axis_fontsize = o.get('axis_fontsize', 7)
-    tick_fontsize = o.get('tick_fontsize', 7)
-    title_fontsize = o.get('title_fontsize', 8)
-
-    # Line/axis thickness
-    linewidth_pt = o.get('linewidth', 0.57)
-    axis_width_pt = o.get('axis_width', 0.2) * MM_TO_PT
-    tick_length_pt = o.get('tick_length', 0.8) * MM_TO_PT
-    tick_width_pt = o.get('tick_width', 0.2) * MM_TO_PT
-    tick_direction = o.get('tick_direction', 'out')
-    x_n_ticks = o.get('x_n_ticks', o.get('n_ticks', 4))
-    y_n_ticks = o.get('y_n_ticks', o.get('n_ticks', 4))
-    hide_x_ticks = o.get('hide_x_ticks', False)
-    hide_y_ticks = o.get('hide_y_ticks', False)
-
-    transparent = o.get('transparent', True)
-
-    # Create figure
-    fig, ax = plt.subplots(figsize=fig_size, dpi=dpi)
-    _apply_background(fig, ax, o, transparent)
-
-    # Plot from CSV data
-    if csv_data is not None:
-        plot_from_csv(ax, csv_data, overrides, linewidth=linewidth_pt)
-    else:
-        ax.text(0.5, 0.5, "No plot data available\n(CSV not found)",
-               ha='center', va='center', transform=ax.transAxes,
-               fontsize=axis_fontsize)
-
-    # Apply labels
-    _apply_labels(ax, o, title_fontsize, axis_fontsize)
-
-    # Tick styling
-    _apply_tick_styling(ax, tick_fontsize, tick_length_pt, tick_width_pt, tick_direction,
-                        x_n_ticks, y_n_ticks, hide_x_ticks, hide_y_ticks)
-
-    # Apply grid, limits, spines
-    _apply_style(ax, o, axis_width_pt)
-
-    # Apply annotations
-    _apply_annotations(ax, o, axis_fontsize)
-
-    fig.tight_layout()
-
-    # Get element bounding boxes BEFORE saving (need renderer)
-    fig.canvas.draw()
-    renderer = fig.canvas.get_renderer()
-
-    # Save to buffer first to get actual image size
-    buf = io.BytesIO()
-    fig.savefig(buf, format='png', dpi=dpi, bbox_inches='tight', transparent=transparent)
-    buf.seek(0)
-
-    # Get actual saved image dimensions
-    img = Image.open(buf)
-    img_width, img_height = img.size
-    buf.seek(0)
-
-    # Get bboxes
-    bboxes = extract_bboxes(fig, ax, renderer, img_width, img_height)
-
-    img_data = base64.b64encode(buf.read()).decode('utf-8')
-    plt.close(fig)
-
-    return img_data, bboxes, {'width': img_width, 'height': img_height}
-
-
-def _apply_background(fig, ax, o, transparent):
-    """Apply background settings to figure."""
-    if transparent:
-        fig.patch.set_facecolor('none')
-        ax.patch.set_facecolor('none')
-    elif o.get('facecolor'):
-        fig.patch.set_facecolor(o['facecolor'])
-        ax.patch.set_facecolor(o['facecolor'])
-
-
-def _apply_labels(ax, o, title_fontsize, axis_fontsize):
-    """Apply title and axis labels."""
-    if o.get('title'):
-        ax.set_title(o['title'], fontsize=title_fontsize)
-    if o.get('xlabel'):
-        ax.set_xlabel(o['xlabel'], fontsize=axis_fontsize)
-    if o.get('ylabel'):
-        ax.set_ylabel(o['ylabel'], fontsize=axis_fontsize)
-
-
-def _apply_tick_styling(ax, tick_fontsize, tick_length_pt, tick_width_pt, tick_direction,
-                        x_n_ticks, y_n_ticks, hide_x_ticks, hide_y_ticks):
-    """Apply tick styling to axes."""
-    ax.tick_params(
-        axis='both',
-        labelsize=tick_fontsize,
-        length=tick_length_pt,
-        width=tick_width_pt,
-        direction=tick_direction,
-    )
-
-    if hide_x_ticks:
-        ax.xaxis.set_ticks([])
-        ax.xaxis.set_ticklabels([])
-    else:
-        ax.xaxis.set_major_locator(MaxNLocator(nbins=x_n_ticks))
-    if hide_y_ticks:
-        ax.yaxis.set_ticks([])
-        ax.yaxis.set_ticklabels([])
-    else:
-        ax.yaxis.set_major_locator(MaxNLocator(nbins=y_n_ticks))
-
-
-def _apply_style(ax, o, axis_width_pt):
-    """Apply grid, axis limits, and spine settings."""
-    if o.get('grid'):
-        ax.grid(True, linewidth=axis_width_pt, alpha=0.3)
-
-    if o.get('xlim'):
-        ax.set_xlim(o['xlim'])
-    if o.get('ylim'):
-        ax.set_ylim(o['ylim'])
-
-    if o.get('hide_top_spine', True):
-        ax.spines['top'].set_visible(False)
-    if o.get('hide_right_spine', True):
-        ax.spines['right'].set_visible(False)
-
-    for spine in ax.spines.values():
-        spine.set_linewidth(axis_width_pt)
-
-
-def _apply_annotations(ax, o, axis_fontsize):
-    """Apply text annotations to figure."""
-    for annot in o.get('annotations', []):
-        if annot.get('type') == 'text':
-            ax.text(
-                annot.get('x', 0.5),
-                annot.get('y', 0.5),
-                annot.get('text', ''),
-                transform=ax.transAxes,
-                fontsize=annot.get('fontsize', axis_fontsize),
-            )
-
-
-# EOF