Datasets:

pe-nlp

/

ov-kit-files-filtered-dedup-py

like 0

Follow

PE-NLP 14

ashleygoldstein/LWM-Warehouse-Scene/Scripts/pallet_collision.py

from omni.kit.scripting import BehaviorScript import omni import omni.physx from pxr import Gf, Sdf, PhysxSchema, UsdGeom, Usd from omni.physx.scripts import utils from omni.physx import get_physx_scene_query_interface from omni.physx import get_physx_interface, get_physx_simulation_interface from omni.physx.scripts.physicsUtils import * import carb class CollisionTest(BehaviorScript): def on_init(self): self.ignore_objects = [] self.pallet_collection = 0 self.collected_attr = self.prim.CreateAttribute('Collected', Sdf.ValueTypeNames.Int) self.collected_attr.Set(0) self.reset_character() def on_play(self): '''' Called on runtime ''' self.reset_character() self._contact_report_sub = get_physx_simulation_interface().subscribe_contact_report_events(self._on_contact_report_event) contactReportAPI = PhysxSchema.PhysxContactReportAPI.Apply(self.prim) contactReportAPI.CreateThresholdAttr().Set(self.contact_thresh) def on_stop(self): self.on_destroy() def on_destroy(self): self.pallet = None self.collected_attr.Set(0) self._contact_report_sub.unsubscribe() self._contact_report_sub = None def reset_character(self): self.contact_thresh = 1 self.collected_attr.Set(0) self.pallet_collection = 0 self.ignore_objects = [] # Assign this pallet as agent instance self.pallet = str(self.prim_path) # parent_prim = self.stage.GetPrimAtPath(self.package_path) # if parent_prim.IsValid(): # children = parent_prim.GetAllChildren() # self.package = [str(child.GetPath()) for child in children] def on_update(self, current_time: float, delta_time: float): """ Called on every update. Initializes character at start, publishes character positions and executes character commands. :param float current_time: current time in seconds. :param float delta_time: time elapsed since last update. """ return def subscribe_to_contact(self): # apply contact report ### This would be an example of each object managing their own collision self._contact_report_sub = get_physx_simulation_interface().subscribe_contact_report_events(self._on_contact_report_event) contactReportAPI = PhysxSchema.PhysxContactReportAPI.Apply(self.prim) contactReportAPI.CreateThresholdAttr().Set(self.contact_thresh) def _on_contact_report_event(self, contact_headers, contact_data): # Check if a collision was because of a player for contact_header in contact_headers: collider_1 = str(PhysicsSchemaTools.intToSdfPath(contact_header.actor0)) collider_2 = str(PhysicsSchemaTools.intToSdfPath(contact_header.actor1)) contacts = [collider_1, collider_2] if self.prim_path in contacts: self.object_path = "" if self.prim_path == collider_1: self.object_path = collider_2 else: self.object_path = collider_1 print(collider_2) if self.object_path in self.ignore_objects: continue else: self.ignore_objects.append(self.object_path) self.pallet_collection += 1 print(f'Collected: {self.pallet_collection}') self.collected_attr.Set(self.pallet_collection)

Python

Vadim-Karpenko/omniverse-material-manager-extended/tools/scripts/link_app.py

import os import argparse import sys import json import packmanapi import urllib3 def find_omniverse_apps(): http = urllib3.PoolManager() try: r = http.request("GET", "http://127.0.0.1:33480/components") except Exception as e: print(f"Failed retrieving apps from an Omniverse Launcher, maybe it is not installed?\nError: {e}") sys.exit(1) apps = {} for x in json.loads(r.data.decode("utf-8")): latest = x.get("installedVersions", {}).get("latest", "") if latest: for s in x.get("settings", []): if s.get("version", "") == latest: root = s.get("launch", {}).get("root", "") apps[x["slug"]] = (x["name"], root) break return apps def create_link(src, dst): print(f"Creating a link '{src}' -> '{dst}'") packmanapi.link(src, dst) APP_PRIORITIES = ["code", "create", "view"] if __name__ == "__main__": parser = argparse.ArgumentParser(description="Create folder link to Kit App installed from Omniverse Launcher") parser.add_argument( "--path", help="Path to Kit App installed from Omniverse Launcher, e.g.: 'C:/Users/bob/AppData/Local/ov/pkg/create-2021.3.4'", required=False, ) parser.add_argument( "--app", help="Name of Kit App installed from Omniverse Launcher, e.g.: 'code', 'create'", required=False ) args = parser.parse_args() path = args.path if not path: print("Path is not specified, looking for Omniverse Apps...") apps = find_omniverse_apps() if len(apps) == 0: print( "Can't find any Omniverse Apps. Use Omniverse Launcher to install one. 'Code' is the recommended app for developers." ) sys.exit(0) print("\nFound following Omniverse Apps:") for i, slug in enumerate(apps): name, root = apps[slug] print(f"{i}: {name} ({slug}) at: '{root}'") if args.app: selected_app = args.app.lower() if selected_app not in apps: choices = ", ".join(apps.keys()) print(f"Passed app: '{selected_app}' is not found. Specify one of the following found Apps: {choices}") sys.exit(0) else: selected_app = next((x for x in APP_PRIORITIES if x in apps), None) if not selected_app: selected_app = next(iter(apps)) print(f"\nSelected app: {selected_app}") _, path = apps[selected_app] if not os.path.exists(path): print(f"Provided path doesn't exist: {path}") else: SCRIPT_ROOT = os.path.dirname(os.path.realpath(__file__)) create_link(f"{SCRIPT_ROOT}/../../app", path) print("Success!")

Python

Vadim-Karpenko/omniverse-material-manager-extended/tools/packman/bootstrap/install_package.py

# Copyright 2019 NVIDIA CORPORATION # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import logging import zipfile import tempfile import sys import shutil __author__ = "hfannar" logging.basicConfig(level=logging.WARNING, format="%(message)s") logger = logging.getLogger("install_package") class TemporaryDirectory: def __init__(self): self.path = None def __enter__(self): self.path = tempfile.mkdtemp() return self.path def __exit__(self, type, value, traceback): # Remove temporary data created shutil.rmtree(self.path) def install_package(package_src_path, package_dst_path): with zipfile.ZipFile( package_src_path, allowZip64=True ) as zip_file, TemporaryDirectory() as temp_dir: zip_file.extractall(temp_dir) # Recursively copy (temp_dir will be automatically cleaned up on exit) try: # Recursive copy is needed because both package name and version folder could be missing in # target directory: shutil.copytree(temp_dir, package_dst_path) except OSError as exc: logger.warning( "Directory %s already present, packaged installation aborted" % package_dst_path ) else: logger.info("Package successfully installed to %s" % package_dst_path) install_package(sys.argv[1], sys.argv[2])

Python

Vadim-Karpenko/omniverse-material-manager-extended/exts/karpenko.materialsmanager.ext/karpenko/materialsmanager/ext/prim_serializer.py

# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. # # NVIDIA CORPORATION and its licensors retain all intellectual property # and proprietary rights in and to this software, related documentation # and any modifications thereto. Any use, reproduction, disclosure or # distribution of this software and related documentation without an express # license agreement from NVIDIA CORPORATION is strictly prohibited. # __all__ = ["update_property_paths", "get_prim_as_text", "text_to_stage"] from omni.kit.commands import execute from pxr import Sdf from pxr import Tf from pxr import Usd from typing import List from typing import Optional def _to_layer(text: str) -> Optional[Sdf.Layer]: """Create an sdf layer from the given text""" if not text.startswith("#usda 1.0\n"): text = "#usda 1.0\n" + text anonymous_layer = Sdf.Layer.CreateAnonymous("clipboard.usda") try: if not anonymous_layer.ImportFromString(text): return except Tf.ErrorException: return return anonymous_layer def update_property_paths(prim_spec, old_path, new_path): if not prim_spec: return for rel in prim_spec.relationships: rel.targetPathList.explicitItems = [path.ReplacePrefix(old_path, new_path) for path in rel.targetPathList.explicitItems] for attr in prim_spec.attributes: attr.connectionPathList.explicitItems = [path.ReplacePrefix(old_path, new_path) for path in attr.connectionPathList.explicitItems] for child in prim_spec.nameChildren: update_property_paths(child, old_path, new_path) def get_prim_as_text(stage: Usd.Stage, prim_paths: List[Sdf.Path]) -> Optional[str]: """Generate a text from the stage and prim path""" if not prim_paths: return # TODO: It can be slow in large scenes. Ideally we need to flatten specific prims. flatten_layer = stage.Flatten() anonymous_layer = Sdf.Layer.CreateAnonymous(prim_paths[0].name + ".usda") paths_map = {} for i in range(0, len(prim_paths)): item_name = str.format("Item_{:02d}", i) Sdf.PrimSpec(anonymous_layer, item_name, Sdf.SpecifierDef) prim_path = prim_paths[i] anonymous_path = Sdf.Path.absoluteRootPath.AppendChild(item_name).AppendChild(prim_path.name) # Copy Sdf.CopySpec(flatten_layer, prim_path, anonymous_layer, anonymous_path) paths_map[prim_path] = anonymous_path for prim in anonymous_layer.rootPrims: for source_path, target_path in paths_map.items(): update_property_paths(prim, source_path, target_path) return anonymous_layer.ExportToString() def text_to_stage(stage: Usd.Stage, text: str, root: Sdf.Path = Sdf.Path.absoluteRootPath) -> bool: """ Convert the given text to the prim and place it to the stage under the given root. """ source_layer = _to_layer(text) if not source_layer: return False execute("ImportLayer", layer=source_layer, stage=stage, root=root) return True

Python

Vadim-Karpenko/omniverse-material-manager-extended/exts/karpenko.materialsmanager.ext/karpenko/materialsmanager/ext/style.py

# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. # # NVIDIA CORPORATION and its licensors retain all intellectual property # and proprietary rights in and to this software, related documentation # and any modifications thereto. Any use, reproduction, disclosure or # distribution of this software and related documentation without an express # license agreement from NVIDIA CORPORATION is strictly prohibited. # __all__ = ["materialsmanager_window_style"] import omni.kit.app import omni.ui as ui import pathlib from omni.ui import color as cl EXTENSION_FOLDER_PATH = pathlib.Path( omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__) ) # The main style dict materialsmanager_window_style = { "Image::material_preview": { "image_url": f"{EXTENSION_FOLDER_PATH}/data/icons/[email protected]", }, "Label::main_label": { "alignment": ui.Alignment.LEFT_CENTER, "color": cl("#a1a1a1"), "font_size": 24, }, "Label::main_hint": { "alignment": ui.Alignment.CENTER, "margin_height": 1, "margin_width": 10, "font_size": 16, }, "Label::main_hint_small": { "alignment": ui.Alignment.CENTER, "color": cl("#a1a1a1"), }, "Label::material_name": { "alignment": ui.Alignment.LEFT_CENTER, "font_size": 14, }, "Label::secondary_label": { "alignment": ui.Alignment.LEFT_CENTER, "color": cl("#a1a1a1"), "font_size": 18, }, "Label::material_counter": { "alignment": ui.Alignment.CENTER, "margin_height": 1, "margin_width": 10, "font_size": 14, }, } # The style dict for the viewport widget ui viewport_widget_style = { "Button.Label": { "font_size": 30, }, "Button.Label:disabled": { "color": cl("#a1a1a1") }, "Button:disabled": { "background_color": cl("#4d4d4d"), }, "Button": { "alignment": ui.Alignment.BOTTOM, "background_color": cl("#666666"), }, "Label::name_label": { "alignment": ui.Alignment.CENTER_BOTTOM, "font_size": 34, } }

Python

Vadim-Karpenko/omniverse-material-manager-extended/exts/karpenko.materialsmanager.ext/karpenko/materialsmanager/ext/extension.py

