+
-iGibson is a simulation environment providing fast visual rendering and physics simulation based on Bullet. iGibson is equipped with fifteen fully interactive high quality scenes, hundreds of large 3D scenes reconstructed from real homes and offices, and compatibility with datasets like CubiCasa5K and 3D-Front, providing 8000+ additional interactive scenes. Some of the features of iGibson include domain randomization, integration with motion planners and easy-to-use tools to collect human demonstrations. With these scenes and features, iGibson allows researchers to train and evaluate robotic agents that use visual signals to solve navigation and manipulation tasks such as opening doors, picking up and placing objects, or searching in cabinets.
+OmniGibson is a simulation environment providing fast visual rendering and physics simulation based on Bullet. OmniGibson is equipped with fifteen fully interactive high quality scenes, hundreds of large 3D scenes reconstructed from real homes and offices, and compatibility with datasets like CubiCasa5K and 3D-Front, providing 8000+ additional interactive scenes. Some of the features of OmniGibson include domain randomization, integration with motion planners and easy-to-use tools to collect human demonstrations. With these scenes and features, OmniGibson allows researchers to train and evaluate robotic agents that use visual signals to solve navigation and manipulation tasks such as opening doors, picking up and placing objects, or searching in cabinets.
### Latest Updates
-[8/9/2021] Major update to iGibson to reach iGibson 2.0, for details please refer to our [arxiv preprint](https://arxiv.org/abs/2108.03272).
+[8/9/2021] Major update to OmniGibson to reach OmniGibson 2.0, for details please refer to our [arxiv preprint](https://arxiv.org/abs/2108.03272).
-- iGibson 2.0 supports object states, including temperature, wetness level, cleanliness level, and toggled and sliced states, necessary to cover a wider range of tasks.
-- iGibson 2.0 implements a set of predicate logic functions that map the simulator states to logic states like Cooked or Soaked.
-- iGibson 2.0 includes a virtual reality (VR) interface to immerse humans in its scenes to collect demonstrations.
+- OmniGibson 2.0 supports object states, including temperature, wetness level, cleanliness level, and toggled and sliced states, necessary to cover a wider range of tasks.
+- OmniGibson 2.0 implements a set of predicate logic functions that map the simulator states to logic states like Cooked or Soaked.
+- OmniGibson 2.0 includes a virtual reality (VR) interface to immerse humans in its scenes to collect demonstrations.
-[12/1/2020] Major update to iGibson to reach iGibson 1.0, for details please refer to our [arxiv preprint](https://arxiv.org/abs/2012.02924).
+[12/1/2020] Major update to OmniGibson to reach OmniGibson 1.0, for details please refer to our [arxiv preprint](https://arxiv.org/abs/2012.02924).
-- Release of iGibson dataset that includes 15 fully interactive scenes and 500+ object models annotated with materials and physical attributes on top of [existing 3D articulated models](https://cs.stanford.edu/~kaichun/partnet/).
+- Release of OmniGibson dataset that includes 15 fully interactive scenes and 500+ object models annotated with materials and physical attributes on top of [existing 3D articulated models](https://cs.stanford.edu/~kaichun/partnet/).
- Compatibility to import [CubiCasa5K](https://github.com/CubiCasa/CubiCasa5k) and [3D-Front](https://tianchi.aliyun.com/specials/promotion/alibaba-3d-scene-dataset) scene descriptions leading to more than 8000 extra interactive scenes!
-- New features in iGibson: Physically based rendering, 1-beam and 16-beam LiDAR, domain randomization, motion planning integration, tools to collect human demos and more!
+- New features in OmniGibson: Physically based rendering, 1-beam and 16-beam LiDAR, domain randomization, motion planning integration, tools to collect human demos and more!
- Code refactoring, better class structure and cleanup.
[05/14/2020] Added dynamic light support :flashlight:
@@ -24,11 +24,11 @@ iGibson is a simulation environment providing fast visual rendering and physics
[04/28/2020] Added support for Mac OSX :computer:
### Citation
-If you use iGibson or its assets and models, consider citing the following publication:
+If you use OmniGibson or its assets and models, consider citing the following publication:
```
-@misc{li2021igibson,
- title={iGibson 2.0: Object-Centric Simulation for Robot Learning of Everyday Household Tasks},
+@misc{li2021omnigibson,
+ title={OmniGibson 2.0: Object-Centric Simulation for Robot Learning of Everyday Household Tasks},
author={Chengshu Li and Fei Xia and Roberto Mart\'in-Mart\'in and Michael Lingelbach and Sanjana Srivastava and Bokui Shen and Kent Vainio and Cem Gokmen and Gokul Dharan and Tanish Jain and Andrey Kurenkov and Karen Liu and Hyowon Gweon and Jiajun Wu and Li Fei-Fei and Silvio Savarese},
year={2021},
eprint={2108.03272},
@@ -38,8 +38,8 @@ If you use iGibson or its assets and models, consider citing the following publi
```
```
-@inproceedings{shen2021igibson,
- title={iGibson 1.0: a Simulation Environment for Interactive Tasks in Large Realistic Scenes},
+@inproceedings{shen2021omnigibson,
+ title={OmniGibson 1.0: a Simulation Environment for Interactive Tasks in Large Realistic Scenes},
author={Bokui Shen and Fei Xia and Chengshu Li and Roberto Mart\'in-Mart\'in and Linxi Fan and Guanzhi Wang and Claudia P\'erez-D'Arpino and Shyamal Buch and Sanjana Srivastava and Lyne P. Tchapmi and Micael E. Tchapmi and Kent Vainio and Josiah Wong and Li Fei-Fei and Silvio Savarese},
booktitle={2021 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)},
year={2021},
@@ -49,30 +49,30 @@ If you use iGibson or its assets and models, consider citing the following publi
```
### Documentation
-The documentation for iGibson can be found here: [iGibson Documentation](http://svl.stanford.edu/igibson/docs/). It includes installation guide (including data download instructions), quickstart guide, code examples, and APIs.
+The documentation for OmniGibson can be found here: [OmniGibson Documentation](http://svl.stanford.edu/omnigibson/docs/). It includes installation guide (including data download instructions), quickstart guide, code examples, and APIs.
-If you want to know more about iGibson, you can also check out [our webpage](http://svl.stanford.edu/igibson), [iGibson 2.0 arxiv preprint](https://arxiv.org/abs/2108.03272) and [iGibson 1.0 arxiv preprint](https://arxiv.org/abs/2012.02924).
+If you want to know more about OmniGibson, you can also check out [our webpage](http://svl.stanford.edu/omnigibson), [OmniGibson 2.0 arxiv preprint](https://arxiv.org/abs/2108.03272) and [OmniGibson 1.0 arxiv preprint](https://arxiv.org/abs/2012.02924).
### Dowloading the Dataset of 3D Scenes
-For instructions to install iGibson and download dataset, you can visit [installation guide](http://svl.stanford.edu/igibson/docs/installation.html) and [dataset download guide](http://svl.stanford.edu/igibson/docs/dataset.html).
+For instructions to install OmniGibson and download dataset, you can visit [installation guide](http://svl.stanford.edu/omnigibson/docs/installation.html) and [dataset download guide](http://svl.stanford.edu/omnigibson/docs/dataset.html).
-There are other datasets we link to iGibson. We include support to use CubiCasa5K and 3DFront scenes, adding up more than 10000 extra interactive scenes to use in iGibson! Check our [documentation](https://github.com/StanfordVL/iGibson/tree/master/igibson/utils/data_utils/ext_scene) on how to use those.
+There are other datasets we link to OmniGibson. We include support to use CubiCasa5K and 3DFront scenes, adding up more than 10000 extra interactive scenes to use in OmniGibson! Check our [documentation](https://github.com/StanfordVL/OmniGibson/tree/master/omnigibson/utils/data_utils/ext_scene) on how to use those.
-We also maintain compatibility with datasets of 3D reconstructed large real-world scenes (homes and offices) that you can download and use with iGibson. For Gibson Dataset and Stanford 2D-3D-Semantics Dataset, please fill out this [form](https://forms.gle/36TW9uVpjrE1Mkf9A). For Matterport3D Dataset, please fill in this [form](http://dovahkiin.stanford.edu/matterport/public/MP_TOS.pdf) and send it to [matterport3d@googlegroups.com](mailto:matterport3d@googlegroups.com). Please put "use with iGibson simulator" in your email. Check our [dataset download guide](http://svl.stanford.edu/igibson/docs/dataset.html) for more details.
+We also maintain compatibility with datasets of 3D reconstructed large real-world scenes (homes and offices) that you can download and use with OmniGibson. For Gibson Dataset and Stanford 2D-3D-Semantics Dataset, please fill out this [form](https://forms.gle/36TW9uVpjrE1Mkf9A). For Matterport3D Dataset, please fill in this [form](http://dovahkiin.stanford.edu/matterport/public/MP_TOS.pdf) and send it to [matterport3d@googlegroups.com](mailto:matterport3d@googlegroups.com). Please put "use with OmniGibson simulator" in your email. Check our [dataset download guide](http://svl.stanford.edu/omnigibson/docs/dataset.html) for more details.
-### Using iGibson with VR
-If you want to use iGibson VR interface, please visit the [VR guide (TBA)].
+### Using OmniGibson with VR
+If you want to use OmniGibson VR interface, please visit the [VR guide (TBA)].
### Contributing
-This is the github repository for iGibson (pip package `igibson`) 2.0 release. (For iGibson 1.0, please use `1.0` branch.) Bug reports, suggestions for improvement, as well as community developments are encouraged and appreciated. Please, consider creating an issue or sending us an email.
+This is the github repository for OmniGibson (pip package `omnigibson`) 2.0 release. (For OmniGibson 1.0, please use `1.0` branch.) Bug reports, suggestions for improvement, as well as community developments are encouraged and appreciated. Please, consider creating an issue or sending us an email.
The support for our previous version of the environment, Gibson, can be found in the [following repository](http://github.com/StanfordVL/GibsonEnv/).
### Acknowledgments
-iGibson uses code from a few open source repositories. Without the efforts of these folks (and their willingness to release their implementations under permissable copyleft licenses), iGibson would not be possible. We thanks these authors for their efforts!
+OmniGibson uses code from a few open source repositories. Without the efforts of these folks (and their willingness to release their implementations under permissable copyleft licenses), OmniGibson would not be possible. We thanks these authors for their efforts!
- Syoyo Fujita: [tinyobjloader](https://github.com/syoyo/tinyobjloader)
- Erwin Coumans: [egl_example](https://github.com/erwincoumans/egl_example)
diff --git a/clean.sh b/clean.sh
index a48556807..53df35964 100755
--- a/clean.sh
+++ b/clean.sh
@@ -1,4 +1,4 @@
#!/bin/sh
rm -rf build
-rm -rf igibson/render/mesh_renderer/build/
+rm -rf omnigibson/render/mesh_renderer/build/
diff --git a/docker/.env b/docker/.env
index d98efa377..0877b2800 100644
--- a/docker/.env
+++ b/docker/.env
@@ -1,3 +1,3 @@
REGISTRY=docker.io
-REPO=igibson
+REPO=omnigibson
VERSION=v2.0.4
diff --git a/docker/omnigibson/Dockerfile b/docker/omnigibson/Dockerfile
index b5f317cbd..bc9de1a90 100644
--- a/docker/omnigibson/Dockerfile
+++ b/docker/omnigibson/Dockerfile
@@ -11,31 +11,31 @@ RUN apt-get update && apt-get install -y \
RUN curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xvj -C / bin/micromamba
ENV MAMBA_ROOT_PREFIX /micromamba
-RUN micromamba create -n igibson -c conda-forge python=3.7
+RUN micromamba create -n omnigibson -c conda-forge python=3.7
RUN micromamba shell init --shell=bash --prefix=/micromamba
-ENV PATH /micromamba/envs/igibson/bin:$PATH
+ENV PATH /micromamba/envs/omnigibson/bin:$PATH
RUN echo "source /isaac-sim/setup_conda_env.sh" >> /root/.bashrc
WORKDIR /
ENV GITHUB_USER mjlbach
ENV GITHUB_TOKEN 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
-ENV GITHUB_REPOSITORY stanfordvl/iGibson3.git
+ENV GITHUB_REPOSITORY stanfordvl/OmniGibson3.git
RUN git clone https://${GITHUB_USER}:${GITHUB_TOKEN}@github.com/${GITHUB_REPOSITORY}
ENV GITHUB_REPOSITORY stanfordvl/bddl-dev.git
ENV GITHUB_TOKEN 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
RUN git clone https://${GITHUB_USER}:${GITHUB_TOKEN}@github.com/${GITHUB_REPOSITORY}
-WORKDIR /iGibson3
+WORKDIR /OmniGibson3
RUN pip install -e .
-RUN micromamba install -n igibson -c conda-forge opencv
+RUN micromamba install -n omnigibson -c conda-forge opencv
WORKDIR /bddl-dev
RUN pip install -e .
-WORKDIR /iGibson3/igibson/examples/
+WORKDIR /OmniGibson3/omnigibson/examples/
-RUN sed -i "s/gm.HEADLESS = False/gm.HEADLESS = True/" /iGibson3/igibson/macros.py
+RUN sed -i "s/gm.HEADLESS = False/gm.HEADLESS = True/" /OmniGibson3/omnigibson/macros.py
ENTRYPOINT bash --login
diff --git a/docker/omnigibson/build_docker.sh b/docker/omnigibson/build_docker.sh
index 3fbba9b67..6175b93ad 100644
--- a/docker/omnigibson/build_docker.sh
+++ b/docker/omnigibson/build_docker.sh
@@ -1 +1 @@
-docker build -t omnigibson:latest .
+docker build -t omnomnigibson:latest .
diff --git a/docker/omnigibson/run_docker.sh b/docker/omnigibson/run_docker.sh
index a0d9d4381..6dffb34bc 100644
--- a/docker/omnigibson/run_docker.sh
+++ b/docker/omnigibson/run_docker.sh
@@ -1,3 +1,3 @@
-export OMNIGIBSON_DATA_PATH=/path/to/omnigibson_data
+export OMNIGIBSON_DATA_PATH=/path/to/omnomnigibson_data
# To run with GUI: edit macros.py and add -v /tmp/.X11-unix:/tmp/.X11-unix to container launch command
-docker run -e DISPLAY -v $OMNIGIBSON_DATA_PATH:/iGibson3/igibson/data --rm -it omnigibson
+docker run -e DISPLAY -v $OMNIGIBSON_DATA_PATH:/OmniGibson3/omnigibson/data --rm -it omnomnigibson
diff --git a/docs/acknowledgements.md b/docs/acknowledgements.md
index de67656da..ad3ec0a5b 100644
--- a/docs/acknowledgements.md
+++ b/docs/acknowledgements.md
@@ -1,7 +1,7 @@
Acknowledgments
================
-iGibson uses code from a few open source repositories. Without the efforts of these folks (and their willingness to release their implementations under permissable copyleft licenses), iGibson would not be possible. We thanks these authors for their efforts!
+OmniGibson uses code from a few open source repositories. Without the efforts of these folks (and their willingness to release their implementations under permissable copyleft licenses), OmniGibson would not be possible. We thanks these authors for their efforts!
- Syoyo Fujita: [tinyobjloader](https://github.com/syoyo/tinyobjloader)
- Erwin Coumans: [egl_example](https://github.com/erwincoumans/egl_example)
diff --git a/docs/assets.md b/docs/assets.md
index abe3cba49..0ef984c38 100644
--- a/docs/assets.md
+++ b/docs/assets.md
@@ -2,10 +2,10 @@
## Introduction
-Assets includes necessary files for constructing a scene in iGibson simulator. The files include robot models, interactive objects, articulated objects and mesh files for tests. These files are too large to include in a version control system so we distribute them separately. The assets file can be downloaded to the path set in `your_installation_path/igibson/global_config.yaml` (default to `your_installation_path/igibson/data/assets`) with running
+Assets includes necessary files for constructing a scene in OmniGibson simulator. The files include robot models, interactive objects, articulated objects and mesh files for tests. These files are too large to include in a version control system so we distribute them separately. The assets file can be downloaded to the path set in `your_installation_path/omnigibson/global_config.yaml` (default to `your_installation_path/omnigibson/data/assets`) with running
```bash
-python -m igibson.utils.assets_utils --download_assets
+python -m omnigibson.utils.assets_utils --download_assets
```
The folder structure will look like below (in the future we might add more models):
diff --git a/docs/conf.py b/docs/conf.py
index ed8f39c42..d520fa63c 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -24,18 +24,18 @@
from recommonmark.parser import CommonMarkParser
sys.path.append(os.path.abspath("../"))
-import igibson
+import omnigibson
-project = "iGibson"
+project = "OmniGibson"
copyright = "Stanford University 2018-2021"
author = "Bokui Shen*, Fei Xia*, Chengshu Li*, Roberto Martín-Martín*, Linxi Fan, Guanzhi Wang, Shyamal Buch, Claudia DArpino, Sanjana Srivastava, Lyne P. Tchapmi, Micael E. Tchapmi, Kent Vainio, Li Fei-Fei, Silvio Savarese (*Equal Contribution)"
-github_doc_root = "https://github.com/StanfordVL/iGibson"
+github_doc_root = "https://github.com/StanfordVL/OmniGibson"
# The short X.Y version
-version = igibson.__version__
+version = omnigibson.__version__
# The full version, including alpha/beta/rc tags
-release = igibson.__version__
+release = omnigibson.__version__
sys.path.insert(0, os.path.abspath("../"))
sys.path.insert(0, os.path.abspath("../../"))
diff --git a/docs/dataset.md b/docs/dataset.md
index b8a9c30df..85fe59484 100644
--- a/docs/dataset.md
+++ b/docs/dataset.md
@@ -2,45 +2,45 @@
In this page you will find information about:
-- [How to download iGibson 2.0 scenes and the BEHAVIOR Dataset of Objects](#download-igibson-2-0-scenes-and-the-behavior-dataset-of-objects)
-- [How to download iGibson 1.0 scenes](#download-igibson-1-0-scenes)
+- [How to download OmniGibson 2.0 scenes and the BEHAVIOR Dataset of Objects](#download-omnigibson-2-0-scenes-and-the-behavior-dataset-of-objects)
+- [How to download OmniGibson 1.0 scenes](#download-omnigibson-1-0-scenes)
- [How to download Gibson and Stanford 2D-3D-Semantics scenes](#download-gibson-and-stanford-2d-3d-semantics-scenes)
- [How to download Matterport3D scenes](#download-matterport3d-scenes)
-## Download iGibson 2.0 Scenes and the BEHAVIOR Dataset of Objects
+## Download OmniGibson 2.0 Scenes and the BEHAVIOR Dataset of Objects
What will you download?
-- **iGibson 2.0 Dataset of Scenes**: New versions of the fully interactive scenes, more densely populated with objects.
-- **BEHAVIOR Object Dataset**: Dataset of object models annotated with physical and semantic properties. The 3D models are free to use within iGibson 2.0 for BEHAVIOR (due to artists' copyright, models are encrypted and allowed only to be used with iGibson 2.0). You can download a bundle of the iGibson 2.0 dataset of scenes and the BEHAVIOR dataset of objects here.
+- **OmniGibson 2.0 Dataset of Scenes**: New versions of the fully interactive scenes, more densely populated with objects.
+- **BEHAVIOR Object Dataset**: Dataset of object models annotated with physical and semantic properties. The 3D models are free to use within OmniGibson 2.0 for BEHAVIOR (due to artists' copyright, models are encrypted and allowed only to be used with OmniGibson 2.0). You can download a bundle of the OmniGibson 2.0 dataset of scenes and the BEHAVIOR dataset of objects here.
To download both in a bundle, you need to follow the following steps:
- Fill out the license agreement in this [form](https://docs.google.com/forms/d/e/1FAIpQLScPwhlUcHu_mwBqq5kQzT2VRIRwg_rJvF0IWYBk_LxEZiJIFg/viewform)
-- You will receive a key (igibson.key). Move it into the subfolder of the iGibson repository that contains the dataset, for example, iGibson/igibson/data
-- Download the behavior data bundle (ig_dataset) from [here](https://storage.googleapis.com/gibson_scenes/behavior_data_bundle.zip)
-- Unzip ig_dataset into the folder: `unzip behavior_data_bundle.zip -d iGibson/igibson/data`
+- You will receive a key (omnigibson.key). Move it into the subfolder of the OmniGibson repository that contains the dataset, for example, OmniGibson/omnigibson/data
+- Download the behavior data bundle (og_dataset) from [here](https://storage.googleapis.com/gibson_scenes/behavior_data_bundle.zip)
+- Unzip og_dataset into the folder: `unzip behavior_data_bundle.zip -d OmniGibson/omnigibson/data`
-After this process, you will be able to sample and use the scenes and objects in iGibson, for example, to evaluate your embodied AI solutions in the [BEHAVIOR benchmark](https://behavior.stanford.edu/).
+After this process, you will be able to sample and use the scenes and objects in OmniGibson, for example, to evaluate your embodied AI solutions in the [BEHAVIOR benchmark](https://behavior.stanford.edu/).
-## Download iGibson 1.0 Scenes
+## Download OmniGibson 1.0 Scenes
What will you download?
-- **iGibson 1.0 Dataset of Scenes**: We annotated fifteen 3D reconstructions of real-world scans and converted them into fully interactive scene models. In this process, we respect the original object-instance layout and object-category distribution. The object models are extended from open-source datasets ([ShapeNet Dataset](https://www.shapenet.org/), [Motion Dataset](http://motiondataset.zbuaa.com/), [SAPIEN Dataset](https://sapien.ucsd.edu/)) enriched with annotations of material and dynamic properties.
+- **OmniGibson 1.0 Dataset of Scenes**: We annotated fifteen 3D reconstructions of real-world scans and converted them into fully interactive scene models. In this process, we respect the original object-instance layout and object-category distribution. The object models are extended from open-source datasets ([ShapeNet Dataset](https://www.shapenet.org/), [Motion Dataset](http://motiondataset.zbuaa.com/), [SAPIEN Dataset](https://sapien.ucsd.edu/)) enriched with annotations of material and dynamic properties.
The following image shows the fifteen fully interactive scenes:
-
+
-To download the dataset, you need to first configure where the dataset is to be stored. You can change it in `your_installation_path/igibson/global_config.yaml` (default and recommended: `ig_dataset: your_installation_path/igibson/data/ig_dataset`). iGibson scenes can be downloaded with one single line:
+To download the dataset, you need to first configure where the dataset is to be stored. You can change it in `your_installation_path/omnigibson/global_config.yaml` (default and recommended: `og_dataset: your_installation_path/omnigibson/data/og_dataset`). OmniGibson scenes can be downloaded with one single line:
```bash
-python -m igibson.utils.assets_utils --download_ig_dataset
+python -m omnigibson.utils.assets_utils --download_og_dataset
```
-If the script fails to work, you can download from this [direct link](https://storage.googleapis.com/gibson_scenes/ig_dataset.tar.gz) and extract to `your_installation_path/igibson/data/ig_dataset`.
+If the script fails to work, you can download from this [direct link](https://storage.googleapis.com/gibson_scenes/og_dataset.tar.gz) and extract to `your_installation_path/omnigibson/data/og_dataset`.
-A description of the file structure and format of the files in the dataset can be found [here](https://github.com/StanfordVL/iGibson/tree/master/igibson/utils/data_utils).
+A description of the file structure and format of the files in the dataset can be found [here](https://github.com/StanfordVL/OmniGibson/tree/master/omnigibson/utils/data_utils).
-**Cubicasa / 3D Front Dataset Support:** We provide support for Cubicasa and 3D Front Dataset providing more than 10000 additional scenes (with less furniture than our fifteen scenes). To import them into iGibson, follow the instructions [here](https://github.com/StanfordVL/iGibson/tree/master/igibson/utils/data_utils/ext_scene).
+**Cubicasa / 3D Front Dataset Support:** We provide support for Cubicasa and 3D Front Dataset providing more than 10000 additional scenes (with less furniture than our fifteen scenes). To import them into OmniGibson, follow the instructions [here](https://github.com/StanfordVL/OmniGibson/tree/master/omnigibson/utils/data_utils/ext_scene).
## Download Gibson and Stanford 2D-3D-Semantics scenes
@@ -52,15 +52,15 @@ Files included in the dataset:
- All scenes, 572 scenes (108GB): gibson_v2_all.tar.gz
- 4+ partition, 106 scenes, with textures better packed (2.6GB): gibson_v2_4+.tar.gz
-- Stanford 2D-3D-Semantics, 7 scenes (1.4GB): 2d3ds_for_igibson.zip
+- Stanford 2D-3D-Semantics, 7 scenes (1.4GB): 2d3ds_for_omnigibson.zip
-We have updated these datasets to be used with iGibson so that users can keep developing and studying pure navigation solutions. The following link will bring you to a license agreement and then to a downloading URL: [form](https://forms.gle/36TW9uVpjrE1Mkf9A)
+We have updated these datasets to be used with OmniGibson so that users can keep developing and studying pure navigation solutions. The following link will bring you to a license agreement and then to a downloading URL: [form](https://forms.gle/36TW9uVpjrE1Mkf9A)
After filling in the agreement, you will obtain a downloading `URL`.
-You can download the data manually and store it in the path set in `your_installation_path/igibson/global_config.yaml` (default and recommended: `g_dataset: your_installation_path/igibson/data/g_dataset`).
+You can download the data manually and store it in the path set in `your_installation_path/omnigibson/global_config.yaml` (default and recommended: `g_dataset: your_installation_path/omnigibson/data/g_dataset`).
Alternatively, you can run a single command to download the dataset, decompress, and place it in the correct folder:
```bash
-python -m igibson.utils.assets_utils --download_dataset URL
+python -m omnigibson.utils.assets_utils --download_dataset URL
```
The Gibson Environment Dataset consists of 572 models and 1440 floors. We cover a diverse set of models including households, offices, hotels, venues, museums, hospitals, construction sites, etc. A diverse set of visualization of all spaces in Gibson can be seen [here](http://gibsonenv.stanford.edu/database/).
@@ -103,8 +103,8 @@ For the maps, each pixel represents 0.01m, and the center of the image correspon
What will you download?
- Matterport3D Dataset: 90 scenes (3.2GB)
-Please fill in this [form](http://dovahkiin.stanford.edu/matterport/public/MP_TOS.pdf) and send it to [matterport3d@googlegroups.com](mailto:matterport3d@googlegroups.com). Please put "use with iGibson simulator" in your email.
+Please fill in this [form](http://dovahkiin.stanford.edu/matterport/public/MP_TOS.pdf) and send it to [matterport3d@googlegroups.com](mailto:matterport3d@googlegroups.com). Please put "use with OmniGibson simulator" in your email.
-You'll then recieve a python script via email in response. Run `python download_mp.py --task_data igibson -o .` with the received script to download the data (3.2GB). Afterwards, move each of the scenes to the path set in `your_installation_path/igibson/global_config.yaml` (default and recommended: `g_dataset: your_installation_path/igibson/data/g_dataset`).
+You'll then recieve a python script via email in response. Run `python download_mp.py --task_data omnigibson -o .` with the received script to download the data (3.2GB). Afterwards, move each of the scenes to the path set in `your_installation_path/omnigibson/global_config.yaml` (default and recommended: `g_dataset: your_installation_path/omnigibson/data/g_dataset`).
Reference: [Matterport3D webpage](https://niessner.github.io/Matterport/).
\ No newline at end of file
diff --git a/docs/environments.md b/docs/environments.md
index 9045e00d7..b33f406b4 100644
--- a/docs/environments.md
+++ b/docs/environments.md
@@ -4,13 +4,13 @@
We provide **Environments** that follow the [OpenAI gym](https://github.com/openai/gym) interface for applications such as reinforcement learning algorithms. Generally speaking, an **Environment** instantiates **Scene**, **Object** and **Robot** and import them into its **Simulator**. An **Environment** also instantiates a list of **Sensors** (usually as part of the observation space) and a **Task**, which further includes a list of **Reward Functions** and **Termination Conditions**.
-Most of the code can be found here: [igibson/envs/igibson_env.py](https://github.com/StanfordVL/iGibson/blob/master/igibson/envs/igibson_env.py).
+Most of the code can be found here: [omnigibson/envs/omnigibson_env.py](https://github.com/StanfordVL/OmniGibson/blob/master/omnigibson/envs/omnigibson_env.py).
#### Sensors
We provide different types of sensors as lightweight wrappers around the renderer. Currently we support RGB, surface normal, segmentation, 3D point cloud, depth map, optical flow, and scene flow, and also 1-beam and 16-beam LiDAR signals. Additionally, we provide a sensor noise model with random dropout (currently only for depth map and 1-beam LiDAR) to simulate real-world sensor noise. The amount of noise can be controlled by `depth_noise_rate` and `scan_noise_rate` in the config files. Contribution of more noise models is most welcome.
-Most of the code can be found in [igibson/sensors](https://github.com/StanfordVL/iGibson/tree/master/igibson/sensors).
+Most of the code can be found in [omnigibson/sensors](https://github.com/StanfordVL/OmniGibson/tree/master/omnigibson/sensors).
#### Tasks
@@ -27,7 +27,7 @@ We provide a few Embodied AI tasks.
- ReachingRandomTask
- RoomRearrangementTask
-Most of the code can be found in [igibson/tasks](https://github.com/StanfordVL/iGibson/tree/master/igibson/tasks).
+Most of the code can be found in [omnigibson/tasks](https://github.com/StanfordVL/OmniGibson/tree/master/omnigibson/tasks).
#### Reward Functions
@@ -38,7 +38,7 @@ We provide a few common reward functions for robotics tasks.
- PotentialReward
- CollisionReward
-Most of the code can be found in [igibson/reward_functions](https://github.com/StanfordVL/iGibson/tree/master/igibson/reward_functions).
+Most of the code can be found in [omnigibson/reward_functions](https://github.com/StanfordVL/OmniGibson/tree/master/omnigibson/reward_functions).
#### Termination Conditions
@@ -49,16 +49,16 @@ We provide a few common termination conditions for robotics tasks.
- MaxCollision
- Timeout
- OutOfBound
-Most of the code can be found in [igibson/termination_conditions](https://github.com/StanfordVL/iGibson/tree/master/igibson/termination_conditions).
+Most of the code can be found in [omnigibson/termination_conditions](https://github.com/StanfordVL/OmniGibson/tree/master/omnigibson/termination_conditions).
#### Configs
-To instantiate an **Environment**, we first need to create a YAML config file. It will specify parameters for the **Environment** (e.g. robot type, action frequency, etc), the **Sensors** (e.g. sensor types, image resolution, noise rate, etc), the **Task** (e.g. task type, goal distance range, etc), the **Reward Functions** (e.g. reward types, reward scale, etc) and the **Termination Conditions** (e.g. goal convergence threshold, time limit, etc). Exapmles of config files can be found here: [configs](https://github.com/StanfordVL/iGibson/tree/master/igibson/configs).
+To instantiate an **Environment**, we first need to create a YAML config file. It will specify parameters for the **Environment** (e.g. robot type, action frequency, etc), the **Sensors** (e.g. sensor types, image resolution, noise rate, etc), the **Task** (e.g. task type, goal distance range, etc), the **Reward Functions** (e.g. reward types, reward scale, etc) and the **Termination Conditions** (e.g. goal convergence threshold, time limit, etc). Exapmles of config files can be found here: [configs](https://github.com/StanfordVL/OmniGibson/tree/master/omnigibson/configs).
-Here is one example: [configs/turtlebot_nav.yaml](https://github.com/StanfordVL/iGibson/blob/master/igibson/configs/turtlebot_nav.yaml)
+Here is one example: [configs/turtlebot_nav.yaml](https://github.com/StanfordVL/OmniGibson/blob/master/omnigibson/configs/turtlebot_nav.yaml)
```yaml
# scene
-scene: igibson
+scene: omnigibson
scene_id: Rs_int
build_graph: true
load_texture: true
@@ -138,8 +138,8 @@ Parameters of this config file are explained below:
| Attribute | Example Value | Expalanation |
| ----------| ------------- | ------------ |
-| scene | igibson | which type of scene: [empty, stadium, gibson, igibson] |
-| scene_id | Rs_int | scene_id for the gibson or igibson scene |
+| scene | omnigibson | which type of scene: [empty, stadium, gibson, omnigibson] |
+| scene_id | Rs_int | scene_id for the gibson or omnigibson scene |
| build_graph | true | whether to build traversability graph for the building scene |
| load_texture | true | whether to load texture into MeshRenderer. Can be set to false if RGB is not needed |
| pybullet_load_texture | true | whether to load texture into PyBullet, for debugging purpose only |
@@ -175,7 +175,7 @@ Parameters of this config file are explained below:
| depth_low | 0.8 | lower bound of the valid range of the depth camera |
| depth_high | 3.5 | upper bound of the valid range of the depth camera |
| n_horizontal_rays | 228 | number of horizontal rays to simulate for the LiDAR |
-| n_vertical_beams | 1 | number of vertical beams to simulate for the LiDAR. Currently iGibson only supports n_vertical_beams == 1 |
+| n_vertical_beams | 1 | number of vertical beams to simulate for the LiDAR. Currently OmniGibson only supports n_vertical_beams == 1 |
| laser_linear_range | 5.6 | upper bound of the valid range of the LiDAR |
| laser_angular_range | 240.0 | angular range of the LiDAR (in degrees) |
| min_laser_dist | 0.05 | lower bound of the valid range of the LiDAR |
@@ -188,14 +188,14 @@ Parameters of this config file are explained below:
### Examples
#### Static Environments
-In this example, we show how to instantiate `iGibsonEnv` and how to step through the environment. At the beginning of each episode, we need to call `env.reset()`. Then we need to call `env.step(action)` to step through the environment and retrieve `(state, reward, done, info)`.
+In this example, we show how to instantiate `OmniGibsonEnv` and how to step through the environment. At the beginning of each episode, we need to call `env.reset()`. Then we need to call `env.step(action)` to step through the environment and retrieve `(state, reward, done, info)`.
- `state`: a python dictionary of observations, e.g. `state['rgb']` will be a H x W x 3 numpy array that represents the current image
- `reward`: a scalar that represents the current reward
- `done`: a boolean that indicates whether the episode should terminate
- `info`: a python dictionary for bookkeeping purpose
-The code can be found here: [igibson/examples/environments/env_nonint_example.py](https://github.com/StanfordVL/iGibson/blob/master/igibson/examples/environments/env_nonint_example.py).
+The code can be found here: [omnigibson/examples/environments/env_nonint_example.py](https://github.com/StanfordVL/OmniGibson/blob/master/omnigibson/examples/environments/env_nonint_example.py).
-If the execution fails with segfault 11, you may need to reduce texture scaling in the config file (igibson/configs/turtlebot_static_nav.yaml) to avoid out-of-memory error.
+If the execution fails with segfault 11, you may need to reduce texture scaling in the config file (omnigibson/configs/turtlebot_static_nav.yaml) to avoid out-of-memory error.
```python
import logging
@@ -204,15 +204,15 @@ from sys import platform
import yaml
-import igibson
-from igibson.envs.igibson_env import iGibsonEnv
-from igibson.render.profiler import Profiler
-from igibson.utils.asset_utils import download_assets, download_demo_data
+import omnigibson
+from omnigibson.envs.omnigibson_env import OmniGibsonEnv
+from omnigibson.render.profiler import Profiler
+from omnigibson.utils.asset_utils import download_assets, download_demo_data
def main():
"""
- Creates an iGibson environment from a config file with a turtlebot in Rs (not interactive).
+ Creates an OmniGibson environment from a config file with a turtlebot in Rs (not interactive).
It steps the environment 100 times with random actions sampled from the action space,
using the Gym interface, resetting it 10 times.
"""
@@ -220,12 +220,12 @@ def main():
# If they have not been downloaded before, download assets and Rs Gibson (non-interactive) models
download_assets()
download_demo_data()
- config_filename = os.path.join(igibson.example_config_path, "turtlebot_static_nav.yaml")
+ config_filename = os.path.join(omnigibson.example_config_path, "turtlebot_static_nav.yaml")
config_data = yaml.load(open(config_filename, "r"), Loader=yaml.FullLoader)
# Reduce texture scale for Mac.
if platform == "darwin":
config_data["texture_scale"] = 0.5
- env = iGibsonEnv(config_file=config_data, mode="gui_interactive")
+ env = OmniGibsonEnv(config_file=config_data, mode="gui_interactive")
for j in range(10):
logging.info("Resetting environment")
env.reset()
@@ -244,4 +244,4 @@ if __name__ == "__main__":
```
#### Interactive Environments
-In this example, we show how to instantiate `iGibsobEnv` with a fully interactive scene `Rs_int`. In this scene, the robot can interact with all the objects in the scene (chairs, tables, couches, etc). The code can be found here: [igibson/examples/environments/env_int_example.py](https://github.com/StanfordVL/iGibson/blob/master/igibson/examples/env_int_example.py).
+In this example, we show how to instantiate `iGibsobEnv` with a fully interactive scene `Rs_int`. In this scene, the robot can interact with all the objects in the scene (chairs, tables, couches, etc). The code can be found here: [omnigibson/examples/environments/env_int_example.py](https://github.com/StanfordVL/OmniGibson/blob/master/omnigibson/examples/env_int_example.py).
diff --git a/docs/examples.md b/docs/examples.md
index 5d67aa725..8e1133b7d 100644
--- a/docs/examples.md
+++ b/docs/examples.md
@@ -1,21 +1,21 @@
# Code Examples
-In this section, we include a description of most of the code examples you can find under `igibson/examples/`.
+In this section, we include a description of most of the code examples you can find under `omnigibson/examples/`.
There may be new examples since we wrote this, so check that folder!
-If you are interested in just getting started as an end-user, you only need check out `igibson/examples/environments`.
+If you are interested in just getting started as an end-user, you only need check out `omnigibson/examples/environments`.
-If you are looking for examples of BEHAVIOR, the benchmark of household activities that uses iGibson, please check the BEHAVIOR repository at https://github.com/StanfordVL/behavior.
+If you are looking for examples of BEHAVIOR, the benchmark of household activities that uses OmniGibson, please check the BEHAVIOR repository at https://github.com/StanfordVL/behavior.
-- environments: how to instantiate iGibson environments with interactive or static scenes, optionally with a scene selector.
+- environments: how to instantiate OmniGibson environments with interactive or static scenes, optionally with a scene selector.
- learning: how to train RL policies for robot navigation using stable baselines 3, and how to save and replay demos of agents for imitation learning.
- objects: how to create, load, and place objects to predefined locations or using a logic sampler (e.g. onTop(A, B)), how to change texture as a function of the temperature, and how to generate the minimum volume bounding boxes of objects.
- object_states: how to change various objects states, including dusty, stained, (water sources) toggled on, (cleaning tool) soaked, sliced, and temprature, and how to save and reload object states.
- observations: how to generate different observation modalities such as RGB, depth, LiDAR, segmentation, etc.
- renderer: how to use the renderer directly, without the physics engine.
- robots: how to (keyboard) control robots with differential drive controllers, IK controllers and sampling-based motion planners.
-- ros: how to run ROS with iGibson as if it is the real world.
+- ros: how to run ROS with OmniGibson as if it is the real world.
- scenes: how to load interactive and non-interactive scenes, how to use domain randomization (of object models and/or texture), and how to create a tour video of the scenes.
-- vr: how to use iGibson with VR.
-- web_ui: how to start a web server that hosts iGibson environments.
+- vr: how to use OmniGibson with VR.
+- web_ui: how to start a web server that hosts OmniGibson environments.
diff --git a/docs/extended_states.md b/docs/extended_states.md
index c6c89cb5a..ee4cc7c71 100644
--- a/docs/extended_states.md
+++ b/docs/extended_states.md
@@ -2,9 +2,9 @@
### Extended States
-iGibson 2.0 is an object-oriented simulator: the simulator maintains and updates a list of objects with properties that change over-time.
+OmniGibson 2.0 is an object-oriented simulator: the simulator maintains and updates a list of objects with properties that change over-time.
Object classes are organized following the WordNet hierarchy.
-Different to other simulators, iGibson 2.0 is not limited to kinematic properties of the objects (pose, velocity, acceleration, joint configurations for articulated objects), but it includes also a set of additional object-properties that we call "extended states".
+Different to other simulators, OmniGibson 2.0 is not limited to kinematic properties of the objects (pose, velocity, acceleration, joint configurations for articulated objects), but it includes also a set of additional object-properties that we call "extended states".
The extended states are:
#### Temperature
@@ -19,23 +19,23 @@ Integer value per object. It changes when in contact with a water dropplet.
#### Cleanliness (Dustiness and Stain Level)
-In iGibson 2.0, objects can be initialized with visible dust or stain particles on its surface. The number of particles at initialization corresponds to a 100% level of dustiness, d, or stains, s, as we assume that dust/stain particles cannot be generated after initialization. As particles are cleaned, the level decreases proportionally to the number of particles removed, reaching a level of 0% when all particles have been cleaned.
+In OmniGibson 2.0, objects can be initialized with visible dust or stain particles on its surface. The number of particles at initialization corresponds to a 100% level of dustiness, d, or stains, s, as we assume that dust/stain particles cannot be generated after initialization. As particles are cleaned, the level decreases proportionally to the number of particles removed, reaching a level of 0% when all particles have been cleaned.
#### Toggled State
-Some object categories in iGibson 2.0 can be toggled on and off. iGibson 2.0 maintains and updates an internal binary functional state for those objects.
+Some object categories in OmniGibson 2.0 can be toggled on and off. OmniGibson 2.0 maintains and updates an internal binary functional state for those objects.
#### Sliced State
Many cooking activities require the agent to slice objects, e.g. food items.
-In iGibson 2.0 some objects can be sliced into two halves and the state of the object will be updated.
+In OmniGibson 2.0 some objects can be sliced into two halves and the state of the object will be updated.
## Logic States
-Based on the kinematic and extended states, iGibson 2.0 implements a list of logic predicates, checking conditions to indicate if a logic state is True or False.
-The logic states implemented and checked by iGibson 2.0 include:
+Based on the kinematic and extended states, OmniGibson 2.0 implements a list of logic predicates, checking conditions to indicate if a logic state is True or False.
+The logic states implemented and checked by OmniGibson 2.0 include:
- InsideOf(o1,o2): Object o1 is inside of object o2 if we can find two orthogonal axes crossing at o1 center of mass that intersect o2 collision mesh in both directions.
- OnTopOf(o1,o2): Object o1 is on top of object o2 if o2 is in the list of objects InSameNegativeVerticalAxisObjs(o1) and o2 is in the list of objects InSamePositiveVerticalAxisObjs(o1) and InContactWith(o1, o2), where InSamePositive/NegativeVerticalAxisObjs(o1) is the list of objects in the same positive/negative vertical axis as o1 and InContactWith(o1, o2) is whether the two objects are in physical contact.
- NextTo(o1,o2): Object o1 is next to object o2 if o2 is in the list of objects InSameHorizontalPlaneObjs(o1) and l2(o1, o2) < tNextTo , where InSameHorizontalPlaneObjs(o1) is a list of objects in the same horizontal plane as o1, l2 is the L2 distance between the closest points of the two objects, and tNextTo is a distance threshold that is proportional to the average size of the two objects.
@@ -49,8 +49,8 @@ The logic states implemented and checked by iGibson 2.0 include:
- Soaked(o): The wetness level w of the object o is over a threshold, wsoaked , i.e., w ≥ wsoaked . The default value for the threshold is wsoaked = 1, (the object is soaked if it absorbs one or more droplets), a value that can be adapted per object category and model.
- Dusty(o): The dustiness level d of the object o is over a threshold, ddusty , i.e., d > ddusty . The default value for the threshold is ddusty = 0.5, (half of the dust particles have been cleaned), a value that can be adapted per object category and model.
- Stained(o): The stain level s of the object o is over a threshold, sstained , i.e., s > sstained . The default value for the threshold is sstained = 0.5, (half of the stain particles have been cleaned), a value that can be adapted per object category and model.
-- ToggledOn(o): Object o is toggled on or off. It is a direct query of the iGibson 2.0 objects’ extended state TS, the toggled state.
-- Sliced(o): Object o is sliced or not. It is a direct access of the iGibson 2.0 objects’ extended state SS, the sliced state.
+- ToggledOn(o): Object o is toggled on or off. It is a direct query of the OmniGibson 2.0 objects’ extended state TS, the toggled state.
+- Sliced(o): Object o is sliced or not. It is a direct access of the OmniGibson 2.0 objects’ extended state SS, the sliced state.
- InFoVOfAgent(o): Object o is in the field of view of the agent, i.e., at least one pixel of the image acquired by the agent’s onboard sensors corresponds to the surface of o.
- InHandOfAgent(o): Object o is grasped by the agent’s hands (i.e. assistive grasping is activated on that object).
- InReachOfAgent(o): Object o is within dreach = 2 meters away from the agent.
@@ -59,9 +59,9 @@ The logic states implemented and checked by iGibson 2.0 include:
We do not annotate all objects all extended states.
Objects are annotated with extended states that allow to query meaningful and useful logic states from them, e.g. temperature to query if food is cooked (or frozen or burned).
-This doesn't mean a table does not have temperature, but it is not relevant for most robotics activities simulated in iGibson 2.0.
+This doesn't mean a table does not have temperature, but it is not relevant for most robotics activities simulated in OmniGibson 2.0.
We annotate object classes with meaningful logic states that apply to them, and, possibly, the parameters to check these states.
-The list of classes and states can be found in the BDDL repository ([list of object characteristics](https://github.com/sanjanasrivastava/BDDL/blob/master/utils/synsets_to_filtered_properties_pruned_igibson.json)).
+The list of classes and states can be found in the BDDL repository ([list of object characteristics](https://github.com/sanjanasrivastava/BDDL/blob/master/utils/synsets_to_filtered_properties_pruned_omnigibson.json)).
The characteristics that can be annotated include (additional extended state and parameters in parenthesis):
(e.g., the temperature is not necessary/relevant for non-food categories for most tasks of interest).
diff --git a/docs/index.rst b/docs/index.rst
index f26d580ed..ed211ce3d 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -3,7 +3,7 @@
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
-Welcome to iGibson's documentation!
+Welcome to OmniGibson's documentation!
==================================================
.. toctree::
diff --git a/docs/installation.md b/docs/installation.md
index b0d963b40..d16b39619 100644
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -1,5 +1,5 @@
# Installation
-There are two steps to install iGibson, the Interactive Gibson Environment, on your computer.
+There are two steps to install OmniGibson, the Interactive Gibson Environment, on your computer.
First, you need to install the simulation environment. This may require installing additional dependencies. Then, you need to download the assets: models of the robotic agents, the interactive objects and 3D reconstructed real-world large environments for your agents to train.
@@ -33,7 +33,7 @@ Other system configurations may work, but we haven't tested them extensively and
### Installing dependencies in Linux machines
-As most Python packages, we recommend to install iGibson in a virtual environment.
+As most Python packages, we recommend to install OmniGibson in a virtual environment.
We suggest to use Conda instead of a standard virtual environment.
To setup anaconda with the right dependencies, run the following as your user account (**not as root/superuser**):
@@ -46,15 +46,15 @@ rm Miniconda-latest-Linux-x86_64.sh
# Add conda to your PATH
echo "export PATH=$HOME/.miniconda/bin:$PATH" >> .bashrc
-# Update conda and create a virtual environment for iGibson
+# Update conda and create a virtual environment for OmniGibson
conda update -y conda
-conda create -y -n igibson python=3.8
-conda activate igibson
+conda create -y -n omnigibson python=3.8
+conda activate omnigibson
```
Careful, this may change your GPU drivers!
-There are several system dependencies to correctly run iGibson on Linux, mostly related to Nvidia drivers and Cuda. +There are several system dependencies to correctly run OmniGibson on Linux, mostly related to Nvidia drivers and Cuda. In case your system is a clean Ubuntu 20.04, you can run the following commands as root/superuser to install all required dependencies: