Update app.py

app.py

@@ -1,213 +1,102 @@
-
 import gradio as gr
 import matplotlib.pyplot as plt
-import matplotlib.patches as patches
-import matplotlib.image as mpimg
 import numpy as np
 import random
-import os
-import threading
-import time
-from IPython.display import Audio, display
 
-# Global state
-pose = {"x": 0, "z": 0, "angle": 0}
-trajectory = [(0, 0)]
-obstacle_hits = []
-color_index = 0
-rgb_colors = ['red', 'green', 'blue']
-noise_enabled = True
+# Robot and environment variables
+pose = [250, 250, 0]
+trajectory = []
 obstacles = []
 auto_mode = False
 
-# Generate obstacles
-def generate_obstacles(count=10):
-    return [{
-        "x": random.uniform(-8, 8),
-        "z": random.uniform(-8, 8),
-        "radius": random.uniform(0.5, 1.2)
-    } for _ in range(count)]
-
-obstacles = generate_obstacles(10)
-
-# Toggle noise
-def toggle_noise():
-    global noise_enabled
-    noise_enabled = not noise_enabled
-    return "Noise: ON" if noise_enabled else "Noise: OFF"
+def generate_obstacles(num_obstacles=5):
+    global obstacles
+    obstacles = []
+    for _ in range(num_obstacles):
+        x = random.randint(50, 450)
+        y = random.randint(50, 450)
+        w = random.randint(20, 50)
+        h = random.randint(20, 50)
+        obstacles.append((x, y, w, h))
 
-# Reset simulation
-def reset_sim(count):
-    global pose, trajectory, obstacles, obstacle_hits, color_index
-    pose = {"x": 0, "z": 0, "angle": 0}
-    trajectory = [(0, 0)]
-    obstacle_hits = []
-    color_index = 0
-    obstacles = generate_obstacles(int(count))
-    return render_env(), render_slam_map(), None, f"Simulation Reset with {count} obstacles"
-
-# Check collision
-def check_collision(x, z):
-    for obs in obstacles:
-        dist = np.sqrt((obs["x"] - x)**2 + (obs["z"] - z)**2)
-        if dist <= obs["radius"] + 0.2:
-            return True
-    return False
-
-# Movement logic
 def move_robot(direction):
     global pose, trajectory
-    step = 1
-    direction = direction.upper()
-
+    dx, dy = 0, 0
+    step_size = 10
     if direction == "W":
-        new_x, new_z = pose["x"], pose["z"] + step
-        pose["angle"] = 90
+        dy = -step_size
     elif direction == "S":
-        new_x, new_z = pose["x"], pose["z"] - step
-        pose["angle"] = -90
+        dy = step_size
     elif direction == "A":
-        new_x, new_z = pose["x"] - step, pose["z"]
-        pose["angle"] = 180
+        dx = -step_size
     elif direction == "D":
-        new_x, new_z = pose["x"] + step, pose["z"]
-        pose["angle"] = 0
-    else:
-        return render_env(), render_slam_map(), None, "❌ Invalid Key"
+        dx = step_size
+    pose[0] += dx
+    pose[1] += dy
+    trajectory.append(tuple(pose[:2]))
+    return render_env(), render_slam_map(), None, f"Moved {direction}"
 
-    if check_collision(new_x, new_z):
-        # Play collision1.mp3 directly if in Jupyter/Colab
-        if os.path.exists("collision1.mp3"):
-            try:
-                display(Audio("collision1.mp3", autoplay=True))
-            except:
-                pass
-        return render_env(), render_slam_map(), None, "🚫 Collision detected!"
-
-    pose["x"], pose["z"] = new_x, new_z
-    if noise_enabled:
-        noisy_x = pose["x"] + random.uniform(-0.1, 0.1)
-        noisy_z = pose["z"] + random.uniform(-0.1, 0.1)
-        trajectory.append((noisy_x, noisy_z))
-    else:
-        trajectory.append((pose["x"], pose["z"]))
-
-    return render_env(), render_slam_map(), None, "Moved " + direction
-
-# Environment view
 def render_env():