import asyncio import base64 import json import math import carb import omni.ext import omni.kit.commands import omni.ui as ui import omni.usd from omni.kit.viewport.utility import (get_active_viewport_camera_path, get_active_viewport_window, get_ui_position_for_prim) from pxr import Sdf from .prim_serializer import get_prim_as_text, text_to_stage from .style import materialsmanager_window_style as _style from .viewport_ui.widget_info_scene import WidgetInfoScene class MaterialManagerExtended(omni.ext.IExt): WINDOW_NAME = "Material Manager Extended" SCENE_SETTINGS_WINDOW_NAME = "Material Manager Settings" MENU_PATH = "Window/" + WINDOW_NAME def on_startup(self, ext_id): print("[karpenko.materialsmanager.ext] MaterialManagerExtended startup") self._usd_context = omni.usd.get_context() self._selection = self._usd_context.get_selection() self.latest_selected_prim = None self.variants_frame_original = None self.variants_frame = None self.active_objects_frame = None self._window = None self._window_scenemanager = None self.materials_frame = None self.main_frame = None self.ignore_change = False self.ignore_settings_update = False self.roaming_timer = None self.ext_id = ext_id self._widget_info_viewport = None self.current_ui = "default" self.is_settings_open = False self.ignore_next_select = False self.last_roaming_prim = None self.reticle = None self.stage = self._usd_context.get_stage() self.allowed_commands = [ "SelectPrimsCommand", "SelectPrims", "CreatePrimCommand", "DeletePrims", "TransformPrimCommand", "Undo", "BindMaterial", "BindMaterialCommand", "MovePrims", "MovePrim", ] self.is_settings_window_open = False self.render_default_layout() # show the window in the usual way if the stage is loaded if self.stage: self._window.deferred_dock_in("Property") else: # otherwise, show the window after the stage is loaded self._setup_window_task = asyncio.ensure_future(self._dock_window()) omni.kit.commands.subscribe_on_change(self.on_change) self.roaming_timer = asyncio.ensure_future(self.enable_roaming_timer()) def on_shutdown(self): """ This function is called when the addon is disabled """ omni.kit.commands.unsubscribe_on_change(self.on_change) if self.roaming_timer: self.disable_roaming_timer() # Deregister the function that shows the window from omni.ui ui.Workspace.set_show_window_fn(self.WINDOW_NAME, None) if self._window: self._window.destroy() self._window = None self._selection = None self._usd_context = None self.latest_selected_prim = None self.variants_frame_original = None self.variants_frame = None self.materials_frame = None self.main_frame = None if self._widget_info_viewport: self._widget_info_viewport.destroy() self._widget_info_viewport = None if self.reticle: self.reticle.destroy() self.reticle = None print("[karpenko.materialsmanager.ext] MaterialManagerExtended shutdown") async def _dock_window(self): """ It waits for the property window to appear, then docks the window to it """ property_win = None frames = 3 while frames > 0: if not property_win: property_win = ui.Workspace.get_window("Property") if property_win: break # early out frames = frames - 1 await omni.kit.app.get_app().next_update_async() # Dock to property window after 5 frames. It's enough for window to appear. for _ in range(5): await omni.kit.app.get_app().next_update_async() if property_win: self._window.deferred_dock_in("Property") self._setup_window_task = None async def enable_roaming_timer(self): while True: await asyncio.sleep(1.0) self.get_closest_mme_object() def disable_roaming_timer(self): self.roaming_timer = None def get_latest_version(self, looks): """ It takes a list of looks, and returns the next available version number :param looks: The parent folder of the looks :return: The latest version of the look. """ latest_version = 1 versions = [] for look in looks.GetChildren(): look_path = look.GetPath() if look_path.name.startswith("Look_"): version = int(look_path.name.split("_")[-1]) versions.append(version) versions.sort() for version in versions: if version != latest_version: return latest_version else: latest_version += 1 return latest_version def add_variant(self, looks, parent_prim): """ It creates a new folder under the Looks folder, copies all materials attached to the meshes and re-binds them so the user can tweak copies instead of the original ones. :param looks: The looks folder :param parent_prim: The prim that contains the meshes that need to be assigned the new materials """ looks = parent_prim.GetPrimAtPath("Looks") looks_path = looks.GetPath() self.ignore_change = True # group all commands so it can be undone at once with omni.kit.undo.group(): all_meshes = self.get_meshes_from_prim(parent_prim) all_materials = self.get_data_from_meshes(all_meshes) # Check if folder (prim, Scope) MME already exist if not looks.GetPrimAtPath("MME"): # Create a folder called MME under the looks folder, it will contain all the materials for all variants omni.kit.commands.execute( "CreatePrim", prim_path=f"{looks_path}/MME", prim_type="Scope", attributes={}, select_new_prim=False ) is_active_attr_path = Sdf.Path(f"{looks_path}/MME.MMEisActive") omni.kit.commands.execute( 'CreateUsdAttributeOnPath', attr_path=is_active_attr_path, attr_type=Sdf.ValueTypeNames.Bool, custom=True, attr_value=False, variability=Sdf.VariabilityVarying ) self.set_mesh_data(all_materials, looks_path, None) # Generate a new name for the variant based on the quantity of previous ones folder_name = f"Look_{self.get_latest_version(looks.GetPrimAtPath('MME'))}" # Create a folder for the new variant omni.kit.commands.execute( "CreatePrim", prim_path=f"{looks_path}/MME/{folder_name}", prim_type="Scope", attributes={}, select_new_prim=False ) is_active_attr_path = Sdf.Path(f"{looks_path}/MME/{folder_name}.MMEisActive") omni.kit.commands.execute( 'CreateUsdAttributeOnPath', attr_path=is_active_attr_path, attr_type=Sdf.ValueTypeNames.Bool, custom=True, variability=Sdf.VariabilityVarying ) if folder_name is None: new_looks_folder = looks else: new_looks_folder = looks.GetPrimAtPath(f"MME/{folder_name}") new_looks_folder_path = new_looks_folder.GetPath() materials_to_copy = [mat_data["path"] for mat_data in all_materials] # remove duplicates materials_to_copy = list(set(materials_to_copy)) # Copy material's prim as text usd_code = get_prim_as_text(self.stage, materials_to_copy) # put the clone material into the scene text_to_stage(self.stage, usd_code, new_looks_folder_path) self.bind_materials(all_materials, new_looks_folder_path) self.set_mesh_data(all_materials, looks_path, folder_name) self.deactivate_all_variants(looks) # Set current variant as active omni.kit.commands.execute( 'ChangeProperty', prop_path=is_active_attr_path, value=True, prev=False, ) self.ignore_change = False if not self.ignore_settings_update: self.render_active_objects_frame() self.render_variants_frame(looks, parent_prim) def get_meshes_from_prim(self, parent_prim): """ It takes a parent prim and returns a list of all the meshes that are children of that prim :param parent_prim: The parent prim of the mesh you want to get :return: A list of all meshes in the scene. """ all_meshes = [] for mesh in self.get_all_children_of_prim(parent_prim): if mesh.GetTypeName() == "Mesh": all_meshes.append(mesh) return all_meshes def get_data_from_meshes(self, all_meshes): """ It loops through all passed meshes, gets the materials that are bound to them, and returns a list of dictionaries containing the material name, path, and the mesh it's bound to :param all_meshes: a list of all the meshes in the scene :return: A list of dictionaries. """ result = [] # loop through all meshes for mesh_data in all_meshes: # Get currently binded materials for the current mesh current_material_prims = mesh_data.GetRelationship('material:binding').GetTargets() # Loop through all binded materials paths for original_material_prim_path in current_material_prims: original_material_prim = self.stage.GetPrimAtPath(original_material_prim_path) if not original_material_prim: continue result.append({ "name": original_material_prim.GetName(), "path": original_material_prim_path, "mesh": mesh_data.GetPath(), }) return result def bind_materials(self, all_materials, variant_folder_path): """ Look through all the materials and bind them to the meshes. If variant_folder_path is empty, then just binds passed materials. If not, looks for the materials in the variant folder and binds them instead using all_materials as a reference. :param all_materials: A list of dictionaries containing the material path and the mesh path :param variant_folder_path: The path to the variant folder """ # Check if there is a variant folder where new materials are stored if variant_folder_path: variant_materials_prim = self.stage.GetPrimAtPath(variant_folder_path) with omni.kit.undo.group(): # loop through all passed materials for mat_data in all_materials: if variant_folder_path and variant_materials_prim: # loop throug all materials in the variant folder for var_mat in variant_materials_prim.GetChildren(): # If found material matches with the one in the all_materials list, bind it to the mesh if var_mat.GetName() == str(mat_data["path"]).split("/")[-1]: omni.kit.commands.execute( "BindMaterialCommand", prim_path=mat_data["mesh"], material_path=var_mat.GetPath(), strength=['weakerThanDescendants'] ) break else: if mat_data["mesh"] and mat_data["path"]: # If there's no variant folder, then just bind passed material to the mesh omni.kit.commands.execute( 'BindMaterialCommand', material_path=mat_data["path"], prim_path=mat_data["mesh"], strength=['weakerThanDescendants'] ) def deactivate_all_variants(self, looks): """ It deactivates all variants in a given looks prim :param looks: The looks prim """ looks_path = looks.GetPath() mme_folder = looks.GetPrimAtPath("MME") # Check if mme folder exists if mme_folder: # MMEisActive also present in MME folder, so we need to set it to False as well. mme_folder_prop_path = Sdf.Path(f"{looks_path}/MME.MMEisActive") mme_is_active = self.stage.GetAttributeAtPath(mme_folder_prop_path).Get() if mme_is_active: omni.kit.commands.execute( 'ChangeProperty', prop_path=mme_folder_prop_path, value=False, prev=True, ) # Loop through all variants in the MME folder and deactivate them for look in mme_folder.GetChildren(): p_type = look.GetTypeName() if p_type == "Scope": look_is_active_path = Sdf.Path(f"{looks_path}/MME/{look.GetName()}.MMEisActive") look_is_active = self.stage.GetAttributeAtPath(look_is_active_path).Get() if look_is_active: omni.kit.commands.execute( 'ChangeProperty', prop_path=look_is_active_path, value=False, prev=True, ) def get_parent_from_mesh(self, mesh_prim): """ It takes a mesh prim as an argument and returns the first Xform prim it finds in the prim's ancestry :param mesh_prim: The mesh prim you want to get the parent of :return: The parent of the mesh_prim. """ parent_prim = mesh_prim.GetParent() default_prim = self.stage.GetDefaultPrim() if not default_prim: return default_prim_name = default_prim.GetName() rootname = f"/{default_prim_name}" while True: if parent_prim is None or parent_prim.IsPseudoRoot(): return parent_prim if str(parent_prim.GetPath()) == "/" or str(parent_prim.GetPath()) == rootname: return None if parent_prim.GetPrimAtPath("Looks") and str(parent_prim.GetPath()) != rootname: return parent_prim parent_prim = parent_prim.GetParent() return parent_prim def get_looks_folder(self, parent_prim): """ If the parent_prim has a child prim named "Looks", return that found prim. Otherwise, return None :param parent_prim: The parent prim of the looks folder :return: The looks folder if it exists, otherwise None. """ if not parent_prim: return None looks_folder = parent_prim.GetPrimAtPath("Looks") return looks_folder if looks_folder else None def check_if_original_active(self, mme_folder): """ If the folder has an attribute called "MMEisActive" and it's value is True, return the folder and True. Otherwise, return the folder and False :param mme_folder: The folder that contains the MME data :return: the mme_folder and a boolean value. """ if mme_folder: mme_is_active_attr = mme_folder.GetAttribute("MMEisActive") if mme_is_active_attr and mme_is_active_attr.Get(): return mme_folder, True return mme_folder, False def get_currently_active_folder(self, looks): """ It looks for a folder called "MME" in the "Looks" folder, and if it finds it, it search for a folder inside with an attribute MMEisActive set to True and returns it if it finds one. If it doesn't find one, it returns None. :param looks: The looks node :return: The currently active folder. """ mme_folder = looks.GetPrimAtPath("MME") if mme_folder: if mme_folder.GetTypeName() == "Scope": for look in mme_folder.GetChildren(): if look.GetTypeName() == "Scope": is_active_attr = look.GetAttribute("MMEisActive") if is_active_attr and is_active_attr.Get(): return look return None def update_material_data(self, latest_action): """ It updates the material data in the looks folder when a material is changed using data from the latest action. All data is converted into string and encrypted into base64 to prevent it from being seen or modified by the user. :param latest_action: The latest action that was performed in the scene :return: The return value is a list of dictionaries. """ if "prim_path" not in latest_action.kwargs or "material_path" not in latest_action.kwargs: return prim_path = latest_action.kwargs["prim_path"] if not prim_path: return if type(prim_path) == list: prim_path = prim_path[0] new_material_path = latest_action.kwargs["material_path"] if not new_material_path: return if type(new_material_path) == list: new_material_path = new_material_path[0] parent_mesh = self.get_parent_from_mesh(self.stage.GetPrimAtPath(prim_path)) looks = self.get_looks_folder(parent_mesh) if looks: looks_path = looks.GetPath() mme_folder, is_original_active = self.check_if_original_active(looks.GetPrimAtPath("MME")) if is_original_active: folder_name = None else: active_folder = self.get_currently_active_folder(looks) if not active_folder: return folder_name = active_folder.GetName() mesh_data = self.get_mesh_data(looks_path, folder_name) mesh_data_to_update = [] previous_mats = [] unique_mats = [] mesh_mats = {} if mesh_data: for mat_data in mesh_data: material_prim = self.stage.GetPrimAtPath(new_material_path) mat_name = material_prim.GetName() if mat_data["mesh"] == prim_path and mat_data["path"] != new_material_path: carb.log_warn("Material changes detected. Updating material data...") if mat_data["path"] in previous_mats: unique_mats.append(mat_data["path"]) mesh_mats[mat_name] = True else: mesh_mats[mat_name] = False previous_mats.append(mat_data["path"]) mat_data["path"] = new_material_path mesh_data_to_update.append(mat_data) else: mesh_mats[mat_name] = False if not is_original_active and folder_name: active_folder_path = active_folder.GetPath() # Copy material's prim as text usd_code = get_prim_as_text( self.stage, [Sdf.Path(i["path"]) for i in mesh_data if i["path"] not in unique_mats] ) mats_to_delete = [i.GetPath() for i in active_folder.GetChildren() if str(i.GetPath()) not in unique_mats and not mesh_mats.get(i.GetName(), False)] if mats_to_delete: omni.kit.commands.execute( 'DeletePrims', paths=mats_to_delete, ) # put the clone material into the scene text_to_stage(self.stage, usd_code, active_folder_path) self.ignore_change = True self.bind_materials(mesh_data_to_update, active_folder_path) self.ignore_change = False self.set_mesh_data(mesh_data, looks_path, folder_name) self.render_current_materials_frame(parent_mesh) def on_change(self): """ Everytime the user changes the scene, this method is called. Method does the following: It checks if the user has changed the material, and if so, it updates the material data in the apropriate variant folder or save it into the MME folder if the variant is set to \"original\". It checks if the selected object has a material, and if it does, it renders a new window with the material's properties of the selected object. If the selected object doesn't have a material, it renders a new window with a prompt to select an object with a material. :return: None """ if not self.stage: self._usd_context = omni.usd.get_context() self._selection = self._usd_context.get_selection() self.stage = self._usd_context.get_stage() # Get history of commands current_history = reversed(omni.kit.undo.get_history().values()) # Get the latest one try: latest_action = next(current_history) except StopIteration: return if latest_action.name == "ChangePrimVarCommand" and latest_action.level == 1: latest_action = next(current_history) if self.ignore_next_select and latest_action.name == "SelectPrimsCommand": self.ignore_next_select = False omni.kit.commands.execute('Undo') else: self.ignore_next_select = False if latest_action.name not in self.allowed_commands: return # To skip the changes made by the addon if self.ignore_change: return show_default_layout = True if latest_action.name in ["BindMaterial", "BindMaterialCommand"]: self.update_material_data(latest_action) return # Get the top-level prim (World) default_prim = self.stage.GetDefaultPrim() if not default_prim: return default_prim_name = default_prim.GetName() rootname = f"/{default_prim_name}" # Get currently selected prim paths = self._selection.get_selected_prim_paths() if paths: # Get path of the first selected prim base_path = paths[0] if len(paths) > 0 else None base_path = Sdf.Path(base_path) if base_path else None if base_path: # Skip if the prim is the root of the stage to avoid unwanted errors if base_path == rootname: return # Skip if this object was already selected previously. Protection from infinite loop. if base_path == self.latest_selected_prim: return # Save the path of the currently selected prim for the next iteration self.latest_selected_prim = base_path # Get prim from path prim = self.stage.GetPrimAtPath(base_path) if prim: p_type = prim.GetTypeName() # This is needed to successfully get the prim even if it's child was selected if p_type == "Mesh" or p_type == "Scope" or p_type == "Material": prim = self.get_parent_from_mesh(prim) elif p_type == "Xform": # Current prim is already parental one, so we don't need to do anything. pass else: # In case if something unexpected is selected, we just return None carb.log_warn(f"Selected {prim} does not has any materials or has invalid type.") return if not prim: self.render_scenelevel_frame() return if prim.GetPrimAtPath("Looks") and prim != self.latest_selected_prim: # Save the type of the rendered window self.current_ui = "object" # Render new window for the selected prim self.render_objectlevel_frame(prim) if not self.ignore_settings_update: self.render_active_objects_frame() show_default_layout = False if show_default_layout and self.current_ui != "default": self.current_ui = "default" self.render_scenelevel_frame() if not self.ignore_settings_update: self.render_active_objects_frame() self.latest_selected_prim = None def _get_looks(self, path): """ It gets the prim at the path, checks if it's a mesh, scope, or material, and if it is, it gets the parent prim. If it's an xform, it does nothing. If it's something else, it returns None :param path: The path to the prim you want to get the looks from :return: The prim and the looks. """ prim = self.stage.GetPrimAtPath(path) p_type = prim.GetTypeName() # User could select not the prim directly but sub-items of it, so we need to make sure in any scenario # we will get the parent prim. if p_type == "Mesh" or p_type == "Scope" or p_type == "Material": prim = self.get_parent_from_mesh(prim) elif p_type == "Xform": # Current prim is already parental one, so we don't need to do anything. pass else: # In case if something unexpected is selected, we just return None carb.log_error("No selected prim") return None, None # Get all looks (a.k.a. materials) looks = prim.GetPrimAtPath("Looks").GetChildren() # return a parental prim object and its looks return prim, looks def get_all_materials_variants(self, looks_prim): """ It returns a list of all the variants in the MME folder :param looks_prim: The prim that contains the MME folder :return: A list of all the variants in the MME folder. """ variants = [] mme_folder = looks_prim.GetPrimAtPath("MME") if mme_folder: for child in mme_folder.GetChildren(): if child.GetTypeName() == "Scope": variants.append(child) return variants def get_mesh_data(self, looks_path, folder_name): """ It gets the mesh data from the folder you pass as a parameter. It does decode it back from base64 and returns it as a dictionary. :param looks_path: The path to the looks prim :param folder_name: The name of the folder that contains the mesh data :return: A list of dictionaries. """ if folder_name: data_attr_path = Sdf.Path(f"{looks_path}/MME/{folder_name}.MMEMeshData") else: data_attr_path = Sdf.Path(f"{looks_path}/MME.MMEMeshData") data_attr = self.stage.GetAttributeAtPath(data_attr_path) if data_attr: attr_value = data_attr.Get() if attr_value: result = [] # decode base64 string and load json for item in attr_value: result.append(json.loads(base64.b64decode(item).decode("utf-8"))) return result def set_mesh_data(self, mesh_materials, looks_path, folder_name): """ It creates a custom attribute on a USD prim, and sets the value of that attribute to a list of base64 encoded JSON strings :param mesh_materials: A list of dictionaries containing the following keys: path, mesh :param looks_path: The path to the looks prim :param folder_name: The name of the folder that contains the mesh data """ # Convert every Path to string in mesh_materials to be able to pass it into JSON all_materials = [{ "path": str(mat_data["path"]), "mesh": str(mat_data["mesh"]), } for mat_data in mesh_materials] if folder_name: data_attr_path = Sdf.Path(f"{looks_path}/MME/{folder_name}.MMEMeshData") else: data_attr_path = Sdf.Path(f"{looks_path}/MME.MMEMeshData") omni.kit.commands.execute( 'CreateUsdAttributeOnPath', attr_path=data_attr_path, attr_type=Sdf.ValueTypeNames.StringArray, custom=True, variability=Sdf.VariabilityVarying, attr_value=[base64.b64encode(json.dumps(i).encode()) for i in all_materials], ) def delete_variant(self, prim_path, looks, parent_prim): """ It deletes the variant prim and then re-renders the variants frame :param prim_path: The path to the variant prim you want to delete :param looks: a list of all the looks in the current scene :param parent_prim: The prim path of the parent prim of the variant set """ omni.kit.commands.execute('DeletePrims', paths=[prim_path, ]) self.render_variants_frame(looks, parent_prim) def enable_variant(self, folder_name, looks, parent_prim, ignore_changes=True, ignore_select=False): """ It takes a folder name, a looks prim, and a parent prim, and then it activates the variant in the folder, binds the materials in the variant, and renders the variant and current materials frames :param folder_name: The name of the folder that contains the materials you want to enable :param looks: the looks prim :param parent_prim: The prim that contains the variant sets """ if ignore_changes: self.ignore_change = True if folder_name is None: new_looks_folder = looks.GetPrimAtPath("MME") else: new_looks_folder = looks.GetPrimAtPath(f"MME/{folder_name}") new_looks_folder_path = new_looks_folder.GetPath() all_materials = self.get_mesh_data(looks.GetPath(), folder_name) self.deactivate_all_variants(looks) is_active_attr_path = Sdf.Path(f"{new_looks_folder_path}.MMEisActive") omni.kit.commands.execute( 'ChangeProperty', prop_path=is_active_attr_path, value=True, prev=False, ) self.bind_materials(all_materials, None if folder_name is None else new_looks_folder_path) if ignore_select: self.ignore_next_select = True self.render_variants_frame(looks, parent_prim, ignore_widget=True) self.render_current_materials_frame(parent_prim) if ignore_changes: self.ignore_change = False def select_material(self, associated_mesh): """ It selects the material of the mesh that is currently selected in the viewport :param associated_mesh: The path to the mesh you want to select the material for """ if associated_mesh: mesh = self.stage.GetPrimAtPath(associated_mesh) if mesh: current_material_prims = mesh.GetRelationship('material:binding').GetTargets() if current_material_prims: omni.usd.get_context().get_selection().set_prim_path_selected( str(current_material_prims[0]), True, True, True, True) ui.Workspace.show_window("Property", True) property_window = ui.Workspace.get_window("Property") ui.WindowHandle.focus(property_window) def render_variants_frame(self, looks, parent_prim, ignore_widget=False): """ It renders the variants frame, it contains all the variants of the current prim :param parent_prim: The prim that contains the variants """ # Checking if any of the variants are active. is_variants_active = False all_variants = self.get_all_materials_variants(looks) for variant_prim in all_variants: is_active_attr = variant_prim.GetAttribute("MMEisActive") if is_active_attr: if is_active_attr.Get(): is_variants_active = True break # Checking if the is_variants_active variable is True or False. If it is True, then the active_status variable # is set to an empty string. If it is False, then the active_status variable is set to ' (Active)'. active_status = '' if is_variants_active else ' (Active)' # Creating a frame in the UI. if not self.variants_frame_original: self.variants_frame_original = ui.Frame( name="variants_frame_original", identifier="variants_frame_original" ) with self.variants_frame_original: with ui.CollapsableFrame(f"Original{active_status}", height=ui.Pixel(10), collapsed=is_variants_active): with ui.VStack(): ui.Label("Your original, unmodified materials. Cannot be deleted.", name="variant_label", height=40) if is_variants_active: with ui.HStack(): ui.Button( "Enable", name="variant_button", clicked_fn=lambda: self.enable_variant(None, looks, parent_prim)) if not self.variants_frame: self.variants_frame = ui.Frame(name="variants_frame", identifier="variants_frame") with self.variants_frame: with ui.VStack(height=ui.Pixel(10)): for variant_prim in all_variants: # Creating a functions that will be called later in this loop. prim_name = variant_prim.GetName() prim_path = variant_prim.GetPath() is_active_attr = variant_prim.GetAttribute("MMEisActive") if is_active_attr: # Checking if the attribute is_active_attr is active. is_active = is_active_attr.Get() active_status = ' (Active)' if is_active else '' with ui.CollapsableFrame(f"{variant_prim.GetName()}{active_status}", height=ui.Pixel(10), collapsed=not is_active): with ui.VStack(height=ui.Pixel(10)): with ui.HStack(): if not active_status: ui.Button( "Enable", name="variant_button", clicked_fn=lambda p_name=prim_name: self.enable_variant( p_name, looks, parent_prim )) ui.Button( "Delete", name="variant_button", clicked_fn=lambda p_path=prim_path: self.delete_variant( p_path, looks, parent_prim )) else: label_text = "This variant is enabled.\nMake changes to the active materials" \ "from above to edit this variant.\nAll changes will be saved automatically." ui.Label(label_text, name="variant_label", height=40) if not ignore_widget and self.get_setting("MMEEnableViewportUI"): if hasattr(self, "_widget_info_viewport") and self._widget_info_viewport: self._widget_info_viewport.destroy() self._widget_info_viewport = None if len(all_variants) > 0: # Get the active viewport (which at startup is the default Viewport) viewport_window = get_active_viewport_window() # Issue an error if there is no Viewport if not viewport_window: carb.log_warn(f"No Viewport Window to add {self.ext_id} scene to") self._widget_info_viewport = None return if hasattr(self, "ext_id"): print("ext_id", self.ext_id) # Build out the scene self._widget_info_viewport = WidgetInfoScene( viewport_window, self.ext_id, all_variants=all_variants, enable_variant=self.enable_variant, looks=looks, check_visibility=self.get_setting, parent_prim=parent_prim ) return self.variants_frame_original, self.variants_frame def get_closest_mme_object(self): """ If the user has enabled the roaming mode, then we get the camera position and the list of all visible MME objects. We then find the closest MME object to the camera and render the widget for that object. :return: The closest prim to the currently active camera. """ if not self.get_setting("MMEEnableRoamingMode", False): return False camera_prim = self.stage.GetPrimAtPath(get_active_viewport_camera_path()) camera_position = camera_prim.GetAttribute("xformOp:translate").Get() window = get_active_viewport_window() mme_objects = self.get_mme_valid_objects_on_stage() all_visible_prims = [] for prim in mme_objects: ui_position, is_visible = get_ui_position_for_prim(window, prim.GetPath()) if is_visible: all_visible_prims.append(prim) closest_prim = None closest_distance = 0 for prim in all_visible_prims: prim_position = prim.GetAttribute("xformOp:translate").Get() distance = math.sqrt( (prim_position[0] - camera_position[0]) ** 2 + (prim_position[1] - camera_position[1]) ** 2 + (prim_position[2] - camera_position[2]) ** 2 ) if closest_distance > self.get_setting("MMEMaxVisibleDistance", 500): closest_prim = None continue if not closest_prim: closest_prim = prim closest_distance = distance elif distance < closest_distance: closest_prim = prim closest_distance = distance if not hasattr(self, "last_roaming_prim"): self.last_roaming_prim = closest_prim return if closest_distance > 0 and closest_prim and self.last_roaming_prim != closest_prim: self.last_roaming_prim = closest_prim self.render_objectlevel_frame(closest_prim) if hasattr(self, "_widget_info_viewport") and self._widget_info_viewport: self._widget_info_viewport.info_manipulator.model._on_kit_selection_changed() elif not closest_prim: if hasattr(self, "latest_selected_prim") and self.latest_selected_prim: return self.last_roaming_prim = None self.render_scenelevel_frame() if hasattr(self, "_widget_info_viewport") and self._widget_info_viewport: self._widget_info_viewport.destroy() return closest_prim def get_all_children_of_prim(self, prim): """ It takes a prim as an argument and returns a list of all the prims that are children of that prim :param prim: The prim you want to get the children of :return: A list of all the children of the prim. """ children = [] for child in prim.GetChildren(): children.append(child) children.extend(self.get_all_children_of_prim(child)) return children def render_current_materials_frame(self, prim): """ It loops through all meshes of the selected prim, gets all materials that are binded to the mesh, and then loops through all materials and renders a button for each material :param prim: The prim to get all children of :return: The return value is a ui.Frame object. """ all_meshes = [] all_mat_paths = [] # Get all meshes for mesh in self.get_all_children_of_prim(prim): if mesh.GetTypeName() == "Mesh": material_paths = mesh.GetRelationship('material:binding').GetTargets() all_meshes.append({"mesh": mesh, "material_paths": material_paths}) for original_material_prim_path in material_paths: all_mat_paths.append(original_material_prim_path) materials_quantity = len(list(dict.fromkeys(all_mat_paths))) processed_materials = [] scrolling_frame_height = ui.Percent(80) materials_column_count = 1 if materials_quantity < 2: scrolling_frame_height = ui.Percent(50) elif materials_quantity < 4: scrolling_frame_height = ui.Percent(70) elif materials_quantity > 6: materials_column_count = 2 scrolling_frame_height = ui.Percent(100) if not self.materials_frame: self.materials_frame = ui.Frame(name="materials_frame", identifier="materials_frame") with self.materials_frame: with ui.ScrollingFrame(height=scrolling_frame_height): with ui.VGrid(column_count=materials_column_count, height=ui.Pixel(10)): material_counter = 1 # loop through all meshes for mesh_data in all_meshes: def sl_mat_fn(mesh_path=mesh_data["mesh"].GetPath()): return self.select_material(mesh_path) # Get currently binded materials for the current mesh current_material_prims = mesh_data["material_paths"] # Loop through all binded materials paths for original_material_prim_path in current_material_prims: if original_material_prim_path in processed_materials: continue # Get the material prim from path original_material_prim = self.stage.GetPrimAtPath(original_material_prim_path) if not original_material_prim: continue with ui.HStack(): if materials_column_count == 1: ui.Spacer(height=10, width=10) ui.Label( f"{material_counter}.", name="material_counter", width=20 if materials_column_count == 1 else 50, ) ui.Image( height=24, width=24, name="material_preview", fill_policy=ui.FillPolicy.PRESERVE_ASPECT_FIT ) if materials_column_count == 1: ui.Spacer(height=10, width=10) ui.Label( original_material_prim.GetName(), elided_text=True, name="material_name" ) ui.Button( "Select", name="variant_button", width=ui.Percent(30), clicked_fn=sl_mat_fn, ) material_counter += 1 processed_materials.append(original_material_prim_path) if len(all_mat_paths) == 0: ui.Label( "No materials were found. Please make sure that the selected model is valid.", name="main_hint", height=30 ) ui.Spacer(height=10) return self.materials_frame def render_objectlevel_frame(self, prim): """ It renders a frame with a list of all the variants of a given object, and a list of all the materials of the currently active variant. :param prim: The prim that is currently selected in the viewport :return: The main_frame is being returned. """ if not prim: return looks = prim.GetPrimAtPath("Looks") if not hasattr(self, "variants_frame") or self.variants_frame: self.variants_frame = None if not hasattr(self, "variants_frame_original") or self.variants_frame_original: self.variants_frame_original = None if not hasattr(self, "materials_frame") or self.materials_frame: self.materials_frame = None if not hasattr(self, "main_frame") or not self.main_frame: self.main_frame = ui.Frame(name="main_frame", identifier="main_frame") with self.main_frame: with ui.VStack(style=_style): with ui.HStack(height=ui.Pixel(10), name="label_container"): ui.Spacer(width=10) ui.Label(prim.GetName(), name="main_label", height=ui.Pixel(10)) ui.Spacer(height=6) ui.Separator(height=6) ui.Spacer(height=10) with ui.HStack(height=ui.Pixel(30)): ui.Spacer(width=10) ui.Label("Active materials", name="secondary_label") self.render_current_materials_frame(prim) with ui.HStack(height=ui.Pixel(30)): ui.Spacer(width=10) ui.Label("All variants", name="secondary_label") with ui.ScrollingFrame(): with ui.VStack(): self.render_variants_frame(looks, prim) ui.Spacer(height=10) ui.Button( "Add new variant", height=30, clicked_fn=lambda: self.add_variant(looks, prim), alignment=ui.Alignment.CENTER_BOTTOM, tooltip="Create a new variant, based on the current look", ) def open_scene_settings(self): """ If the settings window is not open, render the settings layout, set the settings window to open, and then show the settings window. If the settings window is open, render the active objects frame, and then show the settings window """ if not self.is_settings_open: self.render_scene_settings_layout(dock_in=True) self.is_settings_open = True else: self.render_active_objects_frame() ui.Workspace.show_window(self.SCENE_SETTINGS_WINDOW_NAME, True) scene_settings_window = ui.Workspace.get_window(self.SCENE_SETTINGS_WINDOW_NAME) ui.WindowHandle.focus(scene_settings_window) def render_scenelevel_frame(self): """ It creates a frame with a hint and a button to open the settings window. :return: The main_frame is being returned. """ if not hasattr(self, "main_frame") or not self.main_frame: self.main_frame = ui.Frame(name="main_frame", identifier="main_frame") with self.main_frame: with ui.VStack(style=_style): ui.Spacer() with ui.VStack(): ui.Label("Please select any object to see its materials", name="main_hint", height=30) ui.Label("or", name="main_hint_small", height=10) ui.Spacer(height=5) with ui.HStack(height=ui.Pixel(10)): ui.Spacer() ui.Button( "Open settings", height=20, width=150, name="open_mme_settings", clicked_fn=self.open_scene_settings, ) ui.Spacer() ui.Spacer() return self.main_frame def render_default_layout(self, prim=None): """ It's a function that renders a default layout for the UI :param prim: The prim that is selected in the viewport """ if self.main_frame: self.main_frame = None if self.variants_frame: self.variants_frame = None if self.variants_frame_original: self.variants_frame_original = None if self._window: self._window.destroy() self._window = None self._window = ui.Window(self.WINDOW_NAME, width=300, height=300) with self._window.frame: if not prim: self.render_scenelevel_frame() else: self.render_objectlevel_frame(prim) # SCENE SETTINGS def is_MME_exists(self, prim): """ A recursive method that checks if the prim has a MME prim in its hierarchy :param prim: The prim to check :return: A boolean value. """ for child in prim.GetChildren(): if child.GetName() == "Looks": if child.GetPrimAtPath("MME"): return True else: return False if self.is_MME_exists(child): return True return False def get_mme_valid_objects_on_stage(self): """ Returns a list of valid objects on the stage. """ if not self.stage: return [] valid_objects = [] default_prim = self.stage.GetDefaultPrim() # Get all objects and check if it has Looks folder for obj in default_prim.GetAllChildren(): if obj: if self.is_MME_exists(obj): valid_objects.append(obj) return valid_objects def select_prim(self, prim_path): """ It selects the prim at the given path, shows the property window, and focuses it :param prim_path: The path to the prim you want to select """ self.ignore_settings_update = True omni.kit.commands.execute( 'SelectPrimsCommand', old_selected_paths=[], new_selected_paths=[str(prim_path), ], expand_in_stage=True ) ui.Workspace.show_window(self.WINDOW_NAME, True) property_window = ui.Workspace.get_window(self.WINDOW_NAME) ui.WindowHandle.focus(property_window) self.ignore_settings_update = False def check_stage(self): """ It gets the current stage from the USD context """ if not hasattr(self, "stage") or not self.stage: self._usd_context = omni.usd.get_context() self.stage = self._usd_context.get_stage() def set_setting(self, value, attribute_name, create_only=False): """ It checks if the attribute for showing viewport ui exists, under the DefaultPrim if it doesn't, it creates it, but if it does, it changes the value instead :param value: True or False :param create_only: If True, the attribute will only be created if it doesn't exist, defaults to False (optional) :return: The return value is the value of the attribute. """ self.check_stage() if not self.stage: return # Get DefaultPrim from Stage default_prim = self.stage.GetDefaultPrim() # Get attribute from DefaultPrim if it exists attribute = default_prim.GetAttribute(attribute_name) attribute_path = attribute.GetPath() # check if attribute exists if not attribute: # if not, create it omni.kit.commands.execute( 'CreateUsdAttributeOnPath', attr_path=attribute_path, attr_type=Sdf.ValueTypeNames.Bool, custom=True, attr_value=value, variability=Sdf.VariabilityVarying ) else: if attribute.Get() == value or create_only: return omni.kit.commands.execute( 'ChangeProperty', prop_path=attribute_path, value=value, prev=not value, ) def get_setting(self, attribute_name, default_value=True): """ It gets the value of an attribute from the default prim of the stage :param attribute_name: The name of the attribute you want to get :param default_value: The value to return if the attribute doesn't exist, defaults to True (optional) :return: The value of the attribute. """ self.check_stage() if not self.stage: return # Get DefaultPrim from Stage default_prim = self.stage.GetDefaultPrim() # Get attribute from DefaultPrim called attribute = default_prim.GetAttribute(attribute_name) if attribute: return attribute.Get() else: return default_value # Attribute was not created yet, so we return default_value def render_active_objects_frame(self, valid_objects=None): """ It creates a UI frame with a list of buttons that select objects in the scene :param valid_objects: a list of objects that have variants :return: The active_objects_frame is being returned. """ if not valid_objects: valid_objects = self.get_mme_valid_objects_on_stage() objects_quantity = len(valid_objects) objects_column_count = 1 if objects_quantity > 6: objects_column_count = 2 if not self.active_objects_frame: self.active_objects_frame = ui.Frame(name="active_objects_frame", identifier="active_objects_frame") with self.active_objects_frame: with ui.VGrid(column_count=objects_column_count): material_counter = 1 # loop through all meshes for prim in valid_objects: if not prim: continue with ui.HStack(): if objects_column_count == 1: ui.Spacer(height=10, width=10) ui.Label( f"{material_counter}.", name="material_counter", width=20 if objects_column_count == 1 else 50, ) if objects_column_count == 1: ui.Spacer(height=10, width=10) ui.Label( prim.GetName(), elided_text=True, name="material_name" ) ui.Button( "Select", name="variant_button", width=ui.Percent(30), clicked_fn=lambda mesh_path=prim.GetPath(): self.select_prim(mesh_path), ) material_counter += 1 if objects_quantity == 0: ui.Label( "No models with variants were found.", name="main_hint", height=30 ) ui.Spacer(height=10) return self.active_objects_frame def render_scene_settings_layout(self, dock_in=False): """ It renders a window with a list of objects in the scene that have variants and some settings. Called only once, all interactive elements are updated through the frames. """ valid_objects = self.get_mme_valid_objects_on_stage() if self._window_scenemanager: self._window_scenemanager.destroy() self._window_scenemanager = None self._window_scenemanager = ui.Window(self.SCENE_SETTINGS_WINDOW_NAME, width=300, height=300) if dock_in: self._window_scenemanager.deferred_dock_in(self.WINDOW_NAME) if self.active_objects_frame: self.active_objects_frame = None with self._window_scenemanager.frame: with ui.VStack(style=_style): with ui.HStack(height=ui.Pixel(10), name="label_container"): ui.Spacer(width=10) ui.Label(self.SCENE_SETTINGS_WINDOW_NAME, name="main_label", height=ui.Pixel(10)) ui.Spacer(height=6) ui.Separator(height=6) ui.Spacer(height=10) with ui.HStack(height=ui.Pixel(30)): ui.Spacer(width=10) ui.Label("Models with variants in your scene", name="secondary_label") ui.Spacer(height=40) with ui.ScrollingFrame(height=ui.Pixel(100)): self.render_active_objects_frame(valid_objects) ui.Spacer(height=10) with ui.HStack(height=ui.Pixel(30)): ui.Spacer(width=10) ui.Label("Settings", name="secondary_label") ui.Spacer(height=10) ui.Separator(height=6) with ui.ScrollingFrame(): with ui.VStack(): ui.Spacer(height=5) with ui.HStack(height=20): ui.Spacer(width=ui.Percent(5)) ui.Label("Enable viewport widget rendering:", width=ui.Percent(70)) ui.Spacer(width=ui.Percent(10)) # Creating a checkbox and setting the value to the value of the get_setting() # function. self.enable_viewport_ui = ui.CheckBox(width=ui.Percent(15)) self.enable_viewport_ui.model.set_value(self.get_setting("MMEEnableViewportUI")) self.enable_viewport_ui.model.add_value_changed_fn( lambda value: self.set_setting(value.get_value_as_bool(), "MMEEnableViewportUI") ) ui.Spacer(height=10) ui.Separator(height=6) with ui.HStack(height=20): # Window will appear if you look at the object in the viewport, instead of clicking on it ui.Spacer(width=ui.Percent(5)) ui.Label("Roaming mode:", width=ui.Percent(70)) ui.Spacer(width=ui.Percent(10)) self.enable_roaming_mode = ui.CheckBox(width=ui.Percent(15)) self.enable_roaming_mode.model.set_value(self.get_setting("MMEEnableRoamingMode", False)) self.enable_roaming_mode.model.add_value_changed_fn( lambda value: self.set_setting(value.get_value_as_bool(), "MMEEnableRoamingMode") ) ui.Spacer(height=10) ui.Separator(height=6)

