Replace dynamic control APIs with Isaac.Core View APIs

omnigibson/object_states/particle_modifier.py

@@ -348,7 +348,7 @@ def overlap_callback(hit):
             z_offset = 0.0 if self._projection_mesh_params["type"] == "Sphere" else self._projection_mesh_params["extents"][2] / 2
 
             self.projection_mesh.set_local_pose(
-                translation=np.array([0, 0, -z_offset]),
+                position=np.array([0, 0, -z_offset]),
                 orientation=T.euler2quat([0, 0, 0]),
             )
 

omnigibson/object_states/toggle.py

@@ -72,7 +72,7 @@ def _initialize(self):
         self.visual_marker.visible = True
 
         # Make sure the marker isn't translated at all
-        self.visual_marker.set_local_pose(translation=np.zeros(3), orientation=np.array([0, 0, 0, 1.0]))
+        self.visual_marker.set_local_pose(position=np.zeros(3), orientation=np.array([0, 0, 0, 1.0]))
 
         # Store the projection mesh's IDs
         projection_mesh_ids = PhysicsSchemaTools.encodeSdfPath(self.visual_marker.prim_path)

omnigibson/objects/controllable_object.py

@@ -242,7 +242,7 @@ def reload_controllers(self, controller_config=None):
             else self._create_continuous_action_space()
 
     def reset(self):
-        # Make sure simulation is playing, otherwise, we cannot reset because DC requires active running
+        # Make sure simulation is playing, otherwise, we cannot reset because physx requires active running
         # simulation in order to set joints
         assert og.sim.is_playing(), "Simulator must be playing in order to reset controllable object's joints!"
 

omnigibson/prims/xform_prim.py

@@ -175,7 +175,7 @@ def set_position_orientation(self, position=None, orientation=None):
         calculated_translation = transform.GetTranslation()
         calculated_orientation = transform.GetRotation().GetQuat()
         self.set_local_pose(
-            translation=np.array(calculated_translation), orientation=gf_quat_to_np_array(calculated_orientation)[[1, 2, 3, 0]]     # Flip from w,x,y,z to x,y,z,w
+            position=np.array(calculated_translation), orientation=gf_quat_to_np_array(calculated_orientation)[[1, 2, 3, 0]]     # Flip from w,x,y,z to x,y,z,w
         )
 
     def get_position_orientation(self):
@@ -268,24 +268,24 @@ def get_local_pose(self):
         xform_orient_op = self.get_attribute("xformOp:orient")
         return np.array(xform_translate_op), gf_quat_to_np_array(xform_orient_op)[[1, 2, 3, 0]]
 
-    def set_local_pose(self, translation=None, orientation=None):
+    def set_local_pose(self, position=None, orientation=None):
         """
         Sets prim's pose with respect to the local frame (the prim's parent frame).
 
         Args:
-            translation (None or 3-array): if specified, (x,y,z) translation in the local frame of the prim
+            position (None or 3-array): if specified, (x,y,z) position in the local frame of the prim
                 (with respect to its parent prim). Default is None, which means left unchanged.
             orientation (None or 4-array): if specified, (x,y,z,w) quaternion orientation in the local frame of the prim
                 (with respect to its parent prim). Default is None, which means left unchanged.
         """
         properties = self.prim.GetPropertyNames()
-        if translation is not None:
-            translation = Gf.Vec3d(*np.array(translation, dtype=float))
+        if position is not None:
+            position = Gf.Vec3d(*np.array(position, dtype=float))
             if "xformOp:translate" not in properties:
                 carb.log_error(
                     "Translate property needs to be set for {} before setting its position".format(self.name)
                 )
-            self.set_attribute("xformOp:translate", translation)
+            self.set_attribute("xformOp:translate", position)
         if orientation is not None:
             orientation = np.array(orientation, dtype=float)[[3, 0, 1, 2]]
             if "xformOp:orient" not in properties:

omnigibson/robots/manipulation_robot.py

@@ -1,6 +1,7 @@
 from abc import abstractmethod
 from collections import namedtuple
 import numpy as np
+import networkx as nx
 
 import omnigibson as og
 from omnigibson.macros import gm, create_module_macros
@@ -783,12 +784,11 @@ def _calculate_in_hand_object_rigid(self, arm="default"):
 
         candidate_data = []
         for prim_path in candidates_set:
-            # Calculate position of the object link
-            # Note: this assumes the simulator is playing!
-            rb_handle = self._dc.get_rigid_body(prim_path)
-            pose = self._dc.get_rigid_body_pose(rb_handle)
-            link_pos = np.asarray(pose.p)
-            dist = np.linalg.norm(np.array(link_pos) - np.array(gripper_center_pos))
+            # Calculate position of the object link. Only allow this for objects currently.
+            obj_prim_path, link_name = prim_path.rsplit("/", 1)[-1]
+            candidate_obj = og.sim.scene.object_registry("prim_path", obj_prim_path)
+            candidate_link = candidate_obj.links[link_name]
+            dist = np.linalg.norm(np.array(candidate_link.get_position()) - np.array(gripper_center_pos))
             candidate_data.append((prim_path, dist))
 
         candidate_data = sorted(candidate_data, key=lambda x: x[-1])
