Update app.py

app.py

@@ -1,9 +1,10 @@
-# app.py — Crowd Behavior Lab (animated GIF, bolletjes-only)
-# ----------------------------------------------------------
-# Focus in deze stap:
-# - Altijd bewegende bolletjes via één geanimeerde GIF (server-side gerenderd).
-# - Autostart bij openen van de Space (demo.load).
-# - Geen pijlen, geen slider/timer — zo vermijden we event-/queue-problemen.
+# app.py — Crowd Behavior Lab (GIF, solide afbakening met swept collisions)
+# ------------------------------------------------------------------------
+# Wat is nieuw:
+# - Swept collision (segment-rect) per agent per stap → geen tunneling
+# - Iteratieve push-out + normale-reflectie van snelheid
+# - Funnel-segmenten met overlap_eps zodat er geen kieren zijn
+# - Nog steeds: geanimeerde GIF (betrouwbare beweging), geen pijlen
 #
 # Vereisten (requirements.txt):
 # gradio>=4.44.0
@@ -14,11 +15,7 @@
 
 from __future__ import annotations
 
-import io
-import os
-import json
-import math
-import tempfile
+import io, os, json, math, tempfile
 from dataclasses import dataclass, asdict
 from typing import List, Tuple, Optional, Dict
 
@@ -47,19 +44,19 @@ CUSTOM_CSS = """
 
 
 # ---------------------------
-# Obstakels (rechthoek-basic)
+# Obstakels (rechthoek)
 # ---------------------------
 @dataclass
 class RectObstacle:
     x: float; y: float; w: float; h: float
     def contains(self, px: float, py: float) -> bool:
-        return self.x <= px <= self.x + self.w and self.y <= py <= self.y + self.h
+        return (self.x <= px <= self.x + self.w) and (self.y <= py <= self.y + self.h)
     def nearest_point(self, p: np.ndarray) -> np.ndarray:
         qx = np.clip(p[0], self.x, self.x + self.w)
         qy = np.clip(p[1], self.y, self.y + self.h)
         return np.array([qx, qy], dtype=np.float32)
     def to_json(self) -> Dict:
-        d = asdict(self); return d
+        return asdict(self)
 
 @dataclass
 class World:
@@ -73,49 +70,53 @@ class Agent:
 
 
 # ---------------------------
-# Presets (incl. taps toelopende hals)
+# Presets (incl. taps toelopende hals met overlap)
 # ---------------------------
 def funnel_presets():
     presets = {}
-    # Taps toelopende flessenhals met segmenten
+
+    # Taps toelopende flessenhals met segment-overlap om kieren te dichten
     obs = []
     world_w, world_h = 20.0, 12.0
     left_x, right_x = 2.0, 18.0
     steps = 8
     top_y0, bot_y0 = 9.5, 2.5
     top_y1, bot_y1 = 6.8, 5.2
+    overlap_eps = 0.07  # kleine overlap tussen segmenten
     for i in range(steps):
-        x0 = left_x + (right_x - left_x) * (i / steps)
-        x1 = left_x + (right_x - left_x) * ((i + 1) / steps)
+        x0 = left_x + (right_x - left_x) * (i / steps) - (overlap_eps if i > 0 else 0.0)
+        x1 = left_x + (right_x - left_x) * ((i + 1) / steps) + (overlap_eps if i < steps - 1 else 0.0)
         t = i / (steps - 1)
         top_y = (1 - t) * top_y0 + t * top_y1
         bot_y = (1 - t) * bot_y0 + t * bot_y1
-        obs.append(RectObstacle(x0, top_y, x1 - x0, world_h - top_y))
-        obs.append(RectObstacle(x0, 0.0, x1 - x0, bot_y))
-    presets["Flessenhals (taps)"] = obs
+        obs.append(RectObstacle(max(0.0,x0), top_y, min(world_w,x1)-max(0.0,x0), world_h - top_y))  # bovenwand
+        obs.append(RectObstacle(max(0.0,x0), 0.0, min(world_w,x1)-max(0.0,x0), bot_y))             # onderwand
+    presets["Flessenhals (taps, solide)"] = obs
 
-    # Dubbele funnel
+    # Dubbele funnel met overlap
     obs2 = []
     top_y0, bot_y0 = 10.0, 2.0
     top_mid, bot_mid = 7.0, 5.0
     top_end, bot_end = 9.5, 2.5
+    # links -> midden
     for i in range(steps):
         t = i / (steps - 1)
-        x0 = 0.5 + (9.5 - 0.5) * (i / steps)
-        x1 = 0.5 + (9.5 - 0.5) * ((i + 1) / steps)
+        x0 = 0.5 + (9.5 - 0.5) * (i / steps) - (overlap_eps if i > 0 else 0.0)
+        x1 = 0.5 + (9.5 - 0.5) * ((i + 1) / steps) + (overlap_eps if i < steps - 1 else 0.0)
         top_y = (1 - t) * top_y0 + t * top_mid
         bot_y = (1 - t) * bot_y0 + t * bot_mid
-        obs2.append(RectObstacle(x0, top_y, x1 - x0, 12.0 - top_y))
-        obs2.append(RectObstacle(x0, 0.0, x1 - x0, bot_y))
+        obs2.append(RectObstacle(max(0.0,x0), top_y, min(world_w,x1)-max(0.0,x0), 12.0 - top_y))
+        obs2.append(RectObstacle(max(0.0,x0), 0.0, min(world_w,x1)-max(0.0,x0), bot_y))
+    # midden -> rechts
     for i in range(steps):
         t = i / (steps - 1)
-        x0 = 10.5 + (19.5 - 10.5) * (i / steps)
-        x1 = 10.5 + (19.5 - 10.5) * ((i + 1) / steps)
+        x0 = 10.5 + (19.5 - 10.5) * (i / steps) - (overlap_eps if i > 0 else 0.0)
+        x1 = 10.5 + (19.5 - 10.5) * ((i + 1) / steps) + (overlap_eps if i < steps - 1 else 0.0)
         top_y = (1 - t) * top_mid + t * top_end
         bot_y = (1 - t) * bot_mid + t * bot_end
-        obs2.append(RectObstacle(x0, top_y, x1 - x0, 12.0 - top_y))
-        obs2.append(RectObstacle(x0, 0.0, x1 - x0, bot_y))
-    presets["Dubbele funnel (taps)"] = obs2
+        obs2.append(RectObstacle(max(0.0,x0), top_y, min(world_w,x1)-max(0.0,x0), 12.0 - top_y))
+        obs2.append(RectObstacle(max(0.0,x0), 0.0, min(world_w,x1)-max(0.0,x0), bot_y))
+    presets["Dubbele funnel (solide)"] = obs2
     return presets
 
 PRESETS = {
@@ -129,8 +130,9 @@ PRESETS = {
 DEFAULT_PARAMS = dict(
     desired_speed=1.3, relax_time=0.6,
     people_repulsion=4.0, people_range=1.2,
-    obstacle_repulsion=8.0, obstacle_range=1.0,
-    noise=0.08, bounce_walls=True,
+    obstacle_repulsion=10.0,  # iets sterker langs wanden
+    obstacle_range=1.2,       # iets verder van tevoren afremmen
+    noise=0.07, bounce_walls=True,
 )
 
 
@@ -166,88 +168,183 @@ def init_agents(n_agents: int, world: World, layout: str, seed: int = 42) -> Lis
 
 
 # ---------------------------
-# Social-force step
+# Swept collision utils (segment vs axis-aligned rect)
 # ---------------------------
-def social_force_step(agents: List[Agent], world: World, params: dict, dt: float = 0.12) -> None:
-    positions = np.array([a.pos for a in agents])
-    velocities = np.array([a.vel for a in agents])
+def segment_rect_intersection(p0: np.ndarray, p1: np.ndarray, ob: RectObstacle):
+    """
+    Liang-Barsky/slab: parametrize P(t)=p0+t*(p1-p0), t∈[0,1].
+    Return (hit:bool, t_enter:float, normal:np.ndarray) for first contact; normal is outward rect normal.
+    """
+    dirv = p1 - p0
+    tmin, tmax = 0.0, 1.0
+    normal = np.array([0.0, 0.0], dtype=np.float32)
+
+    def slab(p, d, slab_min, slab_max, axis):
+        nonlocal tmin, tmax, normal
+        if abs(d) < 1e-9:
+            # parallel; must be within slab to proceed
+            if p < slab_min or p > slab_max:
+                return False
+            return True
+        t1 = (slab_min - p) / d
+        t2 = (slab_max - p) / d
+        n1 = np.array([0,0], dtype=np.float32); n2 = np.array([0,0], dtype=np.float32)
+        if axis == 0:
+            n1 = np.array([-1, 0], dtype=np.float32)  # left wall outward
+            n2 = np.array([ 1, 0], dtype=np.float32)  # right wall
+        else:
+            n1 = np.array([0,-1], dtype=np.float32)   # bottom
+            n2 = np.array([0, 1], dtype=np.float32)   # top
+        if t1 > t2:
+            t1, t2 = t2, t1
+            n1, n2 = n2, n1
+        if t1 > tmin:
+            tmin = t1
+            normal = n1
+        if t2 < tmax:
+            tmax = t2
+        if tmin > tmax:
+            return False
+        return True
+
+    if not slab(p0[0], dirv[0], ob.x, ob.x + ob.w, 0): return (False, None, None)
+    if not slab(p0[1], dirv[1], ob.y, ob.y + ob.h, 1): return (False, None, None)
+    if tmin < 0.0 or tmin > 1.0:
+        return (False, None, None)
+    return (True, float(tmin), normal)
+
 
+# ---------------------------
+# Social-force step (met swept collisions + push-out)
+# ---------------------------
+def social_force_step(agents: List[Agent], world: World, params: dict, dt: float = 0.10, substeps: int = 2) -> None:
+    """
+    Kleine dt + substeps om nauwkeuriger rond randen te bewegen.
+    Swept-collision per substep; na beweging nog iteratief push-out.
+    """
     desired_speed = params.get("desired_speed", 1.3)
     relax_time = params.get("relax_time", 0.6)
     people_repulsion = params.get("people_repulsion", 4.0)
     people_range = params.get("people_range", 1.2)
-    obstacle_repulsion = params.get("obstacle_repulsion", 8.0)
-    obstacle_range = params.get("obstacle_range", 1.0)
-    noise = params.get("noise", 0.08)
+    obstacle_repulsion = params.get("obstacle_repulsion", 10.0)
+    obstacle_range = params.get("obstacle_range", 1.2)
+    noise = params.get("noise", 0.07)
     bounce_walls = params.get("bounce_walls", True)
 
-    forces = np.zeros_like(positions)
-
-    # Driving force
-    goals = np.array([a.goal for a in agents])
-    to_goal = goals - positions
-    dist_goal = np.linalg.norm(to_goal, axis=1) + 1e-6
-    desired_dir = (to_goal.T / dist_goal).T
-    desired_vel = desired_speed * desired_dir
-    forces += (desired_vel - velocities) / max(1e-6, relax_time)
-
-    # Repulsie mensen
-    for i in range(len(agents)):
-        diff = positions[i] - positions
-        d = np.linalg.norm(diff, axis=1) + 1e-6
-        mask = (d > 0) & (d < people_range * 3.0)
-        if np.any(mask):
-            dir_ij = (diff[mask].T / d[mask]).T
-            mag = people_repulsion * np.exp(-d[mask] / max(1e-6, people_range))
-            forces[i] += (dir_ij.T * mag).T.sum(axis=0)
-
-    # Repulsie obstakels
-    for i in range(len(agents)):
-        p = positions[i]; f = np.zeros(2, dtype=np.float32)
-        for ob in world.obstacles:
-            q = ob.nearest_point(p)
-            diff = p - q
-            d = np.linalg.norm(diff) + 1e-6
-            if d < obstacle_range * 3:
-                dir_ = diff / d
-                mag = obstacle_repulsion * math.exp(-d / max(1e-6, obstacle_range))
-                f += dir_ * mag
-        forces[i] += f
-
-    # Ruis
-    forces += noise * np.random.randn(*forces.shape)
-
-    # Integratie + limiet
-    new_vel = velocities + dt * forces
-    speeds = np.linalg.norm(new_vel, axis=1) + 1e-6
-    new_vel = (new_vel.T * np.minimum(1.0, (desired_speed * 1.8) / speeds)).T
-    new_pos = positions + dt * new_vel
-
-    # Collisions met obstakels
-    for i in range(len(agents)):
-        for ob in world.obstacles:
-            if ob.contains(new_pos[i, 0], new_pos[i, 1]):
-                q = ob.nearest_point(new_pos[i])
-                dir_ = new_pos[i] - q
-                if np.linalg.norm(dir_) < 1e-6: dir_ = np.array([0.5, 0.0], dtype=np.float32)
-                dir_ = dir_ / (np.linalg.norm(dir_) + 1e-6)
-                new_pos[i] = q + 0.06 * dir_
-
-    # Muren
-    if bounce_walls:
-        for i in range(len(agents)):
-            if new_pos[i, 0] < 0: new_pos[i, 0] = 0; new_vel[i, 0] *= -0.5
-            if new_pos[i, 0] > world.width: new_pos[i, 0] = world.width; new_vel[i, 0] *= -0.5
-            if new_pos[i, 1] < 0: new_pos[i, 1] = 0; new_vel[i, 1] *= -0.5
-            if new_pos[i, 1] > world.height: new_pos[i, 1] = world.height; new_vel[i, 1] *= -0.5
+    h = dt / max(1, substeps)
+
+    for _ in range(substeps):
+        positions = np.array([a.pos for a in agents])
+        velocities = np.array([a.vel for a in agents])
+        forces = np.zeros_like(positions)
+
+        # Driving force
+        goals = np.array([a.goal for a in agents])
+        to_goal = goals - positions
+        dist_goal = np.linalg.norm(to_goal, axis=1) + 1e-6
+        desired_dir = (to_goal.T / dist_goal).T
+        desired_vel = desired_speed * desired_dir
+        forces += (desired_vel - velocities) / max(1e-6, relax_time)
 
-    # Commit
-    for i, a in enumerate(agents):
-        a.pos = new_pos[i]; a.vel = new_vel[i]
+        # Repulsie mensen
+        for i in range(len(agents)):
+            diff = positions[i] - positions
+            d = np.linalg.norm(diff, axis=1) + 1e-6
+            mask = (d > 0) & (d < people_range * 3.0)
+            if np.any(mask):
+                dir_ij = (diff[mask].T / d[mask]).T
+                mag = people_repulsion * np.exp(-d[mask] / max(1e-6, people_range))
+                forces[i] += (dir_ij.T * mag).T.sum(axis=0)
+
+        # Repulsie obstakels (continu)
+        for i in range(len(agents)):
+            p = positions[i]
+            f = np.zeros(2, dtype=np.float32)
+            for ob in world.obstacles:
+                q = ob.nearest_point(p)
+                diff = p - q
+                d = np.linalg.norm(diff) + 1e-6
+                if d < obstacle_range * 3:
+                    dir_ = diff / d
+                    mag = obstacle_repulsion * math.exp(-d / max(1e-6, obstacle_range))
+                    f += dir_ * mag
+            forces[i] += f
+
+        # Ruis
+        forces += noise * np.random.randn(*forces.shape)
+
+        # Integratie
+        new_vel = velocities + h * forces
+        speeds = np.linalg.norm(new_vel, axis=1) + 1e-6
+        max_speed = desired_speed * 1.8
+        new_vel = (new_vel.T * np.minimum(1.0, max_speed / speeds)).T
+        trial_pos = positions + h * new_vel  # gewenste nieuwe pos voor dit substep
+
+        # Swept collision per agent
+        for i, a in enumerate(agents):
+            p0 = a.pos.copy()
+            p1 = trial_pos[i].copy()
+            v  = new_vel[i].copy()
+            hit_any = False
+            earliest_t = 1.0
+            hit_normal = np.array([0.0, 0.0], dtype=np.float32)
+            ob_hit = None
+
+            for ob in world.obstacles:
+                hit, t_enter, normal = segment_rect_intersection(p0, p1, ob)
+                if hit and t_enter < earliest_t:
+                    earliest_t = t_enter
+                    hit_any = True
+                    hit_normal = normal
+                    ob_hit = ob
+
+            if hit_any:
+                # Ga tot net vóór impact en reflecteer snelheid over wandnormaal
+                eps = 1e-3
+                p_hit = p0 + max(0.0, earliest_t - eps) * (p1 - p0)
+                # Reflecteer: v' = v - 2*(v·n)*n
+                vn = np.dot(v, hit_normal)
+                v_ref = v - 2.0 * vn * hit_normal
+                # Klein beetje tangentiele demping voor stabiliteit
+                v_ref *= 0.6
+                a.pos = p_hit
+                a.vel = v_ref
+            else:
+                a.pos = p1
+                a.vel = v
+
+            # World-bounds
+            if bounce_walls:
+                if a.pos[0] < 0: a.pos[0] = 0; a.vel[0] *= -0.5
+                if a.pos[0] > world.width: a.pos[0] = world.width; a.vel[0] *= -0.5
+                if a.pos[1] < 0: a.pos[1] = 0; a.vel[1] *= -0.5
+                if a.pos[1] > world.height: a.pos[1] = world.height; a.vel[1] *= -0.5
+
+            # Iteratieve push-out (mocht je eindigen ín een obstakel door numeriek effect)
+            for _it in range(4):
+                inside = False
+                for ob in world.obstacles:
+                    if ob.contains(a.pos[0], a.pos[1]):
+                        inside = True
+                        q = ob.nearest_point(a.pos)
+                        d = a.pos - q
+                        nrm = np.linalg.norm(d)
+                        if nrm < 1e-9:
+                            d = np.array([0.5, 0], dtype=np.float32)
+                            nrm = 0.5
+                        n = d / nrm
+                        a.pos = q + 0.05 * n
+                        # demp component naar binnen toe
+                        vn = np.dot(a.vel, n)
+                        if vn < 0:
+                            a.vel = a.vel - vn * n
+                        break
+                if not inside:
+                    break
 
 
 # ---------------------------
-# Visual metrics & kleur
+# Visual metrics & kleuren
 # ---------------------------
 def k3_distance(point: np.ndarray, all_points: np.ndarray) -> float:
     dists = np.linalg.norm(all_points - point, axis=1)
@@ -273,7 +370,7 @@ def stress_to_color(s: float) -> str:
 
 
 # ---------------------------
-# Rendering (één frame)
+# Rendering van één frame
 # ---------------------------
 def render_frame(positions: np.ndarray, velocities: np.ndarray, world: World, params: dict,
                  trail_positions: List[np.ndarray], show_trails=True, show_heatmap=False,
@@ -288,7 +385,7 @@ def render_frame(positions: np.ndarray, velocities: np.ndarray, world: World, pa
     ax.set_xlim(0, world.width); ax.set_ylim(0, world.height)
     ax.set_aspect("equal"); ax.set_facecolor("#f9fafb")
 
-    # Obstacles
+    # Obstakels
     for ob in world.obstacles:
         rect = plt.Rectangle((ob.x, ob.y), ob.w, ob.h, facecolor="#6b7280", alpha=0.20, edgecolor="#1f2937", linewidth=1.0)
         ax.add_patch(rect)
@@ -350,7 +447,7 @@ def render_frame(positions: np.ndarray, velocities: np.ndarray, world: World, pa
 
 
 # ---------------------------
-# Simulatie → lijst frames → GIF
+# Simulatie → frames → GIF
 # ---------------------------
 def simulate_states(n_agents: int, steps: int, world: World, params: dict, layout: str):
     agents = init_agents(n_agents, world, layout)
@@ -359,7 +456,7 @@ def simulate_states(n_agents: int, steps: int, world: World, params: dict, layou
         pos = np.array([a.pos.copy() for a in agents])
         vel = np.array([a.vel.copy() for a in agents])
         states.append({"pos": pos, "vel": vel})
-        social_force_step(agents, world, params, dt=0.12)
+        social_force_step(agents, world, params, dt=0.10, substeps=2)
     return states
 
 def states_to_gif_path(states, world: World, params: dict,
@@ -367,8 +464,7 @@ def states_to_gif_path(states, world: World, params: dict,
                        performance_mode=True, fps: float = 12.0) -> str:
     frames_np = []
     trail_positions: List[np.ndarray] = []
-    for i, st in enumerate(states):
-        # bouw korte trail
+    for st in states:
         trail_positions.append(st["pos"])
         if len(trail_positions) > 12: trail_positions.pop(0)
         img = render_frame(st["pos"], st["vel"], world, params, trail_positions,
@@ -378,7 +474,6 @@ def states_to_gif_path(states, world: World, params: dict,
 
     tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".gif")
     tmp_path = tmp.name; tmp.close()
-    # duration = seconden per frame
     duration = 1.0 / max(1.0, fps)
     imageio.mimsave(tmp_path, frames_np, format="GIF", duration=duration, loop=0)
     return tmp_path
@@ -411,7 +506,6 @@ def run_sim_to_gif(
     badge_html = f"<span class='stat-badge'>{len(world.obstacles)} obstakels</span>"
     return gif_path, badge_html
 
-# Autostart bij load
 def do_autostart(preset, obstacles_json, n_agents, steps, layout,
                  desired_speed, relax_time, people_repulsion, people_range,
                  obstacle_repulsion, obstacle_range, noise, bounce,
@@ -425,7 +519,7 @@ def do_autostart(preset, obstacles_json, n_agents, steps, layout,
 # ---------------------------
 # UI
 # ---------------------------
-with gr.Blocks(theme=THEME, css=CUSTOM_CSS, title="Crowd Behavior Lab — GIF") as demo:
+with gr.Blocks(theme=THEME, css=CUSTOM_CSS, title="Crowd Behavior Lab — GIF (solide)") as demo:
     gr.Markdown("""
     <div id='title' class='card' style='margin-bottom:12px'>
       <h1>👥 Crowd Behavior Lab</h1>
