antioch-py 1.9.7__py3-none-any.whl

antioch/session/views/animation.py

@@ -0,0 +1,189 @@
+from typing import Literal, overload
+
+from antioch.session.session import Session, SessionContainer
+from common.message import Vector3
+from common.session.views.animation import (
+    AddAnimationFromBasisCurve,
+    AddAnimationFromWaypoints,
+    RemoveAnimation,
+    UpdateAnimationBasisCurve,
+    UpdateAnimationWaypoints,
+)
+
+
+class Animation(SessionContainer):
+    """
+    Ergonomic wrapper for animation operations.
+
+    Animations should be added using scene.add_animation() or retrieved using scene.get_animation().
+    Animations wrap around an existing skeleton UsdSkel.Root and provide a way to play and control the animation.
+
+    Example:
+        scene = Scene()
+
+        # Add xform
+        animation = scene.add_animation(
+            path="/World/skeleton",
+            waypoints=[Vector3(1.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), Vector3(0.0, 0.0, 1.0)],
+            loop=True,
+        )
+    """
+
+    def __init__(self, path: str):
+        """
+        Initialize animation by resolving path and validating existence.
+
+        :param path: USD path for the animation.
+        """
+
+        super().__init__()
+        self._path = path
+
+    @overload
+    @classmethod
+    def add(
+        cls,
+        path: str,
+        *,
+        waypoints: list[Vector3],
+        loop: bool = True,
+    ) -> "Animation": ...
+
+    @overload
+    @classmethod
+    def add(
+        cls,
+        path: str,
+        *,
+        basis_curve: str,
+        samples_per_segment: int = 10,
+        sort_by: Literal["X", "Y", "Z"] | None = None,
+        ascending: bool = True,
+    ) -> "Animation": ...
+
+    @classmethod
+    def add(
+        cls,
+        path: str,
+        *,
+        waypoints: list[Vector3] | None = None,
+        basis_curve: str | None = None,
+        samples_per_segment: int = 10,
+        sort_by: Literal["X", "Y", "Z"] | None = None,
+        ascending: bool = True,
+        loop: bool = True,
+    ) -> "Animation":
+        """
+        Add an animation to the scene.
+
+        :param path: USD path for the animation.
+        :param waypoints: List of waypoints.
+        :param basis_curve: Path to the basis curve to use for the animation.
+        :param samples_per_segment: The number of samples per segment to use from the basis curve.
+        :param sort_by: The axis to sort the points by.
+        :param ascending: Whether to sort the points in ascending order.
+        :param loop: Whether to loop the animation (waypoints only).
+        :return: The animation instance.
+        """
+
+        if waypoints is not None:
+            Session.get_current().query_sim_rpc(
+                endpoint="add_animation_from_waypoints",
+                payload=AddAnimationFromWaypoints(
+                    path=path,
+                    waypoints=waypoints,
+                    loop=loop,
+                ),
+            )
+        elif basis_curve is not None:
+            Session.get_current().query_sim_rpc(
+                endpoint="add_animation_from_basis_curve",
+                payload=AddAnimationFromBasisCurve(
+                    path=path,
+                    basis_curve=basis_curve,
+                    samples_per_segment=samples_per_segment,
+                    sort_by=sort_by,
+                    ascending=ascending,
+                ),
+            )
+        else:
+            raise ValueError("Must provide either waypoints or basis_curve")
+
+        return cls(path)
+
+    @overload
+    def update(
+        self,
+        *,
+        waypoints: list[Vector3],
+        loop: bool = True,
+    ) -> "Animation": ...
+
+    @overload
+    def update(
+        self,
+        *,
+        basis_curve: str,
+        samples_per_segment: int = 10,
+        sort_by: Literal["X", "Y", "Z"] | None = None,
+        ascending: bool = True,
+    ) -> "Animation": ...
+
+    def update(
+        self,
+        *,
+        waypoints: list[Vector3] | None = None,
+        basis_curve: str | None = None,
+        samples_per_segment: int = 10,
+        sort_by: Literal["X", "Y", "Z"] | None = None,
+        ascending: bool = True,
+        loop: bool = True,
+    ) -> "Animation":
+        """
+        Update the animation.
+
+        :param waypoints: List of waypoints.
+        :param basis_curve: Path to the basis curve to use for the animation.
+        :param samples_per_segment: The number of samples per segment to use from the basis curve.
+        :param sort_by: The axis to sort the points by.
+        :param ascending: Whether to sort the points in ascending order.
+        :param loop: Whether to loop the animation (waypoints only).
+        :raises ValueError: If both waypoints and basis curve are provided.
+        :return: The animation instance.
+        """
+        if waypoints is not None and basis_curve is not None:
+            raise ValueError("Must provide either waypoints or basis_curve")
+
+        if waypoints is not None:
+            Session.get_current().query_sim_rpc(
+                endpoint="update_animation_waypoints",
+                payload=UpdateAnimationWaypoints(
+                    path=self._path,
+                    waypoints=waypoints,
+                    loop=loop,
+                ),
+            )
+        elif basis_curve is not None:
+            Session.get_current().query_sim_rpc(
+                endpoint="update_animation_basis_curve",
+                payload=UpdateAnimationBasisCurve(
+                    path=self._path,
+                    basis_curve=basis_curve,
+                    samples_per_segment=samples_per_segment,
+                    sort_by=sort_by,
+                    ascending=ascending,
+                ),
+            )
+        else:
+            raise ValueError("Must provide either waypoints or basis_curve")
+        return self
+
+    def remove(self) -> None:
+        """
+        Remove the animation from the scene (deletes the character).
+        """
+
+        self._session.query_sim_rpc(
+            endpoint="remove_animation",
+            payload=RemoveAnimation(path=self._path),
+        )

