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

phg/pipe_string_phg.py

@@ -6,18 +6,27 @@ This module provides functionality to convert pipe strings into PHG (Python Grap
 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
+- world_pipestr_vis: Direct visualization for world coordinate pipes (converts to local first)
 - local_pipestr_vis: Direct visualization for local coordinate pipes
+- multiple_pipes_vis: Advanced visualization for multiple pipes
 
 Pipe String Format:
-- F: Forward
-- B: Backward  
-- R: Right
-- L: Left
-- U: Up
-- D: Down
+World Coordinate System:
+- N: North (World X+)
+- S: South (World X-)
+- E: East (World Z+)
+- W: West (World Z-)
+- U: Up (World Y+)
+- D: Down (World Y-)
+
+Local Coordinate System:
+- F: Forward (Local Z+)
+- B: Backward (Local Z-)
+- R: Right (Local X+)
+- L: Left (Local X-)
+- U: Up (Local Y+)
+- D: Down (Local Y-)
 """
 
 import phg
@@ -27,124 +36,90 @@ 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):
+def world_to_local_pipe_str(world_pipe_str, start_c):
     """
-    Convert world coordinate system pipe string to PHG script
+    Convert world coordinate system pipe string to local coordinate system
     
     Parameters:
-        world_pipe_str: World coordinate pipe string (e.g., "FFRUD")
+        world_pipe_str: World coordinate pipe string (e.g., "NNEUD")
         start_c: Starting coordinate system
-        pipe_color: Pipe color as (R, G, B) tuple
-        pipe_radius: Pipe radius
     
     Returns:
-        PHG script string
+        Local coordinate pipe 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-)
+    if not world_pipe_str:
+        return ""
+
+    # World coordinate system direction definitions (cardinal directions)
+    directions = {
+        'E': vec3(1, 0, 0),   # East (X+)
+        'W': vec3(-1, 0, 0),  # West (X-)
+        'N': vec3(0, 0, 1),   # North (Z+)
+        'S': vec3(0, 0, -1),  # South (Z-)
+        'U': vec3(0, 1, 0),   # Up (Y+)
+        'D': vec3(0, -1, 0)   # Down (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;}}'
+    # Local coordinate system direction definitions
+    local_directions = {
+        'F': vec3(0, 0, 1),   # Forward (local Z+)
+        'B': vec3(0, 0, -1),  # Backward (local Z-)
+        'R': vec3(1, 0, 0),   # Right (local X+)
+        'L': vec3(-1, 0, 0),  # Left (local X-)
+        'U': vec3(0, 1, 0),   # Up (local Y+)
+        'D': vec3(0, -1, 0)   # Down (local Y-)
     }
 
-    # 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")
+    # Initialize local coordinate system
+    cur_c = start_c.Q()
+    local_pipe_str = ""
+
+    for i, move in enumerate(world_pipe_str):
+        if move not in directions:
             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
+
+        # Get movement direction vector in world coordinate system
+        world_dir = directions[move]
+
+        # Transform world direction vector to current local coordinate system
+        local_dir = world_dir / cur_c
+
+        # Find the component with largest absolute value to determine primary 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
+
+        # Determine movement direction based on the largest component
         if max_idx == 0:  # X-axis
-            local_move = 'R' if local_dir.x > 0 else 'L'
+            local_move = 'L' if local_dir.x > 0 else 'R'
         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
+            local_move = 'F' if local_dir.z > 0 else 'B' # NO BACKWARD!
+
+        # Debug first 8 characters
+        if i < 8:
+            print(f"      [{i}] world:'{move}' → local_dir:({local_dir.x:.2f},{local_dir.y:.2f},{local_dir.z:.2f}) → local:'{local_move}', uz:({cur_c.uz.x:.2f},{cur_c.uz.y:.2f},{cur_c.uz.z:.2f})")
+
+        local_pipe_str += local_move
+
+        # Update local coordinate system (when turning)
+        if local_move == 'R':
             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)
+            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)
+            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
-
+            
+    return local_pipe_str
 
-def local_pipe_to_phg(local_pipe_str, start_c, pipe_color=DEFAULT_PIPE_COLOR, pipe_radius=DEFAULT_PIPE_RADIUS):
+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
 
