IR-SIM (Intelligent Robot Simulator)

Path planning in IR-SIM is a programmatic workflow used to compute collision-free trajectories on an occupancy map. The process follows a consistent four-step pattern regardless of the algorithm used:

1. Build the map: Use env.get_map(resolution=...) to generate an occupancy grid. The resolution parameter defines the planning cell size in meters.
2. Create the planner: Instantiate a planner from irsim.lib.path_planners by passing the map (and optionally the robot for sampling-based planners).
3. Plan: Call planner.planning(start, goal) where start and goal are typically retrieved from env.get_robot_state() and env.get_robot_info().goal respectively. This returns a list of [x, y] points (a trajectory) or None if no path is found.
4. Draw / follow: Use env.draw_trajectory(trajectory) to visualize the path in the simulator, or pass the trajectory to a controller to move the robot.

import irsim
from irsim.lib.path_planners import AStarPlanner

env = irsim.make("path_planning.yaml")

# 1. Build map
env_map = env.get_map(resolution=0.2)

# 2. Create planner
planner = AStarPlanner(env_map)

# 3. Plan
robot_state = env.get_robot_state()
goal_xy = env.get_robot_info().goal[:2, 0].tolist()
trajectory = planner.planning(robot_state, goal_xy)

# 4. Draw
if trajectory is not None:
    env.draw_trajectory(trajectory, traj_type="r-")

IR-SIM allows you to create and run multiple environment instances simultaneously. Each instance is completely isolated, meaning they maintain their own independent:

• World parameters: Settings like control_mode, collision_mode, and step_time.
• Simulation state: Current time, step count, and the list of objects.
• Simulation time: Stepping one environment does not affect the clock of another.
• Objects and spatial data: Each environment manages its own objects list and GeometryTree for collision detection.

This isolation makes IR-SIM suitable for parallel simulations, comparative studies between different configurations, and reinforcement learning training loops.

import irsim

# Create two separate environments
env1 = irsim.make("scenario_a.yaml")
env2 = irsim.make("scenario_b.yaml")

# Each environment has its own state
print(f"Env1 robots: {env1.robot_number}")
print(f"Env2 robots: {env2.robot_number}")

The fmcw_lidar2d sensor provides standard LiDAR geometry plus a radial_velocity measurement for each beam, useful for detecting dynamic obstacles via Doppler measurements.

Key FMCW Parameters:

• motion_compensate: Boolean indicating whether to remove ego-motion from the measured radial velocity.
• velocity_noise_std: Standard deviation of Gaussian noise applied to radial_velocity.

Data Access: When calling env.get_lidar_scan(), the returned object contains:

• radial_velocity: Scalar radial velocity for each beam.
• valid: Boolean array indicating if a beam has a valid return within range_max.
• ranges: The distance measurements.

Visualization: Use the plot: sub-dictionary to control colorization:

• velocity_color: Boolean to enable colorizing beams by radial velocity.
• velocity_color_max: The velocity magnitude at which the color saturates.

import irsim

env = irsim.make("fmcw_lidar_world.yaml")

for step in range(120):
    env.step()

    scan = env.get_lidar_scan()
    valid_count = int(scan["valid"].sum())
    valid_indices = scan["valid"].nonzero()[0]
    if len(valid_indices) > 0:
        # Find the beam with the highest absolute radial velocity
        beam_idx = max(valid_indices, key=lambda idx: abs(scan["radial_velocity"][idx]))
        print(
            f"step={step:03d} valid_beams={valid_count:03d} "
            f"beam={beam_idx:03d} range={scan['ranges'][beam_idx]:.3f} "
            f"radial_velocity={scan['radial_velocity'][beam_idx]:.3f}"
        )

    env.render(0.05, mode="all")

env.end(3)

IR-SIM is a declarative simulator where you describe a scene in YAML and instantiate it using irsim.make(). The simulation follows a specific lifecycle managed by the Environment (EnvBase).

To run a simulation, you implement a step → render → done loop:

1. step(): Advances the simulation by one time step. This resolves actions/behaviors, integrates motion, refreshes sensors, and updates collision/arrival status.
2. render(): Draws the current state using Matplotlib.
3. done(): Checks if a terminal condition (like a collision or all robots reaching goals) has been met.
4. end(): Closes the window and releases resources.

Other lifecycle methods include reset() (restore initial states) and reload() (rebuild from YAML).

import irsim

# Create the environment from a YAML file
env = irsim.make("scene.yaml")

# The core simulation loop
while not env.done():
    env.step()
    env.render()

env.end()