scitex 2.10.2__py3-none-any.whl → 2.11.0__py3-none-any.whl

scitex/fig/editor/_defaults.py

@@ -1,300 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# File: ./src/scitex/vis/editor/_defaults.py
-"""Default style settings for SciTeX visual editor."""
-
-from scitex.plt.styles import get_default_dpi, get_preview_dpi
-
-
-def get_scitex_defaults():
-    """
-    Get default style values based on SciTeX publication standards.
-
-    Returns
-    -------
-    dict
-        Dictionary of default style settings
-    """
-    return {
-        # Font sizes (from _configure_mpl.py)
-        "fontsize": 7,  # Base font size for publication
-        "title_fontsize": 8,  # Title size
-        "axis_fontsize": 7,  # Axis label size
-        "tick_fontsize": 7,  # Tick label size
-        "legend_fontsize": 6,  # Legend font size
-        # Line settings (in points, 1mm = 2.83465pt)
-        "linewidth": 0.57,  # Default line width (0.2mm)
-        # Tick settings
-        "n_ticks": 4,  # Number of ticks
-        "tick_length": 0.8,  # Tick length in mm
-        "tick_width": 0.2,  # Tick width in mm
-        "tick_direction": "out",  # Tick direction
-        # Axes settings
-        "axis_width": 0.2,  # Spine/axes line width in mm
-        "hide_top_spine": True,  # Hide top spine
-        "hide_right_spine": True,  # Hide right spine
-        # Grid settings
-        "grid": False,  # Grid off by default
-        "grid_linewidth": 0.6,
-        "grid_alpha": 0.3,
-        # Figure settings
-        "dpi": get_default_dpi(),  # From SCITEX_STYLE.yaml
-        "fig_size": [3.15, 2.68],  # Default figure size in inches
-        # Colors (SciTeX defaults)
-        "facecolor": "#ffffff",  # White background
-        "transparent": True,  # Transparent background
-        # Legend
-        "legend_visible": True,
-        "legend_frameon": False,
-        "legend_loc": "best",
-        # Font family
-        "font_family": "Arial",  # Sans-serif for publication
-        # Annotations
-        "annotations": [],
-    }
-
-
-def get_scitex_colors():
-    """
-    Get SciTeX color palette.
-
-    Returns
-    -------
-    dict
-        Dictionary of named colors with hex values
-    """
-    # Based on scitex.plt.color.PARAMS
-    return {
-        "blue": "#1f77b4",
-        "orange": "#ff7f0e",
-        "green": "#2ca02c",
-        "red": "#d62728",
-        "purple": "#9467bd",
-        "brown": "#8c564b",
-        "pink": "#e377c2",
-        "gray": "#7f7f7f",
-        "olive": "#bcbd22",
-        "cyan": "#17becf",
-        # Additional publication colors
-        "black": "#000000",
-        "white": "#ffffff",
-        "dark_gray": "#404040",
-        "light_gray": "#d0d0d0",
-    }
-
-
-def extract_defaults_from_metadata(metadata):
-    """
-    Extract style defaults from loaded figure metadata.
-
-    Parameters
-    ----------
-    metadata : dict
-        Figure metadata loaded from JSON
-
-    Returns
-    -------
-    dict
-        Dictionary of style values extracted from metadata
-    """
-    defaults = get_scitex_defaults()
-
-    if not metadata:
-        return defaults
-
-    # Extract from scitex section (new format)
-    scitex_meta = metadata.get("scitex", {})
-    style_mm = scitex_meta.get("style_mm", {})
-
-    # Font sizes from style_mm
-    if "axis_font_size_pt" in style_mm:
-        defaults["axis_fontsize"] = style_mm["axis_font_size_pt"]
-    if "tick_font_size_pt" in style_mm:
-        defaults["tick_fontsize"] = style_mm["tick_font_size_pt"]
-    if "title_font_size_pt" in style_mm:
-        defaults["title_fontsize"] = style_mm["title_font_size_pt"]
-    if "legend_font_size_pt" in style_mm:
-        defaults["legend_fontsize"] = style_mm["legend_font_size_pt"]
-
-    # Line/axis thickness from metadata (in mm)
-    if "trace_thickness_mm" in style_mm:
-        defaults["linewidth"] = style_mm["trace_thickness_mm"] * 2.83465  # mm to pt
-    if "axis_thickness_mm" in style_mm:
-        defaults["axis_width"] = style_mm["axis_thickness_mm"]
-    if "tick_length_mm" in style_mm:
-        defaults["tick_length"] = style_mm["tick_length_mm"]
-    if "tick_thickness_mm" in style_mm:
-        defaults["tick_width"] = style_mm["tick_thickness_mm"]
-    if "n_ticks" in style_mm:
-        defaults["n_ticks"] = style_mm["n_ticks"]
-
-    # Dimensions from metadata (support both old and new formats)
-    dimensions = metadata.get("dimensions", {})
-    if "dpi" in dimensions:
-        defaults["dpi"] = dimensions["dpi"]
-    if "figure_size_inch" in dimensions:
-        defaults["fig_size"] = dimensions["figure_size_inch"]
-
-    # New format: size.width_mm, size.height_mm, size.dpi
-    size = metadata.get("size", {})
-    if "dpi" in size:
-        defaults["dpi"] = size["dpi"]
-    if "width_mm" in size and "height_mm" in size:
-        # Convert mm to inches
-        width_inch = size["width_mm"] / 25.4
-        height_inch = size["height_mm"] / 25.4
-        defaults["fig_size"] = [width_inch, height_inch]
-
-    # Axis labels from metadata
-    if "xlabel" in metadata:
-        defaults["xlabel"] = metadata["xlabel"]
-    if "ylabel" in metadata:
-        defaults["ylabel"] = metadata["ylabel"]
-    if "title" in metadata:
-        defaults["title"] = metadata["title"]
-
-    # Try to extract from axes if present
-    axes = metadata.get("axes", {})
-    if isinstance(axes, dict):
-        # New format: {'x': {'label': ...}, 'y': {'label': ...}}
-        x_axis = axes.get("x", {})
-        y_axis = axes.get("y", {})
-        if "label" in x_axis:
-            unit = x_axis.get("unit", "")
-            label = x_axis["label"]
-            if unit:
-                defaults["xlabel"] = f"{label} [{unit}]"
-            else:
-                defaults["xlabel"] = label
-        if "label" in y_axis:
-            unit = y_axis.get("unit", "")
-            label = y_axis["label"]
-            if unit:
-                defaults["ylabel"] = f"{label} [{unit}]"
-            else:
-                defaults["ylabel"] = label
-        # Extract axis limits
-        if "lim" in x_axis:
-            defaults["xlim"] = x_axis["lim"]
-        if "lim" in y_axis:
-            defaults["ylim"] = y_axis["lim"]
-    elif isinstance(axes, list) and len(axes) > 0:
-        # Legacy format: list of axes
-        ax = axes[0]
-        if "xlabel" in ax:
-            defaults["xlabel"] = ax["xlabel"]
-        if "ylabel" in ax:
-            defaults["ylabel"] = ax["ylabel"]
-        if "title" in ax:
-            defaults["title"] = ax["title"]
-        if "grid" in ax:
-            defaults["grid"] = ax["grid"]
-        # Extract axis limits from list format
-        if "xlim" in ax:
-            defaults["xlim"] = ax["xlim"]
-        if "ylim" in ax:
-            defaults["ylim"] = ax["ylim"]
-
-    # Extract traces information - check multiple possible locations
-    traces = metadata.get("traces", [])
-
-    # Also check axes[].lines (pltz bundle format)
-    if not traces and isinstance(axes, list) and len(axes) > 0:
-        ax = axes[0]
-        lines = ax.get("lines", [])
-        if lines:
-            traces = lines
-
-    # Also check hit_regions.color_map for trace info
-    if not traces:
-        hit_regions = metadata.get("hit_regions", {})
-        color_map = hit_regions.get("color_map", {})
-        if color_map:
-            traces = []
-            for trace_id, trace_info in color_map.items():
-                traces.append({
-                    "id": trace_id,
-                    "label": trace_info.get("label", f"Trace {trace_id}"),
-                    "type": trace_info.get("type", "line"),
-                })
-
-    if traces:
-        defaults["traces"] = traces
-
-    # Extract legend information from multiple possible locations
-    legend = metadata.get("legend", {})
-
-    # Also check selectable_regions.axes[0].legend (pltz bundle format)
-    if not legend:
-        selectable = metadata.get("selectable_regions", {})
-        sel_axes = selectable.get("axes", [])
-        if sel_axes and len(sel_axes) > 0:
-            legend = sel_axes[0].get("legend", {})
-
-    if legend:
-        defaults["legend_visible"] = legend.get("visible", True)
-        defaults["legend_frameon"] = legend.get("frameon", False)
-        # Support both old format (loc) and new format (location)
-        loc = legend.get("location") or legend.get("loc", "best")
-        # Convert numeric legend loc to string (matplotlib accepts both but GUI needs string)
-        defaults["legend_loc"] = _normalize_legend_loc(loc)
-        # Extract fontsize if present
-        if "fontsize" in legend:
-            defaults["legend_fontsize"] = legend["fontsize"]
-        # Extract ncols if present
-        if "ncols" in legend:
-            defaults["legend_ncols"] = legend["ncols"]
-        # Extract title if present
-        if "title" in legend:
-            defaults["legend_title"] = legend["title"]
-
-        # Extract legend entries if present
-        entries = legend.get("entries", [])
-        if entries and not traces:
-            # Use legend entries as trace labels
-            defaults["traces"] = [
-                {"label": e.get("text", f"Trace {i}")}
-                for i, e in enumerate(entries)
-            ]
-
-    return defaults
-
-
-def _normalize_legend_loc(loc):
-    """Convert legend location to string format for GUI compatibility.
-
-    Matplotlib accepts both numeric codes and string locations for legends.
-    This function ensures consistency by converting numeric codes to strings.
-
-    Parameters
-    ----------
-    loc : int or str
-        Legend location (numeric or string)
-
-    Returns
-    -------
-    str
-        String representation of legend location
-    """
-    if isinstance(loc, str):
-        return loc
-
-    # Numeric to string mapping (matplotlib legend location codes)
-    loc_map = {
-        0: "best",
-        1: "upper right",
-        2: "upper left",
-        3: "lower left",
-        4: "lower right",
-        5: "right",
-        6: "center left",
-        7: "center right",
-        8: "lower center",
-        9: "upper center",
-        10: "center",
-    }
-
-    return loc_map.get(loc, "best")
-
-
-# EOF

