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

phg/__init__.py

@@ -1,48 +1,68 @@
 """
-__init__.py
-PHG主库 - 集成PHG到Shader转换功能
+PHG - Python Hypergraphics Library
+===================================
+
+A powerful graphics library for procedural 3D visualization using PHG scripts.
+
+Main Features:
+- PHG script visualization via vis.exe
+- Shader-based rendering with GLSL conversion
+- Pipe system visualization with world/local coordinate systems
+- 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
+)
 
-# 扩展ShaderRenderer类以支持PHG直接渲染
+# Extend ShaderRenderer class to support direct PHG rendering
 class PHGShaderRenderer(ShaderRenderer):
-    """支持PHG直接渲染的Shader渲染器"""
+    """Shader renderer that supports direct PHG rendering"""
     
     def render_phg(self, phg_script: str, duration=0, interactive=True):
         """
-        渲染PHG脚本
+        Render PHG script
         
-        参数:
-            phg_script: PHG脚本代码
-            duration: 渲染持续时间
-            interactive: 是否允许交互
+        Parameters:
+            phg_script: PHG script code
+            duration: Render duration
+            interactive: Whether to allow interaction
             
-        返回:
-            success: 是否成功渲染
+        Returns:
+            success: Whether rendering was successful
         """
         converter = PHGToShaderConverter()
         shader_code = converter.generate_shader_code(phg_script)
         
         if not shader_code:
-            print("错误: PHG转换失败")
+            print("Error: PHG conversion failed")
             return False
             
         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"):
     """
-    直接渲染PHG脚本
-    
-    参数:
-        phg_script: PHG脚本代码
-        width: 窗口宽度
-        height: 窗口高度  
-        duration: 渲染持续时间
-        title: 窗口标题
+    Directly render PHG script
+    
+    Parameters:
+        phg_script: PHG script code
+        width: Window width
+        height: Window height  
+        duration: Render duration
+        title: Window title
     """
     renderer = PHGShaderRenderer(width, height, title)
     success = renderer.render_phg(phg_script, duration)
@@ -51,32 +71,259 @@ def render_phg(phg_script: str, width=800, height=600, duration=0, title="PHG Re
 
 def convert_phg_to_shader(phg_script: str) -> str:
     """
-    将PHG脚本转换为GLSL着色器代码
+    Convert PHG script to GLSL shader code
+
+    Parameters:
+        phg_script: PHG script
+
+    Returns:
+        shader_code: GLSL shader code
+    """
+    return phg_to_shader(phg_script)
+
+def visualize_pipe_variants(pipe_variants, start_position=None, colors=None, coordinate_system='world'):
+    """
+    Visualize multiple pipe variants for comparison
+    
+    Parameters:
+        pipe_variants: List of pipe strings or configuration dictionaries
+        start_position: Starting coordinate (optional)
+        colors: List of colors for each pipe variant
+        coordinate_system: 'world' or 'local' coordinate system
+    
+    Returns:
+        PHG script string
+    """
+    from coordinate_system import vec3, quat, coord3
+    
+    # Handle start position
+    if start_position is None:
+        start_c = coord3(vec3(0, 0, 0), quat(1, 0, 0, 0))
+    else:
+        start_c = start_position
     
-    参数:
-        phg_script: PHG脚本
+    # Handle different input formats
+    if isinstance(pipe_variants[0], str):
+        # Simple list of pipe strings
+        if colors is None:
+            # Generate distinct colors for each variant
+            import colorsys
+            colors = []
+            for i in range(len(pipe_variants)):
+                hue = i / len(pipe_variants)
+                rgb = colorsys.hsv_to_rgb(hue, 0.8, 0.9)
+                colors.append(tuple(int(c * 255) for c in rgb))
         
-    返回:
-        shader_code: GLSL着色器代码
+        if coordinate_system == 'world':
+            return world_pipestr_vis(pipe_variants, start_c, colors)
+        else:
+            return local_pipestr_vis(pipe_variants, start_c, colors)
+    
+    else:
+        # List of configuration dictionaries
+        pipe_configs = []
+        for i, variant in enumerate(pipe_variants):
+            if isinstance(variant, str):
+                config = {
+                    'pipe_str': variant,
+                    'start_c': start_c,
+                    'color': colors[i] if colors else None,
+                    'radius': 0.3
+                }
+            else:
+                config = variant
+                if 'start_c' not in config:
+                    config['start_c'] = start_c
+            
+            pipe_configs.append(config)
+        
+        return multiple_pipes_vis(pipe_configs, coordinate_system)
+
+def create_pipe_comparison_grid(pipe_strings, grid_size=(2, 2), start_position=None, 
+                               base_color=(0, 55, 255), coordinate_system='world'):
     """
-    return phg_to_shader(phg_script)
+    Create a grid layout for comparing multiple pipe paths
+    
+    Parameters:
+        pipe_strings: List of pipe strings to compare
+        grid_size: (rows, cols) for grid layout
+        start_position: Base starting position
+        base_color: Base color for pipes
+        coordinate_system: 'world' or 'local'
+    
+    Returns:
+        PHG script string
+    """
+    from coordinate_system import vec3, quat, coord3
+    
+    if start_position is None:
+        start_position = coord3(vec3(0, 0, 0), quat(1, 0, 0, 0))
+    
+    rows, cols = grid_size
+    spacing = 5.0  # Space between pipes in grid
+    
+    pipe_configs = []
+    
+    for i, pipe_str in enumerate(pipe_strings):
+        if i >= rows * cols:
+            break
+            
+        row = i // cols
+        col = i % cols
+        
+        # Calculate position in grid
+        x_offset = col * spacing
+        z_offset = row * spacing
+        
+        # Create individual start position for this pipe
+        individual_start = coord3(
+            vec3(
+                start_position.o.x + x_offset,
+                start_position.o.y,
+                start_position.o.z + z_offset
+            ),
+            start_position.Q()
+        )
+        
+        # Generate color variation
+        color_variation = (
+            min(255, base_color[0] + (i * 30) % 100),
+            min(255, base_color[1] + (i * 50) % 100),
+            min(255, base_color[2] + (i * 70) % 100)
+        )
+        
+        pipe_configs.append({
+            'pipe_str': pipe_str,
+            'start_c': individual_start,
+            'color': color_variation,
+            'radius': 0.25 + (i * 0.05)  # Vary radius slightly
+        })
+    
+    return multiple_pipes_vis(pipe_configs, coordinate_system)
+
+def generate_pipe_variants_from_rules(base_pipe, num_variants=5, apply_rules=None):
+    """
+    Generate pipe variants using transformation rules
+    
+    Parameters:
+        base_pipe: Base pipe string
+        num_variants: Number of variants to generate
+        apply_rules: List of rules to apply ('swap', 'insert', 'cancel')
+    
+    Returns:
+        List of pipe variant strings
+    """
+    if apply_rules is None:
+        apply_rules = ['swap', 'insert', 'cancel']
+    
+    variants = [base_pipe]
+    
+    # Import the pipe transformer if available
+    try:
+        from .pipe_string_phg import PipeStringTransformer
+        transformer = PipeStringTransformer()
+        
+        for _ in range(num_variants - 1):
+            current_pipe = base_pipe
+            
+            # Apply random transformations
+            import random
+            for _ in range(random.randint(1, 3)):
+                rule = random.choice(apply_rules)
+                
+                if rule == 'swap' and len(current_pipe) >= 2:
+                    i, j = random.sample(range(len(current_pipe)), 2)
+                    current_pipe = transformer.swap_positions(current_pipe, i, j)
+                
+                elif rule == 'insert':
+                    position = random.randint(0, len(current_pipe))
+                    direction = random.choice(list(transformer.CANCEL_PAIRS.keys()))
+                    current_pipe = transformer.insert_cancel_pair(current_pipe, position, direction)
+                
+                elif rule == 'cancel':
+                    current_pipe = transformer.cancel_adjacent_pairs(current_pipe)
+            
+            # Simplify and add if valid
+            simplified = transformer.simplify_path(current_pipe)
+            if simplified not in variants:
+                variants.append(simplified)
+    
+    except ImportError:
+        # Fallback: simple variant generation
+        import random
+        for i in range(num_variants - 1):
+            # Simple character shuffling
+            pipe_list = list(base_pipe)
+            random.shuffle(pipe_list)
+            variant = ''.join(pipe_list)
+            if variant not in variants:
+                variants.append(variant)
+    
+    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):
+    """
+    Visualize a pipe string along with its transformed variants
+    
+    Parameters:
+        pipe_string: Base pipe string
+        start_position: Starting coordinate
+        transformations: List of transformation rules to apply
+        show_variants: Number of variants to show
+    
+    Returns:
+        PHG script string
+    """
+    # Generate variants
+    variants = generate_pipe_variants_from_rules(
+        pipe_string, 
+        num_variants=show_variants + 1,  # +1 for original
+        apply_rules=transformations
+    )
+    
+    # Create comparison visualization
+    return visualize_pipe_variants(variants, start_position)
 
 __all__ = [
-    'vis', 
-    'image', 
-    'ShaderRenderer', 
+    # Core visualization functions
+    'vis',
+    'image',
+
+    # Shader rendering
+    'ShaderRenderer',
     'render_shader',
-    'PHGToShaderConverter',
-    'PHGShaderRenderer', 
     'render_phg',
+    'PHGShaderRenderer',
+
+    # PHG conversion
+    'PHGToShaderConverter',
+    'phg_to_shader',
     'convert_phg_to_shader',
-    'phg_to_shader'
+
+    # Pipe visualization
+    'world_pipe_to_phg',
+    'local_pipe_to_phg',
+    'world_pipestr_vis',
+    'local_pipestr_vis',
+    'multiple_pipes_vis',
+    
+    # Enhanced pipe visualization
+    'visualize_pipe_variants',
+    'create_pipe_comparison_grid',
+    'generate_pipe_variants_from_rules',
+    'visualize_pipe_with_transformations',
 ]
 
-__version__ = "0.2.0"
-__author__ = "PHG Development Team"
-__description__ = "Python Graphics Library with PHG to Shader conversion"
+__version__ = "1.3.1"
+__author__ = "PanGuoJun"
+__description__ = "Python Hypergraphics Library"
 
-# 包初始化信息
+# Package initialization information
 print(f"PHG {__version__} - {__description__}")
-print("PHG to Shader转换器已加载")
+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/pipe_string_phg.py

@@ -0,0 +1,411 @@
+"""
+Pipe String to PHG Converter
+============================
+
+This module provides functionality to convert pipe strings into PHG (Python Graphics) scripts.
+Supports both world coordinate system and local coordinate system pipe descriptions.
+
+Main Features:
+- world_pipe_to_phg: World coordinate system pipe conversion
+- local_pipe_to_phg: Local coordinate system pipe conversion  
+- world_pipestr_vis: Direct visualization for world coordinate pipes
+- local_pipestr_vis: Direct visualization for local coordinate pipes
+
+Pipe String Format:
+- F: Forward
+- B: Backward  
+- R: Right
+- L: Left
+- U: Up
+- D: Down
+"""
+
+import phg
+from coordinate_system import vec3, quat, coord3
+
+# Default color and pipe radius
+DEFAULT_PIPE_COLOR = (0, 55, 255)
+DEFAULT_PIPE_RADIUS = 0.3
+
+def world_pipe_to_phg(world_pipe_str, start_c, pipe_color=DEFAULT_PIPE_COLOR, pipe_radius=DEFAULT_PIPE_RADIUS):
+    """
+    Convert world coordinate system pipe string to PHG script
+    
+    Parameters:
+        world_pipe_str: World coordinate pipe string (e.g., "FFRUD")
+        start_c: Starting coordinate system
+        pipe_color: Pipe color as (R, G, B) tuple
+        pipe_radius: Pipe radius
+    
+    Returns:
+        PHG script string
+    """
+    
+    # World coordinate direction definitions
+    world_directions = {
+        'F': vec3(0, 0, 1),   # Forward (World Z+)
+        'B': vec3(0, 0, -1),  # Backward (World Z-)
+        'R': vec3(1, 0, 0),   # Right (World X+)
+        'L': vec3(-1, 0, 0),  # Left (World X-)
+        'U': vec3(0, 1, 0),   # Up (World Y+)
+        'D': vec3(0, -1, 0)   # Down (World Y-)
+    }
+
+    # Parse color
+    r, g, b = pipe_color
+    
+    # Pipe component mapping (all components use fixed length 1.0)
+    pipe_components = {
+        'F': f'{{{{rgb:{r},{g},{b};md:cylinder {pipe_radius} 1.0;rx:90;z:-0.5;}};z:1.0}}',
+        'B': f'{{{{rgb:{r},{g},{b};md:cylinder {pipe_radius} 1.0;rx:-90;z:{-1.0-0.5};}};z:1.0}}',
+        'R': f'{{{{{{rgb:{r},{g},{b};md:elbow 90 0.5 {pipe_radius};x:0.5;z:0.5;}}ry:90;x:1.0;z:-1.0}}}},{{x:1.0;ry:-90;}}',
+        'L': f'{{{{{{rgb:{r},{g},{b};md:elbow 90 0.5 {pipe_radius};x:0.5;z:0.5;}}ry:-90;m:x;z:-1.0;x:-1.0}}}},{{x:-1.0;ry:90;}}',
+        'U': f'{{{{{{rgb:{r},{g},{b};md:elbow 90 0.5 {pipe_radius};x:0.5;z:0.5;}}rz:90;y:1.0;z:-1}}}},{{y:1.0;rx:90;}}',
+        'D': f'{{{{{{rgb:{r},{g},{b};md:elbow 90 0.5 {pipe_radius};x:0.5;z:0.5;}}rz:-90;y:-1;z:-1}}}},{{y:-1.0;rx:-90;}}'
+    }
+
+    # Initialize current coordinate system (using starting coordinate)
+    cur_c = coord3(start_c.o, start_c.Q())
+    
+    # Store all pipe component scripts
+    script_parts = []
+    
+    # Iterate through each character in pipe string
+    for move_char in world_pipe_str:
+        if move_char not in pipe_components:
+            print(f"Warning: Unknown pipe character '{move_char}', skipped")
+            continue
+        
+        # Get current movement direction in world coordinates
+        world_dir = world_directions[move_char]
+        
+        # Transform world direction to current local coordinate system
+        local_dir = vec3(
+            world_dir.dot(cur_c.ux),  # Component in local X-axis
+            world_dir.dot(cur_c.uy),  # Component in local Y-axis
+            world_dir.dot(cur_c.uz)   # Component in local Z-axis
+        )
+        
+        # Find component with largest absolute value to determine main movement direction
+        abs_components = [abs(local_dir.x), abs(local_dir.y), abs(local_dir.z)]
+        max_idx = abs_components.index(max(abs_components))
+        
+        # Determine local movement direction based on maximum component
+        if max_idx == 0:  # X-axis
+            local_move = 'R' if local_dir.x > 0 else 'L'
+        elif max_idx == 1:  # Y-axis
+            local_move = 'U' if local_dir.y > 0 else 'D'
+        else:  # Z-axis
+            local_move = 'F' if local_dir.z > 0 else 'B'
+        
+        # Add corresponding pipe component script
+        script_parts.append(pipe_components[local_move])
+        
+        # Update current coordinate system (simulate new position and direction after movement)
+        if local_move == 'F':
+            # Forward: move 1.0 unit along local Z-axis positive direction
+            cur_c = cur_c * coord3(vec3(0, 0, 1.0))
+        elif local_move == 'B':
+            # Backward: move 1.0 unit along local Z-axis negative direction
+            cur_c = cur_c * coord3(vec3(0, 0, -1.0))
+        elif local_move == 'R':
+            # Right turn: rotate -90 degrees around Y-axis, then move 1.0 unit along X-axis
+            rotation = quat(-3.1416 / 2, cur_c.uy)
+            cur_c = cur_c * rotation
+            cur_c = cur_c * coord3(vec3(1.0, 0, 0))
+        elif local_move == 'L':
+            # Left turn: rotate 90 degrees around Y-axis, then move 1.0 unit along X-axis
+            rotation = quat(3.1416 / 2, cur_c.uy)
+            cur_c = cur_c * rotation
+            cur_c = cur_c * coord3(vec3(-1.0, 0, 0))
+        elif local_move == 'U':
+            # Up turn: rotate 90 degrees around X-axis, then move 1.0 unit along Y-axis
+            rotation = quat(3.1416 / 2, cur_c.ux)
+            cur_c = cur_c * rotation
+            cur_c = cur_c * coord3(vec3(0, 1.0, 0))
+        elif local_move == 'D':
+            # Down turn: rotate -90 degrees around X-axis, then move 1.0 unit along Y-axis
+            rotation = quat(-3.1416 / 2, cur_c.ux)
+            cur_c = cur_c * rotation
+            cur_c = cur_c * coord3(vec3(0, -1.0, 0))
+
+    # Combine all pipe component scripts
+    inner_script = ',\n'.join(script_parts)
+    
+    # Get quaternion of starting coordinate system
+    q = start_c.Q()
+    
+    # Build complete PHG script
+    complete_script = f"""{{
+    {{xyz:{start_c.o.x},{start_c.o.y},{start_c.o.z};q:{q.w},{q.x},{q.y},{q.z};s:0.5;
+    <{inner_script}>}}
+    }}"""
+    
+    return complete_script
+
+
+def local_pipe_to_phg(local_pipe_str, start_c, pipe_color=DEFAULT_PIPE_COLOR, pipe_radius=DEFAULT_PIPE_RADIUS):
+    """
+    Convert local coordinate system pipe string to PHG script
+
+    Parameters:
+        local_pipe_str: Local coordinate pipe string (e.g., "FFRUD")
+        start_c: Starting coordinate system
+        pipe_color: Pipe color as (R, G, B) tuple
+        pipe_radius: Pipe radius
+
+    Returns:
+        PHG script string
+    """
+
+    # Parse color
+    r, g, b = pipe_color
+
+    # Pipe component mapping (all components use fixed length 1.0)
+    pipe_components = {
+        'F': f'{{{{rgb:{r},{g},{b};md:cylinder {pipe_radius} 1.0;rx:90;z:-0.5;}};z:1.0}}',
+        'B': f'{{{{rgb:{r},{g},{b};md:cylinder {pipe_radius} 1.0;rx:-90;z:{-1.0-0.5};}};z:1.0}}',
+        'R': f'{{{{{{rgb:{r},{g},{b};md:elbow 90 0.5 {pipe_radius};x:0.5;z:0.5;}}ry:90;x:1.0;z:-1.0}}}},{{x:1.0;ry:-90;}}',
+        'L': f'{{{{{{rgb:{r},{g},{b};md:elbow 90 0.5 {pipe_radius};x:0.5;z:0.5;}}ry:-90;m:x;z:-1.0;x:-1.0}}}},{{x:-1.0;ry:90;}}',
+        'U': f'{{{{{{rgb:{r},{g},{b};md:elbow 90 0.5 {pipe_radius};x:0.5;z:0.5;}}rz:90;y:1.0;z:-1}}}},{{y:1.0;rx:90;}}',
+        'D': f'{{{{{{rgb:{r},{g},{b};md:elbow 90 0.5 {pipe_radius};x:0.5;z:0.5;}}rz:-90;y:-1;z:-1}}}},{{y:-1.0;rx:-90;}}'
+    }
+
+    # Store all pipe component scripts
+    script_parts = []
+
+    # Iterate through each character in pipe string
+    for move_char in local_pipe_str:
+        if move_char not in pipe_components:
+            print(f"Warning: Unknown pipe character '{move_char}', skipped")
+            continue
+
+        # Directly use local coordinate system movement commands
+        script_parts.append(pipe_components[move_char])
+
+    # Combine all pipe component scripts
+    inner_script = ',\n'.join(script_parts)
+
+    # Get quaternion of starting coordinate system
+    q = start_c.Q()
+
+    # Build complete PHG script
+    complete_script = f"""{{
+    {{xyz:{start_c.o.x},{start_c.o.y},{start_c.o.z};q:{q.w},{q.x},{q.y},{q.z};s:0.5;
+    <{inner_script}>}}
+    }}"""
+
+    return complete_script
+
+
+def world_pipestr_vis(world_pipe_strs, start_c=None, pipe_colors=None, pipe_radius=DEFAULT_PIPE_RADIUS):
+    """
+    Direct visualization for world coordinate pipe strings with support for multiple pipes
+    
+    Parameters:
+        world_pipe_strs: World coordinate pipe string or list of strings (e.g., "FFRUD" or ["FFR", "LLU"])
+        start_c: Starting coordinate system, defaults to origin
+        pipe_colors: Single color or list of colors as (R, G, B) tuples
+        pipe_radius: Pipe radius
+    
+    Returns:
+        PHG script string
+    """
+    # Handle single string input
+    if isinstance(world_pipe_strs, str):
+        world_pipe_strs = [world_pipe_strs]
+    
+    # Handle single color input
+    if pipe_colors is None:
+        pipe_colors = [DEFAULT_PIPE_COLOR] * len(world_pipe_strs)
+    elif isinstance(pipe_colors, tuple):
+        pipe_colors = [pipe_colors] * len(world_pipe_strs)
+    
+    # Ensure colors list matches pipes list length
+    if len(pipe_colors) != len(world_pipe_strs):
+        pipe_colors = [DEFAULT_PIPE_COLOR] * len(world_pipe_strs)
+        print("Warning: Colors list length doesn't match pipes list, using default colors")
+    
+    # Use default origin if no starting coordinate provided
+    if start_c is None:
+        start_c = coord3(vec3(0, 0, 0), quat(1, 0, 0, 0))
+
+    # Generate PHG scripts for all pipes
+    script_parts = []
+    for i, (pipe_str, color) in enumerate(zip(world_pipe_strs, pipe_colors)):
+        phg_script = world_pipe_to_phg(pipe_str, start_c, color, pipe_radius)
+        # Extract inner content between outer braces
+        inner_content = phg_script.strip()[1:-1].strip()
+        script_parts.append(inner_content)
+
+    # Combine all pipe scripts
+    combined_script = "{\n" + ",\n".join(script_parts) + "\n}"
+
+    # Call visualization function
+    try:
+        phg.vis(combined_script)
+        print(f"Visualizing {len(world_pipe_strs)} world coordinate pipes")
+    except ImportError:
+        print("Warning: Cannot import visualization module, returning PHG script")
+
+    return combined_script
+
+
+def local_pipestr_vis(local_pipe_strs, start_c=None, pipe_colors=None, pipe_radius=DEFAULT_PIPE_RADIUS):
+    """
+    Direct visualization for local coordinate pipe strings with support for multiple pipes
+    
+    Parameters:
+        local_pipe_strs: Local coordinate pipe string or list of strings (e.g., "FFRUD" or ["FFR", "LLU"])
+        start_c: Starting coordinate system, defaults to origin
+        pipe_colors: Single color or list of colors as (R, G, B) tuples
+        pipe_radius: Pipe radius
+    
+    Returns:
+        PHG script string
+    """
+    # Handle single string input
+    if isinstance(local_pipe_strs, str):
+        local_pipe_strs = [local_pipe_strs]
+    
+    # Handle single color input
+    if pipe_colors is None:
+        pipe_colors = [DEFAULT_PIPE_COLOR] * len(local_pipe_strs)
+    elif isinstance(pipe_colors, tuple):
+        pipe_colors = [pipe_colors] * len(local_pipe_strs)
+    
+    # Ensure colors list matches pipes list length
+    if len(pipe_colors) != len(local_pipe_strs):
+        pipe_colors = [DEFAULT_PIPE_COLOR] * len(local_pipe_strs)
+        print("Warning: Colors list length doesn't match pipes list, using default colors")
+    
+    # Use default origin if no starting coordinate provided
+    if start_c is None:
+        start_c = coord3(vec3(0, 0, 0), quat(1, 0, 0, 0))
+
+    # Generate PHG scripts for all pipes
+    script_parts = []
+    for i, (pipe_str, color) in enumerate(zip(local_pipe_strs, pipe_colors)):
+        phg_script = local_pipe_to_phg(pipe_str, start_c, color, pipe_radius)
+        # Extract inner content between outer braces
+        inner_content = phg_script.strip()[1:-1].strip()
+        script_parts.append(inner_content)
+
+    # Combine all pipe scripts
+    combined_script = "{\n" + ",\n".join(script_parts) + "\n}"
+
+    # Call visualization function
+    try:
+        phg.vis(combined_script)
+        print(f"Visualizing {len(local_pipe_strs)} local coordinate pipes")
+    except ImportError:
+        print("Warning: Cannot import visualization module, returning PHG script")
+
+    return combined_script
+
+
+def multiple_pipes_vis(pipe_configs, coordinate_system='world'):
+    """
+    Advanced visualization for multiple pipes with individual configurations
+    
+    Parameters:
+        pipe_configs: List of pipe configuration dictionaries with keys:
+            - 'pipe_str': Pipe string (required)
+            - 'start_c': Starting coordinate (optional, defaults to origin)
+            - 'color': Pipe color (optional, defaults to DEFAULT_PIPE_COLOR)
+            - 'radius': Pipe radius (optional, defaults to DEFAULT_PIPE_RADIUS)
+        coordinate_system: 'world' or 'local' coordinate system
+    
+    Returns:
+        PHG script string
+    """
+    script_parts = []
+    
+    for i, config in enumerate(pipe_configs):
+        pipe_str = config.get('pipe_str')
+        start_c = config.get('start_c', coord3(vec3(0, 0, 0), quat(1, 0, 0, 0)))
+        color = config.get('color', DEFAULT_PIPE_COLOR)
+        radius = config.get('radius', DEFAULT_PIPE_RADIUS)
+        
+        if coordinate_system.lower() == 'world':
+            phg_script = world_pipe_to_phg(pipe_str, start_c, color, radius)
+        else:
+            phg_script = local_pipe_to_phg(pipe_str, start_c, color, radius)
+        
+        # Extract inner content
+        inner_content = phg_script.strip()[1:-1].strip()
+        script_parts.append(inner_content)
+    
+    # Combine all pipe scripts
+    combined_script = "{\n" + ",\n".join(script_parts) + "\n}"
+    
+    # Call visualization
+    try:
+        phg.vis(combined_script)
+        print(f"Visualizing {len(pipe_configs)} pipes in {coordinate_system} coordinate system")
+    except ImportError:
+        print("Warning: Cannot import visualization module, returning PHG script")
+    
+    return combined_script
+
+
+# Usage Examples
+if __name__ == "__main__":
+    # Create starting coordinate system (example)
+    start_coord = coord3(vec3(0, 0, 0), quat(1, 0, 0, 0))
+
+    # Example 1: Single world coordinate pipe string
+    example_world_pipe = "FFRUD"  # Forward twice, right, up, down
+    print("World Coordinate Pipe Example:")
+    phg_script = world_pipe_to_phg(example_world_pipe, start_coord)
+    print("Generated PHG Script:")
+    print(phg_script)
+    print()
+
+    # Example 2: Single local coordinate pipe string
+    example_local_pipe = "FFRUD"  # Movements in local coordinate system
+    print("Local Coordinate Pipe Example:")
+    phg_script = local_pipe_to_phg(example_local_pipe, start_coord)
+    print("Generated PHG Script:")
+    print(phg_script)
+    print()
+
+    # Example 3: Multiple pipes visualization
+    print("Multiple Pipes Visualization Example:")
+    
+    # Multiple world coordinate pipes with different colors
+    world_pipes = ["FFR", "LLU", "RRD"]
+    world_colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255)]  # Red, Green, Blue
+    world_pipestr_vis(world_pipes, start_coord, world_colors)
+    print()
+
+    # Multiple local coordinate pipes
+    local_pipes = ["FFR", "BBL", "UUD"]
+    local_colors = [(255, 255, 0), (255, 0, 255), (0, 255, 255)]  # Yellow, Magenta, Cyan
+    local_pipestr_vis(local_pipes, start_coord, local_colors)
+    print()
+
+    # Example 4: Advanced multiple pipes configuration
+    print("Advanced Multiple Pipes Configuration:")
+    pipe_configs = [
+        {
+            'pipe_str': 'FFR',
+            'start_c': coord3(vec3(0, 0, 0), quat(1, 0, 0, 0)),
+            'color': (255, 100, 100),
+            'radius': 0.4
+        },
+        {
+            'pipe_str': 'LLU', 
+            'start_c': coord3(vec3(5, 0, 0), quat(1, 0, 0, 0)),
+            'color': (100, 255, 100),
+            'radius': 0.3
+        },
+        {
+            'pipe_str': 'RRD',
+            'start_c': coord3(vec3(0, 5, 0), quat(1, 0, 0, 0)),
+            'color': (100, 100, 255),
+            'radius': 0.2
+        }
+    ]
+    
+    multiple_pipes_vis(pipe_configs, 'world')

phg/vis/vis.ini

@@ -1,4 +1,4 @@
-CAMERA=0.000,10.000,18.000;0.000,0.000,0.000;0.000,1.000,0.000;0.724;1.610;0;10.000;0.000,0.000,0.000
+CAMERA=4.057,2.604,-0.507;3.490,2.240,-0.436;0.000,1.000,0.000;0.175;1.610;0;10.000;0.000,0.000,0.000
 CONSOLE=true
 ENABLE_DUAL_SCREEN=false
 HOSTIP=127.0.0.1

{phg_vis-1.3.0.dist-info → phg_vis-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: phg_vis
-Version: 1.3.0
+Version: 1.3.2
 Summary: A package for the PHG modeling language and 3D visualization tool.
 Home-page: https://github.com/panguojun/Coordinate-System
 Author: romeosoft
@@ -13,20 +13,21 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-# PHG - Minimalist 3D Modeling Language
+# PHG - Python Hypergraphics Library
 
-PHG (Bacteriophage) is a specialized modeling language for describing 3D scene node trees. Combining concepts from group theory, it provides custom overloading capabilities for variables and operations, making it particularly suitable for describing complex 3D scenes and 2D sprite structures.
+PHG (Python Hypergraphics) is a powerful 3D modeling and visualization library that combines a minimalist modeling language with Python integration. It provides procedural 3D scene generation, shader-based rendering, and specialized pipe system visualization.
 
 ---
 
 ## 🌟 Features
 
-- **Minimalist Syntax** - Declarative node tree description
+- **Minimalist Syntax** - Declarative node tree description for 3D scenes
 - **Hierarchical Modeling** - Support for nested nodes and transform inheritance
 - **Parametric Design** - Flexible property system and function definitions
-- **Topological Structures** - Two organization methods: sequence and array composition
-- **Visualization Rendering** - Powerful offscreen rendering and screenshot capabilities
-- **Python Integration** - Convenient Python API
+- **Pipe Visualization** - Specialized system for visualizing pipe structures with world/local coordinate support
+- **Shader Conversion** - Convert PHG scripts to GLSL shaders for GPU rendering
+- **Dual Rendering Modes** - Both real-time visualization (vis.exe) and offscreen rendering
+- **Python Integration** - Comprehensive Python API for all features
 
 ---
 
@@ -402,6 +403,122 @@ for size in [5, 10, 15, 20]:
 
 ---
 
+## 🔧 Pipe Visualization System
+
+PHG includes a specialized pipe visualization system for creating 3D pipe structures from simple string commands.
+
+### Pipe String Commands
+
+- **F** - Forward (move forward in current direction)
+- **B** - Back (move backward in current direction)
+- **R** - Right (turn right and move)
+- **L** - Left (turn left and move)
+- **U** - Up (turn up and move)
+- **D** - Down (turn down and move)
+
+### World Coordinate System
+
+World coordinate pipes use absolute directions regardless of current orientation:
+
+```python
+import phg
+from coordinate_system import vec3, quat, coord3
+
+# Create a pipe in world coordinates
+# F moves along world Z+, R moves along world X+, etc.
+start_pos = coord3(vec3(0, 0, 0), quat(1, 0, 0, 0))
+phg_script = phg.world_pipestr_vis("FFRRUD", start_pos)
+
+# Custom pipe appearance
+phg.world_pipestr_vis(
+    "FFLLUU",
+    start_pos,
+    pipe_color=(255, 100, 50),  # Orange pipe
+    pipe_radius=0.5               # Thicker pipe
+)
+```
+
+### Local Coordinate System
+
+Local coordinate pipes use directions relative to current orientation:
+
+```python
+import phg
+from coordinate_system import vec3, quat, coord3
+
+# Create a pipe in local coordinates
+# F moves forward relative to current orientation
+start_pos = coord3(vec3(0, 0, 0), quat(1, 0, 0, 0))
+phg_script = phg.local_pipestr_vis("FFRRUD", start_pos)
+
+# The same string produces different results in local vs world coordinates
+phg.local_pipestr_vis(
+    "FFRRFF",  # Forward, Forward, Right turn, Right turn, Forward, Forward
+    start_pos,
+    pipe_color=(0, 255, 100)  # Green pipe
+)
+```
+
+### Direct PHG Script Generation
+
+For advanced use cases, you can generate PHG scripts without immediate visualization:
+
+```python
+import phg
+from coordinate_system import vec3, quat, coord3
+
+start = coord3(vec3(5, 0, 0), quat(1, 0, 0, 0))
+
+# Generate PHG script for world coordinates
+world_phg = phg.world_pipe_to_phg("FFRUD", start)
+
+# Generate PHG script for local coordinates
+local_phg = phg.local_pipe_to_phg("FFRUD", start)
+
+# Visualize later
+phg.vis(world_phg)
+```
+
+### Example: Complex Pipe System
+
+```python
+import phg
+from coordinate_system import vec3, quat, coord3
+
+# Create a complex pipe network
+def create_pipe_network():
+    # Main pipeline
+    main_pipe = phg.world_pipestr_vis(
+        "FFFFRRFFRRUUFFLLFF",
+        coord3(vec3(0, 0, 0), quat(1, 0, 0, 0)),
+        pipe_color=(100, 100, 255),
+        pipe_radius=0.5
+    )
+
+    # Branch 1
+    branch1 = phg.world_pipestr_vis(
+        "RRUUFFFF",
+        coord3(vec3(4, 0, 0), quat(1, 0, 0, 0)),
+        pipe_color=(255, 100, 100),
+        pipe_radius=0.3
+    )
+
+    # Branch 2
+    branch2 = phg.local_pipestr_vis(
+        "FFLLDDFF",
+        coord3(vec3(8, 2, 2), quat(1, 0, 0, 0)),
+        pipe_color=(100, 255, 100),
+        pipe_radius=0.3
+    )
+
+    return main_pipe, branch1, branch2
+
+# Create and visualize the network
+pipes = create_pipe_network()
+```
+
+---
+
 ## 💡 Complete Examples
 
 ### Example 1: Simple Geometry
@@ -581,7 +698,6 @@ Recommended maximum resolution is **4096 x 4096**. Excessively large resolutions
 ## 🔗 Links
 
 - [PyPI Package](https://pypi.org/project/phg/)
-- [Official Documentation](https://your.documentation.link)
 - [Mathematical Foundation](https://github.com/panguojun/Coordinate-System)
 
 ---

{phg_vis-1.3.0.dist-info → phg_vis-1.3.2.dist-info}/RECORD

@@ -1,5 +1,6 @@
-phg/__init__.py,sha256=S4sIzZXdanLEJ9y407hse4Vm3lLhC_aczBKb4-koiJw,2265
+phg/__init__.py,sha256=kH5hF-vqbLqzBE_xkOYabiYFtdb4CXtlwl67uPbDHpo,10767
 phg/phg_to_shader.py,sha256=rb_LnGE1Py08oz72ES5CnjyCDbjVWDU3If0cYZq4SUU,15172
+phg/pipe_string_phg.py,sha256=xoG8AtHRae_sOskSZxTc7lBgwnemv1u8Ko9GvnvHr8Q,16257
 phg/shader_render.py,sha256=_T8IFp1h5Hcj8TMMHwFMbxhGdHLnOqka7pJ4pde7zMA,16780
 phg/visphg.py,sha256=CtALoNJs0eDT8wnXk_76XG4UsOcV6cWucvWqz7AhOSc,1923
 phg/vis/GCU.dll,sha256=k_slWZ5nOzZNi9zCe0_SKc0F7zXoLyRuRDomyirPY4I,2687488
@@ -11,11 +12,11 @@ phg/vis/pycoder.exe,sha256=joyuVRBleLmOsxQjaq1iauHxC0BbQGKf8Mnwmx4xrVA,61440
 phg/vis/script.phg,sha256=HfEBk9omTAfm-KywupQwAwqgHqsr5hCS0f7gfBH1mYY,123
 phg/vis/sqlite3.dll,sha256=pTf_jpQLK7vaDLipxp4qhPB_MkByPgC-RKXTmmKiy_w,1066496
 phg/vis/vis.exe,sha256=9LGgETiO4lwhz_gJzdUg6gPP9EwGLT5SuLjN3wR2sso,1388032
-phg/vis/vis.ini,sha256=bmF3_kgbLAkiNBQi0ErDE9laZjvOmUSb9GQAISV8qeA,161
+phg/vis/vis.ini,sha256=IjS0Av2BqresPR2oGCOoq5zliXN2wFRMK3rXcU15vKs,161
 phg/vis/zlib1.dll,sha256=oVw_r326ve3oveVZhlSiF8BloZQ6lfqXJEAhUYfMjOQ,89088
 phg/vis/imgui/main.lua,sha256=AIB5dpGrPHXuRiNW7Bg7eu5Lpi2DDcn6n4JS7OS1Hdk,4742
-phg_vis-1.3.0.dist-info/LICENSE,sha256=tDnRkJxBYPzWdfh2gArRqrUPJxQZRZHJVs68qqBHIq4,1083
-phg_vis-1.3.0.dist-info/METADATA,sha256=WojwMRgNuv5I1tbH0VosycYadyq1KQwhUkNNDZZ6mYA,14855
-phg_vis-1.3.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-phg_vis-1.3.0.dist-info/top_level.txt,sha256=5GGhpTP8yi-zTXwW2HrI-zcxKxIM_nHXhL7r0iIDE_k,4
-phg_vis-1.3.0.dist-info/RECORD,,
+phg_vis-1.3.2.dist-info/LICENSE,sha256=tDnRkJxBYPzWdfh2gArRqrUPJxQZRZHJVs68qqBHIq4,1083
+phg_vis-1.3.2.dist-info/METADATA,sha256=gMSdSe_22WeBMCBSxhLdpIYV4EbiP7NhJPVf_FnKQKU,17945
+phg_vis-1.3.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+phg_vis-1.3.2.dist-info/top_level.txt,sha256=5GGhpTP8yi-zTXwW2HrI-zcxKxIM_nHXhL7r0iIDE_k,4
+phg_vis-1.3.2.dist-info/RECORD,,