Create app.py

app.py

@@ -0,0 +1,149 @@
+import gradio as gr
+import matplotlib.pyplot as plt
+import matplotlib.image as mpimg
+import numpy as np
+import random
+import threading
+import time
+
+# 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
+obstacles = []
+auto_mode = True
+
+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)
+
+def reset_sim(count):
+    global pose, trajectory, obstacles, obstacle_hits, color_index
+    pose = {"x": 0, "z": 0, "angle": 0}
+    trajectory = [(0, 0)]
+    obstacle_hits.clear()
+    color_index = 0
+    obstacles[:] = generate_obstacles(int(count))
+    return render_env(), render_slam_map(), f"Simulation Reset with {count} obstacles"
+
+def check_collision(x, z):
+    if abs(x) > 10 or abs(z) > 10:
+        return True
+    for obs in obstacles:
+        dist = np.sqrt((obs["x"] - x)**2 + (obs["z"] - z)**2)
+        if dist <= obs["radius"] + 0.3:
+            return True
+    return False
+
+def try_move(dx, dz):
+    global pose, trajectory
+    new_x = pose["x"] + dx
+    new_z = pose["z"] + dz
+    if not check_collision(new_x, new_z):
+        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 True
+    return False
+
+def smart_auto_step():
+    directions = [(0, 1), (-1, 0), (1, 0), (0, -1)]  # N, W, E, S
+    random.shuffle(directions)
+    for dx, dz in directions:
+        if try_move(dx, dz):
+            return f"Moved to ({pose['x']:.1f}, {pose['z']:.1f})"
+    return "No movement: blocked by obstacles"
+
+def render_env():
+    global obstacle_hits
+    fig, ax = plt.subplots(figsize=(5, 5))
+    ax.set_xlim(-10, 10)
+    ax.set_ylim(-10, 10)
+    ax.set_title("SLAM Environment View")
+
+    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)
+
+    # Clear and regenerate hits
+    obstacle_hits.clear()
+    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)
+    return fig
+
+def render_slam_map():
+    global color_index
+    fig, ax = plt.subplots(figsize=(5, 5))
+    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 % len(rgb_colors)]
+        for hit in obstacle_hits[-20:]:
+            ax.plot(hit[0], hit[1], 'o', color=current_color, markersize=6)
+        color_index += 1
+
+    plt.close(fig)
+    return fig
+
+def auto_movement(update_callback):
+    while auto_mode:
+        msg = smart_auto_step()
+        env = render_env()
+        slam = render_slam_map()
+        update_callback(env, slam, msg)
+        time.sleep(0.5)
+
+# Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown("## 🤖 Automatic SLAM Snake-like Navigation")
+
+    obstacle_slider = gr.Slider(1, 20, value=10, step=1, label="Number of Obstacles")
+    status_text = gr.Textbox(label="Status", interactive=False)
+
+    with gr.Row():
+        with gr.Column():
+            env_plot = gr.Plot(label="Robot View")
+        with gr.Column():
+            slam_plot = gr.Plot(label="SLAM Map")
+
+    reset = gr.Button("🔄 Reset")
+
+    reset.click(fn=reset_sim, inputs=[obstacle_slider], outputs=[env_plot, slam_plot, status_text])
+
+    def update_ui(e, s, t):
+        env_plot.update(value=e)
+        slam_plot.update(value=s)
+        status_text.update(value=t)
+
+    # Start auto mode immediately
+    thread = threading.Thread(target=auto_movement, args=(update_ui,), daemon=True)
+    thread.start()
+
+demo.launch()