@@ -161,10 +136,10 @@ def local_pipe_to_phg(local_pipe_str, start_c, pipe_color=DEFAULT_PIPE_COLOR, pi
     # Parse color
     r, g, b = pipe_color
 
-    # Pipe component mapping (all components use fixed length 1.0)
+    # Pipe component mapping
     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}}',
+        'B': f'{{{{rgb:{r},{g},{b};md:cylinder {pipe_radius} 1.0;rx:-90;z:-1.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;}}',
@@ -195,15 +170,31 @@ def local_pipe_to_phg(local_pipe_str, start_c, pipe_color=DEFAULT_PIPE_COLOR, pi
     <{inner_script}>}}
     }}"""
 
-    return complete_script
-
+    return complete_script
+
+
+def world_pipe_to_phg(world_pipe_str, start_c, pipe_color=DEFAULT_PIPE_COLOR, pipe_radius=DEFAULT_PIPE_RADIUS):
+    """
+    Convert world coordinate pipe string to PHG script.
+
+    Parameters:
+        world_pipe_str: World coordinate pipe string (e.g., "NNEUD")
+        start_c: Starting coordinate system
+        pipe_color: Pipe color as (R, G, B) tuple
+        pipe_radius: Pipe radius
+
+    Returns:
+        PHG script string
+    """
+    local_pipe_str = world_to_local_pipe_str(world_pipe_str, start_c)
+    return local_pipe_to_phg(local_pipe_str, start_c, pipe_color, pipe_radius)
 
 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"])
+        world_pipe_strs: World coordinate pipe string or list of strings (e.g., "NNEUD" or ["NNE", "SSU"])
         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
@@ -233,7 +224,10 @@ def world_pipestr_vis(world_pipe_strs, start_c=None, pipe_colors=None, pipe_radi
     # 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)
+        # Convert world coordinate pipe string to local coordinate system first
+        local_pipe_str = world_to_local_pipe_str(pipe_str, start_c)
+        # Generate PHG script from local pipe string
+        phg_script = local_pipe_to_phg(local_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)
@@ -244,13 +238,12 @@ def world_pipestr_vis(world_pipe_strs, start_c=None, pipe_colors=None, pipe_radi
     # Call visualization function
     try:
         phg.vis(combined_script)
-        print(f"Visualizing {len(world_pipe_strs)} world coordinate pipes")
+        print(f"Visualizing {len(world_pipe_strs)} world coordinate pipes (converted to local)")
     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
@@ -303,7 +296,6 @@ def local_pipestr_vis(local_pipe_strs, start_c=None, pipe_colors=None, pipe_radi
 
     return combined_script
 
-
 def multiple_pipes_vis(pipe_configs, coordinate_system='world'):
     """
     Advanced visualization for multiple pipes with individual configurations
@@ -328,8 +320,11 @@ def multiple_pipes_vis(pipe_configs, coordinate_system='world'):
         radius = config.get('radius', DEFAULT_PIPE_RADIUS)
         
         if coordinate_system.lower() == 'world':
-            phg_script = world_pipe_to_phg(pipe_str, start_c, color, radius)
+            # Convert world coordinate pipe string to local coordinate system first
+            local_pipe_str = world_to_local_pipe_str(pipe_str, start_c)
+            phg_script = local_pipe_to_phg(local_pipe_str, start_c, color, radius)
         else:
+            # Use local coordinate pipe string directly
             phg_script = local_pipe_to_phg(pipe_str, start_c, color, radius)
         
         # Extract inner content
@@ -348,16 +343,22 @@ def multiple_pipes_vis(pipe_configs, coordinate_system='world'):
     
     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
+    # Example 1: World coordinate pipe string visualization
+    example_world_pipe = "NNEUD"  # North twice, east, up, down
     print("World Coordinate Pipe Example:")
-    phg_script = world_pipe_to_phg(example_world_pipe, start_coord)
+    print(f"Original world pipe: '{example_world_pipe}'")
+    
+    # Convert to local coordinate system
+    local_pipe_str = world_to_local_pipe_str(example_world_pipe, start_coord)
+    print(f"Converted to local: '{local_pipe_str}'")
+    
+    # Generate PHG script
+    phg_script = local_pipe_to_phg(local_pipe_str, start_coord)
     print("Generated PHG Script:")
     print(phg_script)
     print()
@@ -374,7 +375,7 @@ if __name__ == "__main__":
     print("Multiple Pipes Visualization Example:")
     
     # Multiple world coordinate pipes with different colors