Python

Vadim-Karpenko/omniverse-material-manager-extended/exts/karpenko.materialsmanager.ext/karpenko/materialsmanager/ext/__init__.py

from .extension import *

Python

Vadim-Karpenko/omniverse-material-manager-extended/exts/karpenko.materialsmanager.ext/karpenko/materialsmanager/ext/viewport_ui/widget_info_manipulator.py

# Copyright (c) 2018-2021, NVIDIA CORPORATION. All rights reserved. # # NVIDIA CORPORATION and its licensors retain all intellectual property # and proprietary rights in and to this software, related documentation # and any modifications thereto. Any use, reproduction, disclosure or # distribution of this software and related documentation without an express # license agreement from NVIDIA CORPORATION is strictly prohibited. # __all__ = ["WidgetInfoManipulator"] from omni.ui import color as cl from omni.ui import scene as sc import omni.ui as ui from ..style import viewport_widget_style class _ViewportLegacyDisableSelection: """Disables selection in the Viewport Legacy""" def __init__(self): self._focused_windows = None focused_windows = [] try: # For some reason is_focused may return False, when a Window is definitely in fact is the focused window! # And there's no good solution to this when mutliple Viewport-1 instances are open; so we just have to # operate on all Viewports for a given usd_context. import omni.kit.viewport_legacy as vp vpi = vp.acquire_viewport_interface() for instance in vpi.get_instance_list(): window = vpi.get_viewport_window(instance) if not window: continue focused_windows.append(window) if focused_windows: self._focused_windows = focused_windows for window in self._focused_windows: # Disable the selection_rect, but enable_picking for snapping window.disable_selection_rect(True) except Exception: pass class _DragPrioritize(sc.GestureManager): """Refuses preventing _DragGesture.""" def can_be_prevented(self, gesture): # Never prevent in the middle of drag return gesture.state != sc.GestureState.CHANGED def should_prevent(self, gesture, preventer): if preventer.state == sc.GestureState.BEGAN or preventer.state == sc.GestureState.CHANGED: return True class _DragGesture(sc.DragGesture): """"Gesture to disable rectangle selection in the viewport legacy""" def __init__(self): super().__init__(manager=_DragPrioritize()) def on_began(self): # When the user drags the slider, we don't want to see the selection # rect. In Viewport Next, it works well automatically because the # selection rect is a manipulator with its gesture, and we add the # slider manipulator to the same SceneView. # In Viewport Legacy, the selection rect is not a manipulator. Thus it's # not disabled automatically, and we need to disable it with the code. self.__disable_selection = _ViewportLegacyDisableSelection() def on_ended(self): # This re-enables the selection in the Viewport Legacy self.__disable_selection = None class WidgetInfoManipulator(sc.Manipulator): def __init__(self, all_variants, enable_variant, looks, parent_prim, check_visibility, **kwargs): super().__init__(**kwargs) self.destroy() self.all_variants = all_variants self.enable_variant = enable_variant self.looks = looks self.parent_prim = parent_prim self.check_visibility = check_visibility self._radius = 2 self._distance_to_top = 5 self._thickness = 2 self._radius_hovered = 20 self.prev_button = None self.next_button = None def destroy(self): self._root = None self._slider_subscription = None self._slider_model = None self._name_label = None self.prev_button = None self.next_button = None self.all_variants = None self.enable_variant = None self.looks = None self.parent_prim = None def _on_build_widgets(self): with ui.ZStack(height=70, style=viewport_widget_style): ui.Rectangle( style={ "background_color": cl(0.2), "border_color": cl(0.7), "border_width": 2, "border_radius": 4, } ) with ui.VStack(): ui.Spacer(height=4) with ui.HStack(): ui.Spacer(width=10) self.prev_button = ui.Button("Prev", width=100) self._name_label = ui.Label( "", elided_text=True, name="name_label", height=0, alignment=ui.Alignment.CENTER_BOTTOM ) self.next_button = ui.Button("Next", width=100) ui.Spacer(width=10) # setup some model, just for simple demonstration here self._slider_model = ui.SimpleIntModel() ui.Spacer(height=5) with ui.HStack(style={"font_size": 26}): ui.Spacer(width=5) ui.IntSlider(self._slider_model, min=0, max=len(self.all_variants)) ui.Spacer(width=5) ui.Spacer(height=24) ui.Spacer() self.on_model_updated(None) # Additional gesture that prevents Viewport Legacy selection self._widget.gestures += [_DragGesture()] def on_build(self): """Called when the model is changed and rebuilds the whole slider""" self._root = sc.Transform(visible=False) with self._root: with sc.Transform(scale_to=sc.Space.SCREEN): with sc.Transform(transform=sc.Matrix44.get_translation_matrix(0, 100, 0)): # Label with sc.Transform(look_at=sc.Transform.LookAt.CAMERA): self._widget = sc.Widget(500, 130, update_policy=sc.Widget.UpdatePolicy.ON_MOUSE_HOVERED) self._widget.frame.set_build_fn(self._on_build_widgets) # Update the slider def update_variant(self, value): if not self._root or not self._root.visible or not self.looks or not self.parent_prim: return if value == 0: self.enable_variant(None, self.looks, self.parent_prim, ignore_select=True) else: selected_variant = self.all_variants[value - 1] if not selected_variant: return prim_name = selected_variant.GetName() self.enable_variant(prim_name, self.looks, self.parent_prim, ignore_select=True) def on_model_updated(self, _): if not self._root: return # if we don't have selection then show nothing if not self.model or not self.model.get_item("name") or not self.check_visibility("MMEEnableViewportUI"): self._root.visible = False return # Update the shapes position = self.model.get_as_floats(self.model.get_item("position")) self._root.transform = sc.Matrix44.get_translation_matrix(*position) self._root.visible = True active_index = 0 for variant_prim in self.all_variants: is_active_attr = variant_prim.GetAttribute("MMEisActive") if is_active_attr: # Checking if the attribute is_active_attr is active. is_active = is_active_attr.Get() if is_active: active_index = self.all_variants.index(variant_prim) + 1 break if self._slider_model: if self._slider_subscription: self._slider_subscription.unsubscribe() self._slider_subscription = None self._slider_model.as_int = active_index self._slider_subscription = self._slider_model.subscribe_value_changed_fn( lambda m: self.update_variant(m.as_int) ) if self.prev_button and self.next_button: self.prev_button.enabled = active_index > 0 self.next_button.enabled = active_index < len(self.all_variants) self.prev_button.set_clicked_fn(lambda: self.update_variant(active_index - 1)) self.next_button.set_clicked_fn(lambda: self.update_variant(active_index + 1)) # Update the shape name if self._name_label: if active_index == 0: self._name_label.text = "Orginal" else: self._name_label.text = f"{self.all_variants[active_index - 1].GetName()}"

