scitex 2.14.0__py3-none-any.whl → 2.15.3__py3-none-any.whl

scitex/canvas/editor/flask_editor/_core/_routes_export.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/flask_editor/_core/_routes_export.py
+
+"""Export and download Flask routes for the editor."""
+
+import io
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .._core import WebEditor
+
+__all__ = [
+    "create_export_route",
+    "create_download_route",
+    "create_download_figz_route",
+]
+
+
+def create_export_route(app, editor: "WebEditor"):
+    """Create the export route."""
+    from flask import jsonify, request
+
+    @app.route("/export", methods=["POST"])
+    def export_figure():
+        try:
+            data = request.get_json()
+            formats = data.get("formats", ["png", "svg"])
+
+            if not editor.panel_info:
+                return jsonify({"success": False, "error": "No panel info available"})
+
+            bundle_path = editor.panel_info.get("bundle_path")
+            if not bundle_path:
+                return jsonify({"success": False, "error": "Bundle path not available"})
+
+            import matplotlib
+
+            matplotlib.use("Agg")
+            import matplotlib.pyplot as plt
+
+            from scitex.io import ZipBundle
+
+            figure_name = Path(bundle_path).stem
+            dpi = data.get("dpi", 150)
+
+            with ZipBundle(bundle_path, mode="a") as bundle:
+                try:
+                    spec = bundle.read_json("spec.json")
+                except:
+                    spec = {}
+
+                fig_width_mm, fig_height_mm = _get_figure_dimensions(spec)
+                fig_width_in = fig_width_mm / 25.4
+                fig_height_in = fig_height_mm / 25.4
+
+                fig = plt.figure(
+                    figsize=(fig_width_in, fig_height_in),
+                    dpi=dpi,
+                    facecolor="white",
+                )
+
+                _compose_panels_from_spec(
+                    fig, spec, bundle, fig_width_mm, fig_height_mm
+                )
+
+                exported = {}
+                for fmt in formats:
+                    buf = io.BytesIO()
+                    if fmt in ["png", "jpeg", "jpg"]:
+                        fig.savefig(
+                            buf,
+                            format="png" if fmt == "png" else "jpeg",
+                            dpi=dpi,
+                            bbox_inches="tight",
+                            facecolor="white",
+                            pad_inches=0.02,
+                        )
+                    elif fmt == "svg":
+                        fig.savefig(
+                            buf, format="svg", bbox_inches="tight", pad_inches=0.02
+                        )
+                    elif fmt == "pdf":
+                        fig.savefig(
+                            buf, format="pdf", bbox_inches="tight", pad_inches=0.02
+                        )
+                    else:
+                        continue
+
+                    buf.seek(0)
+                    export_path = f"exports/{figure_name}.{fmt}"
+                    bundle.write_bytes(export_path, buf.read())
+                    exported[fmt] = export_path
+
+                plt.close(fig)
+
+            return jsonify(
+                {
+                    "success": True,
+                    "exported": exported,
+                    "bundle_path": str(bundle_path),
+                }
+            )
+
+        except Exception as e:
+            import traceback
+
+            return jsonify(
+                {
+                    "success": False,
+                    "error": str(e),
+                    "traceback": traceback.format_exc(),
+                }
+            )
+
+    return export_figure
+
+
+def create_download_route(app, editor: "WebEditor"):
+    """Create the download route."""
+    from flask import send_file
+
+    @app.route("/download/<fmt>")
+    def download_figure(fmt):
+        try:
+            mime_types = {
+                "png": "image/png",
+                "jpeg": "image/jpeg",
+                "jpg": "image/jpeg",
+                "svg": "image/svg+xml",
+                "pdf": "application/pdf",
+            }
+
+            if fmt not in mime_types:
+                return f"Unsupported format: {fmt}", 400
+
+            # For figure bundles, download the composed figure
+            if editor.panel_info:
+                from ._export_helpers import compose_panels_to_figure
+
+                bundle_path = editor.panel_info.get("bundle_path")
+                figure_dir = editor.panel_info.get("figure_dir")
+                figure_name = (
+                    Path(bundle_path).stem
+                    if bundle_path
+                    else (
+                        Path(figure_dir).stem.replace(".figure", "")
+                        if figure_dir
+                        else "figure"
+                    )
+                )
+
+                if bundle_path or figure_dir:
+                    dpi = 150 if fmt in ["jpeg", "jpg"] else 300
+                    buf = compose_panels_to_figure(editor, fmt=fmt, dpi=dpi)
+                    return send_file(
+                        buf,
+                        mimetype=mime_types[fmt],
+                        as_attachment=True,
+                        download_name=f"{figure_name}.{fmt}",
+                    )
+
+            # For single pltz files, render from csv_data
+            import matplotlib
+
+            matplotlib.use("Agg")
+            import matplotlib.pyplot as plt
+
+            from .._renderer import render_preview_with_bboxes
+
+            figure_name = "figure"
+            if editor.json_path:
+                figure_name = Path(editor.json_path).stem
+
+            img_data, _, _ = render_preview_with_bboxes(
+                editor.csv_data,
+                editor.current_overrides,
+                metadata=editor.metadata,
+                dark_mode=False,
+            )
+
+            if fmt == "png":
+                import base64
+
+                content = base64.b64decode(img_data)
+                buf = io.BytesIO(content)
+                return send_file(
+                    buf,
+                    mimetype=mime_types[fmt],
+                    as_attachment=True,
+                    download_name=f"{figure_name}.{fmt}",
+                )
+
+            # For other formats, re-render
+            from .._plotter import plot_from_csv
+
+            fig, ax = plt.subplots(figsize=(8, 6))
+            plot_from_csv(ax, editor.csv_data, editor.current_overrides)
+
+            buf = io.BytesIO()
+            dpi = 150 if fmt in ["jpeg", "jpg"] else 300
+            fig.savefig(
+                buf,
+                format=fmt if fmt != "jpg" else "jpeg",
+                dpi=dpi,
+                bbox_inches="tight",
+                facecolor="white" if fmt in ["jpeg", "jpg"] else None,
+            )
+            plt.close(fig)
+            buf.seek(0)
+
+            return send_file(
+                buf,
+                mimetype=mime_types[fmt],
+                as_attachment=True,
+                download_name=f"{figure_name}.{fmt}",
+            )
+
+        except Exception as e:
+            import traceback
+
+            return f"Error: {str(e)}\n{traceback.format_exc()}", 500
+
+    return download_figure
+
+
+def create_download_figz_route(app, editor: "WebEditor"):
+    """Create the download_figz route."""
+    from flask import send_file
+
+    @app.route("/download_figz")
+    def download_figz():
+        try:
+            if not editor.panel_info:
+                return "No panel info available", 404
+
+            bundle_path = editor.panel_info.get("bundle_path")
+            if not bundle_path:
+                return "Bundle path not available", 404
+
+            return send_file(
+                bundle_path,
+                mimetype="application/zip",
+                as_attachment=True,
+                download_name=Path(bundle_path).name,
+            )
+
+        except Exception as e:
+            return str(e), 500
+
+    return download_figz
+
+
+def _get_figure_dimensions(spec):
+    """Extract figure dimensions from spec."""
+    fig_width_mm = 180
+    fig_height_mm = 120
+
+    if "figure" in spec:
+        fig_info = spec.get("figure", {})
+        styles = fig_info.get("styles", {})
+        size = styles.get("size", {})
+        fig_width_mm = size.get("width_mm", 180)
+        fig_height_mm = size.get("height_mm", 120)
+
+    return fig_width_mm, fig_height_mm
+
+
+def _compose_panels_from_spec(fig, spec, bundle, fig_width_mm, fig_height_mm):
+    """Compose panels onto figure from spec (used in export route)."""
+    import tempfile
+
+    import numpy as np
+    from PIL import Image
+
+    from scitex.io import ZipBundle
+
+    panels_spec = spec.get("panels", [])
+
+    for panel_spec in panels_spec:
+        panel_id = panel_spec.get("id", "")
+        plot_name = panel_spec.get("plot", "")
+        pos = panel_spec.get("position", {})
+        size = panel_spec.get("size", {})
+
+        x_mm = pos.get("x_mm", 0)
+        y_mm = pos.get("y_mm", 0)
+        w_mm = size.get("width_mm", 60)
+        h_mm = size.get("height_mm", 40)
+
+        x_frac = x_mm / fig_width_mm
+        y_frac = 1 - (y_mm + h_mm) / fig_height_mm
+        w_frac = w_mm / fig_width_mm
+        h_frac = h_mm / fig_height_mm
+
+        img_loaded = False
+        for plot_path in [f"{panel_id}.plot", plot_name.replace(".d", "")]:
+            if img_loaded:
+                break
+            try:
+                plot_bytes = bundle.read_bytes(plot_path)
+                with tempfile.NamedTemporaryFile(suffix=".plot", delete=False) as tmp:
+                    tmp.write(plot_bytes)
+                    tmp_path = tmp.name
+                try:
+                    with ZipBundle(tmp_path, mode="r") as plot_bundle:
+                        for preview_path in [
+                            "exports/preview.png",
+                            "preview.png",
+                            f"exports/{panel_id}.png",
+                        ]:
+                            try:
+                                img_data = plot_bundle.read_bytes(preview_path)
+                                img = Image.open(io.BytesIO(img_data))
+                                ax = fig.add_axes([x_frac, y_frac, w_frac, h_frac])
+                                ax.imshow(np.array(img))
+                                ax.axis("off")
+                                img_loaded = True
+                                break
+                            except:
+                                continue
+                finally:
+                    import os
+
+                    os.unlink(tmp_path)
+            except Exception as e:
+                print(f"Could not load plot {plot_path}: {e}")
+                continue
+
+
+# EOF

