'Camera' object has no attribute 'initialize'？

[li-zhuoyuan]

Description

When I used a camera from a robot model, I want to initialize it. But there came a error that
AttributeError: 'Camera' object has no attribute 'initialize'. Did you mean: 'is_initialized'?

Here is my code：

import os
import sys

# Critical: Set environment variable before any Isaac Lab imports
os.environ["ENABLE_CAMERAS"] = "1"

# Add project root to path
project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
if project_root not in sys.path:
    sys.path.insert(0, project_root)

import argparse
from isaaclab.app import AppLauncher

# Parse command line arguments
parser = argparse.ArgumentParser(description="G2 Robot Wrist Camera Capture")
AppLauncher.add_app_launcher_args(parser)
args_cli = parser.parse_args()

# Launch application (force enable cameras)
app_launcher = AppLauncher(headless=False, enable_cameras=True)
simulation_app = app_launcher.app

import torch
import numpy as np
from PIL import Image

from isaaclab.assets import Articulation
from isaaclab.sim import SimulationContext
from isaaclab.actuators import ImplicitActuatorCfg
from isaaclab.assets.articulation import ArticulationCfg
from isaaclab.sensors.camera import CameraCfg
from isaaclab.sensors import Camera
import isaaclab.sim as sim_utils


def save_image(data: torch.Tensor, filename: str, output_dir: str = "./img"):
    """Save image to specified directory"""
    os.makedirs(output_dir, exist_ok=True)
    
    # Convert to numpy array
    if isinstance(data, torch.Tensor):
        img_np = data.cpu().numpy()
    else:
        img_np = data
    
    filepath = os.path.join(output_dir, filename)
    
    # Handle RGB images [H, W, 3]
    if len(img_np.shape) == 3 and img_np.shape[2] == 3:
        if img_np.dtype != np.uint8:
            if img_np.max() <= 1.0:
                img_np = (img_np * 255).astype(np.uint8)
            else:
                img_np = img_np.astype(np.uint8)
        
        img = Image.fromarray(img_np)
        img.save(filepath)
        print(f"  ✓ RGB image saved: {filepath}")
    
    # Handle depth images [H, W]
    elif len(img_np.shape) == 2:
        depth_min, depth_max = img_np.min(), img_np.max()
        if depth_max > depth_min:
            depth_normalized = ((img_np - depth_min) / (depth_max - depth_min) * 255).astype(np.uint8)
        else:
            depth_normalized = np.zeros_like(img_np, dtype=np.uint8)
        
        img = Image.fromarray(depth_normalized)
        img.save(filepath)
        print(f"  ✓ Depth image saved: {filepath}")


