antioch-py 2.0.6__py3-none-any.whl → 2.1.0__py3-none-any.whl

antioch/session/scene.py

@@ -1,8 +1,7 @@
 from typing import Literal, overload
 
 from antioch.session.ark import Ark
-from antioch.session.session import SessionContainer
-from antioch.session.views import (
+from antioch.session.objects import (
     Animation,
     Articulation,
     BasisCurve,
@@ -22,40 +21,38 @@ from antioch.session.views import (
     set_collision,
     set_pir_material,
 )
+from antioch.session.session import SessionContainer
 from common.core import ContainerSource, get_asset_path
 from common.core.agent import Agent
 from common.message import Pose, Vector3
-from common.session.environment import SessionEnvironment
-from common.session.sim import (
-    AddAsset,
-    GetPrimAttribute,
-    PrimAttributeValue,
-    QueryScene,
-    SceneQueryResponse,
-    SceneTarget,
-    SetPrimAttribute,
-    SetSimulationControls,
-    SimulationInfo,
-    SimulationTime,
-    Step,
-    ToggleUi,
+from common.session.config import (
+    ArticulationConfig,
+    ArticulationJointConfig,
+    BodyType,
+    CameraConfig,
+    CameraMode,
+    DistortionModel,
+    GeometryConfig,
+    GeometryType,
+    GroundPlaneConfig,
+    ImuConfig,
+    JointAxis,
+    JointConfig,
+    JointType,
+    LightConfig,
+    LightType,
+    MeshApproximation,
+    PirSensorConfig,
+    RadarConfig,
+    RigidBodyConfig,
 )
-from common.session.views.articulation import ArticulationConfig, ArticulationJointConfig
-from common.session.views.camera import CameraConfig, CameraMode, DistortionModel
-from common.session.views.geometry import GeometryConfig, GeometryType, MeshApproximation  # noqa: F401
-from common.session.views.ground_plane import GroundPlaneConfig
-from common.session.views.imu import ImuConfig
-from common.session.views.joint import JointAxis, JointConfig, JointType
-from common.session.views.light import LightConfig, LightType
-from common.session.views.pir_sensor import PirSensorConfig
-from common.session.views.radar import RadarConfig
-from common.session.views.rigid_body import BodyType, RigidBodyConfig
-from common.session.views.viewport import SetActiveViewportCamera, SetCameraView
+from common.session.environment import SessionEnvironment
+from common.session.sim import PrimAttributeValue, SceneQueryResponse, SceneTarget, SimulationInfo, SimulationTime
 
 
 class Scene(SessionContainer):
     """
-    Singleton wrapper for scene-level operations and view factory.
+    Singleton wrapper for scene-level operations.
 
     Uses a lazy singleton pattern - the first instantiation or call to get_current()
     creates the instance, and all subsequent calls return the same instance.
@@ -67,9 +64,8 @@ class Scene(SessionContainer):
         scene = Scene()  # or Scene.get_current()
         scene.clear()
         scene.toggle_ui(show_ui=False)
-        scene.set_speed(1.0)
         scene.play()
-        scene.step(dt=0.01)
+        scene.step(dt_us=1_000_000)
 
         # Add views
         geometry = scene.add_geometry(path="/World/box", ...)
@@ -277,34 +273,28 @@ class Scene(SessionContainer):
 
         self._session.query_sim_rpc(
             endpoint="set_simulation_controls",
-            payload=SetSimulationControls(
-                max_physics_dt_us=max_physics_dt_us,
-                render_interval_us=render_interval_us,
-            ),
+            payload={
+                "max_physics_dt_us": max_physics_dt_us,
+                "render_interval_us": render_interval_us,
+            },
         )
 
     def clear(self, timeout: float = 30.0) -> None:
         """
         Clear and completely reset the scene.
 
-        Stops any running Ark before clearing the scene. If a task is active,
-        restarts it to reset telemetry with the same configuration.
+        Stops any running Ark before clearing the scene.
 
         :param timeout: Timeout in seconds for stopping the Ark.
         """
 
-        from antioch.session.task import Task
-
         # Always try to stop the Ark via the agent (idempotent)
         self._agent.stop_ark(timeout=timeout)
         self._ark = None
 
-        # Clear the simulation scenne completely
+        # Clear the simulation scene completely
         self._session.query_sim_rpc(endpoint="clear")
 
-        # Clear any existing task
-        Task.get_current().clear()
-
     def restart(self) -> None:
         """
         Restart the simulation container.
@@ -316,8 +306,6 @@ class Scene(SessionContainer):
         Note: This function will not return as the process will be killed immediately.
         """
 
-        from antioch.session.task import Task
-
         # Always try to stop the Ark via the agent (idempotent)
         self._agent.stop_ark()
         self._ark = None
@@ -325,9 +313,6 @@ class Scene(SessionContainer):
         # Restart the RPC container
         self._session.query_sim_rpc(endpoint="restart")
 
-        # Clear any existing task
-        Task.get_current().clear()
-
     def toggle_ui(self, show_ui: bool) -> None:
         """
         Toggle the Isaac Sim UI visibility.
@@ -337,7 +322,7 @@ class Scene(SessionContainer):
 
         self._session.query_sim_rpc(
             endpoint="toggle_ui",
-            payload=ToggleUi(show_ui=show_ui),
+            payload={"show_ui": show_ui},
         )
 
     def set_camera_view(
@@ -356,11 +341,11 @@ class Scene(SessionContainer):
 
         self._session.query_sim_rpc(
             endpoint="set_camera_view",
-            payload=SetCameraView(
-                eye=Vector3.from_any(eye),
-                target=Vector3.from_any(target),
-                camera_prim_path=camera_prim_path,
-            ),
+            payload={
+                "eye": Vector3.from_any(eye),
+                "target": Vector3.from_any(target),
+                "camera_prim_path": camera_prim_path,
+            },
         )
 
     def set_active_viewport_camera(self, camera_prim_path: str) -> None:
@@ -372,7 +357,7 @@ class Scene(SessionContainer):
 
         self._session.query_sim_rpc(
             endpoint="set_active_viewport_camera",
-            payload=SetActiveViewportCamera(camera_prim_path=camera_prim_path),
+            payload={"camera_prim_path": camera_prim_path},
         )
 
     def get_prim_attribute(self, path: str, attribute_name: str) -> float | int | str | bool | list[float]:
@@ -388,9 +373,9 @@ class Scene(SessionContainer):
         """
 
         return self._session.query_sim_rpc(
-            endpoint="get_prim_attribute_value",
+            endpoint="scene/get_prim_attribute_value",
             response_type=PrimAttributeValue,
-            payload=GetPrimAttribute(path=path, attribute_name=attribute_name),
+            payload={"path": path, "attribute_name": attribute_name},
         ).value
 
     def set_prim_attribute(self, path: str, attribute_name: str, value: float | int | str | bool | list[float]) -> None:
@@ -407,8 +392,8 @@ class Scene(SessionContainer):
         """
 
         self._session.query_sim_rpc(
-            endpoint="set_prim_attribute_value",
-            payload=SetPrimAttribute(path=path, attribute_name=attribute_name, value=value),
+            endpoint="scene/set_prim_attribute_value",
+            payload={"path": path, "attribute_name": attribute_name, "value": value},
         )
 
     def query_scene(self, root_path: str = "/World", target: SceneTarget | None = None) -> SceneQueryResponse:
@@ -425,9 +410,9 @@ class Scene(SessionContainer):
         """
 
         return self._session.query_sim_rpc(
-            endpoint="query_scene_hierarchy",
+            endpoint="scene/query_hierarchy",
             response_type=SceneQueryResponse,
-            payload=QueryScene(root_path=root_path, target=target),
+            payload={"root_path": root_path, "target": target},
         )
 
     def add_asset(
@@ -484,18 +469,18 @@ class Scene(SessionContainer):
         if not asset_file_path:
             raise ValueError("Asset file path is required")
         self._session.query_sim_rpc(
-            endpoint="add_asset",
-            payload=AddAsset(
-                path=path,
-                asset_file_path=asset_file_path,
-                asset_prim_path=asset_prim_path,
-                remove_articulation=remove_articulation,
-                remove_rigid_body=remove_rigid_body,
-                remove_sensors=remove_sensors,
-                world_pose=Pose.from_any(world_pose) if world_pose is not None else None,
-                local_pose=Pose.from_any(local_pose) if local_pose is not None else None,
-                scale=Vector3.from_any(scale) if scale is not None else None,
-            ),
+            endpoint="scene/add_asset",
+            payload={
+                "path": path,
+                "asset_file_path": asset_file_path,
+                "asset_prim_path": asset_prim_path,
+                "remove_articulation": remove_articulation,
+                "remove_rigid_body": remove_rigid_body,
+                "remove_sensors": remove_sensors,
+                "world_pose": Pose.from_any(world_pose) if world_pose is not None else None,
+                "local_pose": Pose.from_any(local_pose) if local_pose is not None else None,
+                "scale": Vector3.from_any(scale) if scale is not None else None,
+            },
         )
         return path
 
@@ -526,7 +511,6 @@ class Scene(SessionContainer):
 
         :param path: USD path for the geometry.
         :param geometry_type: Type of geometry (sphere, cube, cylinder, cone, capsule, mesh).
-        :param name: Optional unique name for the view.
         :param radius: Radius for sphere/cylinder/cone/capsule.
         :param height: Height for cylinder/cone/capsule.
         :param size: Size for cube (uniform).
@@ -598,7 +582,6 @@ class Scene(SessionContainer):
         Add an articulation to the scene.
 
         :param path: USD path for the articulation.
-        :param name: Optional unique name for the view.
         :param joint_configs: Per-joint configurations (stiffness, damping, limits, etc).
         :param solver_position_iterations: Number of position iterations for the solver.
         :param solver_velocity_iterations: Number of velocity iterations for the solver.
@@ -656,7 +639,6 @@ class Scene(SessionContainer):
         :param path: USD path for the joint.
         :param parent_path: USD path to parent body.
         :param child_path: USD path to child body.
-        :param name: Optional unique name for the view.
         :param pose: Joint pose relative to parent (defaults to identity).
         :param joint_type: Type of joint motion (FIXED, REVOLUTE, PRISMATIC).
         :param axis: Axis of motion for non-fixed joints.
@@ -714,7 +696,6 @@ class Scene(SessionContainer):
         Add rigid body physics to the scene.
 
         :param path: USD path for the rigid body.
-        :param name: Optional unique name for the view.
         :param body_type: Body type (dynamic or kinematic).
         :param mass: Mass in kg.
         :param density: Density in kg/m³ (alternative to mass).
@@ -778,7 +759,6 @@ class Scene(SessionContainer):
         Add a light to the scene.
 
         :param path: USD path for the light.
-        :param name: Optional unique name for the view.
         :param light_type: Type of light (sphere, rect, disk, cylinder, distant, dome).
         :param intensity: Light intensity.
         :param exposure: Light exposure value.
@@ -833,7 +813,6 @@ class Scene(SessionContainer):
         Add an xform to the scene.
 
         :param path: USD path for the xform.
-        :param name: Optional unique name for the view.
         :param world_pose: Optional world pose as Pose (or dict with position/orientation lists).
         :param local_pose: Optional local pose as Pose (or dict with position/orientation lists).
         :param scale: Optional scale as Vector3 (or list/tuple of 3 floats).
@@ -944,8 +923,7 @@ class Scene(SessionContainer):
         """
         Add a ground plane to the scene.
 
-        :param path: USD path for the ground plane (default: "/World/ground").
-        :param name: Optional unique name for the view.
+        :param path: USD path for the ground plane.
         :param size: Size of the ground plane in meters.
         :param z_position: Z position of the ground plane.
         :param color: RGB color as Vector3 (or list/tuple of 3 floats) with values 0-1 (defaults to gray).
@@ -1003,7 +981,6 @@ class Scene(SessionContainer):
         Add a camera to the scene.
 
         :param path: USD path for the camera.
-        :param name: Optional unique name for the camera.
         :param config: Optional camera configuration (alternative to individual parameters).
         :param mode: Camera capture mode (RGB or depth).
         :param frequency: Camera update frequency in Hz.
@@ -1076,7 +1053,6 @@ class Scene(SessionContainer):
         Add an IMU to the scene.
 
         :param path: USD path for the IMU.
-        :param name: Optional unique name for the IMU.
         :param config: Optional IMU configuration (alternative to individual parameters).
         :param frequency: Sensor update frequency in Hz (optional, defaults to physics rate).
         :param linear_acceleration_filter_size: Filter window size for linear acceleration.
@@ -1132,7 +1108,6 @@ class Scene(SessionContainer):
         Add a radar to the scene.
 
         :param path: USD path for the radar.
-        :param name: Optional unique name for the radar.
         :param config: Optional radar configuration (alternative to individual parameters).
         :param frequency: Sensor update frequency in Hz.
         :param max_azimuth: Maximum azimuth angle in degrees (±FOV from center).
@@ -1281,41 +1256,6 @@ class Scene(SessionContainer):
 
         return BasisCurve(path)
 
-    def get_basis_curve_extents(self, path: str) -> tuple[Vector3, Vector3]:
-        """
-        Get the extents of the basis curve.
-
-        :param path: USD path for the basis curve.
-        :return: The extents of the basis curve.
-        """
-
-        return BasisCurve(path).get_extents()
-
-    def get_basis_curve_points(
-        self, path: str, samples_per_segment: int = 10, sort_by: Literal["X", "Y", "Z"] | None = None, ascending: bool = True
-    ) -> list[Vector3]:
-        """
-        Get the points of the basis curve.
-
-        :param path: USD path for the basis curve.
-        :param samples_per_segment: The number of samples per segment.
-        :param sort_by: The axis to sort the points by.
-        :param ascending: Whether to sort the points in ascending order.
-        :return: The points of the basis curve.
-        """
-
-        return BasisCurve(path).get_points(samples_per_segment=samples_per_segment, sort_by=sort_by, ascending=ascending)
-
-    def set_basis_curve_visibility(self, path: str, visible: bool) -> None:
-        """
-        Set the visibility of the basis curve.
-
-        :param path: USD path for the basis curve.
-        :param visible: True to make visible, False to hide.
-        """
-
-        BasisCurve(path).set_visibility(visible)
-
     def get_radar(self, path: str) -> Radar:
         """
         Get existing radar from the scene.
@@ -1330,28 +1270,33 @@ class Scene(SessionContainer):
         self,
         path: str,
         config: PirSensorConfig | None = None,
-        update_rate_hz: float = 10.0,
-        max_range: float = 12.0,
-        horiz_fov_deg: float = 90.0,
-        vert_fov_deg: float = 60.0,
-        rays_per_h: int = 64,
-        rays_per_v: int = 16,
-        gain: float = 0.01,
-        hp_corner_hz: float = 0.1,
-        lp_corner_hz: float = 3.0,
+        update_rate_hz: float = 60.0,
+        max_range: float = 20.0,
+        total_horiz_fov_deg: float = 150.0,
+        sensor_side_fov_deg: float = 45.0,
+        sensor_center_fov_deg: float = 45.0,
+        sensor_rays_horiz: int = 128,
+        sensor_rays_vert: int = 16,
+        min_vertical_angle_center: float = -30.0,
+        max_vertical_angle_center: float = 30.0,
+        min_vertical_angle_side: float = -30.0,
+        max_vertical_angle_side: float = 30.0,
+        gain_center: float = 0.015,
+        gain_sides: float = 0.01,
+        hp_corner_hz: float = 0.4,
+        lp_corner_hz: float = 10.0,
         threshold: float | None = None,
         threshold_scale: float = 1.0,
-        hold_time_s: float = 2.0,
+        blind_time_s: float = 0.5,
+        pulse_counter: int = 2,
+        window_time_s: float = 2.0,
+        count_mode: int = 0,
         lens_transmission: float = 0.9,
         lens_segments_h: int = 6,
-        vertical_gain_falloff: float = 0.5,
-        element_fov_overlap_deg: float = 20.0,
-        element_scatter_gain: float = 0.1,
-        element_fov_transition_deg: float = 15.0,
         ambient_temp_c: float = 20.0,
         thermal_time_constant_s: float = 0.2,
-        pyro_responsivity: float = 1.0,
-        noise_amplitude: float = 0.0,
+        pyro_responsivity: float = 4000.0,
+        noise_amplitude: float = 20e-6,
         target_delta_t: float = 10.0,
         target_distance: float = 5.0,
         target_emissivity: float = 0.98,
@@ -1369,22 +1314,27 @@ class Scene(SessionContainer):
         :param config: Optional PIR sensor configuration (alternative to individual parameters).
         :param update_rate_hz: Sensor update frequency in Hz.
         :param max_range: Maximum detection range in meters.
-        :param horiz_fov_deg: Horizontal field of view in degrees.
-        :param vert_fov_deg: Vertical field of view in degrees.
-        :param rays_per_h: Number of rays in horizontal direction.
-        :param rays_per_v: Number of rays in vertical direction.
-        :param gain: Amplifier gain.
+        :param total_horiz_fov_deg: Total horizontal coverage in degrees. Enables automatic fanning.
+        :param sensor_side_fov_deg: Horizontal FOV for side sensors in degrees.
+        :param sensor_center_fov_deg: Horizontal FOV for center sensor in degrees.
+        :param sensor_rays_horiz: Number of rays per sensor in horizontal direction.
+        :param sensor_rays_vert: Number of rays per sensor in vertical direction.
+        :param min_vertical_angle_center: Minimum vertical angle for center sensor in degrees.
+        :param max_vertical_angle_center: Maximum vertical angle for center sensor in degrees.
+        :param min_vertical_angle_side: Minimum vertical angle for side sensors in degrees.
+        :param max_vertical_angle_side: Maximum vertical angle for side sensors in degrees.
+        :param gain_center: Amplifier gain for center sensor.
+        :param gain_sides: Amplifier gain for side sensors.
         :param hp_corner_hz: High-pass filter corner frequency in Hz.
         :param lp_corner_hz: Low-pass filter corner frequency in Hz.
         :param threshold: Detection threshold (auto-calibrated if None).
         :param threshold_scale: Scale factor applied to auto-calibrated threshold.
-        :param hold_time_s: Detection hold time in seconds.
+        :param blind_time_s: Blind time after detection in seconds.
+        :param pulse_counter: Number of pulses required to trigger detection (1-4).
+        :param window_time_s: Window time for pulse counting in seconds.
+        :param count_mode: Pulse counting mode (0 = sign change required, 1 = any crossing).
         :param lens_transmission: Lens transmission coefficient (0-1).
-        :param lens_segments_h: Number of horizontal lens segments (sinusoidal sensitivity peaks).
-        :param vertical_gain_falloff: Exponent for elevation-based gain reduction (0=uniform).
-        :param element_fov_overlap_deg: Half-angle of center region where both elements see well (degrees).
-        :param element_scatter_gain: Minimum gain for blocked element due to scatter/reflections (0-1).
-        :param element_fov_transition_deg: Width of soft transition from full gain to scatter gain (degrees).
+        :param lens_segments_h: Number of horizontal lens segments (facets).
         :param ambient_temp_c: Ambient temperature in Celsius.
         :param thermal_time_constant_s: Pyroelectric element thermal time constant in seconds.
         :param pyro_responsivity: Pyroelectric responsivity scaling factor.
@@ -1402,22 +1352,27 @@ class Scene(SessionContainer):
             config = PirSensorConfig(
                 update_rate_hz=update_rate_hz,
                 max_range=max_range,
-                horiz_fov_deg=horiz_fov_deg,
-                vert_fov_deg=vert_fov_deg,
-                rays_per_h=rays_per_h,
-                rays_per_v=rays_per_v,
-                gain=gain,
+                total_horiz_fov_deg=total_horiz_fov_deg,
+                sensor_side_fov_deg=sensor_side_fov_deg,
+                sensor_center_fov_deg=sensor_center_fov_deg,
+                sensor_rays_horiz=sensor_rays_horiz,
+                sensor_rays_vert=sensor_rays_vert,
+                min_vertical_angle_center=min_vertical_angle_center,
+                max_vertical_angle_center=max_vertical_angle_center,
+                min_vertical_angle_side=min_vertical_angle_side,
+                max_vertical_angle_side=max_vertical_angle_side,
+                gain_center=gain_center,
+                gain_sides=gain_sides,
                 hp_corner_hz=hp_corner_hz,
                 lp_corner_hz=lp_corner_hz,
                 threshold=threshold,
                 threshold_scale=threshold_scale,
-                hold_time_s=hold_time_s,
+                blind_time_s=blind_time_s,
+                pulse_counter=pulse_counter,
+                window_time_s=window_time_s,
+                count_mode=count_mode,
                 lens_transmission=lens_transmission,
                 lens_segments_h=lens_segments_h,
-                vertical_gain_falloff=vertical_gain_falloff,
-                element_fov_overlap_deg=element_fov_overlap_deg,
-                element_scatter_gain=element_scatter_gain,
-                element_fov_transition_deg=element_fov_transition_deg,
                 ambient_temp_c=ambient_temp_c,
                 thermal_time_constant_s=thermal_time_constant_s,
                 pyro_responsivity=pyro_responsivity,
@@ -1484,12 +1439,7 @@ class Scene(SessionContainer):
 
         return get_mesh_approximation(path)
 
-    def set_pir_material(
-        self,
-        path: str,
-        emissivity: float = 0.9,
-        temperature_c: float | None = None,
-    ) -> None:
+    def set_pir_material(self, path: str, emissivity: float = 0.9, temperature_c: float | None = None) -> None:
         """
         Set PIR-specific thermal properties on a prim.
 
@@ -1507,6 +1457,46 @@ class Scene(SessionContainer):
 
         set_pir_material(path, emissivity, temperature_c)
 
+    def set_nonvisual_material(self, path: str, base: str, coating: str = "none", attribute: str = "none") -> int:
+        """
+        Set non-visual material properties on all Material prims in a subtree.
+
+        These properties define how objects appear to RTX sensors (LiDAR and Radar).
+
+        Valid base materials:
+            Metals: aluminum, steel, oxidized_steel, iron, oxidized_iron, silver, brass,
+                    bronze, oxidized_bronze_patina, tin
+            Polymers: plastic, fiberglass, carbon_fiber, vinyl, plexiglass, pvc, nylon, polyester
+            Glass: clear_glass, frosted_glass, one_way_mirror, mirror, ceramic_glass
+            Other: asphalt, concrete, leaf_grass, dead_leaf_grass, rubber, wood, bark,
+                   cardboard, paper, fabric, skin, fur_hair, leather, marble, brick,
+                   stone, gravel, dirt, mud, water, salt_water, snow, ice, calibration_lambertion
+            Default: none
+
+        Valid coatings: none, paint, clearcoat, paint_clearcoat
+
+        Valid attributes: none, emissive, retroreflective, single_sided, visually_transparent
+
+        Example:
+            # Make a person visible to radar/lidar with skin material
+            scene.set_nonvisual_material("/World/person", base="skin")
+
+            # Make a car with aluminum body and paint coating
+            scene.set_nonvisual_material("/World/car", base="aluminum", coating="paint")
+
+        :param path: USD path of the root prim to configure.
+        :param base: Base material type.
+        :param coating: Coating type.
+        :param attribute: Material attribute.
+        :return: Number of Material prims modified.
+        """
+
+        return self._session.query_sim_rpc(
+            endpoint="material/set_nonvisual",
+            payload={"path": path, "base": base, "coating": coating, "attribute": attribute},
+            response_type=int,
+        )
+
     def _step_physics(self, dt_us: int) -> None:
         """
         Step physics by dt_us.
@@ -1517,5 +1507,5 @@ class Scene(SessionContainer):
         if dt_us > 0:
             self._session.query_sim_rpc(
                 endpoint="step",
-                payload=Step(dt_us=dt_us),
+                payload={"dt_us": dt_us},
             )