Python

Vadim-Karpenko/omniverse-material-manager-extended/exts/karpenko.materialsmanager.ext/karpenko/materialsmanager/ext/viewport_ui/widget_info_scene.py

# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. # # NVIDIA CORPORATION and its licensors retain all intellectual property # and proprietary rights in and to this software, related documentation # and any modifications thereto. Any use, reproduction, disclosure or # distribution of this software and related documentation without an express # license agreement from NVIDIA CORPORATION is strictly prohibited. # __all__ = ["WidgetInfoScene"] from omni.ui import scene as sc from .widget_info_model import WidgetInfoModel from .widget_info_manipulator import WidgetInfoManipulator class WidgetInfoScene(): """The Object Info Manupulator, placed into a Viewport""" def __init__(self, viewport_window, ext_id: str, all_variants: list, enable_variant, looks, parent_prim, check_visibility): self._scene_view = None self._viewport_window = viewport_window # Create a unique frame for our SceneView with self._viewport_window.get_frame(ext_id): # Create a default SceneView (it has a default camera-model) self._scene_view = sc.SceneView() # Add the manipulator into the SceneView's scene with self._scene_view.scene: self.info_manipulator = WidgetInfoManipulator( model=WidgetInfoModel(parent_prim=parent_prim, get_setting=check_visibility), all_variants=all_variants, enable_variant=enable_variant, looks=looks, parent_prim=parent_prim, check_visibility=check_visibility, ) # Register the SceneView with the Viewport to get projection and view updates self._viewport_window.viewport_api.add_scene_view(self._scene_view) def __del__(self): self.destroy() def destroy(self): if self.info_manipulator: self.info_manipulator.destroy() if self._scene_view: # Empty the SceneView of any elements it may have self._scene_view.scene.clear() # Be a good citizen, and un-register the SceneView from Viewport updates if self._viewport_window: self._viewport_window.viewport_api.remove_scene_view(self._scene_view) # Remove our references to these objects self._viewport_window = None self._scene_view = None self.info_manipulator = None

Python

Vadim-Karpenko/omniverse-material-manager-extended/exts/karpenko.materialsmanager.ext/karpenko/materialsmanager/ext/viewport_ui/widget_info_model.py

# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. # # NVIDIA CORPORATION and its licensors retain all intellectual property # and proprietary rights in and to this software, related documentation # and any modifications thereto. Any use, reproduction, disclosure or # distribution of this software and related documentation without an express # license agreement from NVIDIA CORPORATION is strictly prohibited. # __all__ = ["WidgetInfoModel"] from omni.ui import scene as sc from pxr import UsdGeom from pxr import Usd from pxr import UsdShade from pxr import Tf from pxr import UsdLux import omni.usd import omni.kit.commands class WidgetInfoModel(sc.AbstractManipulatorModel): """ User part. The model tracks the position and info of the selected object. """ class PositionItem(sc.AbstractManipulatorItem): """ The Model Item represents the position. It doesn't contain anything because because we take the position directly from USD when requesting. """ def __init__(self): super().__init__() self.value = [0, 0, 0] class ValueItem(sc.AbstractManipulatorItem): """The Model Item contains a single float value about some attibute""" def __init__(self, value=0): super().__init__() self.value = [value] def __init__(self, parent_prim, get_setting): super().__init__() self.material_name = "" self.position = WidgetInfoModel.PositionItem() # The distance from the bounding box to the position the model returns self._offset = 0 # Current selection self._prim = parent_prim self.get_setting = get_setting self._current_path = "" self._stage_listener = None # Save the UsdContext name (we currently only work with single Context) self._usd_context_name = '' usd_context = self._get_context() # Track selection self._events = usd_context.get_stage_event_stream() self._stage_event_sub = self._events.create_subscription_to_pop( self._on_stage_event, name="Object Info Selection Update" ) def _get_context(self) -> Usd.Stage: # Get the UsdContext we are attached to return omni.usd.get_context(self._usd_context_name) def _notice_changed(self, notice, stage): """Called by Tf.Notice""" if self.get_setting("MMEEnableRoamingMode", False): self._item_changed(self.position) return for p in notice.GetChangedInfoOnlyPaths(): if self._current_path in str(p.GetPrimPath()): self._item_changed(self.position) def get_item(self, identifier): if identifier == "position": return self.position if identifier == "name": return self._current_path if identifier == "material": return self.material_name def get_as_floats(self, item): if item == self.position: # Requesting position return self._get_position() if item: # Get the value directly from the item return item.value return [] def set_floats(self, item, value): if not self._current_path: return if not value or not item or item.value == value: return # Set directly to the item item.value = value # This makes the manipulator updated self._item_changed(item) def _on_stage_event(self, event): """Called by stage_event_stream""" if event.type == int(omni.usd.StageEventType.SELECTION_CHANGED): self._on_kit_selection_changed() def _on_kit_selection_changed(self): # selection change, reset it for now self._current_path = "" usd_context = self._get_context() stage = usd_context.get_stage() if not stage: return if not self.get_setting("MMEEnableRoamingMode", False): prim_paths = usd_context.get_selection().get_selected_prim_paths() if not prim_paths or len(prim_paths) > 1 or len(prim_paths) == 0 or str(self._prim.GetPath()) not in prim_paths[0]: self._item_changed(self.position) # Revoke the Tf.Notice listener, we don't need to update anything if self._stage_listener: self._stage_listener.Revoke() self._stage_listener = None return prim = self._prim if prim.GetTypeName() == "Light": self.material_name = "I am a Light" elif prim.IsA(UsdGeom.Imageable): material, relationship = UsdShade.MaterialBindingAPI(prim).ComputeBoundMaterial() if material: self.material_name = str(material.GetPath()) else: self.material_name = "N/A" else: self._prim = None return self._current_path = str(self._prim.GetPath()) # Add a Tf.Notice listener to update the position if not self._stage_listener: self._stage_listener = Tf.Notice.Register(Usd.Notice.ObjectsChanged, self._notice_changed, stage) (old_scale, old_rotation_euler, old_rotation_order, old_translation) = omni.usd.get_local_transform_SRT(prim) # Position is changed self._item_changed(self.position) def find_child_mesh_with_position(self, prim): """ A recursive method to find a child with a valid position. """ if prim.IsA(UsdGeom.Mesh): self._current_path = str(prim.GetPath()) prim_position = self._get_position(non_recursive=True) if prim_position[0] == 0.0 or prim_position[1] == 0.0 or prim_position[2] == 0.0: pass else: return prim for child in prim.GetChildren(): result = self.find_child_mesh_with_position(child) if result: return result return None def _get_position(self, non_recursive=False): """Returns position of currently selected object""" stage = self._get_context().get_stage() if not stage or not self._current_path: return [0, 0, 0] # Get position directly from USD if non_recursive: prim = stage.GetPrimAtPath(self._current_path) else: prim = self.find_child_mesh_with_position(stage.GetPrimAtPath(self._current_path)) box_cache = UsdGeom.BBoxCache(Usd.TimeCode.Default(), includedPurposes=[UsdGeom.Tokens.default_]) bound = box_cache.ComputeWorldBound(prim) range = bound.ComputeAlignedBox() bboxMin = range.GetMin() bboxMax = range.GetMax() position = [(bboxMin[0] + bboxMax[0]) * 0.5, bboxMax[1] + self._offset, (bboxMin[2] + bboxMax[2]) * 0.5] return position