antioch/session/views/articulation.py

@@ -0,0 +1,245 @@
+from antioch.session.session import Session, SessionContainer
+from common.message import JointState, JointTarget, Pose, Vector3
+from common.session.sim import GetLocalPose, GetWorldPose, SetLocalPose, SetWorldPose
+from common.session.views.articulation import (
+    AddArticulation,
+    ArticulationConfig,
+    ArticulationJointConfig,
+    ArticulationJointConfigs,
+    ArticulationJointStates,
+    ArticulationJointTargets,
+    GetArticulation,
+    GetArticulationJointConfigs,
+    GetArticulationJointStates,
+    GetArticulationJointTargets,
+    GetArticulationResponse,
+    SetArticulationJointConfigs,
+    SetArticulationJointStates,
+    SetArticulationJointTargets,
+)
+
+
+class Articulation(SessionContainer):
+    """
+    Ergonomic wrapper for articulation operations.
+
+    Articulations should be added using scene.add_articulation() or retrieved using scene.get_articulation().
+
+    Example:
+        scene = Scene()
+
+        # Get an existing articulation
+        robot = scene.get_articulation(path="/World/robot")
+
+        # Use articulation
+        joint_states = robot.get_joint_states()
+        robot.set_joint_targets(
+            joint_targets=[
+                JointTarget(position=0.1, velocity=0.0, effort=0.0),
+                JointTarget(position=0.2, velocity=0.0, effort=0.0),
+            ]
+        )
+        pose = robot.get_world_pose()
+    """
+
+    def __init__(self, path: str):
+        """
+        Initialize articulation by resolving path and validating existence.
+
+        :param path: USD path for the articulation.
+        """
+
+        super().__init__()
+
+        # Validate path
+        self._path = self._session.query_sim_rpc(
+            endpoint="get_articulation",
+            payload=GetArticulation(path=path),
+            response_type=GetArticulationResponse,
+        ).path
+
+    @classmethod
+    def add(
+        cls,
+        path: str,
+        config: ArticulationConfig,
+        world_pose: Pose | None,
+        local_pose: Pose | None,
+        scale: Vector3 | None,
+    ) -> "Articulation":
+        """
+        Add an articulation to the scene.
+
+        :param path: USD path for the articulation.
+        :param config: Articulation configuration.
+        :param world_pose: Optional world pose.
+        :param local_pose: Optional local pose.
+        :param scale: Optional scale.
+        :return: The articulation instance.
+        """
+
+        Session.get_current().query_sim_rpc(
+            endpoint="add_articulation",
+            payload=AddArticulation(
+                path=path,
+                config=config,
+                world_pose=world_pose,
+                local_pose=local_pose,
+                scale=scale,
+            ),
+        )
+        return cls(path)
+
+    def get_joint_states(
+        self,
+        joint_names: list[str] | None = None,
+    ) -> list[JointState]:
+        """
+        Get current joint states.
+
+        :param joint_names: Optional list of joint names. If None, returns all joints.
+        :return: List of joint states.
+        """
+
+        response = self._session.query_sim_rpc(
+            endpoint="get_articulation_joint_states",
+            payload=GetArticulationJointStates(path=self._path, joint_names=joint_names),
+            response_type=ArticulationJointStates,
+        )
+
+        return response.joint_states if response else []
+
+    def get_joint_targets(self, joint_names: list[str] | None = None) -> list[JointTarget]:
+        """
+        Get current applied control targets.
+
+        :param joint_names: Optional list of joint names. If None, returns all joints.
+        :return: List of joint control targets.
+        """
+
+        return self._session.query_sim_rpc(
+            endpoint="get_articulation_joint_targets",
+            payload=GetArticulationJointTargets(path=self._path, joint_names=joint_names),
+            response_type=ArticulationJointTargets,
+        ).joint_targets
+
+    def get_joint_configs(self, joint_names: list[str] | None = None) -> list[ArticulationJointConfig]:
+        """
+        Get complete joint configurations.
+
+        Only returns DOF joints. Non-DOF joints are automatically filtered out.
+        Use the joint_name field in each config to get joint names.
+
+        :param joint_names: Optional list of joint names. If None, returns all DOF joints.
+        :return: List of joint configurations (DOF joints only).
+        """
+
+        return self._session.query_sim_rpc(
+            endpoint="get_articulation_joint_configs",
+            payload=GetArticulationJointConfigs(path=self._path, joint_names=joint_names),
+            response_type=ArticulationJointConfigs,
+        ).joint_configs
+
+    def set_joint_configs(self, joint_configs: list[ArticulationJointConfig]) -> None:
+        """
+        Set complete joint configurations.
+
+        :param joint_configs: List of joint configurations to apply.
+        """
+
+        self._session.query_sim_rpc(
+            endpoint="set_articulation_joint_configs",
+            payload=SetArticulationJointConfigs(path=self._path, joint_configs=joint_configs),
+        )
+
+    def set_joint_states(
+        self,
+        joint_names: list[str] | None = None,
+        joint_states: list[JointState] | None = None,
+    ) -> None:
+        """
+        Set the joint states of the articulation (immediate teleport).
+
+        :param joint_names: Optional list of joint names. If None, sets all joints.
+        :param joint_states: List of joint states to set.
+        """
+
+        self._session.query_sim_rpc(
+            endpoint="set_articulation_joint_states",
+            payload=SetArticulationJointStates(
+                path=self._path,
+                joint_names=joint_names,
+                joint_states=joint_states,
+            ),
+        )
+
+    def set_joint_targets(
+        self,
+        joint_names: list[str] | None = None,
+        joint_targets: list[JointTarget] | None = None,
+    ) -> None:
+        """
+        Set control targets for the articulation's PD controllers.
+
+        :param joint_names: Optional list of joint names. If None, targets all joints.
+        :param joint_targets: List of joint control targets.
+        """
+
+        self._session.query_sim_rpc(
+            endpoint="set_articulation_joint_targets",
+            payload=SetArticulationJointTargets(
+                path=self._path,
+                joint_names=joint_names,
+                joint_targets=joint_targets,
+            ),
+        )
+
+    def get_world_pose(self) -> Pose:
+        """
+        Get the world pose of the articulation.
+
+        :return: World pose.
+        """
+
+        return self._session.query_sim_rpc(
+            endpoint="get_articulation_world_pose",
+            payload=GetWorldPose(path=self._path),
+            response_type=Pose,
+        )
+
+    def get_local_pose(self) -> Pose:
+        """
+        Get the local pose of the articulation.
+
+        :return: Local pose.
+        """
+
+        return self._session.query_sim_rpc(
+            endpoint="get_articulation_local_pose",
+            payload=GetLocalPose(path=self._path),
+            response_type=Pose,
+        )
+
+    def set_world_pose(self, pose: Pose | dict) -> None:
+        """
+        Set the world pose of the articulation.
+
+        :param pose: World pose as Pose (or dict with position/orientation lists).
+        """
+
+        self._session.query_sim_rpc(
+            endpoint="set_articulation_world_pose",
+            payload=SetWorldPose(path=self._path, pose=Pose.from_any(pose)),
+        )
+
+    def set_local_pose(self, pose: Pose | dict) -> None:
+        """
+        Set the local pose of the articulation.
+
+        :param pose: Local pose as Pose (or dict with position/orientation lists).
+        """
+
+        self._session.query_sim_rpc(
+            endpoint="set_articulation_local_pose",
+            payload=SetLocalPose(path=self._path, pose=Pose.from_any(pose)),
+        )

