iGibson

https://github.com/stanfordvl/igibson
Admin
iGibson is a simulation environment for training robots in large realistic interactive scenes with...
Tokens:47,615
Snippets:502
Trust Score:9.7
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Visualize All Robots

Source: https://github.com/stanfordvl/igibson/blob/master/docs/robots.md

Run this example to see all supported robots in the iGibson environment. No specific setup is required beyond installing iGibson.

```default
python -m igibson.examples.robots.all_robots_visualizer
```

--------------------------------

### Prepare ROS Environment for Running Examples

Source: https://github.com/stanfordvl/igibson/blob/master/docs/ros_integration.md

Source the ROS environment and your catkin workspace setup script before running any iGibson-ROS examples.

```bash
source /opt/ros/kinetic/setup.bash
source ~/catkin_ws/devel/setup.bash
```

--------------------------------

### Install iGibson and Download Assets

Source: https://context7.com/stanfordvl/igibson/llms.txt

Installs iGibson using pip and downloads necessary robot assets and demo data. Verifies the installation and runs a quickstart navigation demo.

```bash
# Install iGibson (compiles C++ renderer, ~4 minutes)
pip install igibson

# Download robot assets and demo scene
python -m igibson.utils.assets_utils --download_assets
python -m igibson.utils.assets_utils --download_demo_data

# Verify installation
python -c "import igibson; print('iGibson', igibson.__version__)"

# Run the quickstart navigation demo
python -m igibson.examples.environments.env_nonint_example
```

--------------------------------

### Install Miniconda and Setup Environment

Source: https://github.com/stanfordvl/igibson/blob/master/docs/installation.md

Installs Miniconda, adds it to the PATH, updates conda, and creates a Python 3.8 virtual environment named 'igibson'. This is recommended for managing iGibson dependencies.

```bash
curl -LO http://repo.continuum.io/miniconda/Miniconda-latest-Linux-x86_64.sh
bash Miniconda-latest-Linux-x86_64.sh
rm Miniconda-latest-Linux-x86_64.sh

echo "export PATH=$HOME/.miniconda/bin:$PATH" >> .bashrc 

conda update -y conda
conda create -y -n igibson python=3.8
conda activate igibson
```

--------------------------------

### Run Non-GUI Docker Example

Source: https://github.com/stanfordvl/igibson/blob/master/docs/quickstart.md

Launches a Docker container to run a non-GUI iGibson example. Ensure you have Docker installed and the NVIDIA container toolkit for GPU support.

```bash
docker run --gpus all -ti --rm igibson/igibson:latest /bin/bash
# run a non-GUI example after the container command line prompt shows:
python -m tests.benchmark.benchmark_static_scene
```

--------------------------------

### Simple Mesh Rendering Example

Source: https://github.com/stanfordvl/igibson/blob/master/docs/renderer.md

Demonstrates the basic usage of MeshRenderer to load a scene, set up the camera, and render multiple image modalities. Use this for a quick start with scene rendering.

```python
import logging
import os
import sys

import cv2
import numpy as np

from igibson.render.mesh_renderer.mesh_renderer_cpu import MeshRenderer
from igibson.utils.assets_utils import get_scene_path


def main(selection="user", headless=False, short_exec=False):
    """
    Minimal example of use of the renderer. Loads Rs (non interactive), renders one set of images (RGB, normals,
    3D points (as depth)), shows them.
    """
    print("*" * 80 + "\nDescription:" + main.__doc__ + "*" * 80)

    # If a model is given, we load it, otherwise we load Rs mesh (non interactive)
    if len(sys.argv) > 1:
        model_path = sys.argv[1]
    else:
        model_path = os.path.join(get_scene_path("Rs"), "mesh_z_up.obj")

    renderer = MeshRenderer(width=512, height=512)
    renderer.load_object(model_path)
    renderer.add_instance_group([0])
    camera_pose = np.array([0, 0, 1.2])
    view_direction = np.array([1, 0, 0])
    renderer.set_camera(camera_pose, camera_pose + view_direction, [0, 0, 1])
    renderer.set_fov(90)
    frames = renderer.render(modes=("rgb", "normal", "3d"))

    # Render 3d points as depth map
    depth = np.linalg.norm(frames[2][:, :, :3], axis=2)
    depth /= depth.max()
    frames[2][:, :, :3] = depth[..., None]

    if not headless:
        frames = cv2.cvtColor(np.concatenate(frames, axis=1), cv2.COLOR_RGB2BGR)
        cv2.imshow("image", frames)
        cv2.waitKey(0)


if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    main()

```

--------------------------------

### Install iGibson from Source

Source: https://context7.com/stanfordvl/igibson/llms.txt

Installs iGibson by cloning the repository and setting up a Conda environment. It also downloads assets and demo data.

```bash
git clone https://github.com/StanfordVL/iGibson --recursive
cd iGibson
conda create -y -n igibson python=3.8 && conda activate igibson
pip install -e .
python -m igibson.utils.assets_utils --download_assets
python -m igibson.utils.assets_utils --download_demo_data
```

--------------------------------

### Run Robot Control Example

Source: https://github.com/stanfordvl/igibson/blob/master/docs/robots.md

Execute the example script to test controlling different robots, controllers, and input methods.

```default
python -m igibson.examples.robots.robot_control_example
```

--------------------------------

### Run GUI Docker Example (X11)

Source: https://github.com/stanfordvl/igibson/blob/master/docs/quickstart.md

Launches a Docker container with GUI access for iGibson examples on workstations with an X11 server. This configuration allows interaction with the simulator's graphical interface.

