update

Author: Kashu7100

examples/rigid/single_franka_batch_render.py

@@ -15,6 +15,7 @@ def main():
     parser.add_argument("-r", "--render_all_cameras", action="store_true", default=False)
     parser.add_argument("-o", "--output_dir", type=str, default="img_output/test")
     parser.add_argument("-u", "--use_rasterizer", action="store_true", default=False)
+    parser.add_argument("-d", "--debug", action="store_true", default=False)
     args = parser.parse_args()
 
     ########################## init ##########################
@@ -37,6 +38,14 @@ def main():
     )
 
     ########################## cameras ##########################
+    debug_cam = scene.add_camera(
+        res=(720, 1280),
+        pos=(1.5, -0.5, 1.0),
+        lookat=(0.0, 0.0, 0.5),
+        fov=60,
+        GUI=args.vis,
+        debug=True,
+    )
     cam_0 = scene.add_camera(
         res=(512, 512),
         pos=(1.5, 0.5, 1.5),
@@ -75,14 +84,20 @@ def main():
     # Create an image exporter
     exporter = FrameImageExporter(args.output_dir)
 
+    if args.debug:
+        debug_cam.start_recording()
     for i in range(args.n_steps):
         scene.step()
+        if args.debug:
+            debug_cam.render()
         if args.render_all_cameras:
             rgba, depth, _, _ = scene.render_all_cameras(rgb=True, depth=True)
             exporter.export_frame_all_cameras(i, rgb=rgba, depth=depth)
         else:
             rgba, depth, _, _ = cam_1.render(rgb=True, depth=True)
             exporter.export_frame_single_camera(i, cam_1.idx, rgb=rgba, depth=depth)
+    if args.debug:
+        debug_cam.stop_recording("debug_cam.mp4")
 
 
 if __name__ == "__main__":

genesis/constants.py

@@ -23,12 +23,6 @@ def __format__(self, format_spec):
         return f"<{self.name}: {self.value}>"
 
 
-class CAMERA_TYPE(IntEnum):
-    RASTERIZER = 0
-    RAYTRACER = 1
-    BATCH_RENDERER = 2
-
-
 # geom type in rigid solver
 class GEOM_TYPE(IntEnum):
     # Beware PLANE must be the first geometry type as this is assumed by MPR collision detection.

genesis/engine/scene.py

@@ -16,7 +16,6 @@
 from genesis.engine.entities import Emitter
 from genesis.engine.states.solvers import SimState
 from genesis.engine.simulator import Simulator
-from genesis.constants import CAMERA_TYPE
 from genesis.options import (
     AvatarOptions,
     BaseCouplerOptions,
@@ -529,7 +528,7 @@ def add_camera(
         spp=256,
         denoise=True,
         env_idx=None,
-        camera_type=CAMERA_TYPE.RASTERIZER,
+        debug=False,
     ):
         """
         Add a camera to the scene.
@@ -568,16 +567,16 @@ def add_camera(
             Whether to denoise the camera's rendered image. Only available when using the RayTracer renderer. Defaults
             to True. If OptiX denoiser is not available in your platform, consider enabling the OIDN denoiser option
             when building the RayTracer.
-        camera_type : CAMERA_TYPE
-            The type of camera to add. Options are CAMERA_TYPE.RASTERIZER, CAMERA_TYPE.RAYTRACER, CAMERA_TYPE.BATCH_RENDERER.
+        debug : bool
+            Whether to use the debug camera (Rasterizer). Effective for BatchRenderer and RayTracer settings. Defaults to False.
 
         Returns
         -------
         camera : genesis.Camera
             The created camera object.
         """
         return self._visualizer.add_camera(
-            res, pos, lookat, up, model, fov, aperture, focus_dist, GUI, spp, denoise, env_idx, camera_type
+            res, pos, lookat, up, model, fov, aperture, focus_dist, GUI, spp, denoise, env_idx, debug
         )
 
     @gs.assert_unbuilt

genesis/vis/batch_renderer.py

@@ -6,7 +6,6 @@
 
 import genesis as gs
 from genesis.repr_base import RBC
-from genesis.constants import CAMERA_TYPE
 
 try:
     from gs_madrona.renderer_gs import MadronaBatchRendererAdapter
@@ -86,9 +85,7 @@ def build(self):
         if gs.backend != gs.cuda:
             gs.raise_exception("BatchRenderer requires CUDA backend.")
 
-        self._cameras = gs.List(
-            [camera for camera in self._visualizer._cameras if camera.camera_type == CAMERA_TYPE.BATCH_RENDERER]
-        )
+        self._cameras = gs.List([camera for camera in self._visualizer._cameras if not camera.debug])
         lights = self._lights
         rigid = self._visualizer.scene.rigid_solver
         n_envs = max(self._visualizer.scene.n_envs, 1)
@@ -220,3 +217,7 @@ def reset(self):
     @property
     def lights(self):
         return self._lights
+
+    @property
+    def cameras(self):
+        return self._cameras

genesis/vis/camera.py

@@ -2,6 +2,7 @@
 import os
 import time
 import math
+from functools import lru_cache
 
 import cv2
 import numpy as np
@@ -11,7 +12,6 @@
 import genesis.utils.geom as gu
 from genesis.sensors import Sensor
 from genesis.utils.misc import tensor_to_array
-from genesis.constants import CAMERA_TYPE
 
 
 # quat for Madrona needs to be transformed to y-forward
@@ -92,7 +92,7 @@ def __init__(
         far=100.0,
         transform=None,
         env_idx=None,
-        camera_type=CAMERA_TYPE.RASTERIZER,
+        debug=False,
     ):
         self._idx = idx
         self._uid = gs.UID()
@@ -117,7 +117,7 @@ def __init__(
         self._is_built = False
         self._attached_link = None
         self._attached_offset_T = None
-        self._camera_type = camera_type
+        self._debug = debug
 
         self._env_idx = env_idx
         self._envs_offset = None
@@ -318,13 +318,13 @@ def _batch_render(
         # If n_envs == 0, the second dimension of the output is camera.
         # Only return the current camera's image
         if rgb_arr:
-            rgb_arr = rgb_arr[self._idx]
+            rgb_arr = rgb_arr[self.b_idx]
         if depth:
-            depth_arr = depth_arr[self._idx]
+            depth_arr = depth_arr[self.b_idx]
         if segmentation:
-            seg_arr = seg_arr[self._idx]
+            seg_arr = seg_arr[self.b_idx]
         if normal:
-            normal_arr = normal_arr[self._idx]
+            normal_arr = normal_arr[self.b_idx]
         return rgb_arr, depth_arr, seg_arr, normal_arr
 
     @gs.assert_built
@@ -380,25 +380,22 @@ def render(
         """
         rgb_arr, depth_arr, seg_arr, seg_color_arr, normal_arr = None, None, None, None, None
 
-        if self._camera_type == CAMERA_TYPE.BATCH_RENDERER:
-            assert self._batch_renderer is not None, "Batch renderer is not initialized."
+        if not self._debug and self._batch_renderer is not None:
             rgb_arr, depth_arr, seg_idxc_arr, normal_arr = self._batch_render(
                 rgb, depth, segmentation, normal, force_render, antialiasing
             )
-        elif self._camera_type == CAMERA_TYPE.RAYTRACER:
+        elif self._debug and self._raytracer is not None:
             if rgb:
-                assert self._raytracer is not None, "Ray tracer is not initialized."
                 self._raytracer.update_scene()
                 rgb_arr = self._raytracer.render_camera(self)
 
             if depth or segmentation or normal:
-                assert self._rasterizer is not None, "Rasterizer is not initialized"
                 self._rasterizer.update_scene()
                 _, depth_arr, seg_idxc_arr, normal_arr = self._rasterizer.render_camera(
                     self, False, depth, segmentation, normal=normal
                 )
-        elif self._camera_type == CAMERA_TYPE.RASTERIZER:
-            assert self._rasterizer is not None, "Rasterizer is not initialized"
+        else:
+            print("Camera is debug camera")
             self._rasterizer.update_scene()
             rgb_arr, depth_arr, seg_idxc_arr, normal_arr = self._rasterizer.render_camera(
                 self, rgb, depth, segmentation, normal=normal
@@ -716,7 +713,7 @@ def stop_recording(self, save_to_filename=None, fps=60):
                 + f'_cam_{self.idx}_{time.strftime("%Y%m%d_%H%M%S")}.mp4'
             )
 
-        if self._rgb_stacked:
+        if not self._debug and self._rgb_stacked:
             for env_idx in self._visualizer._context.rendered_envs_idx:
                 env_imgs = [imgs[env_idx] for imgs in self._recorded_imgs]
                 env_name, env_ext = os.path.splitext(save_to_filename)
@@ -774,9 +771,18 @@ def is_built(self):
 
     @property
     def idx(self):
-        """The integer index of the camera."""
+        """The global integer index of the camera."""
         return self._idx
 
+    @property
+    @lru_cache(maxsize=1)
+    def b_idx(self):
+        """The index of the camera in the batch renderer."""
+        assert self._batch_renderer is not None, "Batch renderer is not initialized."
+        print(f"{[c.uid for c in self._batch_renderer.cameras]}")
+        print(f"self: {self.uid}")
+        return self._batch_renderer.cameras.index(self)
+
     @property
     def uid(self):
         """The unique ID of the camera"""
@@ -861,9 +867,9 @@ def env_idx(self):
         return self._env_idx
 
     @property
-    def camera_type(self):
-        """The type of camera."""
-        return self._camera_type
+    def debug(self):
+        """Whether the camera is a debug camera."""
+        return self._debug
 
     @property
     def pos(self):

genesis/vis/visualizer.py

@@ -127,9 +127,7 @@ def destroy(self):
         self.viewer_lock = None
         self._renderer = None
 
-    def add_camera(
-        self, res, pos, lookat, up, model, fov, aperture, focus_dist, GUI, spp, denoise, env_idx, camera_type
-    ):
+    def add_camera(self, res, pos, lookat, up, model, fov, aperture, focus_dist, GUI, spp, denoise, env_idx, debug):
         cam_idx = len(self._cameras)
         camera = Camera(
             self,
@@ -145,8 +143,8 @@ def add_camera(
             GUI,
             spp,
             denoise,
-            env_idx=env_idx,
-            camera_type=camera_type,
+            env_idx=0 if debug else env_idx,
+            debug=debug,
         )
         self._cameras.append(camera)
         return camera