-    global obstacle_hits
-    fig, ax = plt.subplots()
-    ax.set_xlim(-10, 10)
-    ax.set_ylim(-10, 10)
-    ax.set_title("SLAM Environment View")
-
-    try:
-        bg = mpimg.imread("map.png")
-        ax.imshow(bg, extent=(-10, 10, -10, 10), alpha=0.2)
-    except:
-        pass
-
-    for obs in obstacles:
-        circ = plt.Circle((obs["x"], obs["z"]), obs["radius"], color="gray", alpha=0.6)
-        ax.add_patch(circ)
-
-    ax.plot(pose["x"], pose["z"], 'ro', markersize=8)
-
-    angles = np.linspace(0, 2*np.pi, 24)
-    for ang in angles:
-        for r in np.linspace(0, 3, 30):
-            scan_x = pose["x"] + r * np.cos(ang)
-            scan_z = pose["z"] + r * np.sin(ang)
-            if check_collision(scan_x, scan_z):
-                ax.plot([pose["x"], scan_x], [pose["z"], scan_z], 'g-', linewidth=0.5)
-                obstacle_hits.append((scan_x, scan_z))
-                break
-
-    plt.close(fig)
+    fig, ax = plt.subplots(figsize=(5, 5))
+    ax.set_xlim(0, 500)
+    ax.set_ylim(0, 500)
+    ax.set_aspect('equal')
+    # Draw robot
+    ax.plot(pose[0], pose[1], 'bo', label="Robot")
+    ax.plot(*zip(*trajectory), 'b--', label="Trajectory")
+    # Draw obstacles
+    for (x, y, w, h) in obstacles:
+        ax.add_patch(plt.Rectangle((x, y), w, h, color='red'))
+    ax.legend()
+    plt.close()
     return fig
 
-# SLAM map
 def render_slam_map():
-    global color_index
-    fig, ax = plt.subplots()
-    ax.set_title("SLAM Trajectory Map")
-    x_vals = [x for x, z in trajectory]
-    z_vals = [z for x, z in trajectory]
-    ax.plot(x_vals, z_vals, 'bo-', markersize=3)
-    ax.grid(True)
-
-    if obstacle_hits:
-        current_color = rgb_colors[color_index % 3]
-        for hit in obstacle_hits[-20:]:
-            ax.plot(hit[0], hit[1], 'o', color=current_color, markersize=6)
-        color_index += 1
-
-    plt.close(fig)
+    fig, ax = plt.subplots(figsize=(5, 5))
+    ax.set_xlim(0, 500)
+    ax.set_ylim(0, 500)
+    ax.set_aspect('equal')
+    ax.plot(pose[0], pose[1], 'go', label="SLAM Robot")
+    ax.legend()
+    plt.close()
     return fig
 
-# Text command
-def handle_text_input(direction):
-    return move_robot(direction.strip().upper())
-
-# Auto movement thread
-def auto_movement(update_callback):
-    global auto_mode
-    directions = ['W', 'A', 'S', 'D']
-    while auto_mode:
-        direction = random.choice(directions)
-        env, slam, _, msg = move_robot(direction)
-        update_callback(env, slam, None, f"[AUTO] {msg}")
-        time.sleep(1)
-
-def toggle_auto_mode(env_plot, slam_plot, collision_audio, status_text):
-    global auto_mode
-    auto_mode = not auto_mode
+def toggle_auto(auto_state):
+    return not auto_state, "Auto mode ON" if not auto_state else "Auto mode OFF"
 
-    if auto_mode:
-        def update_ui(e, s, _, t):
-            env_plot.update(value=e)
-            slam_plot.update(value=s)
-            status_text.update(value=t)
+def auto_step(auto_state):
+    if auto_state:
+        direction = random.choice(["W", "A", "S", "D"])
+        return move_robot(direction)
+    return render_env(), render_slam_map(), None, "Auto mode is OFF"
 
-        thread = threading.Thread(target=auto_movement, args=(update_ui,))
-        thread.daemon = True
-        thread.start()
-        return "🟢 Auto Mode: ON"
-    else:
-        return "⚪ Auto Mode: OFF"
-
-# UI
+# Build Gradio UI
 with gr.Blocks() as demo:
-    gr.Markdown("## 🤖 SLAM Simulation with Auto Mode + Collision Sound (No Play Button)")
-
-    obstacle_slider = gr.Slider(1, 20, value=10, step=1, label="Number of Obstacles")
-    direction_input = gr.Textbox(label="Type W / A / S / D and press Enter", placeholder="e.g., W")
+    gr.Markdown("## SLAM Robot Demo with Auto Mode")
+    env_plot = gr.Plot()
+    slam_plot = gr.Plot()
+    collision_audio = gr.Audio(type="auto", label="Collision")
     status_text = gr.Textbox(label="Status")
-    collision_audio = gr.Audio(label="(Hidden) Collision Sound", interactive=False, visible=False)
 
-    with gr.Row():
-        with gr.Column():
-            env_plot = gr.Plot(label="Robot View")
-        with gr.Column():
-            slam_plot = gr.Plot(label="SLAM Map")
+    auto_state = gr.State(False)
 
     with gr.Row():
-        w = gr.Button("⬆️ W")
-        a = gr.Button("⬅️ A")
-        s = gr.Button("⬇️ S")
-        d = gr.Button("➡️ D")
-        reset = gr.Button("🔄 Reset")
-        toggle = gr.Button("🔀 Toggle Noise")
-        auto = gr.Button("🤖 Toggle Auto")
+        gr.Button("⬆️").click(fn=move_robot, inputs=gr.Textbox(value="W", visible=False), outputs=[env_plot, slam_plot, collision_audio, status_text])
+        gr.Button("⬇️").click(fn=move_robot, inputs=gr.Textbox(value="S", visible=False), outputs=[env_plot, slam_plot, collision_audio, status_text])
+        gr.Button("⬅️").click(fn=move_robot, inputs=gr.Textbox(value="A", visible=False), outputs=[env_plot, slam_plot, collision_audio, status_text])
+        gr.Button("➡️").click(fn=move_robot, inputs=gr.Textbox(value="D", visible=False), outputs=[env_plot, slam_plot, collision_audio, status_text])
+        auto_button = gr.Button("Toggle Auto Mode")
+
+    # Auto mode toggle updates state
+    auto_button.click(fn=toggle_auto, inputs=auto_state, outputs=[auto_state, status_text])
+
+    # Periodic polling that runs every second to check auto state
+    demo.load(fn=auto_step, inputs=auto_state, outputs=[env_plot, slam_plot, collision_audio, status_text], every=1)
+
+    demo.load(fn=lambda: (render_env(), render_slam_map(), None, "Ready"),
+              outputs=[env_plot, slam_plot, collision_audio, status_text])
 
-    w.click(fn=move_robot, inputs=gr.State("W"), outputs=[env_plot, slam_plot, collision_audio, status_text])
-    a.click(fn=move_robot, inputs=gr.State("A"), outputs=[env_plot, slam_plot, collision_audio, status_text])
-    s.click(fn=move_robot, inputs=gr.State("S"), outputs=[env_plot, slam_plot, collision_audio, status_text])
-    d.click(fn=move_robot, inputs=gr.State("D"), outputs=[env_plot, slam_plot, collision_audio, status_text])
-    reset.click(fn=reset_sim, inputs=[obstacle_slider], outputs=[env_plot, slam_plot, collision_audio, status_text])
-    toggle.click(fn=lambda: (None, None, None, toggle_noise()), outputs=[env_plot, slam_plot, collision_audio, status_text])
-    auto.click(fn=toggle_auto_mode, inputs=[env_plot, slam_plot, collision_audio, status_text], outputs=auto)
-    direction_input.submit(fn=handle_text_input, inputs=direction_input, outputs=[env_plot, slam_plot, collision_audio, status_text])
+    # Reset obstacles and robot pose
+    generate_obstacles()
 
 demo.launch()