Python

zslrmhb/Omniverse-Virtual-Assisstant/nlp.py

# natural language processing module utilizing the Riva SDK import wikipedia as wiki import wikipediaapi as wiki_api import riva.client from config import URI class NLPService: def __init__(self, max_wiki_articles): """ :param max_wiki_articles: max wiki articles to search """ self.max_wiki_articles = max_wiki_articles self.wiki_summary = " " self.input_query = " " self.auth = riva.client.Auth(uri=URI) self.service = riva.client.NLPService(self.auth) self.wiki_wiki = wiki_api.Wikipedia('en') def wiki_query(self, input_query) -> None: """ :param input_query: word to search :return: None """ self.wiki_summary = " " self.input_query = input_query wiki_articles = wiki.search(input_query) for article in wiki_articles[:min(len(wiki_articles), self.max_wiki_articles)]: print(f"Getting summary for: {article}") page = self.wiki_wiki.page(article) self.wiki_summary += "\n" + page.summary def nlp_query(self) -> None: """ :return: Response from the NLP model """ resp = self.service.natural_query(self.input_query, self.wiki_summary) if len(resp.results[0].answer) == 0: return "Sorry, I don't understand, may you speak again?" else: return resp.results[0].answer

Python

zslrmhb/Omniverse-Virtual-Assisstant/tts.py

# text-to-speech module utilizting the Riva SDK import riva.client import riva.client.audio_io from config import URI class TTSService: def __init__(self, language='en-US', sample_rate_hz=44100): """ :param language: language code :param sample_rate_hz: sample rate herz """ self.auth = riva.client.Auth(uri=URI) self.service = riva.client.SpeechSynthesisService(self.auth) self.langauge = language self.voice = "English-US.Male-1" self.sample_rate_hz = sample_rate_hz def speak(self, text) -> None: """ :param text: text to speak :return: None """ sound_stream = riva.client.audio_io.SoundCallBack( 3, nchannels=1, sampwidth=2, framerate=self.sample_rate_hz ) responses = self.service.synthesize_online( text, None, self.langauge, sample_rate_hz=self.sample_rate_hz ) for resp in responses: sound_stream(resp.audio) sound_stream.close() def get_audio_bytes(self, text) -> bytes: """ :param text: text to speak :return: speech audio """ resp = self.service.synthesize(text, self.voice, self.langauge, sample_rate_hz=self.sample_rate_hz) return resp.audio

Python

zslrmhb/Omniverse-Virtual-Assisstant/audio2face_streaming_utils.py

""" This demo script shows how to send audio data to Audio2Face Streaming Audio Player via gRPC requests. There are two options: * Send the whole track at once using PushAudioRequest() * Send the audio chunks seuqntially in a stream using PushAudioStreamRequest() For the second option this script emulates the stream of chunks, generated by splitting an input WAV audio file. But in a real application such stream of chunks may be aquired from some other streaming source: * streaming audio via internet, streaming Text-To-Speech, etc gRPC protocol details could be find in audio2face.proto """ import sys import grpc import time import numpy as np import soundfile import audio2face_pb2 import audio2face_pb2_grpc def push_audio_track(url, audio_data, samplerate, instance_name): """ This function pushes the whole audio track at once via PushAudioRequest() PushAudioRequest parameters: * audio_data: bytes, containing audio data for the whole track, where each sample is encoded as 4 bytes (float32) * samplerate: sampling rate for the audio data * instance_name: prim path of the Audio2Face Streaming Audio Player on the stage, were to push the audio data * block_until_playback_is_finished: if True, the gRPC request will be blocked until the playback of the pushed track is finished The request is passed to PushAudio() """ block_until_playback_is_finished = True # ADJUST with grpc.insecure_channel(url) as channel: stub = audio2face_pb2_grpc.Audio2FaceStub(channel) request = audio2face_pb2.PushAudioRequest() request.audio_data = audio_data.astype(np.float32).tobytes() request.samplerate = samplerate request.instance_name = instance_name request.block_until_playback_is_finished = block_until_playback_is_finished print("Sending audio data...") response = stub.PushAudio(request) if response.success: print("SUCCESS") else: print(f"ERROR: {response.message}") print("Closed channel") def push_audio_track_stream(url, audio_data, samplerate, instance_name): """ This function pushes audio chunks sequentially via PushAudioStreamRequest() The function emulates the stream of chunks, generated by splitting input audio track. But in a real application such stream of chunks may be aquired from some other streaming source. The first message must contain start_marker field, containing only meta information (without audio data): * samplerate: sampling rate for the audio data * instance_name: prim path of the Audio2Face Streaming Audio Player on the stage, were to push the audio data * block_until_playback_is_finished: if True, the gRPC request will be blocked until the playback of the pushed track is finished (after the last message) Second and other messages must contain audio_data field: * audio_data: bytes, containing audio data for an audio chunk, where each sample is encoded as 4 bytes (float32) All messages are packed into a Python generator and passed to PushAudioStream() """ chunk_size = samplerate // 10 # ADJUST sleep_between_chunks = 0.04 # ADJUST block_until_playback_is_finished = True # ADJUST with grpc.insecure_channel(url) as channel: print("Channel creadted") stub = audio2face_pb2_grpc.Audio2FaceStub(channel) def make_generator(): start_marker = audio2face_pb2.PushAudioRequestStart( samplerate=samplerate, instance_name=instance_name, block_until_playback_is_finished=block_until_playback_is_finished, ) # At first, we send a message with start_marker yield audio2face_pb2.PushAudioStreamRequest(start_marker=start_marker) # Then we send messages with audio_data for i in range(len(audio_data) // chunk_size + 1): time.sleep(sleep_between_chunks) chunk = audio_data[i * chunk_size : i * chunk_size + chunk_size] yield audio2face_pb2.PushAudioStreamRequest(audio_data=chunk.astype(np.float32).tobytes()) request_generator = make_generator() print("Sending audio data...") response = stub.PushAudioStream(request_generator) if response.success: print("SUCCESS") else: print(f"ERROR: {response.message}") print("Channel closed") def main(): """ This demo script shows how to send audio data to Audio2Face Streaming Audio Player via gRPC requests. There two options: * Send the whole track at once using PushAudioRequest() * Send the audio chunks seuqntially in a stream using PushAudioStreamRequest() For the second option this script emulates the stream of chunks, generated by splitting an input WAV audio file. But in a real application such stream of chunks may be aquired from some other streaming source: * streaming audio via internet, streaming Text-To-Speech, etc gRPC protocol details could be find in audio2face.proto """ if len(sys.argv) < 3: print("Format: python test_client.py PATH_TO_WAV INSTANCE_NAME") return # Sleep time emulates long latency of the request sleep_time = 2.0 # ADJUST # URL of the Audio2Face Streaming Audio Player server (where A2F App is running) url = "localhost:50051" # ADJUST # Local input WAV file path audio_fpath = sys.argv[1] # Prim path of the Audio2Face Streaming Audio Player on the stage (were to push the audio data) instance_name = sys.argv[2] data, samplerate = soundfile.read(audio_fpath, dtype="float32") # Only Mono audio is supported if len(data.shape) > 1: data = np.average(data, axis=1) print(f"Sleeping for {sleep_time} seconds") time.sleep(sleep_time) if 0: # ADJUST # Push the whole audio track at once push_audio_track(url, data, samplerate, instance_name) else: # Emulate audio stream and push audio chunks sequentially push_audio_track_stream(url, data, samplerate, instance_name) if __name__ == "__main__": main()

Python

zslrmhb/Omniverse-Virtual-Assisstant/asr.py

# Audio to Speech Module utilizing the Riva SDK import riva.client import riva.client.audio_io from typing import Iterable import riva.client.proto.riva_asr_pb2 as rasr from config import URI config = riva.client.StreamingRecognitionConfig( config=riva.client.RecognitionConfig( encoding=riva.client.AudioEncoding.LINEAR_PCM, language_code='en-US', max_alternatives=1, profanity_filter=False, enable_automatic_punctuation=True, verbatim_transcripts=True, sample_rate_hertz=16000 ), interim_results=False, ) class ASRService: def __init__(self): """ """ self.auth = riva.client.Auth(uri=URI) self.service = riva.client.ASRService(self.auth) self.sample_rate_hz = 16000 self.file_streaming_chunk = 1600 self.transcript = "" self.default_device_info = riva.client.audio_io.get_default_input_device_info() self.default_device_index = None if self.default_device_info is None else self.default_device_info['index'] def run(self) -> None: """ :return: None """ with riva.client.audio_io.MicrophoneStream( rate=self.sample_rate_hz, chunk=self.file_streaming_chunk, device=1, ) as audio_chunk_iterator: self.print_response(responses=self.service.streaming_response_generator( audio_chunks=audio_chunk_iterator, streaming_config=config)) def print_response(self, responses: Iterable[rasr.StreamingRecognizeResponse]) -> None: """ :param responses: Streaming Response :return: None """ self.transcript = "" for response in responses: if not response.results: continue for result in response.results: if not result.alternatives: continue if result.is_final: partial_transcript = result.alternatives[0].transcript self.transcript += partial_transcript # print(self.transcript) return # key = input("Press 'q' to finished recording\n" # "Press 'r' to redo\n" # "Press 'c' to continue record\n") # # micStream.closed = True # while key not in ['q', 'r', 'c']: # print("Please input the correct key!\n") # key = input() # micStream.closed = False # if key == "q": return # elif key == "r": self.transcript = "" # else: continue

Python

zslrmhb/Omniverse-Virtual-Assisstant/main.py

# Running the Demo from asr import ASRService from nlp import NLPService from tts import TTSService from audio2face import Audio2FaceService asr_service = ASRService() nlp_service = NLPService(max_wiki_articles=5) tts_service = TTSService() audio2face_service = Audio2FaceService() while True: # speech recognition asr_service.run() print(asr_service.transcript) # natural language processing with the help of Wikipedia API nlp_service.wiki_query(asr_service.transcript) output = nlp_service.nlp_query() print(output) # text-to-speech audio_bytes = tts_service.get_audio_bytes(output) # Audio2Face Animation audio2face_service.make_avatar_speaks(audio_bytes)

Python

zslrmhb/Omniverse-Virtual-Assisstant/config.py

# configuration for accessing the remote local host on the Google Cloud Server URI = "" # This will be in the syntax of external ip of your Riva Server:Port of your Riva Server # Example: 12.34.56.789:50050

Python

zslrmhb/Omniverse-Virtual-Assisstant/audio2face_pb2_grpc.py

# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! """Client and server classes corresponding to protobuf-defined services.""" import grpc import audio2face_pb2 as audio2face__pb2 class Audio2FaceStub(object): """Missing associated documentation comment in .proto file.""" def __init__(self, channel): """Constructor. Args: channel: A grpc.Channel. """ self.PushAudio = channel.unary_unary( "/nvidia.audio2face.Audio2Face/PushAudio", request_serializer=audio2face__pb2.PushAudioRequest.SerializeToString, response_deserializer=audio2face__pb2.PushAudioResponse.FromString, ) self.PushAudioStream = channel.stream_unary( "/nvidia.audio2face.Audio2Face/PushAudioStream", request_serializer=audio2face__pb2.PushAudioStreamRequest.SerializeToString, response_deserializer=audio2face__pb2.PushAudioStreamResponse.FromString, ) class Audio2FaceServicer(object): """Missing associated documentation comment in .proto file.""" def PushAudio(self, request, context): """Missing associated documentation comment in .proto file.""" context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def PushAudioStream(self, request_iterator, context): """Missing associated documentation comment in .proto file.""" context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def add_Audio2FaceServicer_to_server(servicer, server): rpc_method_handlers = { "PushAudio": grpc.unary_unary_rpc_method_handler( servicer.PushAudio, request_deserializer=audio2face__pb2.PushAudioRequest.FromString, response_serializer=audio2face__pb2.PushAudioResponse.SerializeToString, ), "PushAudioStream": grpc.stream_unary_rpc_method_handler( servicer.PushAudioStream, request_deserializer=audio2face__pb2.PushAudioStreamRequest.FromString, response_serializer=audio2face__pb2.PushAudioStreamResponse.SerializeToString, ), } generic_handler = grpc.method_handlers_generic_handler("nvidia.audio2face.Audio2Face", rpc_method_handlers) server.add_generic_rpc_handlers((generic_handler,)) # This class is part of an EXPERIMENTAL API. class Audio2Face(object): """Missing associated documentation comment in .proto file.""" @staticmethod def PushAudio( request, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None, ): return grpc.experimental.unary_unary( request, target, "/nvidia.audio2face.Audio2Face/PushAudio", audio2face__pb2.PushAudioRequest.SerializeToString, audio2face__pb2.PushAudioResponse.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata, ) @staticmethod def PushAudioStream( request_iterator, target, options=(), channel_credentials=None, call_credentials=None, insecure=False, compression=None, wait_for_ready=None, timeout=None, metadata=None, ): return grpc.experimental.stream_unary( request_iterator, target, "/nvidia.audio2face.Audio2Face/PushAudioStream", audio2face__pb2.PushAudioStreamRequest.SerializeToString, audio2face__pb2.PushAudioStreamResponse.FromString, options, channel_credentials, insecure, call_credentials, compression, wait_for_ready, timeout, metadata, )

Python

zslrmhb/Omniverse-Virtual-Assisstant/audio2face.py

# speech to Audio2Face module utilizing the gRPC protocal from audio2face_streaming_utils import riva.client import io from pydub import AudioSegment from scipy.io.wavfile import read import numpy as np from audio2face_streaming_utils import push_audio_track class Audio2FaceService: def __init__(self, sample_rate=44100): """ :param sample_rate: sample rate """ self.a2f_url = 'localhost:50051' # Set it to the port of your local host self.sample_rate = 44100 self.avatar_instance = '/World/audio2face/PlayerStreaming' # Set it to the name of your Audio2Face Streaming Instance def tts_to_wav(self, tts_byte, framerate=22050) -> str: """ :param tts_byte: tts data in byte :param framerate: framerate :return: wav byte """ seg = AudioSegment.from_raw(io.BytesIO(tts_byte), sample_width=2, frame_rate=22050, channels=1) wavIO = io.BytesIO() seg.export(wavIO, format="wav") rate, wav = read(io.BytesIO(wavIO.getvalue())) return wav def wav_to_numpy_float32(self, wav_byte) -> float: """ :param wav_byte: wav byte :return: float32 """ return wav_byte.astype(np.float32, order='C') / 32768.0 def get_tts_numpy_audio(self, audio) -> float: """ :param audio: audio from tts_to_wav :return: float32 of the audio """ wav_byte = self.tts_to_wav(audio) return self.wav_to_numpy_float32(wav_byte) def make_avatar_speaks(self, audio) -> None: """ :param audio: tts audio :return: None """ push_audio_track(self.a2f_url, self.get_tts_numpy_audio(audio), self.sample_rate, self.avatar_instance)

Python

PegasusSimulator/PegasusSimulator/examples/1_px4_single_vehicle.py

