Add kitless OVPhysX IMU pytest suite + check script

Mirror the structure of source/isaaclab_physx/test/sensors/test_imu.py
under the kitless launcher pattern established by the rigid-object test:

- Wheel gate (importorskip ovphysx.types + RIGID_BODY_POSE hasattr check)
  before AppLauncher; no AppLauncher needed at runtime.
- SimulationContext built directly via build_simulation_context; assets
  spawned imperatively via _spawn_envs / _spawn_balls / _spawn_cubes /
  _spawn_anymal helpers; fnmatch-glob prim paths (env_*).
- Six tests run on real Nucleus / procedural USD assets:
  test_constant_velocity, test_constant_acceleration, test_offset_calculation,
  test_env_ids_propagation, test_attachment_validity, test_sensor_print.
- Two URDF-dependent tests (test_single_dof_pendulum, test_indirect_attachment)
  are skipped pending a USD version of simple_2_link.urdf — URDF-USD
  conversion requires the Kit URDF importer extension.

check_imu.py is a kitless smoke-test script (free-falling sphere + IMU,
prints readings for visual inspection).

imu.update(dt) is called with force_recompute=True so the kernel fires
each step (without InteractiveScene's lazy_sensor_update plumbing,
the buffer would otherwise only refresh on imu.data access, leaving
prev_lin_vel unseeded on iterations where the test skips data reads).

Changelog fragment added under source/isaaclab_ovphysx/changelog.d/ per
the new fragment-based workflow (do not edit CHANGELOG.rst directly).

Refs isaac-sim#5318.

Author: AntoineRichard

source/isaaclab_ovphysx/changelog.d/antoiner-feat-ovphysx_imu.minor.rst

@@ -0,0 +1,12 @@
+Added
+^^^^^
+
+* Added :class:`~isaaclab_ovphysx.sensors.Imu` and
+  :class:`~isaaclab_ovphysx.sensors.ImuData` implementing the
+  :class:`~isaaclab.sensors.imu.BaseImu` /
+  :class:`~isaaclab.sensors.imu.BaseImuData` contracts on the OVPhysX
+  backend. Reports angular velocity and proper linear acceleration in
+  the sensor body frame using ovphysx tensor bindings on the rigid-body
+  ancestor of the sensor prim path. Linear acceleration is computed via
+  numerical differentiation of body velocity (matching the PhysX
+  backend) and includes a positive gravity bias by default.

source/isaaclab_ovphysx/test/sensors/check_imu.py

@@ -0,0 +1,79 @@
+# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Standalone validation script for the OVPhysX IMU sensor.
+
+Run with:
+    ./scripts/run_ovphysx.sh source/isaaclab_ovphysx/test/sensors/check_imu.py
+
+Spawns a free-falling sphere with an IMU attached, steps the simulation for
+100 steps, and prints the angular velocity and linear acceleration in the
+IMU body frame. In freefall the proper acceleration is zero (only gravity
+acts on the body), so the IMU reading should be approximately ``[0, 0, 0]``
+— the finite-difference world-frame acceleration ``(-g)`` cancels the IMU's
+gravity bias ``(+g)``.
+
+Runs kitless under ``run_ovphysx.sh`` — no AppLauncher needed.
+"""
+
+from __future__ import annotations
+
+import torch
+from isaaclab_ovphysx.physics import OvPhysxCfg
+
+import isaaclab.sim as sim_utils
+from isaaclab.assets import RigidObject, RigidObjectCfg
+from isaaclab.sensors.imu import Imu, ImuCfg
+from isaaclab.sim import SimulationCfg, build_simulation_context
+
+
+def main() -> None:
+    sim_cfg = SimulationCfg(physics=OvPhysxCfg(), device="cpu", dt=0.005)
+    with build_simulation_context(sim_cfg=sim_cfg) as sim:
+        # Spawn one ball per env at /World/envs/env_<i>/ball.
+        spawn_cfg = sim_utils.SphereCfg(
+            radius=0.25,
+            rigid_props=sim_utils.RigidBodyPropertiesCfg(),
+            mass_props=sim_utils.MassPropertiesCfg(mass=0.5),
+            collision_props=sim_utils.CollisionPropertiesCfg(),
+            visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.0, 0.0, 1.0)),
+        )
+        sim_utils.create_prim("/World/envs", "Xform")
+        num_envs = 2
+        for i in range(num_envs):
+            sim_utils.create_prim(f"/World/envs/env_{i}", "Xform", translation=(i * 5.0, 0.0, 0.0))
+            spawn_cfg.func(f"/World/envs/env_{i}/ball", spawn_cfg, translation=(0.0, 0.0, 1.0))
+
+        balls = RigidObject(
+            RigidObjectCfg(
+                prim_path="/World/envs/env_*/ball",
+                spawn=None,
+                init_state=RigidObjectCfg.InitialStateCfg(pos=(0.0, 0.0, 1.0)),
+            )
+        )
+        imu = Imu(ImuCfg(prim_path="/World/envs/env_*/ball"))
+        sim.reset()
+
+        dt = sim.get_physics_dt()
+        for step in range(100):
+            balls.write_data_to_sim()
+            sim.step()
+            balls.update(dt)
+            imu.update(dt, force_recompute=True)
+
+            if step in (0, 10, 50, 99):
+                ang = imu.data.ang_vel_b.torch
+                lin = imu.data.lin_acc_b.torch
+                print(f"step={step:3d}  ang_vel_b={ang[0].cpu().numpy()}  lin_acc_b={lin[0].cpu().numpy()}")
+
+        # Final sanity check: in freefall the proper acceleration is zero
+        # (gravity cancels the bias). The norm should be near 0.
+        final_lin = imu.data.lin_acc_b.torch
+        magnitude = torch.linalg.norm(final_lin, dim=1).cpu().numpy()
+        print(f"final |lin_acc_b| per env = {magnitude}")
+
+
+if __name__ == "__main__":
+    main()