```bash
docker run --env="DISPLAY" --volume="/tmp/.X11-unix:/tmp/.X11-unix:rw" --env="QT_X11_NO_MITSHM=1" --gpus all -ti --rm igibson/igibson
# run a GUI example after the container command line prompt shows:
python -m igibson.examples.environments.env_nonint_example
```

--------------------------------

### Set up Conda Environment and Install from Source

Source: https://github.com/stanfordvl/igibson/blob/master/docs/installation.md

Creates and activates a Conda environment for iGibson, then installs the simulator from the cloned source code. This method is recommended if you plan to modify iGibson.

```bash
# if you didn't create the conda environment before:
conda create -y -n igibson python=3.8
conda activate igibson
```

```bash
pip install -e . # This step takes about 4 minutes
```

--------------------------------

### Launch iGibson-ROS Examples

Source: https://github.com/stanfordvl/igibson/blob/master/docs/ros_integration.md

Launch various iGibson-ROS examples using roslaunch. These include a minimal bringup, gmapping for SLAM, and the navigation stack.

```bash
roslaunch igibson-ros turtlebot_rgbd.launch # Bare minimal bringup example
roslaunch igibson-ros turtlebot_gmapping.launch # Run gmapping
roslaunch igibson-ros turtlebot_navigation.launch # Run the navigation stack, we have provided the map
```

--------------------------------

### Run Interactive Environment Example

Source: https://github.com/stanfordvl/igibson/blob/master/docs/viewer.md

Execute this command to play with an example of the viewer in an interactive environment. Ensure you have downloaded the Rs_int scene.

```bash
python -m igibson.examples.environments.env_int_example
```

--------------------------------

### Sample Activity Scenes with BDDL

Source: https://context7.com/stanfordvl/igibson/llms.txt

Use this command-line tool to sample valid initial scene configurations for activities defined in BDDL. Ensure BDDL is installed and activity descriptions are placed in the correct directory.

```bash
# Install BDDL first
pip install bddl~=1.0.1

# Place your activity description at:
# bddl/activity_definitions/cleaning_table/problem0.bddl

# Sample a valid scene instance for 'cleaning_table' activity in Rs_int scene
python -m igibson.utils.data_utils.sampling_task.sampling_saver \
    --task cleaning_table \
    --task_id 0 \
    --scenes Rs_int Ihlen_0_int

# Output written to:
# ig_dataset/scenes/Rs_int/urdf/Rs_int_task_cleaning_table_0_0.urdf
# ig_dataset/scenes/Ihlen_0_int/urdf/Ihlen_0_int_task_cleaning_table_0_0.urdf
```

--------------------------------

### Basic MeshRenderer Setup and Rendering

Source: https://context7.com/stanfordvl/igibson/llms.txt

Demonstrates the basic setup of the MeshRenderer, loading an object, setting camera parameters, and rendering multiple modalities like RGB, normals, and 3D coordinates. Useful for visualizing scenes and extracting different types of rendering data.

```python
import os
import cv2
import numpy as np
from igibson.render.mesh_renderer.mesh_renderer_cpu import MeshRenderer, MeshRendererSettings
from igibson.utils.assets_utils import get_scene_path

# ---- Basic renderer setup ----
renderer = MeshRenderer(width=512, height=512)
model_path = os.path.join(get_scene_path("Rs"), "mesh_z_up.obj")
renderer.load_object(model_path)
renderer.add_instance_group([0])

# Position camera 1.2 m above origin, looking along +X axis
camera_pose = np.array([0.0, 0.0, 1.2])
view_direction = np.array([1.0, 0.0, 0.0])
renderer.set_camera(camera_pose, camera_pose + view_direction, [0, 0, 1])
renderer.set_fov(90)

# Render multiple modalities in one call
# modes: "rgb" | "normal" | "seg" | "ins_seg" | "3d" | "optical_flow" | "scene_flow"
frames = renderer.render(modes=("rgb", "normal", "3d"))
# frames[0] -> (H, W, 4) RGBA float32
# frames[1] -> (H, W, 4) surface normals
# frames[2] -> (H, W, 4) 3D world coordinates (xyz + padding)

# Convert 3D frame to depth map
depth = np.linalg.norm(frames[2][:, :, :3], axis=2)
depth /= depth.max()

# Decode segmentation (via Simulator / VisionSensor)
MAX_CLASS_COUNT = 512
MAX_INSTANCE_COUNT = 1024
[seg_frame, ins_frame] = renderer.render(modes=("seg", "ins_seg"))
seg = (seg_frame[:, :, 0:1] * MAX_CLASS_COUNT).astype(np.int32)     # class IDs
ins_seg = (ins_frame[:, :, 0:1] * MAX_INSTANCE_COUNT).astype(np.int32)  # instance IDs
print("Semantic classes in view:", np.unique(seg))

# ---- PBR rendering settings ----
hdr_texture = os.path.join(igibson.ig_dataset_path, "scenes/background/probe_02.hdr")
pbr_settings = MeshRendererSettings(
    enable_pbr=True,
    enable_shadow=True,
    msaa=True,
    optimized=True,
)
# Pass to Simulator: Simulator(rendering_settings=pbr_settings)

rgb_display = cv2.cvtColor((frames[0][:, :, :3] * 255).astype(np.uint8), cv2.COLOR_RGB2BGR)
print("Rendered RGB frame shape:", rgb_display.shape)
```

--------------------------------

### Run GUI Docker Example (VNC)

Source: https://github.com/stanfordvl/igibson/blob/master/docs/quickstart.md

Launches a Docker container with VNC support for GUI access on headless nodes. Connect using a VNC client to the specified IP and port.

```bash
docker run --gpus all -ti --rm igibson/igibson-vnc:latest /bin/bash
# run a GUI example after the container command line prompt shows:
python -m igibson.examples.environments.env_nonint_example
```

--------------------------------

### Run iGibson Example

Source: https://github.com/stanfordvl/igibson/blob/master/tests/test_of_example_template.txt

Executes a specified iGibson example module. Use this to test specific functionalities or scenarios within the library. Ensure the module and selection are correctly defined.

```python
import igibson.examples.$module as example_module

def test_$name():
    example_module.main(selection=$selection, headless=True, short_exec=True)
```

--------------------------------

### Install System Dependencies

Source: https://github.com/stanfordvl/igibson/blob/master/docs/installation.md

Installs essential system packages required for building iGibson. Ensure you have CMake, Git, a C++ compiler, and EGL development libraries.

```bash
apt-get update && apt-get install -y --no-install-recommends \
    cmake \
    git \
    g++ \
    libegl-dev
```

--------------------------------

### Install Linux Dependencies for Headless Mode

Source: https://github.com/stanfordvl/igibson/blob/master/docs/installation.md

Installs necessary Nvidia drivers and CUDA libraries for running iGibson in a headless environment on Ubuntu 20.04. This includes setting up Nvidia repositories and installing specific CUDA versions.

```bash
# Add the nvidia ubuntu repositories
apt-get update && apt-get install -y --no-install-recommends \
    gnupg2 curl ca-certificates && \
    curl -fsSL https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/7fa2af80.pub | apt-key add - && \
    echo "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64 /" > /etc/apt/sources.list.d/cuda.list && \
    echo "deb https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu2004/x86_64 /" > /etc/apt/sources.list.d/nvidia-ml.list

# The following cuda libraries are required to compile igibson
apt-get update && apt-get update && apt-get install -y --no-install-recommends \
    nvidia-headless-470 \
    cuda-cudart-11-1=11.1.74-1 \
    cuda-compat-11-1 \
    cuda-command-line-tools-11-1=11.1.1-1 \
    cuda-libraries-dev-11-1=11.1.1-1 \

# For building and running igibson
apt-get update && apt-get install -y --no-install-recommends \
    cmake \
    git \
    g++ \
    libegl-dev
```

--------------------------------

### Import Objects into iGibson Environment

Source: https://github.com/stanfordvl/igibson/blob/master/docs/objects.md

This snippet shows the necessary imports for working with iGibson, including environment setup, object loading, and rendering settings. It's used as a base for various scene loading examples.

```python
import logging
import os
from sys import platform

import numpy as np
import yaml

import igibson
from igibson.envs.igibson_env import iGibsonEnv
from igibson.external.pybullet_tools.utils import quat_from_euler
from igibson.objects.articulated_object import URDFObject
from igibson.objects.ycb_object import YCBObject
from igibson.render.mesh_renderer.mesh_renderer_cpu import MeshRendererSettings
from igibson.render.profiler import Profiler
from igibson.robots.turtlebot import Turtlebot
from igibson.scenes.empty_scene import EmptyScene
from igibson.scenes.gibson_indoor_scene import StaticIndoorScene
from igibson.simulator import Simulator
from igibson.utils.assets_utils import get_ig_avg_category_specs, get_ig_category_path, get_ig_model_path
from igibson.utils.utils import let_user_pick, parse_config
```

--------------------------------

### Run Non-Interactive Environment Example

Source: https://github.com/stanfordvl/igibson/blob/master/docs/quickstart.md

Executes a non-interactive example demonstrating iGibson's capabilities. Reduce texture scaling in the config file if you encounter out-of-memory errors.

```bash
python -m igibson.examples.environments.env_nonint_example
```

--------------------------------

### Install Linux Dependencies for On-Screen Rendering

Source: https://github.com/stanfordvl/igibson/blob/master/docs/installation.md

Installs necessary Nvidia drivers and CUDA libraries for rendering iGibson on-screen on Ubuntu 20.04. This includes setting up Nvidia repositories and installing specific CUDA versions along with the X server video driver.

```bash
# Add the nvidia ubuntu repositories
apt-get update && apt-get install -y --no-install-recommends \
    gnupg2 curl ca-certificates && \
    curl -fsSL https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/7fa2af80.pub | apt-key add - && \
    echo "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64 /" > /etc/apt/sources.list.d/cuda.list && \
    echo "deb https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu2004/x86_64 /" > /etc/apt/sources.list.d/nvidia-ml.list

# The following cuda libraries are required to compile igibson
apt-get update && apt-get update && apt-get install -y --no-install-recommends \
    xserver-xorg-video-nvidia-470 \
    cuda-cudart-11-1=11.1.74-1 \
    cuda-compat-11-1 \
    cuda-command-line-tools-11-1=11.1.1-1 \
    cuda-libraries-dev-11-1=11.1.1-1 \

```

--------------------------------

### Example File Naming Convention

Source: https://github.com/stanfordvl/igibson/blob/master/docs/dataset.md

Illustrates the naming convention for floor traversable area images.

```text
floor_trav_{}.png
```

--------------------------------

### Clone iGibson and Install from Source

Source: https://github.com/stanfordvl/igibson/blob/master/docs/ros_integration.md

Clone the iGibson repository and install it from source. Ensure you are using Python 3.8 and create a dedicated conda environment.

```bash
git clone https://github.com/StanfordVL/iGibson --recursive
cd iGibson

# if you didn't create the conda environment before:
conda create -y -n igibson python=3.8
conda activate igibson

pip install -e . # This step takes about 4 minutes
```

--------------------------------

### Load Scene, Robot, and Objects in iGibson

Source: https://github.com/stanfordvl/igibson/blob/master/docs/simulators.md

This example demonstrates loading different scene types (Empty, iG, Gibson), importing a Turtlebot robot, and adding objects. It shows how to use the Simulator API directly or the Environment API.

```python
import logging
import os
from sys import platform

import numpy as np
import yaml

import igibson
from igibson.envs.igibson_env import iGibsonEnv
from igibson.external.pybullet_tools.utils import quat_from_euler
from igibson.objects.articulated_object import URDFObject
from igibson.objects.ycb_object import YCBObject
from igibson.render.mesh_renderer.mesh_renderer_cpu import MeshRendererSettings
from igibson.render.profiler import Profiler
from igibson.robots.turtlebot import Turtlebot
from igibson.scenes.empty_scene import EmptyScene
from igibson.scenes.gibson_indoor_scene import StaticIndoorScene
from igibson.simulator import Simulator
from igibson.utils.assets_utils import get_ig_avg_category_specs, get_ig_category_path, get_ig_model_path
from igibson.utils.utils import let_user_pick, parse_config


def main(selection="user", headless=False, short_exec=False):
    """
    This demo shows how to load scaled objects from the iG object model dataset and
    additional objects from the YCB dataset in predefined locations
    Loads a concrete object model of a table, and a random one of the same category, and 10 cracker boxes
    The objects can be loaded into an empty scene, an interactive scene (iG) or a static scene (Gibson)
    The example also shows how to use the Environment API or directly the Simulator API, loading objects and robots
    and executing actions
    """
    print("*" * 80 + "\nDescription:" + main.__doc__ + "*" * 80)
    scene_options = get_first_options()
    type_of_scene = let_user_pick(scene_options, selection=selection) - 1

    if type_of_scene == 0:  # Empty
        config = parse_config(os.path.join(igibson.configs_path, "turtlebot_static_nav.yaml"))
        settings = MeshRendererSettings(enable_shadow=False, msaa=False, texture_scale=0.5)
        s = Simulator(
            mode="gui_interactive" if not headless else "headless",
            image_width=512,
            image_height=512,
            rendering_settings=settings,
        )
        scene = EmptyScene(floor_plane_rgba=[0.6, 0.6, 0.6, 1])
        # scene.load_object_categories(benchmark_names)
        s.import_scene(scene)
        robot_config = config["robot"]
        robot_config.pop("name")
        turtlebot = Turtlebot(**robot_config)
        s.import_object(turtlebot)

    elif type_of_scene == 1:  # iG
        config_filename = os.path.join(igibson.configs_path, "turtlebot_nav.yaml")
        config_data = yaml.load(open(config_filename, "r"), Loader=yaml.FullLoader)
        config_data["load_object_categories"] = []  # Uncomment this line to accelerate loading with only the building
        config_data["visible_target"] = False
        config_data["visible_path"] = False
        # Reduce texture scale for Mac.
        if platform == "darwin":
            config_data["texture_scale"] = 0.5
        env = iGibsonEnv(config_file=config_data, mode="gui_interactive" if not headless else "headless")
        s = env.simulator

    elif type_of_scene == 2:  # Gibson
        config = parse_config(os.path.join(igibson.configs_path, "turtlebot_static_nav.yaml"))
        settings = MeshRendererSettings(enable_shadow=False, msaa=False)
        # Reduce texture scale for Mac.
        if platform == "darwin":
            settings.texture_scale = 0.5
        s = Simulator(
            mode="gui_interactive" if not headless else "headless",
            image_width=512,
            image_height=512,
            rendering_settings=settings,
        )

        scene = StaticIndoorScene("Rs", build_graph=True, pybullet_load_texture=False)
        s.import_scene(scene)
        robot_config = config["robot"]
        robot_config.pop("name")
        turtlebot = Turtlebot(**robot_config)
        s.import_object(turtlebot)

    if not headless:
        # Set a better viewing direction
        s.viewer.initial_pos = [-2, 1.4, 1.2]
        s.viewer.initial_view_direction = [0.6, -0.8, 0.1]
        s.viewer.reset_viewer()

    # Objects to load: two tables, the first one is predefined model, the second, random for the same category
    table_objects_to_load = {
        "table_1": {
            "category": "breakfast_table",
            "model": "1b4e6f9dd22a8c628ef9d976af675b86",
            "pos": (0.0, -0.2, 1.01),
            "orn": (0, 0, 90),
        },
        "table_2": {
            "category": "breakfast_table",
            "pos": (0.5, -2.0, 1.01),
            "orn": (0, 0, 45),
        },
    }

    # Load the specs of the object categories, e.g., common scaling factor
    avg_category_spec = get_ig_avg_category_specs()

    scene_objects = {}
    try:
        for obj in table_objects_to_load.values():
            category = obj["category"]
            if category in scene_objects:
                scene_objects[category] += 1
            else:
                scene_objects[category] = 1

```

--------------------------------

### Install Robot Description Assets

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/examples/ros/igibson-ros/turtlebot/turtlebot_description/CMakeLists.txt

Installs various directories containing robot description assets, such as 'robots', 'meshes', 'test', and 'urdf', into the Catkin package's share directory. This makes these assets available at runtime.

```cmake
install(DIRECTORY robots
        DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
)
install(DIRECTORY meshes
        DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
)
install(DIRECTORY test
        DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
)
install(DIRECTORY urdf
        DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
)
```

--------------------------------

### Test iGibson Installation

Source: https://github.com/stanfordvl/igibson/blob/master/docs/installation.md