@@ -434,31 +528,31 @@ with gr.Blocks(theme=THEME, css=CUSTOM_CSS, title="Crowd Behavior Lab — GIF")
         <span class="legend-dot legend-orange" style="margin-left:12px;"></span>Stress
         <span class="legend-dot legend-red" style="margin-left:12px;"></span>Paniek
       </div>
-      <p style="margin-top:6px">Deze versie rendert een geanimeerde GIF voor gegarandeerde beweging.</p>
+      <p style="margin-top:6px">Solide afbakening met swept collisions. Agents blijven binnen de lijnen.</p>
     </div>
     """)
 
     with gr.Row(equal_height=False):
         with gr.Column(scale=1):
             gr.Markdown("### Scène & parameters", elem_classes=["card"])
-            preset = gr.Dropdown(list(PRESETS.keys()), value="Flessenhals (taps)", label="Obstakelpreset")
+            preset = gr.Dropdown(list(PRESETS.keys()), value="Flessenhals (taps, solide)", label="Obstakelpreset")
             obstacles_json = gr.Textbox(label="Extra obstakels (JSON)", value="[]", lines=4)
 
             layout = gr.Radio(["Links→Rechts","Rechts→Links","Twee-richtingen","Willekeurig"],
                               value="Twee-richtingen", label="Stroomrichting")
 
             with gr.Row():
-                n_agents = gr.Slider(5, 200, value=80, step=1, label="Aantal agenten")
-                steps = gr.Slider(30, 500, value=200, step=10, label="Simulatiestappen")
+                n_agents = gr.Slider(5, 200, value=90, step=1, label="Aantal agenten")
+                steps = gr.Slider(30, 500, value=220, step=10, label="Simulatiestappen")
 
             with gr.Accordion("Krachten & gedrag", open=False):
                 desired_speed = gr.Slider(0.5, 2.5, value=1.3, step=0.05, label="Gewenste snelheid (m/s)")
                 relax_time = gr.Slider(0.2, 2.0, value=0.6, step=0.05, label="Relaxatietijd")
                 people_repulsion = gr.Slider(0.0, 10.0, value=4.0, step=0.1, label="Repulsie tussen mensen")
                 people_range = gr.Slider(0.2, 3.0, value=1.2, step=0.05, label="Interactieradius (mensen)")
-                obstacle_repulsion = gr.Slider(0.0, 16.0, value=8.0, step=0.1, label="Repulsie obstakels")
-                obstacle_range = gr.Slider(0.2, 3.0, value=1.0, step=0.05, label="Interactieradius (obstakels)")
-                noise = gr.Slider(0.0, 0.6, value=0.08, step=0.01, label="Gedragsruis")
+                obstacle_repulsion = gr.Slider(0.0, 16.0, value=10.0, step=0.1, label="Repulsie obstakels")
+                obstacle_range = gr.Slider(0.2, 3.0, value=1.2, step=0.05, label="Interactieradius (obstakels)")
+                noise = gr.Slider(0.0, 0.6, value=0.07, step=0.01, label="Gedragsruis")
                 bounce = gr.Checkbox(value=True, label="Veerkrachtige muren (bounce)")
 
             gr.Markdown("### Visualisatie", elem_classes=["card"])
@@ -474,10 +568,9 @@ with gr.Blocks(theme=THEME, css=CUSTOM_CSS, title="Crowd Behavior Lab — GIF")
 
         with gr.Column(scale=2):
             gr.Markdown("### Geanimeerde simulatie", elem_classes=["card"])
-            # Belangrijk: GIF tonen als filepath
-            canvas = gr.Image(label="Simulatie (GIF)", format="png", interactive=False)  # format negeren; pad eindigt op .gif
+            canvas = gr.Image(label="Simulatie (GIF)", format="png", interactive=False)
 
-    # Autostart bij openen
+    # Autostart
     demo.load(
         fn=do_autostart,
         inputs=[preset, obstacles_json, n_agents, steps, layout,
@@ -498,5 +591,4 @@ with gr.Blocks(theme=THEME, css=CUSTOM_CSS, title="Crowd Behavior Lab — GIF")
     )
 
 if __name__ == "__main__":
-    # Geen timer/queue meer nodig voor animatie — GIF speelt in de browser.
     demo.launch()