antioch/session/views/basis_curve.py

@@ -0,0 +1,186 @@
+from typing import Literal
+
+from antioch.session.session import Session, SessionContainer
+from common.message import Vector3
+from common.session.views.basis_curve import (
+    AddBasisCurveLine,
+    AddBasisCurveSemiCircle,
+    GetBasisCurve,
+    GetBasisCurveExtents,
+    GetBasisCurveExtentsResponse,
+    GetBasisCurvePoints,
+    GetBasisCurvePointsResponse,
+    GetBasisCurveResponse,
+    RemoveBasisCurve,
+    SetBasisCurveVisibility,
+)
+
+
+class BasisCurve(SessionContainer):
+    """
+    Ergonomic wrapper for basis curve operations.
+
+    BasisCurves should be added using scene.add_basis_curve() or retrieved using scene.get_basis_curve().
+
+    Example:
+        scene = Scene()
+
+        # Add basis curve
+        basis_curve = scene.add_basis_curve(
+            path="/World/curve",
+            center=[1.0, 2.0, 3.0],
+            radius=2.0,
+            min_angle_deg=0.0,
+            max_angle_deg=180.0,
+        )
+
+        extents = basis_curve.get_extents()
+    """
+
+    def __init__(self, path: str):
+        """
+        Initialize basis curve by resolving path and validating existence.
+
+        :param path: USD path for the basis curve.
+        """
+
+        super().__init__()
+
+        # Validate path
+        self._path = self._session.query_sim_rpc(
+            endpoint="get_basis_curve",
+            payload=GetBasisCurve(path=path),
+            response_type=GetBasisCurveResponse,
+        ).path
+
+    @property
+    def path(self) -> str:
+        """
+        Get the path of the basis curve.
+
+        :return: The path of the basis curve.
+        """
+
+        return self._path
+
+    @classmethod
+    def add(
+        cls,
+        path: str,
+        center: Vector3 = Vector3.zeros(),
+        radius: float = 1.0,
+        min_angle_deg: float = 0.0,
+        max_angle_deg: float = 180.0,
+    ) -> "BasisCurve":
+        """
+        Add a semi-circle basis curve to the scene.
+
+        :param path: USD path for the basis curve.
+        :param center: Center of the basis curve.
+        :param radius: Radius of the basis curve.
+        :param min_angle_deg: Minimum angle of the basis curve in degrees.
+        :param max_angle_deg: Maximum angle of the basis curve in degrees.
+        :return: The basis curve instance.
+        """
+
+        Session.get_current().query_sim_rpc(
+            endpoint="add_basis_curve_semi_circle",
+            payload=AddBasisCurveSemiCircle(
+                path=path,
+                center=center,
+                radius=radius,
+                min_angle_deg=min_angle_deg,
+                max_angle_deg=max_angle_deg,
+            ),
+        )
+        return cls(path)
+
+    @classmethod
+    def add_line(
+        cls,
+        path: str,
+        start: Vector3,
+        end: Vector3 | None = None,
+        angle_deg: float | None = None,
+        length: float | None = None,
+    ) -> "BasisCurve":
+        """
+        Add a line basis curve to the scene.
+
+        Supports two modes:
+        - Cartesian: Provide start and end points directly
+        - Polar: Provide start point, angle (degrees from +X axis in XY plane), and length
+
+        :param path: USD path for the basis curve.
+        :param start: Start point of the line.
+        :param end: End point of the line (Cartesian mode).
+        :param angle_deg: Angle in degrees from +X axis in XY plane (polar mode).
+        :param length: Length of the line (polar mode).
+        :return: The basis curve instance.
+        :raises ValueError: If both modes are specified or neither mode is complete.
+        """
+
+        Session.get_current().query_sim_rpc(
+            endpoint="add_basis_curve_line",
+            payload=AddBasisCurveLine(
+                path=path,
+                start=start,
+                end=end,
+                angle_deg=angle_deg,
+                length=length,
+            ),
+        )
+        return cls(path)
+
+    def get_extents(self) -> tuple[Vector3, Vector3]:
+        """
+        Get the extents of the basis curve.
+
+        :return: Extents as tuple of start and end points.
+        """
+
+        extents = self._session.query_sim_rpc(
+            endpoint="get_basis_curve_extents",
+            payload=GetBasisCurveExtents(path=self._path),
+            response_type=GetBasisCurveExtentsResponse,
+        )
+        return extents.start, extents.end
+
+    def get_points(
+        self, 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 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 self._session.query_sim_rpc(
+            endpoint="get_basis_curve_points",
+            payload=GetBasisCurvePoints(path=self._path, samples_per_segment=samples_per_segment, sort_by=sort_by, ascending=ascending),
+            response_type=GetBasisCurvePointsResponse,
+        ).points
+
+    def set_visibility(self, visible: bool) -> None:
+        """
+        Set the visibility of the basis curve.
+
+        :param visible: True to make visible, False to hide.
+        """
+
+        self._session.query_sim_rpc(
+            endpoint="set_basis_curve_visibility",
+            payload=SetBasisCurveVisibility(path=self._path, visible=visible),
+        )
+
+    def remove(self) -> None:
+        """
+        Remove the basis curve from the scene.
+        """
+
+        self._session.query_sim_rpc(
+            endpoint="remove_basis_curve",
+            payload=RemoveBasisCurve(path=self._path),
+        )

antioch/session/views/camera.py

@@ -0,0 +1,92 @@
+from antioch.session.session import Session, SessionContainer
+from common.message import CameraInfo, Image, Pose
+from common.session.views.camera import AddCamera, CameraConfig, GetCamera, GetCameraFrame, GetCameraResponse
+
+
+class Camera(SessionContainer):
+    """
+    Camera view for time-synchronized image capture.
+
+    Example:
+        scene = Scene()
+        camera = scene.get_camera(name="my_ark/my_module/my_camera")
+        frame = camera.get_frame()
+    """
+
+    def __init__(
+        self,
+        path: str,
+        config: CameraConfig | None = None,
+    ):
+        """
+        Initialize camera view.
+
+        :param path: USD path for the camera.
+        :param config: Optional camera config for intrinsics.
+        """
+
+        super().__init__()
+
+        self._config = config
+        self._path = self._session.query_sim_rpc(
+            endpoint="get_camera",
+            payload=GetCamera(path=path),
+            response_type=GetCameraResponse,
+        ).path
+
+    @classmethod
+    def add(
+        cls,
+        path: str,
+        config: CameraConfig,
+        world_pose: Pose | None,
+        local_pose: Pose | None,
+    ) -> "Camera":
+        """
+        Add camera to the scene.
+
+        :param path: USD path for the camera.
+        :param config: Camera configuration.
+        :param world_pose: Optional world pose.
+        :param local_pose: Optional local pose.
+        :return: The camera instance.
+        """
+
+        Session.get_current().query_sim_rpc(
+            endpoint="add_camera",
+            payload=AddCamera(
+                path=path,
+                config=config,
+                world_pose=world_pose,
+                local_pose=local_pose,
+            ),
+        )
+        return cls(path, config)
+
+    def get_frame(self) -> Image | None:
+        """
+        Get camera frame with image data.
+
+        :return: Image (RGB or depth based on camera mode), or None if image data is not ready.
+        """
+
+        image = self._session.query_sim_rpc(
+            endpoint="get_camera_frame",
+            payload=GetCameraFrame(path=self._path),
+            response_type=Image,
+        )
+
+        return image
+
+    def get_camera_info(self, frame_id: str = "camera_optical_frame") -> CameraInfo | None:
+        """
+        Get camera info with calculated intrinsics.
+
+        :param frame_id: The coordinate frame ID for the camera.
+        :return: CameraInfo with full intrinsics and distortion parameters, or None if no config.
+        """
+
+        if self._config is None:
+            return None
+
+        return self._config.to_camera_info(frame_id=frame_id)