Verify the iGibson installation by importing the library in a Python interpreter. This is a basic check to ensure the package is accessible.

```python
import igibson
```

--------------------------------

### Example EGL library output

Source: https://github.com/stanfordvl/igibson/blob/master/docs/issues.md

This output shows how EGL libraries might be listed. It's important that 'libEGL_nvidia.so.0' is present and correctly linked.

```text
	libEGL_nvidia.so.0 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libEGL_nvidia.so.0
	libEGL_nvidia.so.0 (libc6) => /usr/lib/i386-linux-gnu/libEGL_nvidia.so.0
	libEGL_mesa.so.0 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libEGL_mesa.so.0
	libEGL.so.1 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libEGL.so.1
	libEGL.so.1 (libc6) => /usr/lib/i386-linux-gnu/libEGL.so.1
	libEGL.so (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libEGL.so
	libEGL.so (libc6) => /usr/lib/i386-linux-gnu/libEGL.so
```

--------------------------------

### CMakeLists.txt Configuration for Turtlebot Description

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/examples/ros/igibson-ros/turtlebot/turtlebot_description/CMakeLists.txt

Sets up the minimum CMake version, project name, and finds necessary Catkin packages. This is a standard starting point for ROS packages.

```cmake
cmake_minimum_required(VERSION 2.8.3)

project(turtlebot_description)
```

--------------------------------

### Run iGibson with Docker (no GPU GUI)

Source: https://context7.com/stanfordvl/igibson/llms.txt

Launches an iGibson Docker container without GPU GUI support and runs a non-interactive environment example.

```bash
docker run --gpus all -ti --rm igibson/igibson:latest /bin/bash
# Inside container:
python -m igibson.examples.environments.env_nonint_example
```

--------------------------------

### iGibson Simulator Core Usage

Source: https://context7.com/stanfordvl/igibson/llms.txt

Demonstrates the core Simulator class for building custom simulation setups. It loads a scene, a robot, objects, and steps through the simulation, rendering camera views.

```python
import numpy as np
from igibson.simulator import Simulator
from igibson.scenes.empty_scene import EmptyScene
from igibson.scenes.gibson_indoor_scene import StaticIndoorScene
from igibson.robots.turtlebot import Turtlebot
from igibson.objects.ycb_object import YCBObject
from igibson.render.mesh_renderer.mesh_renderer_cpu import MeshRendererSettings

# Create simulator in headless mode with custom render settings
settings = MeshRendererSettings(enable_shadow=False, msaa=False, texture_scale=0.5)
s = Simulator(
    mode="headless",          # "gui_interactive" | "headless" | "gui_non_interactive"
    image_width=512,
    image_height=512,
    rendering_settings=settings,
)

# Load a static indoor scene (Gibson dataset)
scene = StaticIndoorScene("Rs", build_graph=True, pybullet_load_texture=False)
s.import_scene(scene)

# Load a robot into both PyBullet and MeshRenderer
robot = Turtlebot(action_type="continuous", action_normalize=True)
s.import_object(robot)

# Load 5 YCB cracker boxes at random positions
for _ in range(5):
    obj = YCBObject("003_cracker_box")
    s.import_object(obj)
    obj.set_position_orientation(
        np.append(np.random.uniform(low=0, high=2, size=2), [1.5]),
        [0, 0, 0, 1],
    )

# Step through 500 simulation frames, applying a fixed drive action
for i in range(500):
    robot.apply_action([0.1, 0.1])   # [left_wheel, right_wheel] normalized velocity
    s.step()                          # advances physics + syncs renderer

    # Render robot camera each step
    rgb = s.renderer.render_robot_cameras(modes=("rgb",))  # list of (H, W, 4) arrays

print("Simulation complete. RGB frame shape:", rgb[0].shape)
s.disconnect()
```

--------------------------------

### Install iGibson via Pip

Source: https://github.com/stanfordvl/igibson/blob/master/docs/installation.md

Installs the iGibson simulator as a Python package using pip. This is a quick method for users who don't need to modify the simulator's source code.

```bash
pip install igibson  # This step takes about 4 minutes
```

```bash
# run the demo
python -m igibson.examples.environments.env_nonint_example
```

--------------------------------

### Query Robot State and Apply Actions

Source: https://context7.com/stanfordvl/igibson/llms.txt

Demonstrates how to get robot position/orientation and joint positions, apply zero or random actions, and render camera observations. Includes tucking the arm and disconnecting the simulator.

```python
base_pos, base_orn = robot.get_position_orientation()
arm_joint_positions = robot.get_joint_positions()
print(f"Robot base position: {base_pos}")
print(f"Action dimension:    {robot.action_dim}")

# Apply a zero action for 200 steps, then a random action
for step in range(400):
    if step < 200:
        action = np.zeros(robot.action_dim)
    else:
        action = np.random.uniform(-0.3, 0.3, robot.action_dim)
    robot.apply_action(action)
    s.step()

    # Render from robot's onboard cameras
    rgb_obs = s.renderer.render_robot_cameras(modes=("rgb",))

# Tuck arm (Fetch-specific convenience)
robot.tuck()
s.step()

s.disconnect()
```

--------------------------------

### Robot State and Action

Source: https://context7.com/stanfordvl/igibson/llms.txt

Demonstrates how to get robot position and orientation, joint positions, apply actions, and render camera views.

