Merge remote-tracking branch 'origin/main' into ipc-coupling-squashed

Author: Roushelfy

.github/workflows/alarm.yml

@@ -68,6 +68,8 @@ jobs:
       PY_COLORS: "1"
       GS_CACHE_FILE_PATH: ".cache/genesis"
       GS_ENABLE_NDARRAY: ${{ matrix.GS_ENABLE_NDARRAY }}
+      # FIXME: Disabling fastcache because it causes crashes for some reason...
+      GS_ENABLE_FASTCACHE: "0"
       GS_TORCH_FORCE_CPU_DEVICE: ${{ startsWith(matrix.OS, 'macos-') && '1' || '0' }}
       TI_OFFLINE_CACHE: "1"
       TI_OFFLINE_CACHE_CLEANING_POLICY: "never"

.github/workflows/generic.yml

@@ -78,7 +78,7 @@ jobs:
               pip install --no-input --extra-index-url https://pypi.nvidia.com/ omniverse-kit
               pip install --no-input ".[dev,render,usd]"
 
-              pytest -v -rs --backend gpu --dev --forked ./tests
+              pytest -v -ra --backend gpu --dev --forked ./tests
           EOF
       - name: Kill srun job systematically
         if: always()

.github/workflows/production.yml

@@ -5,57 +5,42 @@
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument("--pile_type", type=str, default="falling", choices=["static", "falling"])
-    parser.add_argument("--num_cubes", type=int, default=5, choices=range(5, 11))
-    parser.add_argument("--cpu", action="store_true", help="Use CPU backend instead of GPU")
-    parser.add_argument("--steps", type=int, default=100)
+    parser.add_argument("--pile_type", type=str, default="falling", choices=("static", "falling"))
+    parser.add_argument("--num_cubes", type=int, default=5, choices=(5, 6, 7, 8, 9, 10))
+    parser.add_argument("--cpu", action="store_true", help="Use CPU backend instead of GPU", default=True)
+    parser.add_argument("--steps", type=int, default=150)
     parser.add_argument("-v", "--vis", action="store_true", default=False)
-
     args = parser.parse_args()
 
-    pile_type = args.pile_type
-    num_cubes = args.num_cubes
-    cpu = args.cpu
-    backend = gs.cpu if cpu else gs.gpu
-
-    gs.init(backend=backend, precision="32")
+    gs.init(backend=gs.cpu if args.cpu else gs.gpu, precision="32")
 
     scene = gs.Scene(
         sim_options=gs.options.SimOptions(
             dt=0.01,
         ),
-        rigid_options=gs.options.RigidOptions(
-            box_box_detection=False,
-            max_collision_pairs=1000,
-            use_gjk_collision=True,
-            enable_mujoco_compatibility=False,
-        ),
         viewer_options=gs.options.ViewerOptions(
             camera_pos=(0, -5.5, 2.5),
             camera_lookat=(0, 0.0, 1.5),
-            camera_fov=30,
             max_FPS=60,
         ),
         show_viewer=args.vis,
     )
 
-    plane = scene.add_entity(gs.morphs.Plane(pos=(0, 0, 0)))
+    plane = scene.add_entity(gs.morphs.Plane())
 
     # create pyramid of boxes
     box_size = 0.25
-    if pile_type == "static":
-        box_spacing = box_size
-    else:
-        box_spacing = 1.1 * box_size
-    vec_one = np.array([1.0, 1.0, 1.0])
-    box_pos_offset = (0 - 0.5, 1, 0.0) + 0.5 * box_size * vec_one
+    box_spacing = (1.0 - 1e-3 + 0.1 * (args.pile_type == "static")) * box_size
+    box_pos_offset = (-0.5, 1, 0.0) + 0.5 * np.array([box_size, box_size, box_size])
     boxes = {}
-    for i in range(num_cubes):
-        for j in range(num_cubes - i):
+    for i in range(args.num_cubes):
+        for j in range(args.num_cubes - i):
             box = scene.add_entity(
                 gs.morphs.Box(
-                    size=box_size * vec_one, pos=box_pos_offset + box_spacing * np.array([i + 0.5 * j, 0, j])
+                    size=[box_size, box_size, box_size],
+                    pos=box_pos_offset + box_spacing * np.array([i + 0.5 * j, 0, j]),
                 ),
+                # visualize_contact=True,
             )
 
     scene.build()

doc

@@ -1,16 +1,11 @@
-import numpy as np
-import genesis as gs
 import argparse
 
+import genesis as gs
+
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--object",
-        type=str,
-        default="cylinder",
-        choices=["sphere", "cylinder", "duck"],
-    )
+    parser.add_argument("--object", type=str, default="cylinder", choices=("sphere", "cylinder", "duck"))
     parser.add_argument("-v", "--vis", action="store_true", default=False)
     args = parser.parse_args()
     object_type = args.object
@@ -22,46 +17,37 @@ def main():
             dt=0.005,
         ),
         rigid_options=gs.options.RigidOptions(
-            box_box_detection=False,
-            max_collision_pairs=2000,
-            use_gjk_collision=True,
-            enable_mujoco_compatibility=False,
+            max_collision_pairs=200,
         ),
         viewer_options=gs.options.ViewerOptions(
             camera_pos=(20, -20, 20),
             camera_lookat=(0.0, 0.0, 5.0),
-            camera_fov=30,
             max_FPS=60,
         ),
         show_viewer=args.vis,
     )
 
