Add camera_sim + monitor_demo launch (one-command anomaly-monitor demo)

camera_sim publishes a synthetic camera stream that is nominal most of the time
and periodically occludes the lens (an anomaly event); monitor_demo.launch.py
wires it to the monitor so `adapter:=ijepa` shows live anomaly flags on a GPU
(dummy runs GPU-free for wiring). README documents the one-command demo.

Author: rsasaki0109

README.md

@@ -322,6 +322,10 @@ out-of-distribution scene — **without needing any failure data**.
 ```bash
 ros2 run world_model_py monitor_node --ros-args -p adapter:=ijepa
 #   ~/surprise (Float32) · ~/anomaly_threshold (Float32) · ~/anomaly (Bool)
+
+# one-command demo: a synthetic camera with periodic occlusion events + monitor
+ros2 launch world_model_bringup monitor_demo.launch.py adapter:=ijepa
+ros2 topic echo /world_model_monitor/anomaly
 ```
 
 The detector core (`world_model_py.anomaly.AnomalyDetector`) is ROS-free and

world_model_bringup/launch/monitor_demo.launch.py

@@ -0,0 +1,39 @@
+"""Runtime anomaly-monitor demo: a synthetic camera (with periodic occlusion
+events) feeding the World Model monitor.
+
+    ros2 launch world_model_bringup monitor_demo.launch.py            # dummy (GPU-free)
+    ros2 launch world_model_bringup monitor_demo.launch.py adapter:=ijepa   # real detection
+
+Watch it flag the occlusion events:
+    ros2 topic echo /world_model_monitor/anomaly
+"""
+from launch import LaunchDescription
+from launch.actions import DeclareLaunchArgument
+from launch.substitutions import LaunchConfiguration
+from launch_ros.actions import Node
+
+
+def generate_launch_description() -> LaunchDescription:
+    adapter = LaunchConfiguration("adapter")
+
+    camera = Node(
+        package="world_model_py",
+        executable="camera_sim",
+        name="camera_sim",
+        output="screen",
+    )
+    monitor = Node(
+        package="world_model_py",
+        executable="monitor_node",
+        name="world_model_monitor",
+        parameters=[{"adapter": adapter}],
+        remappings=[("image", "/camera_sim/image")],
+        output="screen",
+    )
+    return LaunchDescription(
+        [
+            DeclareLaunchArgument("adapter", default_value="dummy"),
+            camera,
+            monitor,
+        ]
+    )

world_model_py/setup.py

@@ -23,6 +23,7 @@
             "runtime_node = world_model_py.runtime_node:main",
             "monitor_node = world_model_py.monitor_node:main",
             "sample_publisher = world_model_py.sample_publisher:main",
+            "camera_sim = world_model_py.camera_sim:main",
             # standalone CLI + reference remote server (also usable without ROS)
             "world-model = world_model_py.cli:main",
             "world-model-server = world_model_py.server:main",

world_model_py/world_model_py/camera_sim.py

@@ -0,0 +1,82 @@
+"""Synthetic camera for the anomaly-monitor demo (GPU-free).
+
+Publishes a sensor_msgs/Image stream that is normally "nominal" (a smoothly
+moving block on a gradient) and periodically injects an *anomaly* event: the
+lens is briefly occluded by a dark blob. Point the monitor at it and, with a
+real adapter (``ijepa``), watch ``~/anomaly`` fire during the occlusions.
+
+    ros2 run world_model_py camera_sim
+"""
+from __future__ import annotations
+
+import numpy as np
+import rclpy
+from rclpy.node import Node
+
+from sensor_msgs.msg import Image
+from . import conversions as conv
+
+
+class CameraSim(Node):
+    def __init__(self):
+        super().__init__("camera_sim")
+        self.declare_parameter("rate_hz", 4.0)
+        self.declare_parameter("size", 256)
+        self.declare_parameter("period", 40)      # frames between anomaly events
+        self.declare_parameter("event_len", 8)    # occlusion length in frames
+
+        rate = self.get_parameter("rate_hz").get_parameter_value().double_value or 4.0
+        self._n = int(self.get_parameter("size").get_parameter_value().integer_value) or 256
+        self._period = int(self.get_parameter("period").get_parameter_value().integer_value)
+        self._event = int(self.get_parameter("event_len").get_parameter_value().integer_value)
+        self._k = 0
+
+        s = self._n
+        yy, xx = np.mgrid[0:s, 0:s]
+        self._bg = np.stack([xx / s * 170 + 40, yy / s * 110 + 30, np.full((s, s), 90)], 2).astype(np.uint8)
+        self._yy, self._xx = yy, xx
+
+        self._pub = self.create_publisher(Image, "image", 10)
+        self.create_timer(1.0 / rate, self._tick)
+        self.get_logger().info(
+            f"camera_sim: {rate} Hz, anomaly every {self._period} frames for {self._event} frames")
+
+    def _frame(self) -> np.ndarray:
+        s = self._n
+        img = self._bg.copy()
+        # nominal: a block gliding back and forth
+        cx = int((0.5 + 0.4 * np.sin(0.15 * self._k)) * s)
+        img[s // 2 - 24:s // 2 + 24, max(0, cx - 24):cx + 24] = [210, 60, 60]
+        # periodic anomaly: a dark occluder sweeps across the lens
+        phase = self._k % self._period
+        if phase < self._event:
+            prog = phase / max(1, self._event - 1)
+            ox = int(40 + prog * (s - 80))
+            a = np.clip(1.25 - (((self._xx - ox) / 120.0) ** 2 + ((self._yy - s / 2) / 165.0) ** 2), 0, 1) * 0.93
+            img = (img * (1 - a[..., None]) + np.array([16, 16, 20]) * a[..., None]).astype(np.uint8)
+        return img
+
+    def _tick(self) -> None:
+        self._k += 1
+        msg_header_img = Image()
+        msg_header_img.header.stamp = self.get_clock().now().to_msg()
+        msg_header_img.header.frame_id = "camera"
+        out = conv.np_to_image_msg(self._frame(), msg_header_img.header)
+        self._pub.publish(out)
+
+
+def main(args=None) -> None:
+    rclpy.init(args=args)
+    node = CameraSim()
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        if rclpy.ok():
+            rclpy.shutdown()
+
+
+if __name__ == "__main__":
+    main()