```APIDOC
## Robot Control and Simulation Steps

### Description
This section shows how to query the robot's current state, apply actions over a series of simulation steps, and render camera outputs.

### Methods
- `robot.get_position_orientation()`: Retrieves the robot's base position and orientation.
- `robot.get_joint_positions()`: Retrieves the current joint positions of the robot's arm.
- `robot.action_dim`: Property representing the dimensionality of the robot's action space.
- `robot.apply_action(action)`: Applies a given action to the robot.
- `s.step()`: Advances the simulation by one step.
- `s.renderer.render_robot_cameras(modes=("rgb",))`: Renders images from the robot's onboard cameras.
- `robot.tuck()`: A Fetch-specific convenience method to tuck the robot's arm.
- `s.disconnect()`: Disconnects from the simulator.

### Example Usage
```python
base_pos, base_orn = robot.get_position_orientation()
arm_joint_positions = robot.get_joint_positions()

for step in range(400):
    if step < 200:
        action = np.zeros(robot.action_dim)
    else:
        action = np.random.uniform(-0.3, 0.3, robot.action_dim)
    robot.apply_action(action)
    s.step()
    rgb_obs = s.renderer.render_robot_cameras(modes=("rgb",))

robot.tuck()
s.step()
s.disconnect()
```
```

--------------------------------

### CMakeLists.txt Configuration for kobuki_description

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/examples/ros/igibson-ros/turtlebot/kobuki_description/CMakeLists.txt

Sets up the CMake build system for the kobuki_description ROS package. It specifies the minimum required CMake version, project name, and finds necessary Catkin packages like urdf and xacro. It also defines Catkin dependencies and installs package resources.

```cmake
cmake_minimum_required(VERSION 2.8.3)
project(kobuki_description)
find_package(catkin REQUIRED COMPONENTS urdf xacro)

catkin_package(
   CATKIN_DEPENDS urdf xacro
)

install(DIRECTORY launch
        DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
)
install(DIRECTORY meshes
        DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
)
install(DIRECTORY rviz
        DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
)
install(DIRECTORY urdf
        DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
)
```

--------------------------------

### Configure GLFW Subdirectory

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/render/CMakeLists.txt

Configures the GLFW subdirectory for building. It disables examples, tests, docs, and installation to streamline the build process.

```cmake
set(GLFW_DIR glfw)
set(GLFW_BUILD_EXAMPLES
    OFF
    CACHE INTERNAL "Build the GLFW example programs")
set(GLFW_BUILD_TESTS
    OFF
    CACHE INTERNAL "Build the GLFW test programs")
set(GLFW_BUILD_DOCS
    OFF
    CACHE INTERNAL "Build the GLFW documentation")
set(GLFW_INSTALL
    OFF
    CACHE INTERNAL "Generate installation target")
add_subdirectory("${GLFW_DIR}")
include_directories("${GLFW_DIR}/include")
```

--------------------------------

### Install Blender 2.82

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/utils/data_utils/blender_utils/README.md

Run this script to install Blender version 2.82. Ensure your system's PATH is correctly configured if the installation fails.

```bash
./install_blender.sh
```

--------------------------------

### Install CMake with Homebrew

Source: https://github.com/stanfordvl/igibson/blob/master/docs/issues.md

Use Homebrew to install CMake system-wide on macOS to resolve 'ModuleNotFoundError: No module named 'cmake''. Avoid pip or conda installations for CMake.

```bash
brew install cmake
```

--------------------------------

### Install freetype with Conda on arm64 macOS

Source: https://github.com/stanfordvl/igibson/blob/master/docs/issues.md

Address 'RuntimeError: Freetype library not found' on arm64 macOS by installing freetype using Conda, as the pip package may install incorrect binaries.

```bash
conda install freetype
```

--------------------------------

### Install Other Files

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/examples/ros/igibson-ros/CMakeLists.txt

Installs miscellaneous files, such as launch or bag files, to the share directory of the ROS package.

```cmake
install(FILES
  #myfile1
  #myfile2
  DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
)
```

--------------------------------

### Install Targets

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/examples/ros/igibson-ros/CMakeLists.txt

Installs targets (executables, libraries) to their appropriate destinations within the ROS package structure.

```cmake
install(TARGETS ${PROJECT_NAME} ${PROJECT_NAME}_node
  ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
  LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
  RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)
```

--------------------------------

### Check installed EGL libraries

Source: https://github.com/stanfordvl/igibson/blob/master/docs/issues.md

Verify if libegl1 is installed using apt. This is a prerequisite for EGL functionality.

```bash
apt list --installed | grep libegl1
```

--------------------------------

### Install Executable Scripts

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/examples/ros/igibson-ros/CMakeLists.txt

Installs executable scripts, such as Python scripts, to a specified destination within the ROS package.

```cmake
install(PROGRAMS
  scripts/my_python_script
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)
```

--------------------------------

### Load .obj File with tinyobjloader

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/render/cpp/tinyobjloader/README.md

Demonstrates how to load a Wavefront .obj file and its associated .mtl file using the default configuration. Includes error and warning handling.

```python
import sys
import tinyobjloader

# Create reader.
reader = tinyobjloader.ObjReader()

filename = "cornellbox.obj"

# Load .obj(and .mtl) using default configuration
ret = reader.ParseFromFile(filename)

if ret == False:
    print("Warn:", reader.Warning())
    pint("Err:", reader.Error())
    print("Failed to load : ", filename)

    sys.exit(-1)

if reader.Warning():
    print("Warn:", reader.Warning())

attrib = reader.GetAttrib()
print("attrib.vertices = ", len(attrib.vertices))
print("attrib.normals = ", len(attrib.normals))
print("attrib.texcoords = ", len(attrib.texcoords))

materials = reader.GetMaterials()
print("Num materials: ", len(materials))
for m in materials:
    print(m.name)
    print(m.diffuse)

shapes = reader.GetShapes()
print("Num shapes: ", len(shapes))
for shape in shapes:
    print(shape.name)
    print("num_indices = {}".format(len(shape.mesh.indices)))

```

