phg-vis 1.3.1__tar.gz → 1.3.2__tar.gz

{phg_vis-1.3.1/phg_vis.egg-info → phg_vis-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: phg_vis
-Version: 1.3.1
+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

phg_vis-1.3.2/phg/__init__.py

@@ -0,0 +1,329 @@
+"""
+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
+)
+
+# Extend ShaderRenderer class to support direct PHG rendering
+class PHGShaderRenderer(ShaderRenderer):
+    """Shader renderer that supports direct PHG rendering"""
+    
+    def render_phg(self, phg_script: str, duration=0, interactive=True):
+        """
+        Render PHG script
+        
+        Parameters:
+            phg_script: PHG script code
+            duration: Render duration
+            interactive: Whether to allow interaction
+            
+        Returns:
+            success: Whether rendering was successful
+        """
+        converter = PHGToShaderConverter()
+        shader_code = converter.generate_shader_code(phg_script)
+        
+        if not shader_code:
+            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"):
+    """
+    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)
+    renderer.close()
+    return success
+
+def convert_phg_to_shader(phg_script: str) -> str:
+    """
+    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
+    
+    # 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))
+        
+        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'):
+    """
+    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__ = [
+    # Core visualization functions
+    'vis',
+    'image',
+
+    # Shader rendering
+    'ShaderRenderer',
+    'render_shader',
+    'render_phg',
+    'PHGShaderRenderer',
+
+    # PHG conversion
+    'PHGToShaderConverter',
+    'phg_to_shader',
+    'convert_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__ = "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")

phg_vis-1.3.2/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-1.3.1 → phg_vis-1.3.2/phg_vis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: phg_vis
-Version: 1.3.1
+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

{phg_vis-1.3.1 → phg_vis-1.3.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='phg_vis', 
-    version='1.3.1', 
+    version='1.3.2', 
     packages=find_packages(),
     include_package_data=True,
     description='A package for the PHG modeling language and 3D visualization tool.',

phg_vis-1.3.1/phg/__init__.py

@@ -1,113 +0,0 @@
-"""
-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
-- Real-time and image rendering capabilities
-
-Version: 0.2.0
-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
-)
-
-# Extend ShaderRenderer class to support direct PHG rendering
-class PHGShaderRenderer(ShaderRenderer):
-    """Shader renderer that supports direct PHG rendering"""
-    
-    def render_phg(self, phg_script: str, duration=0, interactive=True):
-        """
-        Render PHG script
-        
-        Parameters:
-            phg_script: PHG script code
-            duration: Render duration
-            interactive: Whether to allow interaction
-            
-        Returns:
-            success: Whether rendering was successful
-        """
-        converter = PHGToShaderConverter()
-        shader_code = converter.generate_shader_code(phg_script)
-        
-        if not shader_code:
-            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"):
-    """
-    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)
-    renderer.close()
-    return success
-
-def convert_phg_to_shader(phg_script: str) -> str:
-    """
-    Convert PHG script to GLSL shader code
-
-    Parameters:
-        phg_script: PHG script
-
-    Returns:
-        shader_code: GLSL shader code
-    """
-    return phg_to_shader(phg_script)
-
-__all__ = [
-    # Core visualization functions
-    'vis',
-    'image',
-
-    # Shader rendering
-    'ShaderRenderer',
-    'render_shader',
-    'render_phg',
-    'PHGShaderRenderer',
-
-    # PHG conversion
-    'PHGToShaderConverter',
-    'phg_to_shader',
-    'convert_phg_to_shader',
-
-    # Pipe visualization
-    'world_pipe_to_phg',
-    'local_pipe_to_phg',
-    'world_pipestr_vis',
-    'local_pipestr_vis',
-]
-
-__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")

phg_vis-1.3.1/phg/pipe_string_phg.py

@@ -1,285 +0,0 @@
-"""
-Pipe String to PHG Converter
-============================
-
-该模块提供了管道字符串转换为PHG（Python Graphics）脚本的功能。
-支持世界坐标系和局部坐标系两种管道描述方式。
-
-主要功能：
-- world_pipe_to_phg: 世界坐标系管道转换
-- local_pipe_to_phg: 局部坐标系管道转换
-- world_pipestr_vis: 世界坐标系管道直接可视化
-- local_pipestr_vis: 局部坐标系管道直接可视化
-
-管道字符串格式：
-- F: 前进 (Forward)
-- B: 后退 (Back)
-- R: 右转 (Right)
-- L: 左转 (Left)
-- U: 上转 (Up)
-- D: 下转 (Down)
-"""
-
-import phg
-from coordinate_system import vec3, quat, coord3
-
-# 默认颜色和管径
-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):
-    """
-    将世界坐标系下的管道字符串转换为PHG脚本
-    
-    参数:
-        world_pipe_str: 世界坐标系管道字符串（如 "FFRUD"）
-        start_c: 起始坐标系
-        pipe_color: 管道颜色，格式为(R, G, B)元组
-        pipe_radius: 管道半径
-    
-    返回:
-        PHG脚本字符串
-    """
-    
-    # 世界坐标系方向定义
-    world_directions = {
-        'F': vec3(0, 0, 1),   # 前（世界Z+）
-        'B': vec3(0, 0, -1),  # 后（世界Z-）
-        'R': vec3(1, 0, 0),   # 右（世界X+）
-        'L': vec3(-1, 0, 0),  # 左（世界X-）
-        'U': vec3(0, 1, 0),   # 上（世界Y+）
-        'D': vec3(0, -1, 0)   # 下（世界Y-）
-    }
-
-    # 解析颜色
-    r, g, b = pipe_color
-    
-    # 管道部件映射（所有部件使用固定长度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;}}'
-    }
-
-    # 初始化当前坐标系（使用起始坐标系）
-    cur_c = coord3(start_c.o, start_c.Q())
-    
-    # 存储所有管道部件的脚本
-    script_parts = []
-    
-    # 遍历管道字符串中的每个字符
-    for move_char in world_pipe_str:
-        if move_char not in pipe_components:
-            print(f"警告: 未知的管道字符 '{move_char}'，已跳过")
-            continue
-        
-        # 获取当前移动在世界坐标系中的方向
-        world_dir = world_directions[move_char]
-        
-        # 将世界方向转换到当前局部坐标系
-        local_dir = vec3(
-            world_dir.dot(cur_c.ux),  # 在局部X轴的分量
-            world_dir.dot(cur_c.uy),  # 在局部Y轴的分量
-            world_dir.dot(cur_c.uz)   # 在局部Z轴的分量
-        )
-        
-        # 找到绝对值最大的分量来确定主要移动方向
-        abs_components = [abs(local_dir.x), abs(local_dir.y), abs(local_dir.z)]
-        max_idx = abs_components.index(max(abs_components))
-        
-        # 根据最大分量确定局部移动方向
-        if max_idx == 0:  # X轴
-            local_move = 'R' if local_dir.x > 0 else 'L'
-        elif max_idx == 1:  # Y轴
-            local_move = 'U' if local_dir.y > 0 else 'D'
-        else:  # Z轴
-            local_move = 'F' if local_dir.z > 0 else 'B'
-        
-        # 添加对应的管道部件脚本
-        script_parts.append(pipe_components[local_move])
-        
-        # 更新当前坐标系（模拟移动后的新位置和方向）
-        if local_move == 'F':
-            # 前进：沿局部Z轴正方向移动1.0单位
-            cur_c = cur_c * coord3(vec3(0, 0, 1.0))
-        elif local_move == 'B':
-            # 后退：沿局部Z轴负方向移动1.0单位
-            cur_c = cur_c * coord3(vec3(0, 0, -1.0))
-        elif local_move == 'R':
-            # 右转：绕Y轴旋转-90度，然后沿X轴移动1.0单位
-            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':
-            # 左转：绕Y轴旋转90度，然后沿X轴移动1.0单位
-            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':
-            # 上转：绕X轴旋转90度，然后沿Y轴移动1.0单位
-            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':
-            # 下转：绕X轴旋转-90度，然后沿Y轴移动1.0单位
-            rotation = quat(-3.1416 / 2, cur_c.ux)
-            cur_c = cur_c * rotation
-            cur_c = cur_c * coord3(vec3(0, -1.0, 0))
-
-    # 组合所有管道部件的脚本
-    inner_script = ',\n'.join(script_parts)
-    
-    # 获取起始坐标系的四元数
-    q = start_c.Q()
-    
-    # 构建完整的PHG脚本
-    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):
-    """
-    将局部坐标系下的管道字符串转换为PHG脚本
-
-    参数:
-        local_pipe_str: 局部坐标系管道字符串（如 "FFRUD"）
-        start_c: 起始坐标系
-        pipe_color: 管道颜色，格式为(R, G, B)元组
-        pipe_radius: 管道半径
-
-    返回:
-        PHG脚本字符串
-    """
-
-    # 解析颜色
-    r, g, b = pipe_color
-
-    # 管道部件映射（所有部件使用固定长度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;}}'
-    }
-
-    # 存储所有管道部件的脚本
-    script_parts = []
-
-    # 遍历管道字符串中的每个字符
-    for move_char in local_pipe_str:
-        if move_char not in pipe_components:
-            print(f"警告: 未知的管道字符 '{move_char}'，已跳过")
-            continue
-
-        # 直接使用局部坐标系的移动命令
-        script_parts.append(pipe_components[move_char])
-
-    # 组合所有管道部件的脚本
-    inner_script = ',\n'.join(script_parts)
-
-    # 获取起始坐标系的四元数
-    q = start_c.Q()
-
-    # 构建完整的PHG脚本
-    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_str, start_c=None, pipe_color=DEFAULT_PIPE_COLOR, pipe_radius=DEFAULT_PIPE_RADIUS):
-    """
-    世界坐标系管道字符串直接可视化
-
-    参数:
-        world_pipe_str: 世界坐标系管道字符串（如 "FFRUD"）
-        start_c: 起始坐标系，默认为原点
-        pipe_color: 管道颜色，格式为(R, G, B)元组
-        pipe_radius: 管道半径
-
-    返回:
-        PHG脚本字符串
-    """
-    # 如果没有提供起始坐标系，使用默认原点
-    if start_c is None:
-        start_c = coord3(vec3(0, 0, 0), quat(1, 0, 0, 0))
-
-    # 生成PHG脚本
-    phg_script = world_pipe_to_phg(world_pipe_str, start_c, pipe_color, pipe_radius)
-
-    # 调用可视化函数
-    try:
-        from .visphg import vis
-        vis(phg_script)
-    except ImportError:
-        print("警告: 无法导入可视化模块，返回PHG脚本")
-
-    return phg_script
-
-
-def local_pipestr_vis(local_pipe_str, start_c=None, pipe_color=DEFAULT_PIPE_COLOR, pipe_radius=DEFAULT_PIPE_RADIUS):
-    """
-    局部坐标系管道字符串直接可视化
-
-    参数:
-        local_pipe_str: 局部坐标系管道字符串（如 "FFRUD"）
-        start_c: 起始坐标系，默认为原点
-        pipe_color: 管道颜色，格式为(R, G, B)元组
-        pipe_radius: 管道半径
-
-    返回:
-        PHG脚本字符串
-    """
-    # 如果没有提供起始坐标系，使用默认原点
-    if start_c is None:
-        start_c = coord3(vec3(0, 0, 0), quat(1, 0, 0, 0))
-
-    # 生成PHG脚本
-    phg_script = local_pipe_to_phg(local_pipe_str, start_c, pipe_color, pipe_radius)
-
-    # 调用可视化函数
-    try:
-        from .visphg import vis
-        vis(phg_script)
-    except ImportError:
-        print("警告: 无法导入可视化模块，返回PHG脚本")
-
-    return phg_script
-
-
-# 使用示例
-if __name__ == "__main__":
-    # 创建起始坐标系（示例）
-    start_coord = coord3(vec3(0, 0, 0), quat(1, 0, 0, 0))
-
-    # 示例1: 世界坐标系管道字符串
-    example_world_pipe = "FFRUD"  # 前进2次，右转，上转，下转
-    print("世界坐标系管道示例:")
-    phg_script = world_pipe_to_phg(example_world_pipe, start_coord)
-    print("生成的PHG脚本:")
-    print(phg_script)
-    print()
-
-    # 示例2: 局部坐标系管道字符串
-    example_local_pipe = "FFRUD"  # 在局部坐标系中的移动
-    print("局部坐标系管道示例:")
-    phg_script = local_pipe_to_phg(example_local_pipe, start_coord)
-    print("生成的PHG脚本:")
-    print(phg_script)
-    print()
-
-    # 示例3: 直接可视化
-    print("直接可视化示例:")
-    # world_pipestr_vis(example_world_pipe)  # 世界坐标系可视化
-    # local_pipestr_vis(example_local_pipe)  # 局部坐标系可视化