Update app.py

app.py

@@ -18,15 +18,8 @@ SCAN_ANGLE = 60
 SCAN_RESOLUTION = 30
 SCAN_RANGE_DEFAULT = 6.0
 OBSTACLE_COUNT = 10
-scan_range = 5.0  # or whatever range your LiDAR/scanner is expected to use
-
-
-# State variables
-robot_pose = {'x': 0.0, 'y': 0.0, 'angle': 0.0}
-trajectory = []
-slam_points = []
-obstacles = []
 
+# Utilities
 def to_canvas_coords(x, y):
     cx = int((x + WORLD_UNITS / 2) * SCALE)
     cy = int((WORLD_UNITS / 2 - y) * SCALE)
@@ -87,25 +80,30 @@ def move_robot(robot_pose, obstacles):
 def draw_environment(robot_pose, trajectory, obstacles):
     img = Image.new("RGB", (SPACE_SIZE, SPACE_SIZE), "white")
     draw = ImageDraw.Draw(img)
-    # Draw grid lines
-    for i in range(int(WORLD_UNITS)+1):
+    
+    # Grid
+    for i in range(int(WORLD_UNITS) + 1):
         x = int(i * SCALE)
-        draw.line([(x,0), (x, SPACE_SIZE)], fill=(230,230,230))
-        draw.line([(0,x), (SPACE_SIZE, x)], fill=(230,230,230))
-    # Draw obstacles
+        draw.line([(x, 0), (x, SPACE_SIZE)], fill=(230, 230, 230))
+        draw.line([(0, x), (SPACE_SIZE, x)], fill=(230, 230, 230))
+    
+    # Obstacles
     for ox, oy in obstacles:
         cx, cy = to_canvas_coords(ox, oy)
         r = int(OBSTACLE_RADIUS * SCALE)
         draw.ellipse([cx - r, cy - r, cx + r, cy + r], fill="gray")
-    # Draw trajectory
+
+    # Trajectory
     if len(trajectory) > 1:
         points = [to_canvas_coords(x, y) for x, y in trajectory]
         draw.line(points, fill="blue", width=2)
-    # Draw robot
+
+    # Robot
     rx, ry = to_canvas_coords(robot_pose['x'], robot_pose['y'])
     r = int(ROBOT_RADIUS * SCALE)
     draw.ellipse([rx - r, ry - r, rx + r, ry + r], fill="red")
-    # Draw heading arrow
+
+    # Heading
     dx = math.cos(math.radians(robot_pose['angle'])) * ROBOT_RADIUS * 2 * SCALE
     dy = math.sin(math.radians(robot_pose['angle'])) * ROBOT_RADIUS * 2 * SCALE
     draw.line([rx, ry, rx + dx, ry - dy], fill="darkred", width=2)
@@ -114,48 +112,49 @@ def draw_environment(robot_pose, trajectory, obstacles):
 def draw_slam_map(robot_pose, slam_points, scan_range):
     img = Image.new("RGB", (SPACE_SIZE, SPACE_SIZE), "white")
     draw = ImageDraw.Draw(img)
-    # Draw grid lines
-    for i in range(int(WORLD_UNITS)+1):
+
+    # Grid
+    for i in range(int(WORLD_UNITS) + 1):
         x = int(i * SCALE)
-        draw.line([(x,0), (x, SPACE_SIZE)], fill=(230,230,230))
-        draw.line([(0,x), (SPACE_SIZE, x)], fill=(230,230,230))
-    # Draw laser scan rays
+        draw.line([(x, 0), (x, SPACE_SIZE)], fill=(230, 230, 230))
+        draw.line([(0, x), (SPACE_SIZE, x)], fill=(230, 230, 230))
+
+    # Laser scan lines
     angles = np.linspace(-SCAN_ANGLE / 2, SCAN_ANGLE / 2, SCAN_RESOLUTION) + robot_pose['angle']
     for a in angles:
         rad = math.radians(a)
         dist = scan_range
-        # Find closest slam point along this angle
-        closest_dist = None
         for px, py in slam_points:
             vx, vy = px - robot_pose['x'], py - robot_pose['y']
             point_dist = math.hypot(vx, vy)
             point_angle = math.degrees(math.atan2(vy, vx))
             angle_diff = abs((point_angle - a + 180) % 360 - 180)
             if angle_diff < SCAN_ANGLE / SCAN_RESOLUTION:
-                if closest_dist is None or point_dist < closest_dist:
-                    closest_dist = point_dist
-        if closest_dist is not None:
-            dist = closest_dist
+                if point_dist < dist:
+                    dist = point_dist
         x_end = robot_pose['x'] + dist * math.cos(rad)
         y_end = robot_pose['y'] + dist * math.sin(rad)
         cx_start, cy_start = to_canvas_coords(robot_pose['x'], robot_pose['y'])
         cx_end, cy_end = to_canvas_coords(x_end, y_end)
         draw.line([cx_start, cy_start, cx_end, cy_end], fill="green")
-    # Draw slam points
+
+    # SLAM points
     for px, py in slam_points:
         cx, cy = to_canvas_coords(px, py)
-        draw.ellipse([cx-2, cy-2, cx+2, cy+2], fill="black")
-    # Draw robot
+        draw.ellipse([cx - 2, cy - 2, cx + 2, cy + 2], fill="black")
+
+    # Robot
     rx, ry = to_canvas_coords(robot_pose['x'], robot_pose['y'])
     r = int(ROBOT_RADIUS * SCALE)
     draw.ellipse([rx - r, ry - r, rx + r, ry + r], fill="red")
-    # Draw heading arrow
+
+    # Heading
     dx = math.cos(math.radians(robot_pose['angle'])) * ROBOT_RADIUS * 2 * SCALE
     dy = math.sin(math.radians(robot_pose['angle'])) * ROBOT_RADIUS * 2 * SCALE
     draw.line([rx, ry, rx + dx, ry - dy], fill="red", width=2)
     return img
 
-# State container to persist between calls
+# Simulation State
 class SimulationState:
     def __init__(self):
         self.robot_pose = {'x': 0.0, 'y': 0.0, 'angle': 0.0}
@@ -167,6 +166,7 @@ class SimulationState:
 
 state = SimulationState()
 
+# Handlers
 def reset_simulation(obstacle_count):
     state.robot_pose = {'x': 0.0, 'y': 0.0, 'angle': 0.0}
     state.trajectory = []
@@ -179,43 +179,39 @@ def reset_simulation(obstacle_count):
     return env_img, slam_img, "Simulation reset"
 
 def step_simulation(scan_range):
-    # Move robot and update trajectory
     pose_before = state.robot_pose.copy()
     new_pose, moved = move_robot(state.robot_pose, state.obstacles)
     if moved:
         state.trajectory.append((new_pose['x'], new_pose['y']))
-    # Scan environment and update slam points
+
     new_points = scan_environment(state.robot_pose, state.obstacles, scan_range)
-    # Add only new points that are not close to existing points
     for pt in new_points:
         if all(math.hypot(pt[0] - p[0], pt[1] - p[1]) > 0.1 for p in state.slam_points):
             state.slam_points.append(pt)
-    # Draw images
+
     env_img = draw_environment(state.robot_pose, state.trajectory, state.obstacles)
-    #slam_img = gr.Image(label="SLAM Map View", height=SPACE_SIZE, width=SPACE_SIZE)
-    #slam_img = draw_slam_map(state.robot_pose, state.slam_points, scan_range)
-    slam_img = draw_slam_map(state.robot_pose, state.slam_points)
+    slam_img = draw_slam_map(state.robot_pose, state.slam_points, scan_range)
 
-    # If recording, save frames
     if state.recording:
         combined = Image.new('RGB', (SPACE_SIZE * 2, SPACE_SIZE))
         combined.paste(env_img, (0, 0))
         combined.paste(slam_img, (SPACE_SIZE, 0))
         state.video_frames.append(np.array(combined))
+
     return env_img, slam_img, f"Robot moved: {moved}, Position: ({state.robot_pose['x']:.2f}, {state.robot_pose['y']:.2f})"
 
 def toggle_recording(record):
     state.recording = record
-    if not record:
-        # Stop recording
-        if len(state.video_frames) == 0:
-            return None
-        video_path = "/tmp/slam_simulation.mp4"
-        imageio.mimsave(video_path, state.video_frames, fps=10)
-        return video_path
-    else:
-        state.video_frames = []
-        return None
+    return f"Recording {'started' if record else 'stopped'}."
+
+def export_video():
+    if not state.video_frames:
+        return None, "No frames recorded."
+    buffer = io.BytesIO()
+    imageio.mimsave(buffer, state.video_frames, format="GIF", duration=0.1)
+    buffer.seek(0)
+    return buffer, "Video exported."
+
 
 # Default obstacle count
 OBSTACLE_COUNT = 10