--------------------------------

### Loading and Configuring a Fetch Robot

Source: https://context7.com/stanfordvl/igibson/llms.txt

Demonstrates loading a specific robot (Fetch) into the simulator with custom controller configurations for its base, arm, gripper, and camera. This allows for fine-grained control over robot behavior.

```python
import numpy as np
from igibson.simulator import Simulator
from igibson.scenes.igibson_indoor_scene import InteractiveIndoorScene
from igibson.robots import REGISTERED_ROBOTS

s = Simulator(mode="headless", image_width=512, image_height=512)
scene = InteractiveIndoorScene("Rs_int")
s.import_scene(scene)

# Load Fetch with IK arm controller and binary gripper
robot = REGISTERED_ROBOTS["Fetch"](
    action_type="continuous",
    action_normalize=True,
    controller_config={
        "base": {"name": "DifferentialDriveController"},
        "arm_0": {"name": "InverseKinematicsController"},
        "gripper_0": {"name": "MultiFingerGripperController", "mode": "binary"},
        "camera": {"name": "JointController", "use_delta_commands": False},
    },
)
s.import_object(robot)

# Place robot and reset joints to default (untucked) pose
robot.set_position([0.0, 0.0, 0.0])
robot.reset()
robot.keep_still()
```

--------------------------------

### Install Header Files

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/examples/ros/igibson-ros/CMakeLists.txt

Installs C++ header files to the include directory of the ROS package, matching specific file patterns.

```cmake
install(DIRECTORY include/${PROJECT_NAME}/
  DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION}
  FILES_MATCHING PATTERN "*.h"
  PATTERN ".svn" EXCLUDE
)
```

--------------------------------

### Manage Object States (Temperature, ToggledOn, Frozen, Cooked)

Source: https://context7.com/stanfordvl/igibson/llms.txt

Shows how to load objects (stove, fridge, apple), set their states (ToggledOn, Temperature), and observe derived logic states (Frozen, Cooked, Burnt) over simulation steps. Requires importing specific object states and URDFObject.

```python
import os
import numpy as np
import igibson
from igibson import object_states
from igibson.objects.articulated_object import URDFObject
from igibson.render.mesh_renderer.mesh_renderer_settings import MeshRendererSettings
from igibson.scenes.empty_scene import EmptyScene
from igibson.simulator import Simulator

s = Simulator(
    mode="headless",
    image_width=512,
    image_height=512,
    rendering_settings=MeshRendererSettings(optimized=True),
)

scene = EmptyScene(floor_plane_rgba=[0.6, 0.6, 0.6, 1])
s.import_scene(scene)

# Load a stove and toggle it ON (heat source)
stove_dir = os.path.join(igibson.ig_dataset_path, "objects/stove/101930/")
stove = URDFObject(
    os.path.join(stove_dir, "101930.urdf"),
    name="stove", category="stove", model_path=stove_dir,
)
s.import_object(stove)
stove.set_position([0, 0, 0.782])
stove.states[object_states.ToggledOn].set_value(True)
print("Stove toggled on:", stove.states[object_states.ToggledOn].get_value())

# Load a fridge configured as a cold source
fridge_dir = os.path.join(igibson.ig_dataset_path, "objects/fridge/12252/")
fridge = URDFObject(
    os.path.join(fridge_dir, "12252.urdf"),
    name="fridge", category="fridge", model_path=fridge_dir,
    abilities={"coldSource": {"temperature": -100.0, "requires_inside": True}},
)
s.import_object(fridge)
fridge.set_position([3, 0, 0.75])

# Load an apple and set its initial temperature to -50°C (frozen)
apple_dir = os.path.join(igibson.ig_dataset_path, "objects/apple/00_0/")
apple = URDFObject(
    os.path.join(apple_dir, "00_0.urdf"),
    name="apple", category="apple", model_path=apple_dir,
)
s.import_object(apple)
apple.set_position([0, 0, 1.65])

s.step()  # one step needed before setting states
apple.states[object_states.Temperature].set_value(-50.0)

# Simulate 200 steps and track state transitions
for step in range(200):
    s.step()
    temp = apple.states[object_states.Temperature].get_value()
    is_frozen  = apple.states[object_states.Frozen].get_value()
    is_cooked  = apple.states[object_states.Cooked].get_value()
    is_burnt   = apple.states[object_states.Burnt].get_value()
    if step % 50 == 0:
        print(
            f"Step {step:3d} | Temp: {temp:6.1f}°C | "
            f"Frozen: {is_frozen} | Cooked: {is_cooked} | Burnt: {is_burnt}"
        )

s.disconnect()
```

--------------------------------

### Install ROS Dependencies

Source: https://github.com/stanfordvl/igibson/blob/master/docs/ros_integration.md

Install ROS dependencies for the iGibson-ROS package using rosdep. This ensures all required ROS packages are available.

```bash
cd ~/catkin_ws
rosdep install --from-paths src --ignore-src -r -y
```

--------------------------------

### Fetch and Configure OpenVR

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/render/CMakeLists.txt

Fetches and makes the OpenVR library available for use. It sets up include directories and library paths specific to the OpenVR build.

```cmake
include(FetchContent)
FetchContent_Declare(openvr
    GIT_REPOSITORY https://github.com/ValveSoftware/openvr.git
    GIT_TAG v1.14.15
)
FetchContent_MakeAvailable(openvr)

set(OPENVR_DIR "${FETCHCONTENT_BASE_DIR}/openvr-src")
set(OPENVR_INCLUDE_DIR "${OPENVR_DIR}/headers")
include_directories("${OPENVR_INCLUDE_DIR}")
```