def main():
    print("="*80)
    print("G2 Robot Wrist Camera Image Capture")
    print("="*80)
    
    # Initialize simulation context
    sim = SimulationContext()
    
    # Robot USD path
    robot_usd_path = os.path.join(
        project_root,
        "source/matterix_assets/data/robots/genie/G2_place_workpiece/robot.usda"
    )
    
    print(f"\nLoading robot model: {robot_usd_path}")
    if not os.path.exists(robot_usd_path):
        raise FileNotFoundError(f"Robot model file not found: {robot_usd_path}")
    
    # Create ground plane
    ground_cfg = sim_utils.GroundPlaneCfg(size=(10.0, 10.0))
    ground_cfg.func("/World/defaultGroundPlane", ground_cfg)
    
    # Create lighting
    light_cfg = sim_utils.DomeLightCfg(intensity=1000.0, color=(0.9, 0.9, 1.0))
    light_cfg.func("/World/Light", light_cfg)
    
    # Create robot configuration
    robot_cfg = ArticulationCfg(
        prim_path="/World/Robot",
        spawn=sim_utils.UsdFileCfg(
            usd_path=robot_usd_path,
            activate_contact_sensors=False,
            rigid_props=sim_utils.RigidBodyPropertiesCfg(disable_gravity=False),
            articulation_props=sim_utils.ArticulationRootPropertiesCfg(
                enabled_self_collisions=True,
                solver_position_iteration_count=8,
            ),
        ),
        init_state=ArticulationCfg.InitialStateCfg(
            pos=(-0.5, 0, 0.0),
            rot=(1.0, 0.0, 0.0, 0.0),
        ),
        actuators={
            "left_arm": ImplicitActuatorCfg(
                joint_names_expr=[".*_arm_l_joint.*"],
                stiffness=1000.0,
                damping=200.0,
            ),
        },
    )
    
    # Instantiate robot
    print("Instantiating robot...")
    robot = Articulation(robot_cfg)
    
    # Reset simulation
    print("Resetting simulation...")
    sim.reset()
    
    # Critical fix: Set camera visibility before creating Camera object
    print("\nSetting camera visibility...")
    from pxr import UsdGeom
    stage = sim.stage
    
    left_cam_path = "/World/Robot/gripper_l_base_link/Left_Camera"
    
    prim = stage.GetPrimAtPath(left_cam_path)
    if prim.IsValid():
        visibility_attr = prim.GetAttribute('visibility')
        if visibility_attr.IsValid():
            current_visibility = visibility_attr.Get()
            if current_visibility == 'invisible':
                visibility_attr.Set('inherited')
                print(f"  ✓ Left_Camera: invisible → inherited")
            else:
                print(f"  - Left_Camera: already {current_visibility}")
    
    # Configure left wrist camera (create before sim.play())
    print("\nConfiguring left wrist camera...")
    
    try:
        camera_cfg = CameraCfg(
            prim_path=left_cam_path,
            width=640,
            height=480,
            update_period=0.1,
            data_types=["rgb", "distance_to_image_plane"],
            spawn=None,  # Reference existing prim, don't create new one
        )
        left_camera = Camera(camera_cfg)
        print(f"  ✓ Left camera object created: {left_cam_path}")
        
        left_camera.initialize()
        print(f"     _is_initialized: {left_camera._is_initialized}")
    except Exception as e:
        print(f"  ✗ Left camera configuration failed: {e}")
        import traceback
        traceback.print_exc()
        raise
    
    # Enter simulation play mode (trigger camera initialization callback)
    print("\nStarting simulation play (triggering camera initialization)...")
    sim.play()
    
    # Run simulation steps, wait for camera initialization
    print("Waiting for camera initialization...")
    max_steps = 50
    for i in range(max_steps):
        sim.step(render=True)
        
        if left_camera._is_initialized:
            print(f"  ✓ Left camera initialized at Step {i}")
            break
        
        if i % 10 == 0:
            print(f"    Step {i}: left _is_initialized = {left_camera._is_initialized}")
    else:
        print(f"  ⚠ Warning: Left camera still not initialized after {max_steps} steps")
        print(f"    left _is_initialized = {left_camera._is_initialized}")
        
        # Additional diagnostic information
        print("\n  Diagnostic info:")
        try:
            import carb
            carb_settings = carb.settings.get_settings()
            print(f"    - /isaaclab/render/rtx_sensors: {carb_settings.get('/isaaclab/render/rtx_sensors')}")
            print(f"    - /isaaclab/cameras_enabled: {carb_settings.get('/isaaclab/cameras_enabled')}")
        except:
            print("    - Unable to read carb settings")
    
    # Reset camera
    print("\nResetting camera...")
    try:
        left_camera.reset()
        print(f"  ✓ Left camera reset successful")
    except Exception as e:
        print(f"  ✗ Left camera reset failed: {e}")
        raise

    # Capture and save images
    print("\n" + "="*80)
    print("Starting image capture...")
    print("="*80)
    
    num_captures = 5  # Capture 5 frames
    capture_interval = 30  # Capture every 30 steps
    
    for capture_idx in range(num_captures):
        print(f"\n--- Capturing frame {capture_idx + 1}/{num_captures} ---")
        
        # Run simulation steps
        for step in range(capture_interval):
            sim.step(render=True)
        
        # Get and save left camera images
        try:
            camera_data = left_camera.data.output
            
            # Save RGB image
            if "rgb" in camera_data:
                rgb_data = camera_data["rgb"][0]  # Get data from first environment
                save_image(
                    rgb_data, 
                    f"left_wrist_rgb_frame_{capture_idx}.png",
                    output_dir="./img"
                )
            
            # Save depth image
            if "distance_to_image_plane" in camera_data:
                depth_data = camera_data["distance_to_image_plane"][0]
                save_image(
                    depth_data,
                    f"left_wrist_depth_frame_{capture_idx}.png",
                    output_dir="./img"
                )
                
        except Exception as e:
            print(f"  ✗ Left camera data retrieval failed: {e}")
            import traceback
            traceback.print_exc()
    
    print("\n" + "="*80)
    print(f"Image capture complete! Total frames captured: {num_captures}")
    print(f"Images saved to: ./img folder")
    print("="*80)
    
    # Cleanup
    simulation_app.close()


if __name__ == "__main__":
    main()

And here is the error:

Setting camera visibility...
  ✓ Left_Camera: invisible → inherited

Configuring left wrist camera...
  ✓ Left camera object created: /World/Robot/gripper_l_base_link/Left_Camera
  ✗ Left camera configuration failed: 'Camera' object has no attribute 'initialize'
Traceback (most recent call last):
  File "D:\Beginning with Embodied\Matterix\scripts\robot_config_test\G2-camera-capture-test.py", line 171, in main
    left_camera.initialize()
    ^^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'Camera' object has no attribute 'initialize'
Traceback (most recent call last):
  File "D:\Beginning with Embodied\Matterix\scripts\robot_config_test\G2-camera-capture-test.py", line 270, in <module>
    main()
  File "D:\Beginning with Embodied\Matterix\scripts\robot_config_test\G2-camera-capture-test.py", line 171, in main
    left_camera.initialize()
    ^^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'Camera' object has no attribute 'initialize'. Did you mean: 'is_initialized'?

However, I see the docs that

Is there anything wrong in my env?

Isaac Sim version

5.1.0

Driver Version:

580.97

Operating System (OS)

Windows 11

GPU Name

RTX 4080