-    world_pipes = ["FFR", "LLU", "RRD"]
+    world_pipes = ["NNE", "SSU", "EEW"]
     world_colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255)]  # Red, Green, Blue
     world_pipestr_vis(world_pipes, start_coord, world_colors)
     print()
@@ -389,23 +390,50 @@ if __name__ == "__main__":
     print("Advanced Multiple Pipes Configuration:")
     pipe_configs = [
         {
-            'pipe_str': 'FFR',
+            'pipe_str': 'NNE',
             'start_c': coord3(vec3(0, 0, 0), quat(1, 0, 0, 0)),
             'color': (255, 100, 100),
             'radius': 0.4
         },
         {
-            'pipe_str': 'LLU', 
+            'pipe_str': 'SSU', 
             'start_c': coord3(vec3(5, 0, 0), quat(1, 0, 0, 0)),
             'color': (100, 255, 100),
             'radius': 0.3
         },
         {
-            'pipe_str': 'RRD',
+            'pipe_str': 'FFR',  # Local coordinate pipe
             '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')
+    # Visualize with mixed coordinate systems
+    multiple_pipes_vis(pipe_configs, 'world')  # First two are world, third is local but will be treated as world
+    print()
+
+    # Example 5: Explicit coordinate system specification
+    print("Explicit Coordinate System Example:")
+    world_configs = [
+        {
+            'pipe_str': 'NNE',
+            'start_c': coord3(vec3(0, 0, 0), quat(1, 0, 0, 0)),
+            'color': (255, 0, 0),
+            'radius': 0.3
+        }
+    ]
+    
+    local_configs = [
+        {
+            'pipe_str': 'FFR',
+            'start_c': coord3(vec3(3, 0, 0), quat(1, 0, 0, 0)),
+            'color': (0, 255, 0),
+            'radius': 0.3
+        }
+    ]
+    
+    # Visualize world coordinate pipe
+    world_result = multiple_pipes_vis(world_configs, 'world')
+    # Visualize local coordinate pipe
+    local_result = multiple_pipes_vis(local_configs, 'local')

phg/shader_render.py

@@ -1,9 +1,18 @@
-import pygame
-import numpy as np
-from OpenGL.GL import *
-from OpenGL.GL.shaders import compileProgram, compileShader
-import sys
-import time
+import sys
+import time
+
+try:
+    import pygame
+    import numpy as np
+    from OpenGL.GL import *  # noqa: F401,F403 - OpenGL symbols used dynamically
+    from OpenGL.GL.shaders import compileProgram, compileShader
+    _IMPORT_ERROR = None
+except Exception as exc:  # pragma: no cover - optional dependency
+    pygame = None
+    np = None
+    compileProgram = None
+    compileShader = None
+    _IMPORT_ERROR = exc
 
 class Camera:
     """Camera class with mouse interaction controls"""
@@ -93,7 +102,7 @@ def normalize(v):
         return v
     return v / norm
 
-class ShaderRenderer:
+class ShaderRenderer:
     """
     Shader renderer class for visualizing GLSL shaders
     
@@ -102,15 +111,20 @@ class ShaderRenderer:
     renderer.render_shader(fragment_shader_code)
     """
     
-    def __init__(self, width=800, height=600, title="Shader Renderer"):
-        """
-        Initialize Shader renderer
+    def __init__(self, width=800, height=600, title="Shader Renderer"):
+        """
+        Initialize Shader renderer
         
         Args:
             width: Window width
             height: Window height  
             title: Window title
-        """
+        """
+        if _IMPORT_ERROR is not None:
+            raise ImportError(
+                "ShaderRenderer requires pygame, numpy, and PyOpenGL. "
+                "Install with: pip install phg_vis[shader]"
+            ) from _IMPORT_ERROR
         self.width = width
         self.height = height
         self.title = title
@@ -422,4 +436,4 @@ def render_shader(fragment_shader, width=800, height=600, duration=0, title="Sha
     renderer = ShaderRenderer(width, height, title)
     success = renderer.render_shader(fragment_shader, duration)
     renderer.close()
-    return success
+    return success

phg/visphg.py

@@ -1,55 +1,79 @@
-#################################
-# Launch vis.exe
-#################################
-import http.client
-import subprocess
-import os
-import psutil  # Make sure to import psutil
-
-# Set the path to vis.exe in the current directory of the current script
-current_directory = os.path.dirname(os.path.abspath(__file__))
-vis_exe_path = os.path.join(current_directory, "vis", "vis.exe")
-print(vis_exe_path)
-# Check if vis.exe is running
-def is_vis_running():
-    for proc in psutil.process_iter(['name']):
-        if proc.info['name'] == 'vis.exe':
-            return True
-    return False
-    
-# Send network message
-def HTTPPOST(ip, phg):
-    headers = {
-        "Connection": "keep-alive",
-        "Content-Type": "text/plain"
-    }
-    conn = http.client.HTTPConnection(f"{ip}:5088")
-    conn.request('POST', '/phg', phg, headers)
-    res = conn.getresponse()
-    conn.close()
-    
-# Call HTTPPOST function to send network message
-def vis(phg):
-    if not is_vis_running():  # Check if the process is running
-        subprocess.Popen(vis_exe_path)  # Start the process
-    return HTTPPOST('127.0.0.1', phg.encode())    
-    
-# Send network message
-def HTTPPOST_IMG(ip, phg, filename='shot.png'):
-    headers = {
-        "Connection": "keep-alive",
-        "Content-Type": "text/plain"
-    }
-    # 构建完整的请求体: phg代码 ||| 渲染参数(包含文件名)
-    request_body = f"{phg}|||file={filename}"
-
-    conn = http.client.HTTPConnection(f"{ip}:5088")
-    conn.request('POST', '/phg_img', request_body, headers)
-    res = conn.getresponse()
-    conn.close()
-
-# Call HTTPPOST function to send network message
-def image(phg, filename='shot.png'):
-    if not is_vis_running():  # Check if the process is running
-        subprocess.Popen(vis_exe_path)  # Start the process
-    return HTTPPOST_IMG('127.0.0.1', phg.encode('utf-8').decode('utf-8'), filename)        
+#################################
+# Launch vis.exe
+#################################
+import http.client
+import os
+import re
+import subprocess
+
+try:
+    import psutil
+except Exception:  # pragma: no cover - optional dependency
+    psutil = None
+
+# Set the path to vis.exe in the current directory of the current script
+current_directory = os.path.dirname(os.path.abspath(__file__))
+vis_exe_path = os.path.join(current_directory, "vis", "vis.exe")
+
+
+# Check if vis.exe is running
+def is_vis_running():
+    if psutil is None:
+        return False
+    for proc in psutil.process_iter(["name"]):
+        if proc.info.get("name") == "vis.exe":
+            return True
+    return False
+
+
+# Send network message
+def HTTPPOST(ip, phg):
+    headers = {
+        "Connection": "keep-alive",
+        "Content-Type": "text/plain",
+    }
+    conn = http.client.HTTPConnection(f"{ip}:5088")
+    conn.request("POST", "/phg", phg, headers)
+    conn.getresponse()
+    conn.close()
+
+
+# Call HTTPPOST function to send network message
+def vis(phg):
+    if not is_vis_running():
+        subprocess.Popen(vis_exe_path)
+    return HTTPPOST("127.0.0.1", phg.encode())
+
+
+# Build image request payload with parameters
+def _build_img_request(phg, filename):
+    if "|||" not in phg:
+        return f"{phg}|||file={filename}"
+    code, params = phg.split("|||", 1)
+    params = params.strip()
+    if "file=" in params:
+        params = re.sub(r"file=\\S+", f"file={filename}", params)
+    else:
+        params = f"{params} file={filename}".strip()
+    return f"{code}|||{params}"
+
+
+# Send image request
+def HTTPPOST_IMG(ip, phg, filename="shot.png"):
+    headers = {
+        "Connection": "keep-alive",
+        "Content-Type": "text/plain",
+    }
+    request_body = _build_img_request(phg, filename)
+
+    conn = http.client.HTTPConnection(f"{ip}:5088")
+    conn.request("POST", "/phg_img", request_body, headers)
+    conn.getresponse()
+    conn.close()
+
+
+# Call HTTPPOST function to send network message
+def image(phg, filename="shot.png"):
+    if not is_vis_running():
+        subprocess.Popen(vis_exe_path)
+    return HTTPPOST_IMG("127.0.0.1", phg.encode("utf-8").decode("utf-8"), filename)