@@ -1055,21 +1055,14 @@ def _get_assisted_grasp_joint_type(self, ag_obj, ag_link):
             return None
 
         # Otherwise, compute the joint type. We use a fixed joint unless the link is a non-fixed link.
+        # A link is non-fixed if it has any non-fixed parent joints.
         joint_type = "FixedJoint"
-        if ag_obj.root_link != ag_link:
-            # We search up the tree path from the ag_link until we encounter the root (joint == 0) or a non fixed
-            # joint (e.g.: revolute or fixed)
-            link_handle = ag_link.handle
-            joint_handle = self._dc.get_rigid_body_parent_joint(link_handle)
-            while joint_handle != 0:
-                # If this joint type is not fixed, we've encountered a valid moving joint
-                # So we create a spherical joint rather than fixed joint
-                if self._dc.get_joint_type(joint_handle) != JointType.JOINT_FIXED:
-                    joint_type = "SphericalJoint"
-                    break
-                # Grab the parent link and its parent joint for the link
-                link_handle = self._dc.get_joint_parent_body(joint_handle)
-                joint_handle = self._dc.get_rigid_body_parent_joint(link_handle)
+        articulation_graph = ag_obj.articulation_graph
+        for edge in nx.edge_dfs(articulation_graph, ag_link, orientation="reverse"):
+            joint = articulation_graph.edges[edge]["joint"]
+            if joint.joint_type != JointType.JOINT_FIXED:
+                joint_type = "SphericalJoint"
+                break
 
         return joint_type
 

omnigibson/robots/tiago.py

@@ -3,6 +3,7 @@
 import numpy as np
 from pxr import Gf
 
+import omnigibson as og
 from omnigibson.macros import gm
 import omnigibson.utils.transform_utils as T
 from omnigibson.macros import create_module_macros
@@ -696,13 +697,8 @@ def arm_workspace_range(self):
         }
 
     def get_position_orientation(self):
-        # If the simulator is playing, return the pose of the base_footprint link frame
-        if self._dc is not None and self._dc.is_simulating():
-            return self.base_footprint_link.get_position_orientation()
-
-        # Else, return the pose of the robot frame
-        else:
-            return super().get_position_orientation()
+        # TODO: Investigate the need for this custom behavior.
+        return self.base_footprint_link.get_position_orientation()
 
     def set_position_orientation(self, position=None, orientation=None):
         current_position, current_orientation = self.get_position_orientation()
@@ -713,8 +709,9 @@ def set_position_orientation(self, position=None, orientation=None):
         assert np.isclose(np.linalg.norm(orientation), 1, atol=1e-3), \
             f"{self.name} desired orientation {orientation} is not a unit quaternion."
 
+        # TODO: Reconsider the need for this. Why can't these behaviors be unified? Does the joint really need to move?
         # If the simulator is playing, set the 6 base joints to achieve the desired pose of base_footprint link frame
-        if self._dc is not None and self._dc.is_simulating():
+        if og.sim.is_playing():
             # Find the relative transformation from base_footprint_link ("base_footprint") frame to root_link
             # ("base_footprint_x") frame. Assign it to the 6 1DoF joints that control the base.
             # Note that the 6 1DoF joints are originated from the root_link ("base_footprint_x") frame.

omnigibson/scenes/scene_base.py

@@ -143,7 +143,7 @@ def object_registry_unique_keys(self):
         """
         Returns:
             list of str: Keys with which to index into the object registry. These should be valid public attributes of
-                prims that we can use as unique IDs to reference prims, e.g., prim.prim_path, prim.name, prim.handle, etc.
+                prims that we can use as unique IDs to reference prims, e.g., prim.prim_path, prim.name, etc.
         """
         return ["name", "prim_path", "uuid"]
 

omnigibson/simulator.py

@@ -12,7 +12,6 @@
 from omni.isaac.core.simulation_context import SimulationContext
 from omni.isaac.core.utils.prims import get_prim_at_path
 from omni.isaac.core.utils.stage import open_stage, create_new_stage
-from omni.isaac.dynamic_control import _dynamic_control
 from omni.physx.bindings._physx import ContactEventType, SimulationEvent
 import omni.kit.loop._loop as omni_loop
 from pxr import Usd, PhysicsSchemaTools, UsdUtils
@@ -806,14 +805,6 @@ def __del__(self):
         Simulator._world_initialized = None
         return
 
-    @property
-    def dc(self):
-        """
-        Returns:
-            _dynamic_control.DynamicControl: Dynamic control (dc) interface
-        """
-        return self._dynamic_control
-
     @property
     def pi(self):
         """