--------------------------------

### Load Static and Interactive iGibson Scenes

Source: https://context7.com/stanfordvl/igibson/llms.txt

Demonstrates loading both static and interactive iGibson scenes. For static scenes, it shows pathfinding. For interactive scenes, it illustrates partial loading, room sampling, and texture randomization. Ensure the simulator is initialized with appropriate rendering settings.

```python
import numpy as np
from igibson.simulator import Simulator
from igibson.scenes.gibson_indoor_scene import StaticIndoorScene
from igibson.scenes.igibson_indoor_scene import InteractiveIndoorScene
from igibson.render.mesh_renderer.mesh_renderer_settings import MeshRendererSettings

settings = MeshRendererSettings(enable_shadow=True, msaa=False)
s = Simulator(mode="headless", image_width=512, image_height=512, rendering_settings=settings)

# --- Static scene example with pathfinding ---
static_scene = StaticIndoorScene("Rs", build_graph=True)
s.import_scene(static_scene)

np.random.seed(42)
floor = static_scene.get_random_floor()
p1 = static_scene.get_random_point(floor)[1]      # (floor_idx, [x, y, z])
p2 = static_scene.get_random_point(floor)[1]
path, dist = static_scene.get_shortest_path(floor, p1[:2], p2[:2], entire_path=True)
print(f"Geodesic distance: {dist:.2f} m  |  Path waypoints: {len(path)}")

s.disconnect()

# --- Interactive scene with partial loading and room sampling ---
s2 = Simulator(mode="headless", image_width=512, image_height=512, rendering_settings=settings)
ig_scene = InteractiveIndoorScene(
    "Rs_int",
    load_object_categories=["chair", "table"],  # only load chairs and tables
    load_room_types=["living_room"],             # only load living room
    build_graph=True,
)
s2.import_scene(ig_scene)

# Sample random point in a specific room type
pt = ig_scene.get_random_point_by_room_type("living_room")[1]
print(f"Random living_room point: {pt}")

# Texture randomization (call every N episodes for domain randomization)
ig_scene.randomize_texture()

# Scene quality check after object randomization
is_good = ig_scene.check_scene_quality()
print(f"Scene quality OK: {is_good}")

for _ in range(100):
    s2.step()
s2.disconnect()
```

--------------------------------

### Interactive Mesh Rendering Demo

Source: https://github.com/stanfordvl/igibson/blob/master/docs/renderer.md

Launches an interactive demo of MeshRenderer. Use WASD keys to translate and mouse to rotate the camera. Press Q to exit.

```bash
python -m igibson.examples.renderer.mesh_renderer_example
```

--------------------------------

### Create Catkin Workspace and Link iGibson-ROS

Source: https://github.com/stanfordvl/igibson/blob/master/docs/ros_integration.md

Create a catkin workspace, soft-link the iGibson-ROS package into the src folder, and build the workspace. This step indexes the iGibson-ROS package for ROS.

```bash
mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/src
ln -s $<iGibson root>/igibson/examples/ros/igibson-ros/ .

source /opt/ros/noetic/setup.bash # to setup ros environment
cd ~/catkin_ws && catkin_make
```

--------------------------------

### Install h5py with Conda on arm64 macOS

Source: https://github.com/stanfordvl/igibson/blob/master/docs/issues.md

Resolve 'ERROR: Could not build wheels for h5py' on arm64 macOS by installing h5py using Conda.

```bash
conda install h5py
```

--------------------------------

### Verify Blender Installation

Source: https://github.com/stanfordvl/igibson/blob/master/igibson/utils/data_utils/blender_utils/README.md

Execute this command in your terminal to check if Blender is installed correctly. If the command fails, review your ~/.bashrc file for incorrect PATH settings.

```bash
blender
```

--------------------------------

### iGibsonEnv OpenAI Gym Interface

Source: https://context7.com/stanfordvl/igibson/llms.txt

Sets up and runs the iGibsonEnv, an OpenAI Gym-compatible environment. It demonstrates loading a configuration, overriding parameters, and running multiple episodes with random actions. Observe the observation and action spaces and the shapes of returned observations.

```python
import os
import yaml
import igibson
from igibson.envs.igibson_env import iGibsonEnv

# ---- Load the built-in TurtleBot navigation config ----
config_filename = os.path.join(igibson.configs_path, "turtlebot_nav.yaml")
config = yaml.load(open(config_filename), Loader=yaml.FullLoader)

# Override config values programmatically
config["enable_shadow"] = True
config["enable_pbr"] = True
# config["load_object_categories"] = []  # uncomment to skip objects for faster loading

env = iGibsonEnv(
    config_file=config,
    mode="headless",
    action_timestep=1 / 10.0,    # policy frequency
    physics_timestep=1 / 120.0,  # physics frequency
)

print("Observation space:", env.observation_space)
print("Action space:     ", env.action_space)

# ---- Run 3 episodes with random actions ----
for episode in range(3):
    obs = env.reset()
    done = False
    total_reward = 0.0
    steps = 0
    while not done:
        action = env.action_space.sample()
        obs, reward, done, info = env.step(action)
        total_reward += reward
        steps += 1
        if steps >= 200:
            break

    # obs keys depend on config 'output': ['task_obs', 'rgb', 'depth', 'scan']
    print(
        f"Episode {episode+1}: steps={steps}, reward={total_reward:.2f}, "
        f"rgb={obs['rgb'].shape}, depth={obs['depth'].shape}"
    )

env.close()
```
Tokens:
Raw