scitex/canvas/editor/flask_editor/_core/_routes_panels.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-24 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/canvas/editor/flask_editor/_core/_routes_panels.py
+
+"""Panel-related Flask routes for the editor."""
+
+import base64
+import copy
+import json as json_module
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .._core import WebEditor
+
+__all__ = [
+    "create_panels_route",
+    "create_switch_panel_route",
+]
+
+
+def create_panels_route(app, editor: "WebEditor"):
+    """Create the panels route for multi-panel figure bundles."""
+    from flask import jsonify
+
+    from .._bbox import (
+        extract_bboxes_from_geometry_px,
+        extract_bboxes_from_metadata,
+    )
+    from ..edit import load_panel_data
+
+    @app.route("/panels")
+    def panels():
+        if not editor.panel_info:
+            return jsonify({"error": "Not a multi-panel figure bundle"}), 400
+
+        panel_names = editor.panel_info["panels"]
+        panel_paths = editor.panel_info.get("panel_paths", [])
+        panel_is_zip = editor.panel_info.get("panel_is_zip", [False] * len(panel_names))
+        figure_dir = Path(editor.panel_info["figure_dir"])
+
+        if not panel_paths:
+            panel_paths = [str(figure_dir / name) for name in panel_names]
+
+        # Load figz spec.json for panel layout
+        figure_layout = {}
+        spec_path = figure_dir / "spec.json"
+        if spec_path.exists():
+            with open(spec_path) as f:
+                figure_spec = json_module.load(f)
+                for panel_spec in figure_spec.get("panels", []):
+                    panel_id = panel_spec.get("id", "")
+                    figure_layout[panel_id] = {
+                        "position": panel_spec.get("position", {}),
+                        "size": panel_spec.get("size", {}),
+                    }
+
+        panel_images = []
+
+        for idx, panel_name in enumerate(panel_names):
+            panel_path = panel_paths[idx]
+            is_zip = panel_is_zip[idx] if idx < len(panel_is_zip) else None
+            display_name = panel_name.replace(".plot", "").replace(".plot", "")
+
+            loaded = load_panel_data(panel_path, is_zip=is_zip)
+
+            panel_data = {
+                "name": display_name,
+                "image": None,
+                "bboxes": None,
+                "img_size": None,
+            }
+
+            if display_name in figure_layout:
+                panel_data["layout"] = figure_layout[display_name]
+
+            if loaded:
+                # Get image data
+                if loaded.get("is_zip"):
+                    png_bytes = loaded.get("png_bytes")
+                    if png_bytes:
+                        panel_data["image"] = base64.b64encode(png_bytes).decode(
+                            "utf-8"
+                        )
+                else:
+                    png_path = loaded.get("png_path")
+                    if png_path and png_path.exists():
+                        with open(png_path, "rb") as f:
+                            panel_data["image"] = base64.b64encode(f.read()).decode(
+                                "utf-8"
+                            )
+
+                # Get image size
+                img_size = loaded.get("img_size")
+                if img_size:
+                    panel_data["img_size"] = img_size
+                    panel_data["width"] = img_size["width"]
+                    panel_data["height"] = img_size["height"]
+                elif loaded.get("png_path"):
+                    from PIL import Image
+
+                    img = Image.open(loaded["png_path"])
+                    panel_data["img_size"] = {
+                        "width": img.size[0],
+                        "height": img.size[1],
+                    }
+                    panel_data["width"], panel_data["height"] = img.size
+                    img.close()
+
+                # Extract bboxes
+                if panel_data.get("img_size"):
+                    geometry_data = loaded.get("geometry_data")
+                    metadata = loaded.get("metadata", {})
+
+                    if geometry_data:
+                        panel_data["bboxes"] = extract_bboxes_from_geometry_px(
+                            geometry_data,
+                            panel_data["img_size"]["width"],
+                            panel_data["img_size"]["height"],
+                        )
+                    elif metadata:
+                        panel_data["bboxes"] = extract_bboxes_from_metadata(
+                            metadata,
+                            panel_data["img_size"]["width"],
+                            panel_data["img_size"]["height"],
+                        )
+
+            panel_images.append(panel_data)
+
+        return jsonify(
+            {
+                "panels": panel_images,
+                "count": len(panel_images),
+                "layout": figure_layout,
+            }
+        )
+
+    return panels
+
+
+def create_switch_panel_route(app, editor: "WebEditor"):
+    """Create the switch_panel route."""
+    from flask import jsonify
+
+    from .._bbox import (
+        extract_bboxes_from_geometry_px,
+        extract_bboxes_from_metadata,
+    )
+    from ..edit import load_panel_data
+
+    @app.route("/switch_panel/<int:panel_index>")
+    def switch_panel(panel_index):
+        if not editor.panel_info:
+            return jsonify({"error": "Not a multi-panel figure bundle"}), 400
+
+        panels = editor.panel_info["panels"]
+        panel_paths = editor.panel_info.get("panel_paths", [])
+        panel_is_zip = editor.panel_info.get("panel_is_zip", [False] * len(panels))
+
+        if panel_index < 0 or panel_index >= len(panels):
+            return jsonify({"error": f"Invalid panel index: {panel_index}"}), 400
+
+        panel_name = panels[panel_index]
+        panel_path = (
+            panel_paths[panel_index]
+            if panel_paths
+            else str(Path(editor.panel_info["figure_dir"]) / panel_name)
+        )
+        is_zip = panel_is_zip[panel_index] if panel_index < len(panel_is_zip) else None
+
+        try:
+            loaded = load_panel_data(panel_path, is_zip=is_zip)
+
+            if not loaded:
+                return jsonify({"error": f"Could not load panel: {panel_name}"}), 400
+
+            # Get image data
+            img_data = None
+            if loaded.get("is_zip"):
+                png_bytes = loaded.get("png_bytes")
+                if png_bytes:
+                    img_data = base64.b64encode(png_bytes).decode("utf-8")
+            else:
+                png_path = loaded.get("png_path")
+                if png_path and png_path.exists():
+                    with open(png_path, "rb") as f:
+                        img_data = base64.b64encode(f.read()).decode("utf-8")
+
+            if not img_data:
+                return jsonify({"error": f"No PNG found for panel: {panel_name}"}), 400
+
+            # Get image size
+            img_size = loaded.get("img_size", {"width": 0, "height": 0})
+            if not img_size and loaded.get("png_path"):
+                from PIL import Image
+
+                img = Image.open(loaded["png_path"])
+                img_size = {"width": img.size[0], "height": img.size[1]}
+                img.close()
+
+            # Extract bboxes
+            bboxes = {}
+            geometry_data = loaded.get("geometry_data")
+            metadata = loaded.get("metadata", {})
+
+            if geometry_data and img_size:
+                bboxes = extract_bboxes_from_geometry_px(
+                    geometry_data, img_size["width"], img_size["height"]
+                )
+            elif metadata and img_size:
+                bboxes = extract_bboxes_from_metadata(
+                    metadata, img_size["width"], img_size["height"]
+                )
+
+            # Update editor state
+            editor.metadata = metadata
+            editor.panel_info["current_index"] = panel_index
+
+            # Re-extract defaults
+            from ..._defaults import extract_defaults_from_metadata, get_scitex_defaults
+
+            editor.scitex_defaults = get_scitex_defaults()
+            editor.metadata_defaults = extract_defaults_from_metadata(metadata)
+            editor.current_overrides = copy.deepcopy(editor.scitex_defaults)
+            editor.current_overrides.update(editor.metadata_defaults)
+            editor.current_overrides.update(editor.manual_overrides)
+
+            return jsonify(
+                {
+                    "success": True,
+                    "panel_name": panel_name,
+                    "panel_index": panel_index,
+                    "image": img_data,
+                    "bboxes": bboxes,
+                    "img_size": img_size,
+                    "overrides": editor.current_overrides,
+                }
+            )
+        except Exception as e:
+            import traceback
+
+            return jsonify(
+                {
+                    "error": f"Failed to switch panel: {str(e)}",
+                    "traceback": traceback.format_exc(),
+                }
+            ), 500
+
+    return switch_panel
+
+
+# EOF