#!/usr/bin/env python """ | File: 1_px4_single_vehicle.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: This files serves as an example on how to build an app that makes use of the Pegasus API to run a simulation with a single vehicle, controlled using the MAVLink control backend. """ # Imports to start Isaac Sim from this script import carb from omni.isaac.kit import SimulationApp # Start Isaac Sim's simulation environment # Note: this simulation app must be instantiated right after the SimulationApp import, otherwise the simulator will crash # as this is the object that will load all the extensions and load the actual simulator. simulation_app = SimulationApp({"headless": False}) # ----------------------------------- # The actual script should start here # ----------------------------------- import omni.timeline from omni.isaac.core.world import World # Import the Pegasus API for simulating drones from pegasus.simulator.params import ROBOTS, SIMULATION_ENVIRONMENTS from pegasus.simulator.logic.state import State from pegasus.simulator.logic.backends.mavlink_backend import MavlinkBackend, MavlinkBackendConfig from pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface # Auxiliary scipy and numpy modules import os.path from scipy.spatial.transform import Rotation class PegasusApp: """ A Template class that serves as an example on how to build a simple Isaac Sim standalone App. """ def __init__(self): """ Method that initializes the PegasusApp and is used to setup the simulation environment. """ # Acquire the timeline that will be used to start/stop the simulation self.timeline = omni.timeline.get_timeline_interface() # Start the Pegasus Interface self.pg = PegasusInterface() # Acquire the World, .i.e, the singleton that controls that is a one stop shop for setting up physics, # spawning asset primitives, etc. self.pg._world = World(**self.pg._world_settings) self.world = self.pg.world # Launch one of the worlds provided by NVIDIA self.pg.load_environment(SIMULATION_ENVIRONMENTS["Curved Gridroom"]) # Create the vehicle # Try to spawn the selected robot in the world to the specified namespace config_multirotor = MultirotorConfig() # Create the multirotor configuration mavlink_config = MavlinkBackendConfig({ "vehicle_id": 0, "px4_autolaunch": True, "px4_dir": self.pg.px4_path, "px4_vehicle_model": self.pg.px4_default_airframe # CHANGE this line to 'iris' if using PX4 version bellow v1.14 }) config_multirotor.backends = [MavlinkBackend(mavlink_config)] Multirotor( "/World/quadrotor", ROBOTS['Iris'], 0, [0.0, 0.0, 0.07], Rotation.from_euler("XYZ", [0.0, 0.0, 0.0], degrees=True).as_quat(), config=config_multirotor, ) # Reset the simulation environment so that all articulations (aka robots) are initialized self.world.reset() # Auxiliar variable for the timeline callback example self.stop_sim = False def run(self): """ Method that implements the application main loop, where the physics steps are executed. """ # Start the simulation self.timeline.play() # The "infinite" loop while simulation_app.is_running() and not self.stop_sim: # Update the UI of the app and perform the physics step self.world.step(render=True) # Cleanup and stop carb.log_warn("PegasusApp Simulation App is closing.") self.timeline.stop() simulation_app.close() def main(): # Instantiate the template app pg_app = PegasusApp() # Run the application loop pg_app.run() if __name__ == "__main__": main()

Python

PegasusSimulator/PegasusSimulator/examples/6_paper_results.py

#!/usr/bin/env python """ | File: python_control_backend.py | Author: Marcelo Jacinto and Joao Pinto ([email protected], [email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: This files serves as an example on how to use the control backends API to create a custom controller for the vehicle from scratch and use it to perform a simulation, without using PX4 nor ROS. NOTE: to see the HDR environment as shown in the video and paper, you must have opened ISAAC SIM at least once thorugh the OMNIVERSE APP, otherwise, the path to the HDR environment is not recognized. """ # Imports to start Isaac Sim from this script import carb from omni.isaac.kit import SimulationApp # Start Isaac Sim's simulation environment # Note: this simulation app must be instantiated right after the SimulationApp import, otherwise the simulator will crash # as this is the object that will load all the extensions and load the actual simulator. simulation_app = SimulationApp({"headless": False}) # ----------------------------------- # The actual script should start here # ----------------------------------- import omni.timeline from omni.isaac.core.world import World # Used for adding extra lights to the environment import omni.isaac.core.utils.prims as prim_utils import omni.kit.commands from pxr import Sdf # Import the Pegasus API for simulating drones from pegasus.simulator.params import ROBOTS from pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig from pegasus.simulator.logic.dynamics.linear_drag import LinearDrag from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface # Import the custom python control backend from utils.nonlinear_controller import NonlinearController # Auxiliary scipy and numpy modules import numpy as np from scipy.spatial.transform import Rotation # Use os and pathlib for parsing the desired trajectory from a CSV file import os from pathlib import Path from omni.isaac.debug_draw import _debug_draw class PegasusApp: """ A Template class that serves as an example on how to build a simple Isaac Sim standalone App. """ def __init__(self): """ Method that initializes the PegasusApp and is used to setup the simulation environment. """ # Acquire the timeline that will be used to start/stop the simulation self.timeline = omni.timeline.get_timeline_interface() # Start the Pegasus Interface self.pg = PegasusInterface() # Acquire the World, .i.e, the singleton that controls that is a one stop shop for setting up physics, # spawning asset primitives, etc. self.pg._world_settings = {"physics_dt": 1.0 / 500.0, "stage_units_in_meters": 1.0, "rendering_dt": 1.0 / 60.0} self.pg._world = World(**self.pg._world_settings) self.world = self.pg.world prim_utils.create_prim( "/World/Light/DomeLight", "DomeLight", position=np.array([1.0, 1.0, 1.0]), attributes={ "inputs:intensity": 5e3, "inputs:color": (1.0, 1.0, 1.0), "inputs:texture:file": "omniverse://localhost/NVIDIA/Assets/Skies/Indoor/ZetoCGcom_ExhibitionHall_Interior1.hdr" } ) # Get the current directory used to read trajectories and save results self.curr_dir = str(Path(os.path.dirname(os.path.realpath(__file__))).resolve()) # Create the vehicle 1 # Try to spawn the selected robot in the world to the specified namespace config_multirotor1 = MultirotorConfig() config_multirotor1.drag = LinearDrag([0.0, 0.0, 0.0]) # Use the nonlinear controller with the built-in exponential trajectory config_multirotor1.backends = [NonlinearController( trajectory_file=None, results_file=self.curr_dir + "/results/statistics_1.npz")] Multirotor( "/World/quadrotor1", ROBOTS['Iris'], 1, [-5.0,0.00,1.00], Rotation.from_euler("XYZ", [0.0, 0.0, 0.0], degrees=True).as_quat(), config=config_multirotor1, ) # Create the vehicle 2 #Try to spawn the selected robot in the world to the specified namespace config_multirotor2 = MultirotorConfig() # Use the nonlinear controller with the built-in exponential trajectory config_multirotor2.backends = [NonlinearController( trajectory_file=None, results_file=self.curr_dir + "/results/statistics_2.npz", reverse=True)] Multirotor( "/World/quadrotor2", ROBOTS['Iris'], 2, [-5.0,4.5,1.0], Rotation.from_euler("XYZ", [0.0, 0.0, 0.0], degrees=True).as_quat(), config=config_multirotor2, ) # Set the camera to a nice position so that we can see the 2 drones almost touching each other self.pg.set_viewport_camera([1.0, 5.15, 1.65], [0.0, -1.65, 3.3]) # Draw the lines of the desired trajectory in Isaac Sim with the same color as the output plots for the paper gamma = np.arange(start=-5.0, stop=5.0, step=0.01) num_samples = gamma.size trajectory1 = [config_multirotor1.backends[0].pd(gamma[i], 0.6) for i in range(num_samples)] trajectory2 = [config_multirotor2.backends[0].pd(gamma[i], 0.6, reverse=True) for i in range(num_samples)] draw = _debug_draw.acquire_debug_draw_interface() point_list_1 = [(trajectory1[i][0], trajectory1[i][1], trajectory1[i][2]) for i in range(num_samples)] draw.draw_lines_spline(point_list_1, (31/255, 119/255, 180/255, 1), 5, False) point_list_2 = [(trajectory2[i][0], trajectory2[i][1], trajectory2[i][2]) for i in range(num_samples)] draw.draw_lines_spline(point_list_2, (255/255, 0, 0, 1), 5, False) # Reset the world self.world.reset() def run(self): """ Method that implements the application main loop, where the physics steps are executed. """ # Start the simulation self.timeline.play() # The "infinite" loop while simulation_app.is_running(): # Update the UI of the app and perform the physics step self.world.step(render=True) # Cleanup and stop carb.log_warn("PegasusApp Simulation App is closing.") self.timeline.stop() simulation_app.close() def main(): # Instantiate the template app pg_app = PegasusApp() # Run the application loop pg_app.run() if __name__ == "__main__": main()

Python

PegasusSimulator/PegasusSimulator/examples/5_python_multi_vehicle.py

#!/usr/bin/env python """ | File: python_control_backend.py | Author: Marcelo Jacinto and Joao Pinto ([email protected], [email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: This files serves as an example on how to use the control backends API to create a custom controller for the vehicle from scratch and use it to perform a simulation, without using PX4 nor ROS. """ # Imports to start Isaac Sim from this script import carb from omni.isaac.kit import SimulationApp # Start Isaac Sim's simulation environment # Note: this simulation app must be instantiated right after the SimulationApp import, otherwise the simulator will crash # as this is the object that will load all the extensions and load the actual simulator. simulation_app = SimulationApp({"headless": False}) # ----------------------------------- # The actual script should start here # ----------------------------------- import omni.timeline from omni.isaac.core.world import World # Used for adding extra lights to the environment import omni.isaac.core.utils.prims as prim_utils # Import the Pegasus API for simulating drones from pegasus.simulator.params import ROBOTS from pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface # Import the custom python control backend from utils.nonlinear_controller import NonlinearController # Auxiliary scipy and numpy modules import numpy as np from scipy.spatial.transform import Rotation # Use os and pathlib for parsing the desired trajectory from a CSV file import os from pathlib import Path import random from omni.isaac.debug_draw import _debug_draw class PegasusApp: """ A Template class that serves as an example on how to build a simple Isaac Sim standalone App. """ def __init__(self): """ Method that initializes the PegasusApp and is used to setup the simulation environment. """ # Acquire the timeline that will be used to start/stop the simulation self.timeline = omni.timeline.get_timeline_interface() # Start the Pegasus Interface self.pg = PegasusInterface() # Acquire the World, .i.e, the singleton that controls that is a one stop shop for setting up physics, # spawning asset primitives, etc. self.pg._world = World(**self.pg._world_settings) self.world = self.pg.world # Add a custom light with a high-definition HDR surround environment of an exhibition hall, # instead of the typical ground plane prim_utils.create_prim( "/World/Light/DomeLight", "DomeLight", position=np.array([1.0, 1.0, 1.0]), attributes={ "inputs:intensity": 5e3, "inputs:color": (1.0, 1.0, 1.0), "inputs:texture:file": "omniverse://localhost/NVIDIA/Assets/Skies/Indoor/ZetoCGcom_ExhibitionHall_Interior1.hdr" } ) # Get the current directory used to read trajectories and save results self.curr_dir = str(Path(os.path.dirname(os.path.realpath(__file__))).resolve()) # Create the vehicle 1 # Try to spawn the selected robot in the world to the specified namespace config_multirotor1 = MultirotorConfig() config_multirotor1.backends = [NonlinearController( trajectory_file=self.curr_dir + "/trajectories/pitch_relay_90_deg_1.csv", results_file=self.curr_dir + "/results/statistics_1.npz", Ki=[0.5, 0.5, 0.5], Kr=[2.0, 2.0, 2.0])] Multirotor( "/World/quadrotor1", ROBOTS['Iris'], 1, [0,-1.5, 8.0], Rotation.from_euler("XYZ", [0.0, 0.0, 0.0], degrees=True).as_quat(), config=config_multirotor1, ) # Create the vehicle 2 #Try to spawn the selected robot in the world to the specified namespace config_multirotor2 = MultirotorConfig() config_multirotor2.backends = [NonlinearController( trajectory_file=self.curr_dir + "/trajectories/pitch_relay_90_deg_2.csv", results_file=self.curr_dir + "/results/statistics_2.npz", Ki=[0.5, 0.5, 0.5], Kr=[2.0, 2.0, 2.0])] Multirotor( "/World/quadrotor2", ROBOTS['Iris'], 2, [2.3,-1.5, 8.0], Rotation.from_euler("XYZ", [0.0, 0.0, 0.0], degrees=True).as_quat(), config=config_multirotor2, ) # Set the camera to a nice position so that we can see the 2 drones almost touching each other self.pg.set_viewport_camera([7.53, -1.6, 4.96], [0.0, 3.3, 7.0]) # Read the trajectories and plot them inside isaac sim trajectory1 = np.flip(np.genfromtxt(self.curr_dir + "/trajectories/pitch_relay_90_deg_1.csv", delimiter=','), axis=0) num_samples1,_ = trajectory1.shape trajectory2 = np.flip(np.genfromtxt(self.curr_dir + "/trajectories/pitch_relay_90_deg_2.csv", delimiter=','), axis=0) num_samples2,_ = trajectory2.shape # Draw the lines of the desired trajectory in Isaac Sim with the same color as the output plots for the paper draw = _debug_draw.acquire_debug_draw_interface() point_list_1 = [(trajectory1[i,1], trajectory1[i,2], trajectory1[i,3]) for i in range(num_samples1)] draw.draw_lines_spline(point_list_1, (31/255, 119/255, 180/255, 1), 5, False) point_list_2 = [(trajectory2[i,1], trajectory2[i,2], trajectory2[i,3]) for i in range(num_samples2)] draw.draw_lines_spline(point_list_2, (255/255, 0, 0, 1), 5, False) self.world.reset() def run(self): """ Method that implements the application main loop, where the physics steps are executed. """ # Start the simulation self.timeline.play() # The "infinite" loop while simulation_app.is_running(): # Update the UI of the app and perform the physics step self.world.step(render=True) # Cleanup and stop carb.log_warn("PegasusApp Simulation App is closing.") self.timeline.stop() simulation_app.close() def main(): # Instantiate the template app pg_app = PegasusApp() # Run the application loop pg_app.run() if __name__ == "__main__": main()

Python

PegasusSimulator/PegasusSimulator/examples/0_template_app.py

#!/usr/bin/env python """ | File: 0_template_app.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: This files serves as a template on how to build a clean and simple Isaac Sim based standalone App. """ # Imports to start Isaac Sim from this script import carb from omni.isaac.kit import SimulationApp # Start Isaac Sim's simulation environment # Note: this simulation app must be instantiated right after the SimulationApp import, otherwise the simulator will crash # as this is the object that will load all the extensions and load the actual simulator. simulation_app = SimulationApp({"headless": False}) # ----------------------------------- # The actual script should start here # ----------------------------------- import omni.timeline from omni.isaac.core import World class Template: """ A Template class that serves as an example on how to build a simple Isaac Sim standalone App. """ def __init__(self): """ Method that initializes the template App and is used to setup the simulation environment. """ # Acquire the timeline that will be used to start/stop the simulation self.timeline = omni.timeline.get_timeline_interface() # Acquire the World, .i.e, the singleton that controls that is a one stop shop for setting up physics, # spawning asset primitives, etc. self.world = World() # Create a ground plane for the simulation self.world.scene.add_default_ground_plane() # Create an example physics callback self.world.add_physics_callback('template_physics_callback', self.physics_callback) # Create an example render callback self.world.add_render_callback('template_render_callback', self.render_callback) # Create an example timeline callback self.world.add_timeline_callback('template_timeline_callback', self.timeline_callback) # Reset the simulation environment so that all articulations (aka robots) are initialized self.world.reset() # Auxiliar variable for the timeline callback example self.stop_sim = False def physics_callback(self, dt: float): """An example physics callback. It will get invoked every physics step. Args: dt (float): The time difference between the previous and current function call, in seconds. """ carb.log_info("This is a physics callback. It is called every " + str(dt) + " seconds!") def render_callback(self, data): """An example render callback. It will get invoked for every rendered frame. Args: data: Rendering data. """ carb.log_info("This is a render callback. It is called every frame!") def timeline_callback(self, timeline_event): """An example timeline callback. It will get invoked every time a timeline event occurs. In this example, we will check if the event is for a 'simulation stop'. If so, we will attempt to close the app Args: timeline_event: A timeline event """ if self.world.is_stopped(): self.stop_sim = True def run(self): """ Method that implements the application main loop, where the physics steps are executed. """ # Start the simulation self.timeline.play() # The "infinite" loop while simulation_app.is_running() and not self.stop_sim: # Update the UI of the app and perform the physics step self.world.step(render=True) # Cleanup and stop carb.log_warn("Template Simulation App is closing.") self.timeline.stop() simulation_app.close() def main(): # Instantiate the template app template_app = Template() # Run the application loop template_app.run() if __name__ == "__main__": main()

Python

PegasusSimulator/PegasusSimulator/examples/8_camera_vehicle.py

#!/usr/bin/env python """ | File: 8_camera_vehicle.py | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto and Filip Stec. All rights reserved. | Description: This files serves as an example on how to build an app that makes use of the Pegasus API to run a simulation with a single vehicle equipped with a camera, producing rgb and camera info ROS2 topics. """ # Imports to start Isaac Sim from this script import carb from omni.isaac.kit import SimulationApp # Start Isaac Sim's simulation environment # Note: this simulation app must be instantiated right after the SimulationApp import, otherwise the simulator will crash # as this is the object that will load all the extensions and load the actual simulator. simulation_app = SimulationApp({"headless": False}) # ----------------------------------- # The actual script should start here # ----------------------------------- import omni.timeline from omni.isaac.core.world import World from omni.isaac.core.utils.extensions import disable_extension, enable_extension # Enable/disable ROS bridge extensions to keep only ROS2 Bridge disable_extension("omni.isaac.ros_bridge") enable_extension("omni.isaac.ros2_bridge") # Import the Pegasus API for simulating drones from pegasus.simulator.params import ROBOTS, SIMULATION_ENVIRONMENTS from pegasus.simulator.logic.state import State from pegasus.simulator.logic.backends.mavlink_backend import MavlinkBackend, MavlinkBackendConfig from pegasus.simulator.logic.vehicles.multirotor import Multirotor, MultirotorConfig from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface from pegasus.simulator.logic.graphs import ROS2Camera # Auxiliary scipy and numpy modules from scipy.spatial.transform import Rotation class PegasusApp: """ A Template class that serves as an example on how to build a simple Isaac Sim standalone App. """ def __init__(self): """ Method that initializes the PegasusApp and is used to setup the simulation environment. """ # Acquire the timeline that will be used to start/stop the simulation self.timeline = omni.timeline.get_timeline_interface() # Start the Pegasus Interface self.pg = PegasusInterface() # Acquire the World, .i.e, the singleton that controls that is a one stop shop for setting up physics, # spawning asset primitives, etc. self.pg._world = World(**self.pg._world_settings) self.world = self.pg.world # Launch one of the worlds provided by NVIDIA self.pg.load_environment(SIMULATION_ENVIRONMENTS["Curved Gridroom"]) # Create the vehicle # Try to spawn the selected robot in the world to the specified namespace config_multirotor = MultirotorConfig() # Create the multirotor configuration mavlink_config = MavlinkBackendConfig({ "vehicle_id": 0, "px4_autolaunch": True, "px4_dir": "/home/marcelo/PX4-Autopilot", "px4_vehicle_model": 'iris' }) config_multirotor.backends = [MavlinkBackend(mavlink_config)] # Create camera graph for the existing Camera prim on the Iris model, which can be found # at the prim path `/World/quadrotor/body/Camera`. The camera prim path is the local path from the vehicle's prim path # to the camera prim, to which this graph will be connected. All ROS2 topics published by this graph will have # namespace `quadrotor` and frame_id `Camera` followed by the selected camera types (`rgb`, `camera_info`). config_multirotor.graphs = [ROS2Camera("body/Camera", config={"types": ['rgb', 'camera_info']})] Multirotor( "/World/quadrotor", ROBOTS['Iris'], 0, [0.0, 0.0, 0.07], Rotation.from_euler("XYZ", [0.0, 0.0, 0.0], degrees=True).as_quat(), config=config_multirotor, ) # Reset the simulation environment so that all articulations (aka robots) are initialized self.world.reset() # Auxiliar variable for the timeline callback example self.stop_sim = False def run(self): """ Method that implements the application main loop, where the physics steps are executed. """ # Start the simulation self.timeline.play() # The "infinite" loop while simulation_app.is_running() and not self.stop_sim: # Update the UI of the app and perform the physics step self.world.step(render=True) # Cleanup and stop carb.log_warn("PegasusApp Simulation App is closing.") self.timeline.stop() simulation_app.close() def main(): # Instantiate the template app pg_app = PegasusApp() # Run the application loop pg_app.run() if __name__ == "__main__": main()

Python

PegasusSimulator/PegasusSimulator/examples/utils/nonlinear_controller.py

#!/usr/bin/env python """ | File: nonlinear_controller.py | Author: Marcelo Jacinto and Joao Pinto ([email protected], [email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: This files serves as an example on how to use the control backends API to create a custom controller for the vehicle from scratch and use it to perform a simulation, without using PX4 nor ROS. In this controller, we provide a quick way of following a given trajectory specified in csv files or track an hard-coded trajectory based on exponentials! NOTE: This is just an example, to demonstrate the potential of the API. A much more flexible solution can be achieved """ # Imports to be able to log to the terminal with fancy colors import carb # Imports from the Pegasus library from pegasus.simulator.logic.state import State from pegasus.simulator.logic.backends import Backend # Auxiliary scipy and numpy modules import numpy as np from scipy.spatial.transform import Rotation class NonlinearController(Backend): """A nonlinear controller class. It implements a nonlinear controller that allows a vehicle to track aggressive trajectories. This controlers is well described in the papers [1] J. Pinto, B. J. Guerreiro and R. Cunha, "Planning Parcel Relay Manoeuvres for Quadrotors," 2021 International Conference on Unmanned Aircraft Systems (ICUAS), Athens, Greece, 2021, pp. 137-145, doi: 10.1109/ICUAS51884.2021.9476757. [2] D. Mellinger and V. Kumar, "Minimum snap trajectory generation and control for quadrotors," 2011 IEEE International Conference on Robotics and Automation, Shanghai, China, 2011, pp. 2520-2525, doi: 10.1109/ICRA.2011.5980409. """ def __init__(self, trajectory_file: str = None, results_file: str=None, reverse=False, Kp=[10.0, 10.0, 10.0], Kd=[8.5, 8.5, 8.5], Ki=[1.50, 1.50, 1.50], Kr=[3.5, 3.5, 3.5], Kw=[0.5, 0.5, 0.5]): # The current rotor references [rad/s] self.input_ref = [0.0, 0.0, 0.0, 0.0] # The current state of the vehicle expressed in the inertial frame (in ENU) self.p = np.zeros((3,)) # The vehicle position self.R: Rotation = Rotation.identity() # The vehicle attitude self.w = np.zeros((3,)) # The angular velocity of the vehicle self.v = np.zeros((3,)) # The linear velocity of the vehicle in the inertial frame self.a = np.zeros((3,)) # The linear acceleration of the vehicle in the inertial frame # Define the control gains matrix for the outer-loop self.Kp = np.diag(Kp) self.Kd = np.diag(Kd) self.Ki = np.diag(Ki) self.Kr = np.diag(Kr) self.Kw = np.diag(Kw) self.int = np.array([0.0, 0.0, 0.0]) # Define the dynamic parameters for the vehicle self.m = 1.50 # Mass in Kg self.g = 9.81 # The gravity acceleration ms^-2 # Read the target trajectory from a CSV file inside the trajectories directory # if a trajectory is provided. Otherwise, just perform the hard-coded trajectory provided with this controller if trajectory_file is not None: self.trajectory = self.read_trajectory_from_csv(trajectory_file) self.index = 0 self.max_index, _ = self.trajectory.shape self.total_time = 0.0 # Use the built-in trajectory hard-coded for this controller else: # Set the initial time for starting when using the built-in trajectory (the time is also used in this case # as the parametric value) self.total_time = -5.0 # Signal that we will not used a received trajectory self.trajectory = None self.max_index = 1 self.reverse = reverse # Auxiliar variable, so that we only start sending motor commands once we get the state of the vehicle self.reveived_first_state = False # Lists used for analysing performance statistics self.results_files = results_file self.time_vector = [] self.desired_position_over_time = [] self.position_over_time = [] self.position_error_over_time = [] self.velocity_error_over_time = [] self.atittude_error_over_time = [] self.attitude_rate_error_over_time = [] def read_trajectory_from_csv(self, file_name: str): """Auxiliar method used to read the desired trajectory from a CSV file Args: file_name (str): A string with the name of the trajectory inside the trajectories directory Returns: np.ndarray: A numpy matrix with the trajectory desired states over time """ # Read the trajectory to a pandas frame return np.flip(np.genfromtxt(file_name, delimiter=','), axis=0) def start(self): """ Reset the control and trajectory index """ self.reset_statistics() def stop(self): """ Stopping the controller. Saving the statistics data for plotting later """ # Check if we should save the statistics to some file or not if self.results_files is None: return statistics = {} statistics["time"] = np.array(self.time_vector) statistics["p"] = np.vstack(self.position_over_time) statistics["desired_p"] = np.vstack(self.desired_position_over_time) statistics["ep"] = np.vstack(self.position_error_over_time) statistics["ev"] = np.vstack(self.velocity_error_over_time) statistics["er"] = np.vstack(self.atittude_error_over_time) statistics["ew"] = np.vstack(self.attitude_rate_error_over_time) np.savez(self.results_files, **statistics) carb.log_warn("Statistics saved to: " + self.results_files) self.reset_statistics() def update_sensor(self, sensor_type: str, data): """ Do nothing. For now ignore all the sensor data and just use the state directly for demonstration purposes. This is a callback that is called at every physics step. Args: sensor_type (str): The name of the sensor providing the data data (dict): A dictionary that contains the data produced by the sensor """ pass def update_state(self, state: State): """ Method that updates the current state of the vehicle. This is a callback that is called at every physics step Args: state (State): The current state of the vehicle. """ self.p = state.position self.R = Rotation.from_quat(state.attitude) self.w = state.angular_velocity self.v = state.linear_velocity self.reveived_first_state = True def input_reference(self): """ Method that is used to return the latest target angular velocities to be applied to the vehicle Returns: A list with the target angular velocities for each individual rotor of the vehicle """ return self.input_ref def update(self, dt: float): """Method that implements the nonlinear control law and updates the target angular velocities for each rotor. This method will be called by the simulation on every physics step Args: dt (float): The time elapsed between the previous and current function calls (s). """ if self.reveived_first_state == False: return # ------------------------------------------------- # Update the references for the controller to track # ------------------------------------------------- self.total_time += dt # Check if we need to update to the next trajectory index if self.index < self.max_index - 1 and self.total_time >= self.trajectory[self.index + 1, 0]: self.index += 1 # Update using an external trajectory if self.trajectory is not None: # the target positions [m], velocity [m/s], accelerations [m/s^2], jerk [m/s^3], yaw-angle [rad], yaw-rate [rad/s] p_ref = np.array([self.trajectory[self.index, 1], self.trajectory[self.index, 2], self.trajectory[self.index, 3]]) v_ref = np.array([self.trajectory[self.index, 4], self.trajectory[self.index, 5], self.trajectory[self.index, 6]]) a_ref = np.array([self.trajectory[self.index, 7], self.trajectory[self.index, 8], self.trajectory[self.index, 9]]) j_ref = np.array([self.trajectory[self.index, 10], self.trajectory[self.index, 11], self.trajectory[self.index, 12]]) yaw_ref = self.trajectory[self.index, 13] yaw_rate_ref = self.trajectory[self.index, 14] # Or update the reference using the built-in trajectory else: s = 0.6 p_ref = self.pd(self.total_time, s, self.reverse) v_ref = self.d_pd(self.total_time, s, self.reverse) a_ref = self.dd_pd(self.total_time, s, self.reverse) j_ref = self.ddd_pd(self.total_time, s, self.reverse) yaw_ref = self.yaw_d(self.total_time, s) yaw_rate_ref = self.d_yaw_d(self.total_time, s) # ------------------------------------------------- # Start the controller implementation # ------------------------------------------------- # Compute the tracking errors ep = self.p - p_ref ev = self.v - v_ref self.int = self.int + (ep * dt) ei = self.int # Compute F_des term F_des = -(self.Kp @ ep) - (self.Kd @ ev) - (self.Ki @ ei) + np.array([0.0, 0.0, self.m * self.g]) + (self.m * a_ref) # Get the current axis Z_B (given by the last column of the rotation matrix) Z_B = self.R.as_matrix()[:,2] # Get the desired total thrust in Z_B direction (u_1) u_1 = F_des @ Z_B # Compute the desired body-frame axis Z_b Z_b_des = F_des / np.linalg.norm(F_des) # Compute X_C_des X_c_des = np.array([np.cos(yaw_ref), np.sin(yaw_ref), 0.0]) # Compute Y_b_des Z_b_cross_X_c = np.cross(Z_b_des, X_c_des) Y_b_des = Z_b_cross_X_c / np.linalg.norm(Z_b_cross_X_c) # Compute X_b_des X_b_des = np.cross(Y_b_des, Z_b_des) # Compute the desired rotation R_des = [X_b_des | Y_b_des | Z_b_des] R_des = np.c_[X_b_des, Y_b_des, Z_b_des] R = self.R.as_matrix() # Compute the rotation error e_R = 0.5 * self.vee((R_des.T @ R) - (R.T @ R_des)) # Compute an approximation of the current vehicle acceleration in the inertial frame (since we cannot measure it directly) self.a = (u_1 * Z_B) / self.m - np.array([0.0, 0.0, self.g]) # Compute the desired angular velocity by projecting the angular velocity in the Xb-Yb plane # projection of angular velocity on xB − yB plane # see eqn (7) from [2]. hw = (self.m / u_1) * (j_ref - np.dot(Z_b_des, j_ref) * Z_b_des) # desired angular velocity w_des = np.array([-np.dot(hw, Y_b_des), np.dot(hw, X_b_des), yaw_rate_ref * Z_b_des[2]]) # Compute the angular velocity error e_w = self.w - w_des # Compute the torques to apply on the rigid body tau = -(self.Kr @ e_R) - (self.Kw @ e_w) # Use the allocation matrix provided by the Multirotor vehicle to convert the desired force and torque # to angular velocity [rad/s] references to give to each rotor if self.vehicle: self.input_ref = self.vehicle.force_and_torques_to_velocities(u_1, tau) # ---------------------------- # Statistics to save for later # ---------------------------- self.time_vector.append(self.total_time) self.position_over_time.append(self.p) self.desired_position_over_time.append(p_ref) self.position_error_over_time.append(ep) self.velocity_error_over_time.append(ev) self.atittude_error_over_time.append(e_R) self.attitude_rate_error_over_time.append(e_w) @staticmethod def vee(S): """Auxiliary function that computes the 'v' map which takes elements from so(3) to R^3. Args: S (np.array): A matrix in so(3) """ return np.array([-S[1,2], S[0,2], -S[0,1]]) def reset_statistics(self): self.index = 0 # If we received an external trajectory, reset the time to 0.0 if self.trajectory is not None: self.total_time = 0.0 # if using the internal trajectory, make the parametric value start at -5.0 else: self.total_time = -5.0 # Reset the lists used for analysing performance statistics self.time_vector = [] self.desired_position_over_time = [] self.position_over_time = [] self.position_error_over_time = [] self.velocity_error_over_time = [] self.atittude_error_over_time = [] self.attitude_rate_error_over_time = [] # --------------------------------------------------- # Definition of an exponential trajectory for example # This can be used as a reference if not trajectory file is passed # as an argument to the constructor of this class # --------------------------------------------------- def pd(self, t, s, reverse=False): """The desired position of the built-in trajectory Args: t (float): The parametric value that guides the equation s (float): How steep and agressive the curve is reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False. Returns: np.ndarray: A 3x1 array with the x, y ,z desired [m] """ x = t z = 1 / s * np.exp(-0.5 * np.power(t/s, 2)) + 1.0 y = 1 / s * np.exp(-0.5 * np.power(t/s, 2)) if reverse == True: y = -1 / s * np.exp(-0.5 * np.power(t/s, 2)) + 4.5 return np.array([x,y,z]) def d_pd(self, t, s, reverse=False): """The desired velocity of the built-in trajectory Args: t (float): The parametric value that guides the equation s (float): How steep and agressive the curve is reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False. Returns: np.ndarray: A 3x1 array with the d_x, d_y ,d_z desired [m/s] """ x = 1.0 y = -(t * np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,3) z = -(t * np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,3) if reverse == True: y = (t * np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,3) return np.array([x,y,z]) def dd_pd(self, t, s, reverse=False): """The desired acceleration of the built-in trajectory Args: t (float): The parametric value that guides the equation s (float): How steep and agressive the curve is reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False. Returns: np.ndarray: A 3x1 array with the dd_x, dd_y ,dd_z desired [m/s^2] """ x = 0.0 y = (np.power(t,2)*np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,5) - np.exp(-np.power(t,2)/(2*np.power(s,2)))/np.power(s,3) z = (np.power(t,2)*np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,5) - np.exp(-np.power(t,2)/(2*np.power(s,2)))/np.power(s,3) if reverse == True: y = np.exp(-np.power(t,2)/(2*np.power(s,2)))/np.power(s,3) - (np.power(t,2)*np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,5) return np.array([x,y,z]) def ddd_pd(self, t, s, reverse=False): """The desired jerk of the built-in trajectory Args: t (float): The parametric value that guides the equation s (float): How steep and agressive the curve is reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False. Returns: np.ndarray: A 3x1 array with the ddd_x, ddd_y ,ddd_z desired [m/s^3] """ x = 0.0 y = (3*t*np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,5) - (np.power(t,3)*np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,7) z = (3*t*np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,5) - (np.power(t,3)*np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,7) if reverse == True: y = (np.power(t,3)*np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,7) - (3*t*np.exp(-np.power(t,2)/(2*np.power(s,2))))/np.power(s,5) return np.array([x,y,z]) def yaw_d(self, t, s): """The desired yaw of the built-in trajectory Args: t (float): The parametric value that guides the equation s (float): How steep and agressive the curve is reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False. Returns: np.ndarray: A float with the desired yaw in rad """ return 0.0 def d_yaw_d(self, t, s): """The desired yaw_rate of the built-in trajectory Args: t (float): The parametric value that guides the equation s (float): How steep and agressive the curve is reverse (bool, optional): Choose whether we want to flip the curve (so that we can have 2 drones almost touching). Defaults to False. Returns: np.ndarray: A float with the desired yaw_rate in rad/s """ return 0.0

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/setup.py

""" | File: setup.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: File that defines the installation requirements for this python package. """ import os import toml from setuptools import setup # Obtain the extension data from the extension.toml file EXTENSION_PATH = os.path.dirname(os.path.realpath(__file__)) # Read the extension.toml file EXTENSION_TOML_DATA = toml.load(os.path.join(EXTENSION_PATH, "config", "extension.toml")) # Minimum dependencies required prior to installation INSTALL_REQUIRES = [ # generic "numpy", "pymavlink", "scipy", "pyyaml", ] # Installation operation setup( name="pegasus-simulator", author="Marcelo Jacinto", maintainer="Marcelo Jacinto", maintainer_email="[email protected]", url=EXTENSION_TOML_DATA["package"]["repository"], version=EXTENSION_TOML_DATA["package"]["version"], description=EXTENSION_TOML_DATA["package"]["description"], keywords=EXTENSION_TOML_DATA["package"]["keywords"], license="BSD-3-Clause", include_package_data=True, python_requires=">=3.7", install_requires=INSTALL_REQUIRES, packages=["pegasus.simulator"], classifiers=["Natural Language :: English", "Programming Language :: Python :: 3.7"], zip_safe=False, )

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/extension.py

""" | File: extension.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: Implements the Pegasus_SimulatorExtension which omni.ext.IExt that is created when this class is enabled. In turn, this class initializes the extension widget. """ __all__ = ["Pegasus_SimulatorExtension"] # Python garbage collenction and asyncronous API import gc import asyncio from functools import partial from threading import Timer # Omniverse general API import pxr import carb import omni.ext import omni.usd import omni.kit.ui import omni.kit.app import omni.ui as ui from omni.kit.viewport.utility import get_active_viewport # Pegasus Extension Files and API from pegasus.simulator.params import MENU_PATH, WINDOW_TITLE from pegasus.simulator.logic.interface.pegasus_interface import PegasusInterface # Setting up the UI for the extension's Widget from pegasus.simulator.ui.ui_window import WidgetWindow from pegasus.simulator.ui.ui_delegate import UIDelegate # Any class derived from `omni.ext.IExt` in top level module (defined in `python.modules` of `extension.toml`) will be # instantiated when extension gets enabled and `on_startup(ext_id)` will be called. Later when extension gets disabled # on_shutdown() is called. class Pegasus_SimulatorExtension(omni.ext.IExt): # ext_id is current extension id. It can be used with extension manager to query additional information, like where # this extension is located on filesystem. def on_startup(self, ext_id): carb.log_info("Pegasus Simulator is starting up") # Save the extension id self._ext_id = ext_id # Create the UI of the app and its manager self.ui_delegate = None self.ui_window = None # Start the extension backend self._pegasus_sim = PegasusInterface() # Check if we already have a stage loaded (when using autoload feature, it might not be ready yet) # This is a limitation of the simulator, and we are doing this to make sure that the # extension does no crash when using the GUI with autoload feature # If autoload was not enabled, and we are enabling the extension from the Extension widget, then # we will always have a state open, and the auxiliary timer will never run if omni.usd.get_context().get_stage_state() != omni.usd.StageState.CLOSED: self._pegasus_sim.initialize_world() else: # We need to create a timer to check until the window is properly open and the stage created. This is a limitation # of the current Isaac Sim simulator and the way it loads extensions :( self.autoload_helper() # Add the ability to show the window if the system requires it (QuickLayout feature) ui.Workspace.set_show_window_fn(WINDOW_TITLE, partial(self.show_window, None)) # Add the extension to the editor menu inside isaac sim editor_menu = omni.kit.ui.get_editor_menu() if editor_menu: self._menu = editor_menu.add_item(MENU_PATH, self.show_window, toggle=True, value=True) # Show the window (It call the self.show_window) ui.Workspace.show_window(WINDOW_TITLE, show=True) def autoload_helper(self): # Check if we already have a viewport and a camera of interest if get_active_viewport() != None and type(get_active_viewport().stage) == pxr.Usd.Stage and str(get_active_viewport().stage.GetPrimAtPath("/OmniverseKit_Persp")) != "invalid null prim": self._pegasus_sim.initialize_world() else: Timer(1.0, self.autoload_helper).start() def show_window(self, menu, show): """ Method that controls whether a widget window is created or not """ if show == True: # Create a window and its delegate self.ui_delegate = UIDelegate() self.ui_window = WidgetWindow(self.ui_delegate) self.ui_window.set_visibility_changed_fn(self._visibility_changed_fn) # If we have a window and we are not supposed to show it, then change its visibility elif self.ui_window: self.ui_window.visible = False def _visibility_changed_fn(self, visible): """ This method is invoked when the user pressed the "X" to close the extension window """ # Update the Isaac sim menu visibility self._set_menu(visible) if not visible: # Destroy the window, because we create a new one in the show window method asyncio.ensure_future(self._destroy_window_async()) def _set_menu(self, visible): """ Method that updates the isaac sim ui menu to create the Widget window on and off """ editor_menu = omni.kit.ui.get_editor_menu() if editor_menu: editor_menu.set_value(MENU_PATH, visible) async def _destroy_window_async(self): # Wait one frame before it gets destructed (from NVidia example) await omni.kit.app.get_app().next_update_async() # Destroy the window UI if it exists if self.ui_window: self.ui_window.destroy() self.ui_window = None def on_shutdown(self): """ Callback called when the extension is shutdown """ carb.log_info("Pegasus Isaac extension shutdown") # Destroy the isaac sim menu object self._menu = None # Destroy the window if self.ui_window: self.ui_window.destroy() self.ui_window = None # Destroy the UI delegate if self.ui_delegate: self.ui_delegate = None # De-register the function taht shows the window from the isaac sim ui ui.Workspace.set_show_window_fn(WINDOW_TITLE, None) editor_menu = omni.kit.ui.get_editor_menu() if editor_menu: editor_menu.remove_item(MENU_PATH) # Call the garbage collector gc.collect()

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/__init__.py

""" | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. """ __author__ = "Marcelo Jacinto" __email__ = "[email protected]" from .extension import Pegasus_SimulatorExtension

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/params.py

""" | File: params.py | Author: Marcelo Jacinto ([email protected]) | License: BSD-3-Clause. Copyright (c) 2023, Marcelo Jacinto. All rights reserved. | Description: File that defines the base configurations for the Pegasus Simulator. """ import os from pathlib import Path import omni.isaac.core.utils.nucleus as nucleus # Extension configuration EXTENSION_NAME = "Pegasus Simulator" WINDOW_TITLE = "Pegasus Simulator" MENU_PATH = "Window/" + WINDOW_TITLE DOC_LINK = "https://docs.omniverse.nvidia.com" EXTENSION_OVERVIEW = "This extension shows how to incorporate drones into Isaac Sim" # Get the current directory of where this extension is located EXTENSION_FOLDER_PATH = Path(os.path.dirname(os.path.realpath(__file__))) ROOT = str(EXTENSION_FOLDER_PATH.parent.parent.parent.resolve()) # Get the configurations file path CONFIG_FILE = ROOT + "/pegasus.simulator/config/configs.yaml" # Define the Extension Assets Path ASSET_PATH = ROOT + "/pegasus.simulator/pegasus/simulator/assets" ROBOTS_ASSETS = ASSET_PATH + "/Robots" # Define the built in robots of the extension ROBOTS = {"Iris": ROBOTS_ASSETS + "/Iris/iris.usd"} #, "Flying Cube": ROBOTS_ASSETS + "/iris_cube.usda"} # Setup the default simulation environments path NVIDIA_ASSETS_PATH = str(nucleus.get_assets_root_path()) ISAAC_SIM_ENVIRONMENTS = "/Isaac/Environments" NVIDIA_SIMULATION_ENVIRONMENTS = { "Default Environment": "Grid/default_environment.usd", "Black Gridroom": "Grid/gridroom_black.usd", "Curved Gridroom": "Grid/gridroom_curved.usd", "Hospital": "Hospital/hospital.usd", "Office": "Office/office.usd", "Simple Room": "Simple_Room/simple_room.usd", "Warehouse": "Simple_Warehouse/warehouse.usd", "Warehouse with Forklifts": "Simple_Warehouse/warehouse_with_forklifts.usd", "Warehouse with Shelves": "Simple_Warehouse/warehouse_multiple_shelves.usd", "Full Warehouse": "Simple_Warehouse/full_warehouse.usd", "Flat Plane": "Terrains/flat_plane.usd", "Rough Plane": "Terrains/rough_plane.usd", "Slope Plane": "Terrains/slope.usd", "Stairs Plane": "Terrains/stairs.usd", } OMNIVERSE_ENVIRONMENTS = { "Exhibition Hall": "omniverse://localhost/NVIDIA/Assets/Scenes/Templates/Interior/ZetCG_ExhibitionHall.usd" } SIMULATION_ENVIRONMENTS = {} # Add the Isaac Sim assets to the list for asset in NVIDIA_SIMULATION_ENVIRONMENTS: SIMULATION_ENVIRONMENTS[asset] = ( NVIDIA_ASSETS_PATH + ISAAC_SIM_ENVIRONMENTS + "/" + NVIDIA_SIMULATION_ENVIRONMENTS[asset] ) # Add the omniverse assets to the list for asset in OMNIVERSE_ENVIRONMENTS: SIMULATION_ENVIRONMENTS[asset] = OMNIVERSE_ENVIRONMENTS[asset] # Define the default settings for the simulation environment DEFAULT_WORLD_SETTINGS = {"physics_dt": 1.0 / 250.0, "stage_units_in_meters": 1.0, "rendering_dt": 1.0 / 60.0} # Define where the thumbnail of the vehicle is located THUMBNAIL = ROBOTS_ASSETS + "/Iris/iris_thumbnail.png" # Define where the thumbail of the world is located WORLD_THUMBNAIL = ASSET_PATH + "/Worlds/Empty_thumbnail.png"

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/dynamics_parser.py

# Copyright (c) 2023, Marcelo Jacinto # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # Sensors that can be used with the vehicles from pegasus.simulator.parser import Parser from pegasus.simulator.logic.dynamics import LinearDrag class DynamicsParser(Parser): def __init__(self): # Dictionary of available sensors to instantiate self.dynamics = {"linear_drag": LinearDrag} def parse(self, data_type: str, data_dict): # Get the class of the sensor dynamics_cls = self.dynamics[data_type] # Create an instance of that sensor return dynamics_cls(data_dict)

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/parser.py

# Copyright (c) 2023, Marcelo Jacinto # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause class Parser: def __init__(self): pass def parse(self, data_type: str, data_dict): pass

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/thrusters_parser.py

# Copyright (c) 2023, Marcelo Jacinto # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # Sensors that can be used with the vehicles from pegasus.simulator.parser import Parser from pegasus.simulator.logic.thrusters import QuadraticThrustCurve class ThrustersParser(Parser): def __init__(self): # Dictionary of available thrust curves to instantiate self.thrust_curves = {"quadratic_thrust_curve": QuadraticThrustCurve} def parse(self, data_type: str, data_dict): # Get the class of the sensor thrust_curve_cls = self.thrust_curves[data_type] # Create an instance of that sensor return thrust_curve_cls(data_dict)

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/vehicle_parser.py

# Copyright (c) 2023, Marcelo Jacinto # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause import carb # Sensors that can be used with the vehicles from pegasus.simulator.parser import Parser, SensorParser, ThrustersParser, DynamicsParser, BackendsParser from pegasus.simulator.logic.vehicles import MultirotorConfig class VehicleParser(Parser): def __init__(self): # Initialize the Parser object super().__init__() # Initialize Parsers for the sensors, dynamics and backends for control and communications self.sensor_parser = SensorParser() self.thrusters_parser = ThrustersParser() self.dynamics_parser = DynamicsParser() self.backends_parser = BackendsParser() def parse(self, data_type: str, data_dict={}): # Get the USD model associated with the vehicle usd_model = data_dict.get("usd_model", "") # Get the model thumbnail of the vehicle thumbnail = data_dict.get("thumbnail", "") # --------------------------------------- # Generate the sensors for the multirotor # --------------------------------------- sensors = [] sensors_config = data_dict.get("sensors", {}) for sensor_name in sensors_config: sensor = self.sensor_parser.parse(sensor_name, sensors_config[sensor_name]) if sensor is not None: sensors.append(sensor) # ----------------------------------------- # Generate the thrusters for the multirotor # ----------------------------------------- thrusters = None thrusters_config = data_dict.get("thrusters", {}) # Note: if a dictionary/yaml file contains more than one thrust curve configuration, # only the last one will be kept for thrust_curve_name in thrusters_config: curve = self.thrusters_parser.parse(thrust_curve_name, thrusters_config[thrust_curve_name]) if curve is not None: thrusters = curve # ---------------------------------------- # Generate the dynamics for the multirotor # ---------------------------------------- dynamics = None dynamics_config = data_dict.get("drag", {}) for dynamics_name in dynamics_config: carb.log_warn(dynamics_config[dynamics_name]) dynamic = self.dynamics_parser.parse(dynamics_name, dynamics_config[dynamics_name]) if dynamic is not None: dynamics = dynamic # ---------------------------------------- # Generate the backends for the multirotor # ---------------------------------------- backends = [] backends_config = data_dict.get("backends", {}) for backends_name in backends_config: backend = self.backends_parser.parse(backends_name, backends_config[backends_name]) if backend is not None: backends.append(backend) # Create a Multirotor config from the parsed data multirotor_configuration = MultirotorConfig() multirotor_configuration.usd_file = usd_model multirotor_configuration.thrust_curve = thrusters multirotor_configuration.drag = dynamics multirotor_configuration.sensors = sensors multirotor_configuration.backends = backends return multirotor_configuration

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/__init__.py

# Copyright (c) 2023, Marcelo Jacinto # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause from .parser import Parser from .sensor_parser import SensorParser from .thrusters_parser import ThrustersParser from .dynamics_parser import DynamicsParser from .backends_parser import BackendsParser from .graphs_parser import GraphParser

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/sensor_parser.py

# Copyright (c) 2023, Marcelo Jacinto # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # Sensors that can be used with the vehicles from pegasus.simulator.parser import Parser from pegasus.simulator.logic.sensors import Barometer, GPS, IMU, Magnetometer class SensorParser(Parser): def __init__(self): # Dictionary of available sensors to instantiate self.sensors = {"barometer": Barometer, "gps": GPS, "imu": IMU, "magnetometer": Magnetometer} def parse(self, data_type: str, data_dict): # Get the class of the sensor sensor_cls = self.sensors[data_type] # Create an instance of that sensor return sensor_cls(data_dict)

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/backends_parser.py

# Copyright (c) 2023, Marcelo Jacinto # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # Sensors that can be used with the vehicles from pegasus.simulator.parser import Parser from pegasus.simulator.logic.backends import MavlinkBackendConfig, MavlinkBackend, ROS2Backend class BackendsParser(Parser): # TODO - improve the structure of the backends in order to clean this parser def __init__(self): # Dictionary of available sensors to instantiate self.backends = {"mavlink": MavlinkBackendConfig, "ros2": ROS2Backend} def parse(self, data_type: str, data_dict): # Get the class of the sensor backends_cls = self.backends[data_type] if backends_cls == MavlinkBackendConfig: return MavlinkBackend(backends_cls(data_dict)) # Create an instance of that sensor return backends_cls(data_dict)

Python

PegasusSimulator/PegasusSimulator/extensions/pegasus.simulator/pegasus/simulator/parser/graphs_parser.py

# Copyright (c) 2023, Marcelo Jacinto # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # Graphs that can be used with the vehicles from pegasus.simulator.parser import Parser from pegasus.simulator.logic.graphs import ROS2Camera class GraphParser(Parser): def __init__(self): # Dictionary of available graphs to instantiate self.graphs = { "ROS2 Camera": ROS2Camera } def parse(self, data_type: str, data_dict): # Get the class of the graph graph_cls = self.graphs[data_type] # Create an instance of that graph return graph_cls(data_dict)

Python