Discrete RoverEnvFused Gymnasium Environment API Reference

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/jackvice/RoboTerrain/llms.txt

Use this file to discover all available pages before exploring further.

​

Constructor

RoverEnvFused(   # discrete variant from discrete_rover_env_fused.py
    size=(96, 96),
    length=6000,
    scan_topic='/scan',
    imu_topic='/imu/data',
    cmd_vel_topic='/cmd_vel',
    world_n='inspect',
    connection_check_timeout=30,
    lidar_points=32,
    max_lidar_range=12.0,
    rl_obs_name='rl_observation',
)

​

Action Space

# Speed levels (m/s)
self.n_speeds = 5
self.speed_levels = np.array([-0.2, 0.0, 0.3, 0.6, 1.0], dtype=np.float32)

# Direction angles (radians) — 12 evenly-spaced headings covering [-π, π)
self.n_directions = 12
self.direction_angles = np.linspace(-np.pi, np.pi, 12, endpoint=False)

# Combined flat action space: 5 × 12 = 60 discrete actions
self.action_space = spaces.Discrete(self.n_speeds * self.n_directions)  # Discrete(60)

​

Speed Levels

​

Direction Headings

​

Decoding an Action Integer

action        = int(action)
speed_idx     = action // self.n_directions   # integer division by 12
direction_idx = action % self.n_directions    # remainder

speed           = float(self.speed_levels[speed_idx])
desired_heading = float(self.direction_angles[direction_idx])

​

Example: Action Integer → Command

# Action 27 → speed_idx=2, direction_idx=3
action        = 27
speed_idx     = 27 // 12  # = 2  → 0.3 m/s (slow forward)
direction_idx = 27 % 12   # = 3  → -1.57 rad (South)

​

Observation Space

spaces.Dict({
    'fused_image': spaces.Box(
        low=0.0,
        high=1.0,
        shape=(96, 96, 3),
        dtype=np.float32
    ),
    'pose': spaces.Box(
        low=np.array([-30.0, -30.0, -10.0]),
        high=np.array([ 30.0,  30.0,  10.0]),
        dtype=np.float32
    ),
    'imu': spaces.Box(
        low=np.array([-np.pi, -np.pi, -np.pi]),
        high=np.array([ np.pi,  np.pi,  np.pi]),
        dtype=np.float32
    ),
    'target': spaces.Box(
        low=np.array([0,    -np.pi]),
        high=np.array([100,  np.pi]),
        shape=(2,),
        dtype=np.float32
    ),
    'velocities': spaces.Box(
        low=np.array([-10.0, -10.0]),
        high=np.array([ 10.0,  10.0]),
        shape=(2,),
        dtype=np.float32
    ),
})

​

Stuck Detection

​

Differences from Continuous RoverEnvFused

• Action space type — Discrete(60) instead of Box([-0.6, -π], [1.0, π]). All downstream algorithms must handle integer actions rather than float arrays.
• Action decoding — The continuous variant interprets action[1] as a relative heading offset added to the current yaw. The discrete variant maps the direction index to an absolute heading from the pre-defined 12-point compass table.
• Reverse capability — The continuous environment allows reverse down to −0.6 m/s; the discrete environment provides a single discrete reverse speed of −0.2 m/s.
• Granularity — The continuous action space has infinite resolution; the discrete space has 5 speed levels and 12 direction bins (30° resolution). Fine-grained manoeuvring between compass points is not directly representable.
• Action logging — The discrete step() prints the raw action integer, its type, and dtype at every step for debugging (print(f"Action type: ...")) — a line not present in the continuous variant.
• Reward function — Both variants share the same task_reward(observation) implementation; the fused-image heatmap penalty (heatmap_center × 0.1) applies in both.

​

When to Use

• You are using a value-based algorithm such as DQN, Rainbow, C51, or any method that requires a finite action set.
• You want to constrain exploration during early training by restricting the agent to a pre-defined action vocabulary rather than searching a 2D continuous space.
• You are performing behavioural cloning from human demonstrations where speed/direction pairs map naturally to button presses or a joystick quantised to compass directions.
• Your compute budget is tight and you want to benefit from action-space discretisation to reduce policy-gradient variance.

• You are using an actor-critic method such as PPO, SAC, or TD3 that operates natively on continuous actions.
• You need sub-30° directional precision for tight navigation corridors.
• You want the rover to modulate speed smoothly across the full [-0.6, 1.0] range, for example when approaching a goal at low speed.
• You are training with DreamerV3 or a world-model approach that benefits from a dense, smooth action manifold.