asset_utils

download_behavior_1k_assets(accept_license=False)

Download BEHAVIOR-1K dataset

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def download_behavior_1k_assets(accept_license=False):
    """
    Download BEHAVIOR-1K dataset
    """
    # Print user agreement
    if os.path.exists(get_key_path()):
        print("BEHAVIOR-1K dataset encryption key already installed.")
    else:
        if not accept_license:
            print("\n")
            print_user_agreement()
            while input("Do you agree to the above terms for using BEHAVIOR-1K dataset? [y/n]") != "y":
                print("You need to agree to the terms for using BEHAVIOR-1K dataset.")

        download_key()

    if os.path.exists(get_dataset_path("behavior-1k-assets")):
        print("BEHAVIOR-1K dataset already installed.")
    else:
        download_and_unpack_zipped_dataset("behavior-1k-assets")

download_omnigibson_robot_assets(upgrade=False)

Download OmniGibson robot assets

Parameters:

Name	Type	Description	Default
upgrade	bool	If True, remove existing installation and redownload if no version or older version	False

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def download_omnigibson_robot_assets(upgrade: bool = False):
    """
    Download OmniGibson robot assets

    Args:
        upgrade (bool): If True, remove existing installation and redownload if no version or older version
    """
    dataset_path = get_dataset_path("omnigibson-robot-assets")
    current_version = get_omnigibson_robot_asset_version()
    needs_upgrade = current_version is None or Version(current_version) < Version(MINIMUM_ROBOT_ASSETS_VERSION)
    upgraded = False
    if os.path.exists(dataset_path):
        if upgrade and needs_upgrade:
            print(f"Removing existing omnigibson-robot-assets (version: {current_version}) to upgrade...")
            shutil.rmtree(dataset_path)
            download_and_unpack_zipped_dataset("omnigibson-robot-assets")
            upgraded = True
        else:
            print(f"OmniGibson robot assets already downloaded (version: {current_version}).")
    else:
        download_and_unpack_zipped_dataset("omnigibson-robot-assets")
        upgraded = True
    if upgraded:
        new_version = get_omnigibson_robot_asset_version()
        print(f"Successfully downloaded OmniGibson robot assets version {new_version}.")

get_all_object_categories()

Get OmniGibson all object categories

Returns:

Type	Description
list	all object categories

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_all_object_categories():
    """
    Get OmniGibson all object categories

    Returns:
        list: all object categories
    """
    categories = {x.name for x in Path(gm.DATA_PATH).glob("*/objects/*") if x.is_dir() and not is_dot_file(x.name)}
    return sorted(categories)

get_all_object_category_models(category)

Get all object models from @category

Parameters:

Name	Type	Description	Default
category	str	Object category name	required

Returns:

Type	Description
list of str	all object models belonging to @category

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_all_object_category_models(category):
    """
    Get all object models from @category

    Args:
        category (str): Object category name

    Returns:
        list of str: all object models belonging to @category
    """
    behavior_1k_assets_path = get_dataset_path("behavior-1k-assets")
    categories_path = os.path.join(behavior_1k_assets_path, "objects", category)
    return sorted(os.listdir(categories_path)) if os.path.exists(categories_path) else []

get_all_object_category_models_with_abilities(category, abilities)

Get all object models from @category whose assets are properly annotated with necessary requirements to support abilities @abilities

Parameters:

Name	Type	Description	Default
category	str	Object category name	required
abilities	dict	Dictionary mapping requested abilities to keyword arguments to pass to the corresponding object state constructors. The abilities' required annotations will be guaranteed for the returned models	required

Returns:

Type	Description
list of str	all object models belonging to @category which are properly annotated with necessary requirements to support the requested list of @abilities

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_all_object_category_models_with_abilities(category, abilities):
    """
    Get all object models from @category whose assets are properly annotated with necessary requirements to support
    abilities @abilities

    Args:
        category (str): Object category name
        abilities (dict): Dictionary mapping requested abilities to keyword arguments to pass to the corresponding
            object state constructors. The abilities' required annotations will be guaranteed for the returned
            models

    Returns:
        list of str: all object models belonging to @category which are properly annotated with necessary requirements
            to support the requested list of @abilities
    """
    # Avoid circular imports
    from omnigibson.object_states.factory import get_requirements_for_ability, get_states_and_params_for_ability
    from omnigibson.objects.dataset_object import DatasetObject

    # Get all valid models
    all_models = get_all_object_category_models(category=category)

    # Generate all object states required per object given the requested set of abilities. We must
    # apply the same per-(ability, state) param transform that object hydration uses (via the shared
    # get_states_and_params_for_ability helper), otherwise a state's asset compatibility is checked
    # with the wrong kwargs -- e.g. flammable's HeatSourceOrSink would be validated with
    # requires_on_fire=False and wrongly demand a heatsource meta link.
    abilities_info = {
        ability: get_states_and_params_for_ability(ability, params) for ability, params in abilities.items()
    }

    # Get mapping for class init kwargs
    state_init_default_kwargs = dict()

    for ability, state_types_and_params in abilities_info.items():
        for state_type, _ in state_types_and_params:
            # Add each state's dependencies, too. Note that only required dependencies are added.
            for dependency in state_type.get_dependencies():
                if all(other_state != dependency for other_state, _ in state_types_and_params):
                    state_types_and_params.append((dependency, dict()))

        for state_type, _ in state_types_and_params:
            default_kwargs = inspect.signature(state_type.__init__).parameters
            state_init_default_kwargs[state_type] = {
                kwarg: val.default
                for kwarg, val in default_kwargs.items()
                if kwarg != "self" and val.default != inspect._empty
            }

    # Iterate over all models and sanity check each one, making sure they satisfy all the requested @abilities
    valid_models = []

    def supports_abilities(info, obj_prim):
        for ability, states_and_params in info.items():
            # Check ability requirements
            for requirement in get_requirements_for_ability(ability):
                if not requirement.is_compatible_asset(prim=obj_prim)[0]:
                    return False

            # Check all link states
            for state_type, params in states_and_params:
                kwargs = deepcopy(state_init_default_kwargs[state_type])
                kwargs.update(params)
                if not state_type.is_compatible_asset(prim=obj_prim, **kwargs)[0]:
                    return False
        return True

    for model in all_models:
        usd_path = DatasetObject.get_usd_path(category=category, model=model)
        usd_path = usd_path.replace(".usd", ".encrypted.usd")
        with decrypted(usd_path) as fpath:
            stage = lazy.pxr.Usd.Stage.Open(fpath)
            prim = stage.GetDefaultPrim()
            if supports_abilities(abilities_info, prim):
                valid_models.append(model)

    return valid_models

get_all_object_models()

Get OmniGibson all object models

Returns:

Type	Description
list	all object model paths

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_all_object_models():
    """
    Get OmniGibson all object models

    Returns:
        list: all object model paths
    """
    return sorted({str(x) for x in Path(gm.DATA_PATH).glob("*/objects/*/*") if x.is_dir() and not is_dot_file(x.name)})

get_all_system_categories(include_cloth=False)

Get OmniGibson all system categories

Parameters:

Name	Type	Description	Default
include_cloth	bool	whether to include cloth category; default to only include non-cloth particle systems	False

Returns:

Type	Description
list	all system categories

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_all_system_categories(include_cloth=False):
    """
    Get OmniGibson all system categories

    Args:
        include_cloth (bool): whether to include cloth category; default to only include non-cloth particle systems

    Returns:
        list: all system categories
    """
    behavior_1k_assets_path = get_dataset_path("behavior-1k-assets")
    categories_path = os.path.join(behavior_1k_assets_path, "systems")

    categories = [f for f in os.listdir(categories_path) if not is_dot_file(f)]
    if include_cloth:
        categories.append("cloth")
    return sorted(categories)

get_attachment_meta_links(category, model)

Get attachment meta links for an object model

Parameters:

Name	Type	Description	Default
category	str	Object category name	required
model	str	Object model name	required

Returns:

Type	Description
list of str	all attachment meta links for the object model

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_attachment_meta_links(category, model):
    """
    Get attachment meta links for an object model

    Args:
        category (str): Object category name
        model (str): Object model name

    Returns:
        list of str: all attachment meta links for the object model
    """
    # Avoid circular imports
    from omnigibson.object_states import AttachedTo
    from omnigibson.objects.dataset_object import DatasetObject

    usd_path = DatasetObject.get_usd_path(category=category, model=model)
    usd_path = usd_path.replace(".usd", ".encrypted.usd")
    with decrypted(usd_path) as fpath:
        stage = lazy.pxr.Usd.Stage.Open(fpath)
        prim = stage.GetDefaultPrim()
        attachment_meta_links = []
        for child in prim.GetChildren():
            if child.GetTypeName() == "Xform":
                if any(meta_link_type in child.GetName() for meta_link_type in AttachedTo.meta_link_types):
                    attachment_meta_links.append(child.GetName())
        return attachment_meta_links

get_available_behavior_1k_scenes()

OmniGibson interactive scenes

Returns:

Type	Description
list	Available OmniGibson interactive scenes

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_available_behavior_1k_scenes():
    """
    OmniGibson interactive scenes

    Returns:
        list: Available OmniGibson interactive scenes
    """
    behavior_1k_assets_path = get_dataset_path("behavior-1k-assets")
    behavior_1k_scenes_path = os.path.join(behavior_1k_assets_path, "scenes")
    available_behavior_1k_scenes = sorted(
        [f for f in os.listdir(behavior_1k_scenes_path) if (not is_dot_file(f) and f != "background")]
    )
    return available_behavior_1k_scenes

get_avg_category_specs()

Load average object specs (dimension and mass) for objects

Returns:

Type	Description
dict	Average category specifications for all object categories

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_avg_category_specs():
    """
    Load average object specs (dimension and mass) for objects

    Returns:
        dict: Average category specifications for all object categories
    """
    avg_obj_dim_file = os.path.join(og.example_config_path, "avg_category_specs.json")
    if os.path.exists(avg_obj_dim_file):
        with open(avg_obj_dim_file) as f:
            return json.load(f)
    else:
        log.warning(
            "Requested average specs of the object categories in the BEHAVIOR-1K Dataset of objects, but the "
            "file cannot be found. Did you download the dataset? Returning an empty dictionary"
        )
        return dict()

get_behavior_1k_assets_version()

Returns:

Type	Description
str	BEHAVIOR-1K dataset version

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_behavior_1k_assets_version():
    """
    Returns:
        str: BEHAVIOR-1K dataset version
    """
    try:
        return (Path(get_dataset_path("behavior-1k-assets")) / "VERSION").read_text().strip()
    except FileNotFoundError:
        return None

get_behavior_1k_category_ids()

Get OmniGibson object categories

Returns:

Type	Description
str	file path to the scene name

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_behavior_1k_category_ids():
    """
    Get OmniGibson object categories

    Returns:
        str: file path to the scene name
    """
    behavior_1k_assets_path = get_dataset_path("behavior-1k-assets")
    categories_files = os.path.join(behavior_1k_assets_path, "metadata", "categories.txt")
    name_to_id = {}
    with open(categories_files, "r") as fp:
        for i, l in enumerate(fp.readlines()):
            name_to_id[l.rstrip()] = i
    return defaultdict(lambda: 255, name_to_id)

get_category_path(category_name, dataset_name='behavior-1k-assets')

Get OmniGibson object category path

Parameters:

Name	Type	Description	Default
category_name	str	object category	required

Returns:

Type	Description
str	file path to the object category

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_category_path(category_name, dataset_name="behavior-1k-assets"):
    """
    Get OmniGibson object category path

    Args:
        category_name (str): object category

    Returns:
        str: file path to the object category
    """
    dataset_path = get_dataset_path(dataset_name)
    categories_path = os.path.join(dataset_path, "objects")
    assert category_name in os.listdir(categories_path), "Category {} does not exist".format(category_name)
    return os.path.join(categories_path, category_name)

get_model_path(category_name, model_name, dataset_name='behavior-1k-assets')

Get OmniGibson object model path

Parameters:

Name	Type	Description	Default
category_name	str	object category	required
model_name	str	object model	required

Returns:

Type	Description
str	file path to the object model

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_model_path(category_name, model_name, dataset_name="behavior-1k-assets"):
    """
    Get OmniGibson object model path

    Args:
        category_name (str): object category
        model_name (str): object model

    Returns:
        str: file path to the object model
    """
    category_path = get_category_path(category_name, dataset_name=dataset_name)
    assert model_name in os.listdir(category_path), "Model {} from category {} in dataset {} does not exist".format(
        model_name, category_name, dataset_name
    )
    return os.path.join(category_path, model_name)

get_omnigibson_git_hash()

Returns:

Type	Description
str	OmniGibson commit hash

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_omnigibson_git_hash():
    """
    Returns:
        str: OmniGibson commit hash
    """
    try:
        git_hash = subprocess.check_output(
            ["git", "-C", Path(og.__file__).parent, "rev-parse", "HEAD"], shell=False, stderr=subprocess.DEVNULL
        )
        return git_hash.decode("utf-8").strip()
    except subprocess.CalledProcessError:
        return None

get_omnigibson_robot_asset_version()

Returns:

Type	Description
str	OmniGibson assets version

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_omnigibson_robot_asset_version():
    """
    Returns:
        str: OmniGibson assets version
    """
    try:
        return (Path(get_dataset_path("omnigibson-robot-assets")) / "VERSION").read_text().strip()
    except FileNotFoundError:
        return None

get_scene_path(scene_name, dataset_name='behavior-1k-assets')

Get OmniGibson scene path

Parameters:

Name	Type	Description	Default
scene_name	str	scene name, e.g., "Rs_int"	required

Returns:

Type	Description
str	file path to the scene name

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_scene_path(scene_name, dataset_name="behavior-1k-assets"):
    """
    Get OmniGibson scene path

    Args:
        scene_name (str): scene name, e.g., "Rs_int"

    Returns:
        str: file path to the scene name
    """
    dataset_path = get_dataset_path(dataset_name)
    scenes_path = os.path.join(dataset_path, "scenes")
    log.info("Scene name: {}".format(scene_name))
    assert scene_name in os.listdir(scenes_path), "Scene {} does not exist".format(scene_name)
    return os.path.join(scenes_path, scene_name)

get_task_instance_path(scene_name, instance_name, mode='train')

Get task instance path

Parameters:

Name	Type	Description	Default
scene_name	str	scene name, e.g., "Rs_int"	required
instance_name	str	instance name, e.g., "house_double_floor_lower_task_turning_on_radio_0_0_template"	required
mode	str	Instance split to load. One of "train", "public_test", or "hidden_test".	'train'

Returns:

Type	Description
str	file path to the scene name

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_task_instance_path(scene_name, instance_name, mode="train"):
    """
    Get task instance path

    Args:
        scene_name (str): scene name, e.g., "Rs_int"
        instance_name (str): instance name, e.g., "house_double_floor_lower_task_turning_on_radio_0_0_template"
        mode (str): Instance split to load. One of "train", "public_test", or "hidden_test".

    Returns:
        str: file path to the scene name
    """
    mode_to_dir = {
        "train": "scenes",
        "public_test": os.path.join("scene_test", "public"),
        "hidden_test": os.path.join("scene_test", "private"),
    }
    assert mode in mode_to_dir, f"Invalid task instance mode: {mode}"
    task_instances_path_2026 = os.path.join(
        gm.DATA_PATH, "2026-challenge-task-instances", mode_to_dir[mode], scene_name, "json", f"{instance_name}.json"
    )
    return task_instances_path_2026 if os.path.exists(task_instances_path_2026) else None

get_texture_file(mesh_file)

Get texture file

Parameters:

Name	Type	Description	Default
mesh_file	str	path to mesh obj file	required

Returns:

Type	Description
str	texture file path

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def get_texture_file(mesh_file):
    """
    Get texture file

    Args:
        mesh_file (str): path to mesh obj file

    Returns:
        str: texture file path
    """
    model_dir = os.path.dirname(mesh_file)
    with open(mesh_file, "r") as f:
        lines = [line.strip() for line in f.readlines() if "mtllib" in line]
        if len(lines) == 0:
            return
        mtl_file = lines[0].split()[1]
        mtl_file = os.path.join(model_dir, mtl_file)

    with open(mtl_file, "r") as f:
        lines = [line.strip() for line in f.readlines() if "map_Kd" in line]
        if len(lines) == 0:
            return
        texture_file = lines[0].split()[1]
        texture_file = os.path.join(model_dir, texture_file)

    return texture_file

is_dot_file(p)

Check if a filename starts with a dot. Note that while this does not actually correspond to checking for hidden files on Windows, the files we want to ignore will still start with a dot and thus this works.

Returns:

Type	Description
bool	true if a folder is hidden in the OS

Source code in OmniGibson/omnigibson/utils/asset_utils.py

def is_dot_file(p):
    """
    Check if a filename starts with a dot.
    Note that while this does not actually correspond to checking for hidden files on Windows, the
    files we want to ignore will still start with a dot and thus this works.

    Returns:
        bool: true if a folder is hidden in the OS
    """
    return p.startswith(".")