Create app.py

app.py

@@ -0,0 +1,1414 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()# app.py
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import gradio as gr
+from scipy.optimize import minimize
+
+# Define forward kinematics (simplified example)
+def forward_kinematics(theta):
+    x = np.cos(theta[0]) + np.cos(theta[1]) + np.cos(theta[2])
+    y = np.sin(theta[0]) + np.sin(theta[1]) + np.sin(theta[2])
+    z = theta[3] + theta[4] + theta[5]
+    return np.array([x, y, z])
+
+# Define obstacle positions (example)
+obstacles = [
+    {"position": np.array([0.5, 0.5, 0.5]), "radius": 0.2},
+    {"position": np.array([1.0, 1.0, 1.0]), "radius": 0.3}
+]
+
+# Check for collisions with obstacles
+def is_collision(position):
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        distance = np.linalg.norm(position - obstacle_position)
+        if distance < obstacle_radius:
+            return True  # Collision detected
+    return False  # No collision
+
+# Define inverse kinematics with obstacle avoidance
+def inverse_kinematics(target_position, initial_angles):
+    def error_function(theta):
+        current_position = forward_kinematics(theta)
+        error = np.linalg.norm(target_position - current_position)
+        if is_collision(current_position):
+            error += 1000  # Large penalty for collisions
+        return error
+    
+    result = minimize(error_function, initial_angles, method='BFGS')
+    return result.x
+
+# Generate trajectory (from initial to target position)
+def generate_trajectory(target_position):
+    initial_angles = [0, 0, 0, 0, 0, 0]  # Initial joint angles
+    target_angles = inverse_kinematics(target_position, initial_angles)
+    trajectory = np.linspace(initial_angles, target_angles, 50)  # Reduced to 50 points
+    return trajectory
+
+# Plot the trajectory in 3D with obstacles
+def plot_trajectory(trajectory):
+    x, y, z = [], [], []
+    for theta in trajectory:
+        position = forward_kinematics(theta)
+        x.append(position[0])
+        y.append(position[1])
+        z.append(position[2])
+    
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot(x, y, z, label="Robot Trajectory")
+    ax.scatter(x[0], y[0], z[0], color='green', label="Start")
+    ax.scatter(x[-1], y[-1], z[-1], color='red', label="Target")
+    
+    # Plot obstacles
+    for obstacle in obstacles:
+        obstacle_position = obstacle["position"]
+        obstacle_radius = obstacle["radius"]
+        u, v = np.mgrid[0:2*np.pi:20j, 0:np.pi:10j]
+        x_obs = obstacle_position[0] + obstacle_radius * np.cos(u) * np.sin(v)
+        y_obs = obstacle_position[1] + obstacle_radius * np.sin(u) * np.sin(v)
+        z_obs = obstacle_position[2] + obstacle_radius * np.cos(v)
+        ax.plot_wireframe(x_obs, y_obs, z_obs, color='orange', alpha=0.5, label="Obstacle" if obstacle == obstacles[0] else "")
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.legend()
+    return fig
+
+# Gradio Interface
+def gradio_interface(x, y, z):
+    target_position = np.array([x, y, z])
+    trajectory = generate_trajectory(target_position)
+    fig = plot_trajectory(trajectory)
+    return fig
+
+# Launch Gradio App
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Number(label="Target X"),
+        gr.Number(label="Target Y"),
+        gr.Number(label="Target Z")
+    ],
+    outputs="plot",
+    live=False,
+    title="6-DOF Robot Path Planning with Obstacle Avoidance",
+    description="Enter the target (x, y, z) position and click Submit to generate the optimized trajectory."
+)
+
+iface.launch()