-    plane = scene.add_entity(gs.morphs.Plane(pos=(0, 0, 0)))
+    plane = scene.add_entity(gs.morphs.Plane())
 
     # create pyramid of boxes
-    box_width = 0.25
-    box_length = 2.0
-    box_height = 0.1
+    box_width, box_length, box_height = 0.25, 2.0, 0.1
     num_stacks = 50
-    height_offset = 0.0
     for i in range(num_stacks):
-        horizontal = i % 2 == 0
-
-        if horizontal:
-            box_size = np.array([box_width, box_length, box_height])
-            box_pos_0 = (-0.4 * box_length, 0, i * (height_offset + box_size[2]) + 0.5 * box_size[2])
-            box_pos_1 = (+0.4 * box_length, 0, i * (height_offset + box_size[2]) + 0.5 * box_size[2])
-        else:
-            box_size = np.array([box_length, box_width, box_height])
-            box_pos_0 = (0, -0.4 * box_length, i * (height_offset + box_size[2]) + 0.5 * box_size[2])
-            box_pos_1 = (0, +0.4 * box_length, i * (height_offset + box_size[2]) + 0.5 * box_size[2])
-
-        scene.add_entity(
-            gs.morphs.Box(size=box_size, pos=box_pos_0),
-        )
-        scene.add_entity(
-            gs.morphs.Box(size=box_size, pos=box_pos_1),
-        )
+        if i % 2 == 0:  # horizontal stack
+            box_size = (box_width, box_length, box_height)
+            box_pos_0 = (-0.4 * box_length, 0, i * (box_height - 1e-3) + 0.5 * box_height)
+            box_pos_1 = (+0.4 * box_length, 0, i * (box_height - 1e-3) + 0.5 * box_height)
+        else:  # vertical stack
+            box_size = (box_length, box_width, box_height)
+            box_pos_0 = (0, -0.4 * box_length, i * (box_height - 1e-3) + 0.5 * box_height)
+            box_pos_1 = (0, +0.4 * box_length, i * (box_height - 1e-3) + 0.5 * box_height)
+        for box_pos in (box_pos_0, box_pos_1):
+            scene.add_entity(
+                gs.morphs.Box(
+                    size=box_size,
+                    pos=box_pos,
+                ),
+            )
 
     # Drop a huge mesh
     if object_type == "duck":
@@ -70,29 +56,29 @@ def main():
             morph=gs.morphs.Mesh(
                 file="meshes/duck.obj",
                 scale=duck_scale,
-                pos=(0, 0, num_stacks * (height_offset + box_height) + 10 * duck_scale),
+                pos=(0, 0, num_stacks * box_height + 10 * duck_scale),
             ),
         )
     elif object_type == "sphere":
         sphere_radius = 2.0
         scene.add_entity(
             morph=gs.morphs.Sphere(
-                radius=sphere_radius, pos=(0.0, 0.0, num_stacks * (height_offset + box_height) + 5 * sphere_radius)
+                radius=sphere_radius,
+                pos=(0.0, 0.0, num_stacks * box_height + 5 * sphere_radius),
             ),
         )
     elif object_type == "cylinder":
-        cylinder_radius = 2.0
-        cylinder_height = 1.0
+        cylinder_radius, cylinder_height = 2.0, 1.0
         scene.add_entity(
             morph=gs.morphs.Cylinder(
                 radius=cylinder_radius,
                 height=cylinder_height,
-                pos=(0.0, 0.0, num_stacks * (height_offset + box_height) + 5 * cylinder_height),
+                pos=(0.0, 0.0, num_stacks * box_height + 5 * cylinder_height),
             ),
         )
 
     scene.build()
-    for i in range(500):
+    for i in range(600):
         scene.step()
 
 

examples/collision/pyramid.py

@@ -75,6 +75,7 @@ def __init__(
                 size=env_cfg["box_size"],
                 fixed=env_cfg["box_fixed"],
                 collision=env_cfg["box_collision"],
+                batch_fixed_verts=True,
             ),
             # material=gs.materials.Rigid(gravity_compensation=1),
             surface=gs.surfaces.Rough(

examples/collision/tower.py

@@ -54,8 +54,8 @@ def main():
             link_idx_local=end_effector.idx_local,
             pos_offset=(0.0, 0.0, 0.15),
             # noise parameters
-            acc_axes_skew=(0.0, 0.01, 0.02),
-            gyro_axes_skew=(0.03, 0.04, 0.05),
+            acc_cross_axis_coupling=(0.0, 0.01, 0.02),
+            gyro_cross_axis_coupling=(0.03, 0.04, 0.05),
             acc_noise=(0.01, 0.01, 0.01),
             gyro_noise=(0.01, 0.01, 0.01),
             acc_random_walk=(0.001, 0.001, 0.001),

examples/manipulation/grasp_env.py

@@ -87,7 +87,7 @@ def main():
             max_FPS=60,
         ),
         profiling_options=gs.options.ProfilingOptions(
-            show_FPS=True,
+            show_FPS=False,
         ),
         show_viewer=True,
     )

examples/sensors/imu_franka.py

@@ -38,7 +38,7 @@
 # with the following control: 43M FPS
 # without the following control (arm in collision with the floor): 32M FPS
 franka.control_dofs_position(
-    torch.tile(torch.tensor([0, 0, 0, -1.0, 0, 0, 0, 0.02, 0.02], device=gs.device), (B, 1)),
+    torch.tile(torch.tensor([0, 0, 0, -1.0, 0, 1.0, 0, 0.02, 0.02], device=gs.device), (B, 1)),
 )
 
 for i in range(1000):