phg-vis 1.3.2__py3-none-any.whl → 1.4.1__py3-none-any.whl

phg/__init__.py

@@ -11,21 +11,33 @@ Main Features:
 - Multiple pipe visualization support
 - Real-time and image rendering capabilities
 
-Version: 1.3.1
-Author: PanGuoJun
-License: MIT
-"""
-
-from .visphg import vis, image
-from .shader_render import ShaderRenderer, render_shader
-from .phg_to_shader import PHGToShaderConverter, phg_to_shader
-from .pipe_string_phg import (
-    world_pipe_to_phg,
-    local_pipe_to_phg,
-    world_pipestr_vis,
-    local_pipestr_vis,
-    multiple_pipes_vis
-)
+Version: 1.4.1
+Author: PanGuoJun
+License: MIT
+"""
+
+import os
+import tempfile
+
+from .visphg import vis, image
+from .shader_render import ShaderRenderer, render_shader
+from .phg_to_shader import PHGToShaderConverter, phg_to_shader
+from .pipe_string_phg import (
+    world_to_local_pipe_str,
+    local_pipe_to_phg,
+    world_pipe_to_phg,
+    world_pipestr_vis,
+    local_pipestr_vis,
+    multiple_pipes_vis
+)
+from .ai_bridge import (
+    compile_ai_phg,
+    vis_ai,
+    image_ai,
+    export_ai_obj,
+    web_view_ai,
+)
+from .web_three import write_three_view_html, serve_three_view
 
 # Extend ShaderRenderer class to support direct PHG rendering
 class PHGShaderRenderer(ShaderRenderer):
@@ -52,8 +64,8 @@ class PHGShaderRenderer(ShaderRenderer):
             
         return self.render_shader(shader_code, duration, interactive)
 
-# Convenience functions
-def render_phg(phg_script: str, width=800, height=600, duration=0, title="PHG Renderer"):
+# Convenience functions
+def render_phg(phg_script: str, width=800, height=600, duration=0, title="PHG Renderer"):
     """
     Directly render PHG script
     
@@ -79,7 +91,7 @@ def convert_phg_to_shader(phg_script: str) -> str:
     Returns:
         shader_code: GLSL shader code
     """
-    return phg_to_shader(phg_script)
+    return phg_to_shader(phg_script)
 
 def visualize_pipe_variants(pipe_variants, start_position=None, colors=None, coordinate_system='world'):
     """
@@ -262,8 +274,8 @@ def generate_pipe_variants_from_rules(base_pipe, num_variants=5, apply_rules=Non
     return variants[:num_variants]
 
 # Enhanced pipe visualization with transformation support
-def visualize_pipe_with_transformations(pipe_string, start_position=None, 
-                                      transformations=None, show_variants=3):
+def visualize_pipe_with_transformations(pipe_string, start_position=None, 
+                                      transformations=None, show_variants=3):
     """
     Visualize a pipe string along with its transformed variants
     
@@ -284,23 +296,82 @@ def visualize_pipe_with_transformations(pipe_string, start_position=None,
     )
     
     # Create comparison visualization
-    return visualize_pipe_variants(variants, start_position)
+    return visualize_pipe_variants(variants, start_position)
+
+
+def web_view(script: str, out_html: str = "phg_view.html", out_obj: str = None,
+             ai_root: str = None, title: str = "PHG Web Viewer") -> str:
+    """
+    Export OBJ via AI parser and write a three.js HTML viewer.
+    """
+    return web_view_ai(script, out_html=out_html, out_obj=out_obj, ai_root=ai_root, title=title)
+
+
+def web_serve(script: str, host: str = "127.0.0.1", port: int = 8766,
+              ai_root: str = None, title: str = "PHG Web Viewer") -> str:
+    """
+    Export OBJ via AI parser, write HTML, and serve with a local HTTP server.
+    """
+    temp_dir = tempfile.mkdtemp(prefix="phg_web_")
+    out_obj = os.path.join(temp_dir, "scene.obj")
+    out_html = os.path.join(temp_dir, "viewer.html")
+    web_view_ai(script, out_html=out_html, out_obj=out_obj, ai_root=ai_root, title=title)
+    return serve_three_view(out_obj, html_path=out_html, host=host, port=port, title=title)
+
+
+def visualize(script: str, mode: str = "vis", ai: bool = False, **kwargs):
+    """
+    Unified visualization entrypoint.
+    mode: vis | image | shader | web
+    ai: use AI parser (DGE++) to normalize/expand before visualization
+    """
+    mode = (mode or "vis").lower()
+    ai_root = kwargs.pop("ai_root", None)
+
+    if mode in ("vis", "native", "exe"):
+        return vis_ai(script, ai_root=ai_root) if ai else vis(script)
+
+    if mode in ("image", "img", "png"):
+        filename = kwargs.pop("filename", "shot.png")
+        return image_ai(script, filename=filename, ai_root=ai_root) if ai else image(script, filename=filename)
+
+    if mode in ("shader", "ray", "rt"):
+        phg_script = compile_ai_phg(script, ai_root=ai_root, include_setup=True) if ai else script
+        return render_phg(phg_script, **kwargs)
+
+    if mode in ("web", "three"):
+        out_html = kwargs.pop("out_html", "phg_view.html")
+        out_obj = kwargs.pop("out_obj", None)
+        title = kwargs.pop("title", "PHG Web Viewer")
+        return web_view_ai(script, out_html=out_html, out_obj=out_obj, ai_root=ai_root, title=title)
+
+    raise ValueError(f"Unknown mode: {mode}")
 