scitex/fig/editor/edit/panel_loader.py

@@ -1,232 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-12-14 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/fig/editor/edit/panel_loader.py
-
-"""Panel data loading for figure editor."""
-
-import io
-import json as json_module
-from pathlib import Path
-from typing import Optional, Union, Dict, Any
-
-__all__ = ["load_panel_data"]
-
-
-def load_panel_data(panel_path: Union[Path, str], is_zip: bool = None) -> Optional[Dict[str, Any]]:
-    """
-    Load panel data from either a .pltz.d directory or a .pltz zip file.
-
-    Handles both formats transparently using in-memory reading for zips.
-
-    Parameters
-    ----------
-    panel_path : Path or str
-        Path to .pltz.d directory or .pltz zip file
-    is_zip : bool, optional
-        If True, treat as zip file. If False, treat as directory.
-        If None, auto-detect based on path suffix and existence.
-
-    Returns
-    -------
-    dict or None
-        Dictionary with keys: metadata, csv_data, png_bytes, hitmap_bytes, img_size
-        For directories, also includes: json_path, png_path, hitmap_path
-        Returns None if panel cannot be loaded
-    """
-    from PIL import Image
-
-    panel_path = Path(panel_path)
-
-    # Auto-detect if not specified
-    if is_zip is None:
-        spath = str(panel_path)
-        if spath.endswith('.pltz') and not spath.endswith('.pltz.d'):
-            is_zip = panel_path.is_file()
-        else:
-            is_zip = False
-
-    if is_zip:
-        return _load_from_zip(panel_path)
-    else:
-        return _load_from_directory(panel_path)
-
-
-def _load_from_zip(panel_path: Path) -> Optional[Dict[str, Any]]:
-    """Load panel data from a .pltz zip file."""
-    from PIL import Image
-    from scitex.io.bundle import ZipBundle
-
-    if not panel_path.exists():
-        return None
-
-    try:
-        with ZipBundle(panel_path, mode="r") as zb:
-            # Load spec.json for metadata
-            try:
-                metadata = zb.read_json("spec.json")
-            except FileNotFoundError:
-                metadata = {}
-
-            # Load style.json if exists
-            try:
-                style = zb.read_json("style.json")
-                metadata["style"] = style
-            except FileNotFoundError:
-                pass
-
-            # Find and read PNG
-            png_bytes = None
-            for name in zb.namelist():
-                if name.endswith('.png') and '_hitmap' not in name and '_overview' not in name:
-                    if 'exports/' in name:
-                        png_bytes = zb.read_bytes(name)
-                        break
-
-            # If no PNG in exports/, try root level
-            if not png_bytes:
-                for name in zb.namelist():
-                    if name.endswith('.png') and '_hitmap' not in name and '_overview' not in name:
-                        png_bytes = zb.read_bytes(name)
-                        break
-
-            # Get image size
-            img_size = None
-            if png_bytes:
-                img = Image.open(io.BytesIO(png_bytes))
-                img_size = {"width": img.size[0], "height": img.size[1]}
-                img.close()
-
-            # Find and read hitmap
-            hitmap_bytes = None
-            for name in zb.namelist():
-                if '_hitmap.png' in name:
-                    hitmap_bytes = zb.read_bytes(name)
-                    break
-
-            # Load geometry_px.json if available
-            geometry_data = None
-            try:
-                geometry_data = zb.read_json("cache/geometry_px.json")
-            except FileNotFoundError:
-                pass
-
-            return {
-                "metadata": metadata,
-                "png_bytes": png_bytes,
-                "hitmap_bytes": hitmap_bytes,
-                "img_size": img_size,
-                "geometry_data": geometry_data,
-                "is_zip": True,
-            }
-    except Exception as e:
-        print(f"Error loading panel zip {panel_path}: {e}")
-        return None
-
-
-def _load_from_directory(panel_path: Path) -> Optional[Dict[str, Any]]:
-    """Load panel data from a .pltz.d directory."""
-    import scitex as stx
-
-    panel_dir = panel_path
-    if not panel_dir.exists():
-        return None
-
-    # Check for layered vs legacy format
-    spec_path = panel_dir / "spec.json"
-    if spec_path.exists():
-        return _load_layered_directory(panel_dir)
-    else:
-        return _load_legacy_directory(panel_dir)
-
-
-def _load_layered_directory(panel_dir: Path) -> Dict[str, Any]:
-    """Load panel data from layered format directory."""
-    import scitex as stx
-    from scitex.plt.io import load_layered_pltz_bundle
-
-    bundle_data = load_layered_pltz_bundle(panel_dir)
-    metadata = bundle_data.get("merged", {})
-
-    # Find CSV
-    csv_data = None
-    for f in panel_dir.glob("*.csv"):
-        csv_data = stx.io.load(f)
-        break
-
-    # Find exports - prefer PNG over SVG (PIL can't open SVG)
-    png_path = None
-    svg_path = None
-    hitmap_path = None
-    exports_dir = panel_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('.png') and '_hitmap' not in name and '_overview' not in name:
-                png_path = f
-            elif name.endswith('.svg') and '_hitmap' not in name and svg_path is None:
-                svg_path = f
-
-    if png_path is None:
-        png_path = svg_path
-
-    # Load geometry_px.json if available
-    geometry_data = None
-    geometry_path = panel_dir / "cache" / "geometry_px.json"
-    if geometry_path.exists():
-        with open(geometry_path) as f:
-            geometry_data = json_module.load(f)
-
-    return {
-        "json_path": panel_dir / "spec.json",
-        "metadata": metadata,
-        "csv_data": csv_data,
-        "png_path": png_path,
-        "hitmap_path": hitmap_path,
-        "geometry_data": geometry_data,
-        "is_zip": False,
-    }
-
-
-def _load_legacy_directory(panel_dir: Path) -> Optional[Dict[str, Any]]:
-    """Load panel data from legacy format directory."""
-    import scitex as stx
-
-    json_path = None
-    csv_data = None
-    png_path = None
-    hitmap_path = None
-
-    for f in panel_dir.iterdir():
-        name = f.name
-        if name.endswith('.json') and not name.endswith('.manual.json'):
-            json_path = f
-        elif name.endswith('.csv'):
-            csv_data = stx.io.load(f)
-        elif 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 '_overview' not in name:
-            if png_path is None:
-                png_path = f
-
-    if json_path is None:
-        return None
-
-    with open(json_path, 'r') as f:
-        metadata = json_module.load(f)
-
-    return {
-        "json_path": json_path,
-        "metadata": metadata,
-        "csv_data": csv_data,
-        "png_path": png_path,
-        "hitmap_path": hitmap_path,
-        "is_zip": False,
-    }
-
-
-# EOF