-__all__ = [
-    # Core visualization functions
-    'vis',
-    'image',
+__all__ = [
+    # Core visualization functions
+    'vis',
+    'image',
+    'visualize',
 
     # Shader rendering
     'ShaderRenderer',
     'render_shader',
     'render_phg',
-    'PHGShaderRenderer',
+    'PHGShaderRenderer',
 
     # PHG conversion
     'PHGToShaderConverter',
-    'phg_to_shader',
-    'convert_phg_to_shader',
+    'phg_to_shader',
+    'convert_phg_to_shader',
+    'compile_ai_phg',
+    'vis_ai',
+    'image_ai',
+    'export_ai_obj',
+    'web_view',
+    'web_view_ai',
+    'web_serve',
+    'write_three_view_html',
+    'serve_three_view',
 
     # Pipe visualization
     'world_pipe_to_phg',
@@ -313,17 +384,17 @@ __all__ = [
     'visualize_pipe_variants',
     'create_pipe_comparison_grid',
     'generate_pipe_variants_from_rules',
-    'visualize_pipe_with_transformations',
-]
-
-__version__ = "1.3.1"
-__author__ = "PanGuoJun"
-__description__ = "Python Hypergraphics Library"
-
-# Package initialization information
-print(f"PHG {__version__} - {__description__}")
-print("[OK] Visualization module loaded")
-print("[OK] Shader converter loaded") 
-print("[OK] Pipe visualization loaded")
-print("[OK] Multiple pipe visualization support loaded")
-print("[OK] Pipe transformation utilities loaded")
+    'visualize_pipe_with_transformations',
+]
+
+__version__ = "1.4.1"
+__author__ = "PanGuoJun"
+__description__ = "Python Hypergraphics Library"
+
+if os.environ.get("PHG_VERBOSE"):
+    print(f"PHG {__version__} - {__description__}")
+    print("[OK] Visualization module loaded")
+    print("[OK] Shader converter loaded")
+    print("[OK] Pipe visualization loaded")
+    print("[OK] Multiple pipe visualization support loaded")
+    print("[OK] Pipe transformation utilities loaded")

phg/ai_bridge.py

@@ -0,0 +1,218 @@
+"""
+AI bridge for PHG (DGE++ parser -> normalized PHG -> vis.exe / web).
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from typing import Any, Dict, Iterable, List, Optional
+
+from .visphg import vis as _vis, image as _image
+from .web_three import write_three_view_html
+
+DEFAULT_AI_ROOT = r"C:\Users\18858\Documents\_AILab\DGE++\PHG"
+_AI_MODULE = None
+_AI_MODULE_ROOT = None
+
+
+def resolve_ai_root(ai_root: Optional[str] = None) -> str:
+    root = ai_root or os.environ.get("PHG_AI_ROOT") or DEFAULT_AI_ROOT
+    if not os.path.isdir(root):
+        raise FileNotFoundError(
+            f"AI PHG root not found: {root}. "
+            "Set PHG_AI_ROOT or pass ai_root explicitly."
+        )
+    return root
+
+
+def _run_ai_cli(args: List[str], ai_root: Optional[str] = None, timeout: int = 120) -> subprocess.CompletedProcess:
+    root = resolve_ai_root(ai_root)
+    cmd = [sys.executable, "-m", "phg"] + args
+    return subprocess.run(
+        cmd,
+        cwd=root,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        check=False,
+    )
+
+
+def _load_ai_module(ai_root: Optional[str] = None):
+    global _AI_MODULE, _AI_MODULE_ROOT
+    root = resolve_ai_root(ai_root)
+    if _AI_MODULE is not None and _AI_MODULE_ROOT == root:
+        return _AI_MODULE
+
+    pkg_dir = os.path.join(root, "phg")
+    init_path = os.path.join(pkg_dir, "__init__.py")
+    if not os.path.isfile(init_path):
+        raise FileNotFoundError(f"AI PHG package not found: {init_path}")
+
+    spec = importlib.util.spec_from_file_location(
+        "phg_ai",
+        init_path,
+        submodule_search_locations=[pkg_dir],
+    )
+    if spec is None or spec.loader is None:
+        raise ImportError("Failed to load AI PHG package")
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["phg_ai"] = module
+    spec.loader.exec_module(module)
+    _AI_MODULE = module
+    _AI_MODULE_ROOT = root
+    return module
+
+
+def _write_temp_phg(script: str) -> str:
+    fd, path = tempfile.mkstemp(suffix=".phg")
+    os.close(fd)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(script)
+    return path
+
+
+def dump_scene(script: str, ai_root: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Use AI PHG (DGE++) to parse script and dump scene JSON.
+    """
+    phg_path = _write_temp_phg(script)
+    fd, json_path = tempfile.mkstemp(suffix=".json")
+    os.close(fd)
+    try:
+        try:
+            ai = _load_ai_module(ai_root)
+            engine_mod = importlib.import_module("phg_ai.engine")
+            engine = engine_mod.Engine()
+            engine.run(script)
+            if "setup" not in engine.calls:
+                engine.setup()
+            if "draw" not in engine.calls:
+                engine.draw()
+            return engine._scene_to_dict(engine.scene.root)
+        except Exception:
+            proc = _run_ai_cli(["dump", phg_path, "--out", json_path], ai_root=ai_root)
+            if proc.returncode != 0:
+                raise RuntimeError(proc.stderr.strip() or proc.stdout.strip() or "AI dump failed")
+            with open(json_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+    finally:
+        for p in (phg_path, json_path):
+            try:
+                os.remove(p)
+            except OSError:
+                pass
+
+
+def _format_value(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "1" if value else "0"
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, (list, tuple)):
+        return ",".join(str(v) for v in value)
+    return str(value)
+
+
+def _emit_props(props: Dict[str, Any], indent: str) -> List[str]:
+    lines = []
+    for key, value in props.items():
+        val = _format_value(value)
+        if val == "":
+            lines.append(f"{indent}{key};")
+        else:
+            lines.append(f"{indent}{key}:{val};")
+    return lines
+
+
+def _emit_node(node: Dict[str, Any], indent: str = "    ") -> List[str]:
+    name = node.get("name", "node")
+    props = node.get("props", {}) or {}
+    children = node.get("children", []) or []
+
+    lines = [f"{indent}{name}{{"]
+    lines.extend(_emit_props(props, indent + "    "))
+    for child in children:
+        lines.extend(_emit_node(child, indent + "    "))
+    lines.append(f"{indent}}}")
+    return lines
+
+
+def scene_to_phg(scene: Dict[str, Any], include_setup: bool = True) -> str:
+    """
+    Convert AI scene JSON (dump) to normalized PHG script.
+    """
+    root_props = scene.get("props", {}) or {}
+    root_children = scene.get("children", []) or []
+
+    lines = ["{"]
+    if root_props:
+        # Preserve root-level props by creating a synthetic node.
+        root_node = {
+            "name": scene.get("name", "root"),
+            "props": root_props,
+            "children": root_children,
+        }
+        lines.extend(_emit_node(root_node, indent="    "))
+    else:
+        for child in root_children:
+            lines.extend(_emit_node(child, indent="    "))
+    lines.append("}")
+    if include_setup:
+        lines.append("setup_draw();")
+    return "\n".join(lines)
+
+
+def compile_ai_phg(script: str, ai_root: Optional[str] = None, include_setup: bool = True) -> str:
+    scene = dump_scene(script, ai_root=ai_root)
+    return scene_to_phg(scene, include_setup=include_setup)
+
+
+def vis_ai(script: str, ai_root: Optional[str] = None) -> None:
+    phg_script = compile_ai_phg(script, ai_root=ai_root, include_setup=True)
+    _vis(phg_script)
+
+
+def image_ai(script: str, filename: str = "shot.png", ai_root: Optional[str] = None) -> None:
+    phg_script = compile_ai_phg(script, ai_root=ai_root, include_setup=True)
+    _image(phg_script, filename=filename)
+
+
+def export_ai_obj(script: str, out_obj: str, ai_root: Optional[str] = None) -> str:
+    try:
+        ai = _load_ai_module(ai_root)
+        engine_mod = importlib.import_module("phg_ai.engine")
+        engine = engine_mod.Engine()
+        engine.run(script)
+        if "setup" not in engine.calls:
+            engine.setup()
+        if "draw" not in engine.calls:
+            engine.draw()
+        engine.export_obj(out_obj)
+    finally:
+        pass
+    return out_obj
+
+
+def web_view_ai(
+    script: str,
+    out_html: str,
+    out_obj: Optional[str] = None,
+    ai_root: Optional[str] = None,
+    title: str = "PHG Web Viewer",
+) -> str:
+    if out_obj is None:
+        base, _ = os.path.splitext(out_html)
+        out_obj = base + ".obj"
+    export_ai_obj(script, out_obj, ai_root=ai_root)
+    write_three_view_html(out_obj, out_html, title=title)
+    return out_html